google.maps namespace, though using the global namespace
* is not generally recommended.)
* @param {string} libraryName
* @return {!Promise}
*/
google.maps.importLibrary = function(libraryName) {};
/**
* Google Maps JavaScript API version loaded by the browser. See https://developers.google.com/maps/documentation/javascript/versions
* @const
* @type {string}
*/
google.maps.version;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* A relational description of a location. Includes a ranked set of nearby
* landmarks and the areas containing the target location.
* @record
*/
google.maps.AddressDescriptor = function() {};
/**
* A ranked list of containing or adjacent areas. The most useful (recognizable
* and precise) areas are ranked first.
* @type {!Array}
*/
google.maps.AddressDescriptor.prototype.areas;
/**
* A ranked list of nearby landmarks. The most useful (recognizable and nearby)
* landmarks are ranked first.
* @type {!Array}
*/
google.maps.AddressDescriptor.prototype.landmarks;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* @record
*/
google.maps.AddressValidationLibrary = function() {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.Address}
*/
google.maps.AddressValidationLibrary.prototype.Address;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.AddressComponent}
*/
google.maps.AddressValidationLibrary.prototype.AddressComponent;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.AddressMetadata}
*/
google.maps.AddressValidationLibrary.prototype.AddressMetadata;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.AddressValidation}
*/
google.maps.AddressValidationLibrary.prototype.AddressValidation;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.ConfirmationLevel}
*/
google.maps.AddressValidationLibrary.prototype.ConfirmationLevel;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.Geocode}
*/
google.maps.AddressValidationLibrary.prototype.Geocode;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.Granularity}
*/
google.maps.AddressValidationLibrary.prototype.Granularity;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.PossibleNextAction}
*/
google.maps.AddressValidationLibrary.prototype.PossibleNextAction;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.USPSAddress}
*/
google.maps.AddressValidationLibrary.prototype.USPSAddress;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.USPSData}
*/
google.maps.AddressValidationLibrary.prototype.USPSData;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {typeof google.maps.addressValidation.Verdict}
*/
google.maps.AddressValidationLibrary.prototype.Verdict;
/**
* @record
*/
google.maps.AirQualityLibrary = function() {};
/**
* @type {typeof google.maps.airQuality.AirQualityMeterElement}
*/
google.maps.AirQualityLibrary.prototype.AirQualityMeterElement;
/**
* Animations that can be played on a marker. Use the {@link
* google.maps.Marker.setAnimation} method on Marker or the {@link
* google.maps.MarkerOptions.animation} option to play an animation.
*
* Access by calling `const {Animation} = await
* google.maps.importLibrary("marker")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {number}
*/
google.maps.Animation = {
/**
* Marker bounces until animation is stopped by calling {@link
* google.maps.Marker.setAnimation} with null.
*/
BOUNCE: 0,
/**
* Marker drops from the top of the map to its final location. Animation will
* cease once the marker comes to rest and {@link
* google.maps.Marker.getAnimation} will return null. This type
* of animation is usually specified during creation of the marker.
*/
DROP: 1,
};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* A place that is a small region, such as a neighborhood, sublocality, or large
* complex that contains the target location.
* @record
*/
google.maps.Area = function() {};
/**
* Defines the spatial relationship between the target location and the area.
* @type {!google.maps.Containment}
*/
google.maps.Area.prototype.containment;
/**
* The name for the area.
* @type {string}
*/
google.maps.Area.prototype.display_name;
/**
* The language of the name for the area.
* @type {string}
*/
google.maps.Area.prototype.display_name_language_code;
/**
* The Place ID of the underlying area. Can be used to resolve more information
* about the area through Place Details or Place ID Lookup.
* @type {string}
*/
google.maps.Area.prototype.place_id;
/**
* A layer showing bike lanes and paths.
*
* Access by calling `const {BicyclingLayer} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.BicyclingLayer = function() {};
/**
* Returns the map on which this layer is displayed.
* @return {!google.maps.Map|null}
*/
google.maps.BicyclingLayer.prototype.getMap = function() {};
/**
* Renders the layer on the specified map. If map is set to null,
* the layer will be removed.
* @param {!google.maps.Map|null} map
* @return {void}
*/
google.maps.BicyclingLayer.prototype.setMap = function(map) {};
/**
* The display options for the Camera control.
* @record
*/
google.maps.CameraControlOptions = function() {};
/**
* Position id. Used to specify the position of the control on the map.
* @default {@link google.maps.ControlPosition.INLINE_START_BLOCK_END}
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.CameraControlOptions.prototype.position;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* Used for setting the map's camera options.
* @record
*/
google.maps.CameraOptions = function() {};
/**
* @type {!google.maps.LatLngLiteral|!google.maps.LatLng|undefined}
*/
google.maps.CameraOptions.prototype.center;
/**
* @type {number|undefined}
*/
google.maps.CameraOptions.prototype.heading;
/**
* @type {number|undefined}
*/
google.maps.CameraOptions.prototype.tilt;
/**
* @type {number|undefined}
*/
google.maps.CameraOptions.prototype.zoom;
/**
* Used for retrieving camera parameters, such as that of the GL camera used for
* the {@link google.maps.WebGLOverlayView}.
* @extends {google.maps.CameraOptions}
* @record
*/
google.maps.CameraParams = function() {};
/**
* @type {!google.maps.LatLng}
*/
google.maps.CameraParams.prototype.center;
/**
* @type {number}
*/
google.maps.CameraParams.prototype.heading;
/**
* @type {number}
*/
google.maps.CameraParams.prototype.tilt;
/**
* @type {number}
*/
google.maps.CameraParams.prototype.zoom;
/**
* A circle on the Earth's surface; also known as a "spherical
* cap".
*
* Access by calling `const {Circle} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {(!google.maps.Circle|!google.maps.CircleLiteral|!google.maps.CircleOptions|null)=}
* circleOrCircleOptions
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.Circle = function(circleOrCircleOptions) {};
/**
* Gets the LatLngBounds of this Circle.
* @return {!google.maps.LatLngBounds|null}
*/
google.maps.Circle.prototype.getBounds = function() {};
/**
* Returns the center of this circle.
* @return {!google.maps.LatLng|null}
*/
google.maps.Circle.prototype.getCenter = function() {};
/**
* Returns whether this circle can be dragged by the user.
* @return {boolean}
*/
google.maps.Circle.prototype.getDraggable = function() {};
/**
* Returns whether this circle can be edited by the user.
* @return {boolean}
*/
google.maps.Circle.prototype.getEditable = function() {};
/**
* Returns the map on which this circle is displayed.
* @return {!google.maps.Map|null}
*/
google.maps.Circle.prototype.getMap = function() {};
/**
* Returns the radius of this circle (in meters).
* @return {number}
*/
google.maps.Circle.prototype.getRadius = function() {};
/**
* Returns whether this circle is visible on the map.
* @return {boolean}
*/
google.maps.Circle.prototype.getVisible = function() {};
/**
* Sets the center of this circle.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral|null} center
* @return {undefined}
*/
google.maps.Circle.prototype.setCenter = function(center) {};
/**
* If set to true, the user can drag this circle over the map.
* @param {boolean} draggable
* @return {undefined}
*/
google.maps.Circle.prototype.setDraggable = function(draggable) {};
/**
* If set to true, the user can edit this circle by dragging the
* control points shown at the center and around the circumference of the
* circle.
* @param {boolean} editable
* @return {undefined}
*/
google.maps.Circle.prototype.setEditable = function(editable) {};
/**
* Renders the circle on the specified map. If map is set to null,
* the circle will be removed.
* @param {!google.maps.Map|null} map
* @return {undefined}
*/
google.maps.Circle.prototype.setMap = function(map) {};
/**
* @param {!google.maps.CircleOptions|null} options
* @return {undefined}
*/
google.maps.Circle.prototype.setOptions = function(options) {};
/**
* Sets the radius of this circle (in meters).
* @param {number} radius
* @return {undefined}
*/
google.maps.Circle.prototype.setRadius = function(radius) {};
/**
* Hides this circle if set to false.
* @param {boolean} visible
* @return {undefined}
*/
google.maps.Circle.prototype.setVisible = function(visible) {};
/**
* Object literal which represents a circle.
* @extends {google.maps.CircleOptions}
* @record
*/
google.maps.CircleLiteral = function() {};
/**
* The center of the Circle.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral}
*/
google.maps.CircleLiteral.prototype.center;
/**
* The radius in meters on the Earth's surface.
* @type {number}
*/
google.maps.CircleLiteral.prototype.radius;
/**
* CircleOptions object used to define the properties that can be set on a
* Circle.
* @record
*/
google.maps.CircleOptions = function() {};
/**
* The center of the Circle.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.CircleOptions.prototype.center;
/**
* Indicates whether this Circle handles mouse events.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.CircleOptions.prototype.clickable;
/**
* If set to true, the user can drag this circle over the map.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.CircleOptions.prototype.draggable;
/**
* If set to true, the user can edit this circle by dragging the
* control points shown at the center and around the circumference of the
* circle.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.CircleOptions.prototype.editable;
/**
* The fill color. All CSS3 colors are supported except for extended named
* colors.
* @type {string|null|undefined}
*/
google.maps.CircleOptions.prototype.fillColor;
/**
* The fill opacity between 0.0 and 1.0.
* @type {number|null|undefined}
*/
google.maps.CircleOptions.prototype.fillOpacity;
/**
* Map on which to display the Circle.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.CircleOptions.prototype.map;
/**
* The radius in meters on the Earth's surface.
* @type {number|null|undefined}
*/
google.maps.CircleOptions.prototype.radius;
/**
* The stroke color. All CSS3 colors are supported except for extended named
* colors.
* @type {string|null|undefined}
*/
google.maps.CircleOptions.prototype.strokeColor;
/**
* The stroke opacity between 0.0 and 1.0.
* @type {number|null|undefined}
*/
google.maps.CircleOptions.prototype.strokeOpacity;
/**
* The stroke position.
* @default {@link google.maps.StrokePosition.CENTER}
* @type {!google.maps.StrokePosition|null|undefined}
*/
google.maps.CircleOptions.prototype.strokePosition;
/**
* The stroke width in pixels.
* @type {number|null|undefined}
*/
google.maps.CircleOptions.prototype.strokeWeight;
/**
* Whether this circle is visible on the map.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.CircleOptions.prototype.visible;
/**
* The zIndex compared to other polys.
* @type {number|null|undefined}
*/
google.maps.CircleOptions.prototype.zIndex;
/**
*
* Access by calling `const {CollisionBehavior} = await
* google.maps.importLibrary("marker")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.CollisionBehavior = {
/**
* Display the marker only if it does not overlap with other markers. If two
* markers of this type would overlap, the one with the higher zIndex is
* shown. If they have the same zIndex, the one with the lower vertical screen
* position is shown.
*/
OPTIONAL_AND_HIDES_LOWER_PRIORITY: 'OPTIONAL_AND_HIDES_LOWER_PRIORITY',
/**
* Always display the marker regardless of collision. This is the default
* behavior.
*/
REQUIRED: 'REQUIRED',
/**
* Always display the marker regardless of collision, and hide any
* OPTIONAL_AND_HIDES_LOWER_PRIORITY markers or labels that would overlap with
* the marker.
*/
REQUIRED_AND_HIDES_OPTIONAL: 'REQUIRED_AND_HIDES_OPTIONAL',
};
/**
* Identifiers for map color schemes. Specify these by value, or by using the
* constant's name. For example, 'FOLLOW_SYSTEM' or
* google.maps.ColorScheme.FOLLOW_SYSTEM.
*
* Access by calling `const {ColorScheme} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.ColorScheme = {
/**
* The dark color scheme for a map.
*/
DARK: 'DARK',
/**
* The color scheme is selected based on system preferences, which are checked
* once at method execution time.
*/
FOLLOW_SYSTEM: 'FOLLOW_SYSTEM',
/**
* The light color scheme for a map. Default value for legacy Maps JS.
*/
LIGHT: 'LIGHT',
};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* An enum representing the spatial relationship between the area and the target
* location.
*
* Access by calling `const {Containment} = await
* google.maps.importLibrary("geocoding")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.Containment = {
/**
* The target location is outside the area region, but close by.
*/
NEAR: 'NEAR',
/**
* The target location is within the area region, close to the edge.
*/
OUTSKIRTS: 'OUTSKIRTS',
/**
* The target location is within the area region, close to the center.
*/
WITHIN: 'WITHIN',
};
/**
* Identifiers used to specify the placement of controls on the map. Controls
* are positioned relative to other controls in the same layout position.
* Controls that are added first are positioned closer to the edge of the map.
* Usage of "logical values" (see https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_logical_properties_and_values)
* is recommended in order to be able to automatically support both
* left-to-right (LTR) and right-to-left (RTL) layout contexts.+----------------+ *
| BSIS BSIC BSIE | *
| ISBS IEBS | *
| | *
| ISBC IEBC | *
| | *
| ISBE IEBE | *
| BEIS BEIC BEIE |
+----------------+
+----------------+ *
| BSIE BSIC BSIS | *
| IEBS ISBS | *
| | *
| IEBC ISBC | *
| | *
| IEBE ISBE | *
| BEIE BEIC BEIS |
+----------------+
+----------------+ *
| TL TC TR | *
| LT RT | *
| | *
| LC RC | *
| | *
| LB RB | *
| BL BC BR | *
+----------------+
Every Map has a Data object by
* default, so most of the time there is no need to construct one. For example:
*
var myMap = new google.maps.Map(...);The *
* myMap.data.addGeoJson(...);
myMap.data.setStyle(...);
Data object is a collection of Features.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {google.maps.Data.DataOptions=} options
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.Data = function(options) {};
/**
* Adds a feature to the collection, and returns the added feature. If the
* feature has an ID, it will replace any existing feature in the collection
* with the same ID. If no feature is given, a new feature will be created with
* null geometry and no properties. If FeatureOptions are given, a
* new feature will be created with the specified properties.
Note that the
* IDs Note that the IDs
* NOTE:
* The GeoJSON is fetched using XHR, and may not work cross-domain. If you have
* issues, we recommend you fetch the GeoJSON using your choice of AJAX library,
* and then call If no feature is given, all features have their
* style reverted. Pass
* either an object with the desired style options, or a function that computes
* the style for each feature. The function will be called every time a
* feature's properties are updated.
* @param {google.maps.Data.StylingFunction|google.maps.Data.StyleOptions} style
* @return {undefined}
*/
google.maps.Data.prototype.setStyle = function(style) {};
/**
* Exports the features in the collection to a GeoJSON object.
* @param {function(!Object): void} callback
* @return {undefined}
*/
google.maps.Data.prototype.toGeoJson = function(callback) {};
/**
* The properties of a Deprecated in alternative routes.
* Version 3.27 will be the last version of the API that adds extra
* When using the
* Directions Service to implement draggable directions, it is recommended to
* disable dragging of alternative routes. Only the main route should be
* draggable. Users can drag the main route until it matches an alternative
* route.
* @type {!Array}
*/
google.maps.DirectionsLeg.prototype.via_waypoints;
/**
* Information about traffic speed along the leg.
* @type {!Array<*>}
* @deprecated This array will always be empty.
*/
google.maps.DirectionsLeg.prototype.traffic_speed_entry;
/**
* An object containing a Learn more
* about place
* IDs in the Places API developer guide.
* @type {string|null}
*/
google.maps.IconMouseEvent.prototype.placeId;
/**
* Describes how icons are to be rendered on a line. Most methods that accept The constructor
* also accepts {@link google.maps.LatLngLiteral} and The possible calls to the constructor are below: Examples: LatLng object literals are not supported in the Geometry
* library. Note: This property is not recommended.
* To disable zooming on double click, you can use the
* Note: This
* property is not recommended. To disable zooming using
* scrollwheel, you can use the
* @type {boolean|null|undefined}
* @deprecated The Pan control is deprecated as of September 2015.
*/
google.maps.MapOptions.prototype.panControl;
/**
* The display options for the Pan control.
* @type {!google.maps.PanControlOptions|null|undefined}
* @deprecated The Pan control is deprecated as of September 2015.
*/
google.maps.MapOptions.prototype.panControlOptions;
/**
* @record
*/
google.maps.MapPanes = function() {};
/**
* This pane contains the info window. It is above all map overlays. (Pane 4).
* @type {!Element}
*/
google.maps.MapPanes.prototype.floatPane;
/**
* This pane is the lowest pane and is above the tiles. It does not receive DOM
* events. (Pane 0).
* @type {!Element}
*/
google.maps.MapPanes.prototype.mapPane;
/**
* This pane contains markers. It does not receive DOM events. (Pane 2).
* @type {!Element}
*/
google.maps.MapPanes.prototype.markerLayer;
/**
* This pane contains polylines, polygons, ground overlays and tile layer
* overlays. It does not receive DOM events. (Pane 1).
* @type {!Element}
*/
google.maps.MapPanes.prototype.overlayLayer;
/**
* This pane contains elements that receive DOM events. (Pane 3).
* @type {!Element}
*/
google.maps.MapPanes.prototype.overlayMouseTarget;
/**
* A restriction that can be applied to the Map. The map's viewport will not
* exceed these restrictions.
* @record
*/
google.maps.MapRestriction = function() {};
/**
* When set, a user can only pan and zoom inside the given bounds. Bounds can
* restrict both longitude and latitude, or can restrict latitude only. For
* latitude-only bounds use west and east longitudes of -180 and 180,
* respectively, for example, Calling Note:
* Note: Note: Note: 1234 and '1234' are equivalent. Adding a
* feature with ID 1234 will replace a feature with ID
* '1234', and vice versa.
* @param {(google.maps.Data.Feature|google.maps.Data.FeatureOptions)=} feature
* @return {!google.maps.Data.Feature}
*/
google.maps.Data.prototype.add = function(feature) {};
/**
* Adds GeoJSON features to the collection. Give this method a parsed JSON. The
* imported features are returned. Throws an exception if the GeoJSON could not
* be imported.
* @param {!Object} geoJson
* @param {google.maps.Data.GeoJsonOptions=} options
* @return {!Array}
*/
google.maps.Data.prototype.addGeoJson = function(geoJson, options) {};
/**
* Checks whether the given feature is in the collection.
* @param {!google.maps.Data.Feature} feature
* @return {boolean}
*/
google.maps.Data.prototype.contains = function(feature) {};
/**
* Repeatedly invokes the given function, passing a feature in the collection to
* the function on each invocation. The order of iteration through the features
* is undefined.
* @param {function(!google.maps.Data.Feature): void} callback
* @return {undefined}
*/
google.maps.Data.prototype.forEach = function(callback) {};
/**
* Returns the position of the drawing controls on the map.
* @return {google.maps.ControlPosition}
*/
google.maps.Data.prototype.getControlPosition = function() {};
/**
* Returns which drawing modes are available for the user to select, in the
* order they are displayed. This does not include the null drawing
* mode, which is added by default. Possible drawing modes are
* "Point", "LineString" or "Polygon".
* @return {Arraynull means that the user can interact with the map as normal,
* and clicks do not draw anything. Possible drawing modes are
* null, "Point", "LineString" or
* "Polygon".
* @return {?string}
*/
google.maps.Data.prototype.getDrawingMode = function() {};
/**
* Returns the feature with the given ID, if it exists in the collection.
* Otherwise returns undefined. 1234 and '1234' are equivalent. Either can be used
* to look up the same feature.
* @param {number|string} id
* @return {!google.maps.Data.Feature|undefined}
*/
google.maps.Data.prototype.getFeatureById = function(id) {};
/**
* Returns the map on which the features are displayed.
* @return {google.maps.Map}
*/
google.maps.Data.prototype.getMap = function() {};
/**
* Gets the style for all features in the collection.
* @return {google.maps.Data.StylingFunction|google.maps.Data.StyleOptions}
*/
google.maps.Data.prototype.getStyle = function() {};
/**
* Loads GeoJSON from a URL, and adds the features to the collection. addGeoJson().
* @param {string} url
* @param {google.maps.Data.GeoJsonOptions=} options
* @param {(function(!Array): void)=} callback
* @return {undefined}
*/
google.maps.Data.prototype.loadGeoJson = function(url, options, callback) {};
/**
* Changes the style of a feature. These changes are applied on top of the style
* specified by setStyle(). Style properties set to
* null revert to the value specified via setStyle().
* @param {!google.maps.Data.Feature} feature
* @param {!google.maps.Data.StyleOptions} style
* @return {undefined}
*/
google.maps.Data.prototype.overrideStyle = function(feature, style) {};
/**
* Removes a feature from the collection.
* @param {!google.maps.Data.Feature} feature
* @return {undefined}
*/
google.maps.Data.prototype.remove = function(feature) {};
/**
* Removes the effect of previous overrideStyle() calls. The style
* of the given feature reverts to the style specified by
* setStyle(). null drawing
* mode, which is added by default. If null, drawing controls are
* disabled and not displayed. Possible drawing modes are "Point",
* "LineString" or "Polygon".
* @param {Arraynull means that the user can interact with the map as normal,
* and clicks do not draw anything. Possible drawing modes are
* null, "Point", "LineString" or
* "Polygon".
* @param {?string} drawingMode
* @return {undefined}
*/
google.maps.Data.prototype.setDrawingMode = function(drawingMode) {};
/**
* Renders the features on the specified map. If map is set to
* null, the features will be removed from the map.
* @param {google.maps.Map} map
* @return {undefined}
*/
google.maps.Data.prototype.setMap = function(map) {};
/**
* Sets the style for all features in the collection. Styles specified on a
* per-feature basis via overrideStyle() continue to apply. addfeature event.
* @record
*/
google.maps.Data.AddFeatureEvent = function() {};
/**
* The feature that was added to the FeatureCollection.
* @type {!google.maps.Data.Feature}
*/
google.maps.Data.AddFeatureEvent.prototype.feature;
/**
* DataOptions object used to define the properties that a developer can set on
* a Data object.
* @record
*/
google.maps.Data.DataOptions = function() {};
/**
* The position of the drawing controls on the map.
* @default {@link google.maps.ControlPosition.TOP_LEFT}
* @type {!google.maps.ControlPosition|undefined}
*/
google.maps.Data.DataOptions.prototype.controlPosition;
/**
* Describes which drawing modes are available for the user to select, in the
* order they are displayed. This should not include the null
* drawing mode, which is added by default. If null, drawing
* controls are disabled and not displayed. Possible drawing modes are
* "Point", "LineString" or "Polygon".
* @default null
* @type {!Arraynull means that the user can interact with the map as normal,
* and clicks do not draw anything. Possible drawing modes are
* null, "Point", "LineString" or
* "Polygon".
* @default null
* @type {string|null|undefined}
*/
google.maps.Data.DataOptions.prototype.drawingMode;
/**
* When drawing is enabled and a user draws a Geometry (a Point, Line String or
* Polygon), this function is called with that Geometry and should return a
* Feature that is to be added to the Data layer. If a featureFactory is not
* supplied, a Feature with no id and no properties will be created from that
* Geometry instead. Defaults to null.
* @type {(function(!google.maps.Data.Geometry):
* !google.maps.Data.Feature)|null|undefined}
*/
google.maps.Data.DataOptions.prototype.featureFactory;
/**
* Map on which to display the features in the collection.
* @type {!google.maps.Map}
*/
google.maps.Data.DataOptions.prototype.map;
/**
* Style for all features in the collection. For more details, see the setStyle() method above.
* @type {!google.maps.Data.StylingFunction|!google.maps.Data.StyleOptions|undefined}
*/
google.maps.Data.DataOptions.prototype.style;
/**
* A feature has a geometry, an id, and a set of properties.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {google.maps.Data.FeatureOptions=} options
* @constructor
*/
google.maps.Data.Feature = function(options) {};
/**
* Repeatedly invokes the given function, passing a property value and name on
* each invocation. The order of iteration through the properties is undefined.
* @param {function(*, string): void} callback
* @return {undefined}
*/
google.maps.Data.Feature.prototype.forEachProperty = function(callback) {};
/**
* Returns the feature's geometry.
* @return {google.maps.Data.Geometry}
*/
google.maps.Data.Feature.prototype.getGeometry = function() {};
/**
* Returns the feature ID.
* @return {number|string|undefined}
*/
google.maps.Data.Feature.prototype.getId = function() {};
/**
* Returns the value of the requested property, or undefined if the
* property does not exist.
* @param {string} name
* @return {*}
*/
google.maps.Data.Feature.prototype.getProperty = function(name) {};
/**
* Removes the property with the given name.
* @param {string} name
* @return {undefined}
*/
google.maps.Data.Feature.prototype.removeProperty = function(name) {};
/**
* Sets the feature's geometry.
* @param {google.maps.Data.Geometry|google.maps.LatLng|google.maps.LatLngLiteral}
* newGeometry
* @return {undefined}
*/
google.maps.Data.Feature.prototype.setGeometry = function(newGeometry) {};
/**
* Sets the value of the specified property. If newValue is
* undefined this is equivalent to calling
* removeProperty.
* @param {string} name
* @param {*} newValue
* @return {undefined}
*/
google.maps.Data.Feature.prototype.setProperty = function(name, newValue) {};
/**
* Exports the feature to a GeoJSON object.
* @param {function(!Object): void} callback
* @return {undefined}
*/
google.maps.Data.Feature.prototype.toGeoJson = function(callback) {};
/**
* Optional parameters for creating Data.Feature objects.
* @record
*/
google.maps.Data.FeatureOptions = function() {};
/**
* The feature geometry. If none is specified when a feature is constructed, the
* feature's geometry will be null. If a LatLng
* object or LatLngLiteral is given, this will be converted to a
* Data.Point geometry.
* @type {!google.maps.Data.Geometry|!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.Data.FeatureOptions.prototype.geometry;
/**
* Feature ID is optional. If provided, it can be used to look up the feature in
* a Data object using the getFeatureById() method.
* Note that a feature's ID cannot be subsequently changed.
* @type {number|string|undefined}
*/
google.maps.Data.FeatureOptions.prototype.id;
/**
* The feature properties. This is an arbitrary mapping of property names to
* values.
* @type {!Object|null|undefined}
*/
google.maps.Data.FeatureOptions.prototype.properties;
/**
* Optional parameters for importing GeoJSON.
* @record
*/
google.maps.Data.GeoJsonOptions = function() {};
/**
* The name of the Feature property to use as the feature ID. If not specified,
* the GeoJSON Feature id will be used.
* @type {string|null|undefined}
*/
google.maps.Data.GeoJsonOptions.prototype.idPropertyName;
/**
* A superclass for the various geometry objects.
* @record
*/
google.maps.Data.Geometry = function() {};
/**
* Repeatedly invokes the given function, passing a point from the geometry to
* the function on each invocation.
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
*/
google.maps.Data.Geometry.prototype.forEachLatLng = function(callback) {};
/**
* Returns the type of the geometry object. Possibilities are
* "Point", "MultiPoint", "LineString",
* "MultiLineString", "LinearRing",
* "Polygon", "MultiPolygon", or
* "GeometryCollection".
* @return {string}
*/
google.maps.Data.Geometry.prototype.getType = function() {};
/**
* A GeometryCollection contains a number of geometry objects. Any
* LatLng or LatLngLiteral objects are automatically
* converted to Data.Point geometry objects.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!Array}
* elements
* @implements {google.maps.Data.Geometry}
* @constructor
*/
google.maps.Data.GeometryCollection = function(elements) {};
/**
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
* @override
*/
google.maps.Data.GeometryCollection.prototype.forEachLatLng = function(
callback) {};
/**
* Returns an array of the contained geometry objects. A new array is returned
* each time getArray() is called.
* @return {!Array}
*/
google.maps.Data.GeometryCollection.prototype.getArray = function() {};
/**
* Returns the n-th contained geometry object.
* @param {number} n
* @return {!google.maps.Data.Geometry}
*/
google.maps.Data.GeometryCollection.prototype.getAt = function(n) {};
/**
* Returns the number of contained geometry objects.
* @return {number}
*/
google.maps.Data.GeometryCollection.prototype.getLength = function() {};
/**
* Returns the string "GeometryCollection".
* @return {string}
* @override
*/
google.maps.Data.GeometryCollection.prototype.getType = function() {};
/**
* A LineString geometry contains a number of LatLngs.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!Array} elements
* @implements {google.maps.Data.Geometry}
* @constructor
*/
google.maps.Data.LineString = function(elements) {};
/**
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
* @override
*/
google.maps.Data.LineString.prototype.forEachLatLng = function(callback) {};
/**
* Returns an array of the contained LatLngs. A new array is
* returned each time getArray() is called.
* @return {!Array}
*/
google.maps.Data.LineString.prototype.getArray = function() {};
/**
* Returns the n-th contained LatLng.
* @param {number} n
* @return {!google.maps.LatLng}
*/
google.maps.Data.LineString.prototype.getAt = function(n) {};
/**
* Returns the number of contained LatLngs.
* @return {number}
*/
google.maps.Data.LineString.prototype.getLength = function() {};
/**
* Returns the string "LineString".
* @return {string}
* @override
*/
google.maps.Data.LineString.prototype.getType = function() {};
/**
* A LinearRing geometry contains a number of LatLngs, representing
* a closed LineString. There is no need to make the first LatLng
* equal to the last LatLng. The LinearRing is closed implicitly.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!Array} elements
* @implements {google.maps.Data.Geometry}
* @constructor
*/
google.maps.Data.LinearRing = function(elements) {};
/**
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
* @override
*/
google.maps.Data.LinearRing.prototype.forEachLatLng = function(callback) {};
/**
* Returns an array of the contained LatLngs. A new array is
* returned each time getArray() is called.
* @return {!Array}
*/
google.maps.Data.LinearRing.prototype.getArray = function() {};
/**
* Returns the n-th contained LatLng.
* @param {number} n
* @return {!google.maps.LatLng}
*/
google.maps.Data.LinearRing.prototype.getAt = function(n) {};
/**
* Returns the number of contained LatLngs.
* @return {number}
*/
google.maps.Data.LinearRing.prototype.getLength = function() {};
/**
* Returns the string "LinearRing".
* @return {string}
* @override
*/
google.maps.Data.LinearRing.prototype.getType = function() {};
/**
* This object is passed to mouse event handlers on a Data object.
* @extends {google.maps.MapMouseEvent}
* @record
*/
google.maps.Data.MouseEvent = function() {};
/**
* The feature which generated the mouse event.
* @type {!google.maps.Data.Feature}
*/
google.maps.Data.MouseEvent.prototype.feature;
/**
* A MultiLineString geometry contains a number of LineStrings.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!Array>}
* elements
* @implements {google.maps.Data.Geometry}
* @constructor
*/
google.maps.Data.MultiLineString = function(elements) {};
/**
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
* @override
*/
google.maps.Data.MultiLineString.prototype.forEachLatLng = function(
callback) {};
/**
* Returns an array of the contained Data.LineStrings. A new array
* is returned each time getArray() is called.
* @return {!Array}
*/
google.maps.Data.MultiLineString.prototype.getArray = function() {};
/**
* Returns the n-th contained Data.LineString.
* @param {number} n
* @return {!google.maps.Data.LineString}
*/
google.maps.Data.MultiLineString.prototype.getAt = function(n) {};
/**
* Returns the number of contained Data.LineStrings.
* @return {number}
*/
google.maps.Data.MultiLineString.prototype.getLength = function() {};
/**
* Returns the string "MultiLineString".
* @return {string}
* @override
*/
google.maps.Data.MultiLineString.prototype.getType = function() {};
/**
* A MultiPoint geometry contains a number of LatLngs.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!Array} elements
* @implements {google.maps.Data.Geometry}
* @constructor
*/
google.maps.Data.MultiPoint = function(elements) {};
/**
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
* @override
*/
google.maps.Data.MultiPoint.prototype.forEachLatLng = function(callback) {};
/**
* Returns an array of the contained LatLngs. A new array is
* returned each time getArray() is called.
* @return {!Array}
*/
google.maps.Data.MultiPoint.prototype.getArray = function() {};
/**
* Returns the n-th contained LatLng.
* @param {number} n
* @return {!google.maps.LatLng}
*/
google.maps.Data.MultiPoint.prototype.getAt = function(n) {};
/**
* Returns the number of contained LatLngs.
* @return {number}
*/
google.maps.Data.MultiPoint.prototype.getLength = function() {};
/**
* Returns the string "MultiPoint".
* @return {string}
* @override
*/
google.maps.Data.MultiPoint.prototype.getType = function() {};
/**
* A MultiPolygon geometry contains a number of Data.Polygons.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!Array>>}
* elements
* @implements {google.maps.Data.Geometry}
* @constructor
*/
google.maps.Data.MultiPolygon = function(elements) {};
/**
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
* @override
*/
google.maps.Data.MultiPolygon.prototype.forEachLatLng = function(callback) {};
/**
* Returns an array of the contained Data.Polygons. A new array is
* returned each time getArray() is called.
* @return {!Array}
*/
google.maps.Data.MultiPolygon.prototype.getArray = function() {};
/**
* Returns the n-th contained Data.Polygon.
* @param {number} n
* @return {!google.maps.Data.Polygon}
*/
google.maps.Data.MultiPolygon.prototype.getAt = function(n) {};
/**
* Returns the number of contained Data.Polygons.
* @return {number}
*/
google.maps.Data.MultiPolygon.prototype.getLength = function() {};
/**
* Returns the string "MultiPolygon".
* @return {string}
* @override
*/
google.maps.Data.MultiPolygon.prototype.getType = function() {};
/**
* A Point geometry contains a single LatLng.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} latLng
* @implements {google.maps.Data.Geometry}
* @constructor
*/
google.maps.Data.Point = function(latLng) {};
/**
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
* @override
*/
google.maps.Data.Point.prototype.forEachLatLng = function(callback) {};
/**
* Returns the contained LatLng.
* @return {!google.maps.LatLng}
*/
google.maps.Data.Point.prototype.get = function() {};
/**
* Returns the string "Point".
* @return {string}
* @override
*/
google.maps.Data.Point.prototype.getType = function() {};
/**
* A Polygon geometry contains a number of Data.LinearRings. The
* first linear-ring must be the polygon exterior boundary and subsequent
* linear-rings must be interior boundaries, also known as holes. See the sample
* polygon with a hole.
*
* Access by calling `const {Data} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!Array>}
* elements
* @implements {google.maps.Data.Geometry}
* @constructor
*/
google.maps.Data.Polygon = function(elements) {};
/**
* @param {function(!google.maps.LatLng): void} callback
* @return {undefined}
* @override
*/
google.maps.Data.Polygon.prototype.forEachLatLng = function(callback) {};
/**
* Returns an array of the contained Data.LinearRings. A new array
* is returned each time getArray() is called.
* @return {!Array}
*/
google.maps.Data.Polygon.prototype.getArray = function() {};
/**
* Returns the n-th contained Data.LinearRing.
* @param {number} n
* @return {!google.maps.Data.LinearRing}
*/
google.maps.Data.Polygon.prototype.getAt = function(n) {};
/**
* Returns the number of contained Data.LinearRings.
* @return {number}
*/
google.maps.Data.Polygon.prototype.getLength = function() {};
/**
* Returns the string "Polygon".
* @return {string}
* @override
*/
google.maps.Data.Polygon.prototype.getType = function() {};
/**
* The properties of a removefeature event.
* @record
*/
google.maps.Data.RemoveFeatureEvent = function() {};
/**
* The feature that was removed from the FeatureCollection.
* @type {!google.maps.Data.Feature}
*/
google.maps.Data.RemoveFeatureEvent.prototype.feature;
/**
* The properties of a removeproperty event.
* @record
*/
google.maps.Data.RemovePropertyEvent = function() {};
/**
* The feature whose property was removed.
* @type {!google.maps.Data.Feature}
*/
google.maps.Data.RemovePropertyEvent.prototype.feature;
/**
* The property name.
* @type {string}
*/
google.maps.Data.RemovePropertyEvent.prototype.name;
/**
* The previous value.
* @type {*}
*/
google.maps.Data.RemovePropertyEvent.prototype.oldValue;
/**
* The properties of a setgeometry event.
* @record
*/
google.maps.Data.SetGeometryEvent = function() {};
/**
* The feature whose geometry was set.
* @type {!google.maps.Data.Feature}
*/
google.maps.Data.SetGeometryEvent.prototype.feature;
/**
* The new feature geometry.
* @type {!google.maps.Data.Geometry|undefined}
*/
google.maps.Data.SetGeometryEvent.prototype.newGeometry;
/**
* The previous feature geometry.
* @type {!google.maps.Data.Geometry|undefined}
*/
google.maps.Data.SetGeometryEvent.prototype.oldGeometry;
/**
* The properties of a setproperty event.
* @record
*/
google.maps.Data.SetPropertyEvent = function() {};
/**
* The feature whose property was set.
* @type {!google.maps.Data.Feature}
*/
google.maps.Data.SetPropertyEvent.prototype.feature;
/**
* The property name.
* @type {string}
*/
google.maps.Data.SetPropertyEvent.prototype.name;
/**
* The new value.
* @type {*}
*/
google.maps.Data.SetPropertyEvent.prototype.newValue;
/**
* The previous value. Will be undefined if the property was added.
* @type {*}
*/
google.maps.Data.SetPropertyEvent.prototype.oldValue;
/**
* These options specify the way a Feature should appear when displayed on a
* map.
* @record
*/
google.maps.Data.StyleOptions = function() {};
/**
* The animation to play when marker is added to a map. Only applies to point
* geometries.
* @type {!google.maps.Animation|undefined}
*/
google.maps.Data.StyleOptions.prototype.animation;
/**
* If true, the marker receives mouse and touch events.
* @default true
* @type {boolean|undefined}
*/
google.maps.Data.StyleOptions.prototype.clickable;
/**
* Mouse cursor to show on hover. Only applies to point geometries.
* @type {string|undefined}
*/
google.maps.Data.StyleOptions.prototype.cursor;
/**
* If true, the object can be dragged across the map and the
* underlying feature will have its geometry updated.
* @default false
* @type {boolean|undefined}
*/
google.maps.Data.StyleOptions.prototype.draggable;
/**
* If true, the object can be edited by dragging control points and
* the underlying feature will have its geometry updated. Only applies to
* LineString and Polygon geometries.
* @default false
* @type {boolean|undefined}
*/
google.maps.Data.StyleOptions.prototype.editable;
/**
* The fill color. All CSS3 colors are supported except for extended named
* colors. Only applies to polygon geometries.
* @type {string|undefined}
*/
google.maps.Data.StyleOptions.prototype.fillColor;
/**
* The fill opacity between 0.0 and 1.0. Only applies to polygon geometries.
* @type {number|undefined}
*/
google.maps.Data.StyleOptions.prototype.fillOpacity;
/**
* Icon for the foreground. If a string is provided, it is treated as though it
* were an Icon with the string as url. Only applies
* to point geometries.
* @type {string|!google.maps.Icon|!google.maps.Symbol|undefined}
*/
google.maps.Data.StyleOptions.prototype.icon;
/**
* The icons to be rendered along a polyline. Only applies to line geometries.
* @type {!Array|undefined}
*/
google.maps.Data.StyleOptions.prototype.icons;
/**
* Adds a label to the marker. The label can either be a string, or a
* MarkerLabel object. Only applies to point geometries.
* @type {string|!google.maps.MarkerLabel|undefined}
*/
google.maps.Data.StyleOptions.prototype.label;
/**
* The marker's opacity between 0.0 and 1.0. Only applies to point
* geometries.
* @type {number|undefined}
*/
google.maps.Data.StyleOptions.prototype.opacity;
/**
* Defines the image map used for hit detection. Only applies to point
* geometries.
* @type {!google.maps.MarkerShape|undefined}
*/
google.maps.Data.StyleOptions.prototype.shape;
/**
* The stroke color. All CSS3 colors are supported except for extended named
* colors. Only applies to line and polygon geometries.
* @type {string|undefined}
*/
google.maps.Data.StyleOptions.prototype.strokeColor;
/**
* The stroke opacity between 0.0 and 1.0. Only applies to line and polygon
* geometries.
* @type {number|undefined}
*/
google.maps.Data.StyleOptions.prototype.strokeOpacity;
/**
* The stroke width in pixels. Only applies to line and polygon geometries.
* @type {number|undefined}
*/
google.maps.Data.StyleOptions.prototype.strokeWeight;
/**
* Rollover text. Only applies to point geometries.
* @type {string|undefined}
*/
google.maps.Data.StyleOptions.prototype.title;
/**
* Whether the feature is visible.
* @default true
* @type {boolean|undefined}
*/
google.maps.Data.StyleOptions.prototype.visible;
/**
* All features are displayed on the map in order of their zIndex, with higher
* values displaying in front of features with lower values. Markers are always
* displayed in front of line-strings and polygons.
* @type {number|undefined}
*/
google.maps.Data.StyleOptions.prototype.zIndex;
/**
* @typedef {function(!google.maps.Data.Feature):
* !google.maps.Data.StyleOptions}
*/
google.maps.Data.StylingFunction;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* An interface representing a feature from a Dataset. The
* featureType of a DatasetFeature will always be
* FeatureType.DATASET.
* @extends {google.maps.Feature}
* @record
*/
google.maps.DatasetFeature = function() {};
/**
* Key-value mapping of the feature's attributes.
* @type {!ObjectDirectionsResult. Some fields in the leg
* may not be returned for all requests. Note that though this result is
* "JSON-like," it is not strictly JSON, as it directly and indirectly
* includes LatLng objects.
* @record
*/
google.maps.DirectionsLeg = function() {};
/**
* An estimated arrival time for this leg. Only applicable for TRANSIT requests.
* @type {!google.maps.Time|undefined}
*/
google.maps.DirectionsLeg.prototype.arrival_time;
/**
* An estimated departure time for this leg. Only applicable for TRANSIT
* requests.
* @type {!google.maps.Time|undefined}
*/
google.maps.DirectionsLeg.prototype.departure_time;
/**
* The total distance covered by this leg. This property may be undefined as the
* distance may be unknown.
* @type {!google.maps.Distance|undefined}
*/
google.maps.DirectionsLeg.prototype.distance;
/**
* The total duration of this leg. This property may be undefined
* as the duration may be unknown.
* @type {!google.maps.Duration|undefined}
*/
google.maps.DirectionsLeg.prototype.duration;
/**
* The total duration of this leg, taking into account the traffic conditions
* indicated by the trafficModel property. This property may be
* undefined as the duration may be unknown.
* @type {!google.maps.Duration|undefined}
*/
google.maps.DirectionsLeg.prototype.duration_in_traffic;
/**
* The address of the destination of this leg. This content is meant to be read
* as-is. Do not programmatically parse the formatted address.
* @type {string}
*/
google.maps.DirectionsLeg.prototype.end_address;
/**
* The DirectionsService calculates directions between locations by
* using the nearest transportation option (usually a road) at the start and end
* locations. end_location indicates the actual geocoded
* destination, which may be different than the end_location of the
* last step if, for example, the road is not near the destination of this leg.
* @type {!google.maps.LatLng}
*/
google.maps.DirectionsLeg.prototype.end_location;
/**
* The address of the origin of this leg. This content is meant to be read
* as-is. Do not programmatically parse the formatted address.
* @type {string}
*/
google.maps.DirectionsLeg.prototype.start_address;
/**
* The DirectionsService calculates directions between locations by
* using the nearest transportation option (usually a road) at the start and end
* locations. start_location indicates the actual geocoded origin,
* which may be different than the start_location of the first step
* if, for example, the road is not near the origin of this leg.
* @type {!google.maps.LatLng}
*/
google.maps.DirectionsLeg.prototype.start_location;
/**
* An array of DirectionsSteps, each of which contains information
* about the individual steps in this leg.
* @type {!Array}
*/
google.maps.DirectionsLeg.prototype.steps;
/**
* An array of non-stopover waypoints along this leg, which were specified in
* the original request. via_waypoints in alternative routes. points property to describe the polyline
* of a {@link google.maps.DirectionsStep}.
* @record
*/
google.maps.DirectionsPolyline = function() {};
/**
* An encoded
* polyline.
* @type {string}
*/
google.maps.DirectionsPolyline.prototype.points;
/**
* Renders directions obtained from the DirectionsService.
*
* Access by calling `const {DirectionsRenderer} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {google.maps.DirectionsRendererOptions=} opts
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.DirectionsRenderer = function(opts) {};
/**
* Returns the renderer's current set of directions.
* @return {google.maps.DirectionsResult}
*/
google.maps.DirectionsRenderer.prototype.getDirections = function() {};
/**
* Returns the map on which the DirectionsResult is rendered.
* @return {google.maps.Map}
*/
google.maps.DirectionsRenderer.prototype.getMap = function() {};
/**
* Returns the panel <div> in which the
* DirectionsResult is rendered.
* @return {?HTMLElement}
*/
google.maps.DirectionsRenderer.prototype.getPanel = function() {};
/**
* Returns the current (zero-based) route index in use by this
* DirectionsRenderer object.
* @return {number}
*/
google.maps.DirectionsRenderer.prototype.getRouteIndex = function() {};
/**
* Set the renderer to use the result from the DirectionsService.
* Setting a valid set of directions in this manner will display the directions
* on the renderer's designated map and panel.
* @param {google.maps.DirectionsResult} directions
* @return {undefined}
*/
google.maps.DirectionsRenderer.prototype.setDirections = function(
directions) {};
/**
* This method specifies the map on which directions will be rendered. Pass
* null to remove the directions from the map.
* @param {google.maps.Map} map
* @return {undefined}
*/
google.maps.DirectionsRenderer.prototype.setMap = function(map) {};
/**
* Change the options settings of this DirectionsRenderer after
* initialization.
* @param {google.maps.DirectionsRendererOptions} options
* @return {undefined}
*/
google.maps.DirectionsRenderer.prototype.setOptions = function(options) {};
/**
* This method renders the directions in a <div>. Pass
* null to remove the content from the panel.
* @param {?HTMLElement} panel
* @return {undefined}
*/
google.maps.DirectionsRenderer.prototype.setPanel = function(panel) {};
/**
* Set the (zero-based) index of the route in the DirectionsResult
* object to render. By default, the first route in the array will be rendered.
* @param {number} routeIndex
* @return {undefined}
*/
google.maps.DirectionsRenderer.prototype.setRouteIndex = function(
routeIndex) {};
/**
* This object defines the properties that can be set on a
* DirectionsRenderer object.
* @record
*/
google.maps.DirectionsRendererOptions = function() {};
/**
* The directions to display on the map and/or in a <div>
* panel, retrieved as a DirectionsResult object from
* DirectionsService.
* @type {!google.maps.DirectionsResult|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.directions;
/**
* If true, allows the user to drag and modify the paths of routes
* rendered by this DirectionsRenderer.
* @type {boolean|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.draggable;
/**
* This property indicates whether the renderer should provide a user-selectable
* list of routes shown in the directions panel.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.hideRouteList;
/**
* The InfoWindow in which to render text information when a marker
* is clicked. Existing info window content will be overwritten and its position
* moved. If no info window is specified, the DirectionsRenderer
* will create and use its own info window. This property will be ignored if
* suppressInfoWindows is set to true.
* @type {!google.maps.InfoWindow|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.infoWindow;
/**
* Map on which to display the directions.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.map;
/**
* Options for the markers. All markers rendered by the
* DirectionsRenderer will use these options.
* @type {!google.maps.MarkerOptions|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.markerOptions;
/**
* The <div> in which to display the directions steps.
* @type {!HTMLElement|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.panel;
/**
* Options for the polylines. All polylines rendered by the
* DirectionsRenderer will use these options.
* @type {!google.maps.PolylineOptions|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.polylineOptions;
/**
* If this option is set to true or the map's center and zoom
* were never set, the input map is centered and zoomed to the bounding box of
* this set of directions.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.preserveViewport;
/**
* The index of the route within the DirectionsResult object. The
* default value is 0.
* @type {number|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.routeIndex;
/**
* Suppress the rendering of the BicyclingLayer when bicycling
* directions are requested.
* @type {boolean|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.suppressBicyclingLayer;
/**
* Suppress the rendering of info windows.
* @type {boolean|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.suppressInfoWindows;
/**
* Suppress the rendering of markers.
* @type {boolean|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.suppressMarkers;
/**
* Suppress the rendering of polylines.
* @type {boolean|null|undefined}
*/
google.maps.DirectionsRendererOptions.prototype.suppressPolylines;
/**
* A directions query to be sent to the DirectionsService.
* @record
*/
google.maps.DirectionsRequest = function() {};
/**
* If true, instructs the Directions service to avoid ferries where
* possible. Optional.
* @type {boolean|undefined}
*/
google.maps.DirectionsRequest.prototype.avoidFerries;
/**
* If true, instructs the Directions service to avoid highways
* where possible. Optional.
* @type {boolean|undefined}
*/
google.maps.DirectionsRequest.prototype.avoidHighways;
/**
* If true, instructs the Directions service to avoid toll roads
* where possible. Optional.
* @type {boolean|undefined}
*/
google.maps.DirectionsRequest.prototype.avoidTolls;
/**
* Location of destination. This can be specified as either a string to be
* geocoded, or a LatLng, or a Place. Required.
* @type {string|!google.maps.LatLng|!google.maps.Place|!google.maps.LatLngLiteral}
*/
google.maps.DirectionsRequest.prototype.destination;
/**
* Settings that apply only to requests where travelMode is
* DRIVING. This object will have no effect for other travel modes.
* @type {!google.maps.DrivingOptions|undefined}
*/
google.maps.DirectionsRequest.prototype.drivingOptions;
/**
* A language identifier for the language in which results should be returned,
* when possible. See the list of
* supported languages.
* @type {string|null|undefined}
*/
google.maps.DirectionsRequest.prototype.language;
/**
* If set to true, the DirectionsService will attempt
* to re-order the supplied intermediate waypoints to minimize overall cost of
* the route. If waypoints are optimized, inspect
* DirectionsRoute.waypoint_order in the response to determine the
* new ordering.
* @type {boolean|undefined}
*/
google.maps.DirectionsRequest.prototype.optimizeWaypoints;
/**
* Location of origin. This can be specified as either a string to be geocoded,
* or a LatLng, or a Place. Required.
* @type {string|!google.maps.LatLng|!google.maps.Place|!google.maps.LatLngLiteral}
*/
google.maps.DirectionsRequest.prototype.origin;
/**
* Whether or not route alternatives should be provided. Optional.
* @type {boolean|undefined}
*/
google.maps.DirectionsRequest.prototype.provideRouteAlternatives;
/**
* Region code used as a bias for geocoding requests. The region code accepts a
* ccTLD
* ("top-level domain") two-character value. Most ccTLD codes are
* identical to ISO 3166-1 codes, with some notable exceptions. For example, the
* United Kingdom's ccTLD is "uk" (.co.uk) while its
* ISO 3166-1 code is "gb" (technically for the entity of "The
* United Kingdom of Great Britain and Northern Ireland").
* @type {string|null|undefined}
*/
google.maps.DirectionsRequest.prototype.region;
/**
* Settings that apply only to requests where travelMode is
* TRANSIT. This object will have no effect for other travel modes.
* @type {!google.maps.TransitOptions|undefined}
*/
google.maps.DirectionsRequest.prototype.transitOptions;
/**
* Type of routing requested. Required.
* @type {!google.maps.TravelMode}
*/
google.maps.DirectionsRequest.prototype.travelMode;
/**
* Preferred unit system to use when displaying distance.
* @default The unit system used in the country of origin.
* @type {!google.maps.UnitSystem|undefined}
*/
google.maps.DirectionsRequest.prototype.unitSystem;
/**
* Array of intermediate waypoints. Directions are calculated from the origin to
* the destination by way of each waypoint in this array. See the
* developer's guide for the maximum number of waypoints allowed.
* Waypoints are not supported for transit directions. Optional.
* @type {!Array|undefined}
*/
google.maps.DirectionsRequest.prototype.waypoints;
/**
* The directions response retrieved from the directions server. You can render
* these using a {@link google.maps.DirectionsRenderer} or parse this object and
* render it yourself. You must display the warnings and copyrights as noted in
* the Google Maps
* Platform Terms of Service. Note that though this result is
* "JSON-like," it is not strictly JSON, as it indirectly includes
* LatLng objects.
* @record
*/
google.maps.DirectionsResult = function() {};
/**
* Contains an array of available travel modes. This field is returned when a
* request specifies a travel mode and gets no results. The array contains the
* available travel modes in the countries of the given set of waypoints. This
* field is not returned if one or more of the waypoints are 'via
* waypoints'.
* @type {!Array|undefined}
*/
google.maps.DirectionsResult.prototype.available_travel_modes;
/**
* An array of DirectionsGeocodedWaypoints, each of which contains
* information about the geocoding of origin, destination and waypoints.
* @type {!Array|undefined}
*/
google.maps.DirectionsResult.prototype.geocoded_waypoints;
/**
* The DirectionsRequest that yielded this result.
* @type {!google.maps.DirectionsRequest}
*/
google.maps.DirectionsResult.prototype.request;
/**
* An array of DirectionsRoutes, each of which contains information
* about the legs and steps of which it is composed. There will only be one
* route unless the DirectionsRequest was made with
* provideRouteAlternatives set to true.
* @type {!Array}
*/
google.maps.DirectionsResult.prototype.routes;
/**
* A single route containing a set of legs in a DirectionsResult. Note that though this
* object is "JSON-like," it is not strictly JSON, as it directly and
* indirectly includes LatLng objects.
* @record
*/
google.maps.DirectionsRoute = function() {};
/**
* The bounds for this route.
* @type {!google.maps.LatLngBounds}
*/
google.maps.DirectionsRoute.prototype.bounds;
/**
* Copyrights text to be displayed for this route.
* @type {string}
*/
google.maps.DirectionsRoute.prototype.copyrights;
/**
* The total fare for the whole transit trip. Only applicable to transit
* requests.
* @type {!google.maps.TransitFare|undefined}
*/
google.maps.DirectionsRoute.prototype.fare;
/**
* An array of DirectionsLegs, each of which contains information
* about the steps of which it is composed. There will be one leg for each
* stopover waypoint or destination specified. So a route with no stopover
* waypoints will contain one DirectionsLeg and a route with one
* stopover waypoint will contain two.
* @type {!Array}
*/
google.maps.DirectionsRoute.prototype.legs;
/**
* An array of LatLngs representing the entire course of this
* route. The path is simplified in order to make it suitable in contexts where
* a small number of vertices is required (such as Static Maps API URLs).
* @type {!Array}
*/
google.maps.DirectionsRoute.prototype.overview_path;
/**
* An encoded
* polyline representation of the route in overview_path. This polyline is
* an approximate (smoothed) path of the resulting directions.
* @type {string}
*/
google.maps.DirectionsRoute.prototype.overview_polyline;
/**
* Contains a short textual description for the route, suitable for naming and
* disambiguating the route from alternatives.
* @type {string}
*/
google.maps.DirectionsRoute.prototype.summary;
/**
* Warnings to be displayed when showing these directions.
* @type {!ArrayoptimizeWaypoints was set to true, this field
* will contain the re-ordered permutation of the input waypoints. For example,
* if the input was:
Origin: Los Angeles
* Waypoints: Dallas, Bangor, Phoenix
Destination:
* New York
and the optimized output was ordered as follows:
* Origin: Los Angeles
Waypoints: Phoenix, Dallas,
* Bangor
Destination: New York
then this field will be an
* Array containing the values [2, 0, 1]. Note that the numbering
* of waypoints is zero-based.
If any of the input waypoints has
* stopover set to false, this field will be empty,
* since route optimization is not available for such queries.
* @type {!ArrayDirectionsService on the completion
* of a call to route(). Specify these by value, or by using the
* constant's name. For example, 'OK' or
* google.maps.DirectionsStatus.OK.
*
* Access by calling `const {DirectionsStatus} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.DirectionsStatus = {
/**
* The DirectionsRequest provided was invalid.
*/
INVALID_REQUEST: 'INVALID_REQUEST',
/**
* Too many DirectionsWaypoints were provided in the
* DirectionsRequest. See the
* developer's guide for the maximum number of waypoints allowed.
*/
MAX_WAYPOINTS_EXCEEDED: 'MAX_WAYPOINTS_EXCEEDED',
/**
* At least one of the origin, destination, or waypoints could not be
* geocoded.
*/
NOT_FOUND: 'NOT_FOUND',
/**
* The response contains a valid DirectionsResult.
*/
OK: 'OK',
/**
* The webpage has gone over the requests limit in too short a period of time.
*/
OVER_QUERY_LIMIT: 'OVER_QUERY_LIMIT',
/**
* The webpage is not allowed to use the directions service.
*/
REQUEST_DENIED: 'REQUEST_DENIED',
/**
* A directions request could not be processed due to a server error. The
* request may succeed if you try again.
*/
UNKNOWN_ERROR: 'UNKNOWN_ERROR',
/**
* No route could be found between the origin and destination.
*/
ZERO_RESULTS: 'ZERO_RESULTS',
};
/**
* A single DirectionsStep in a DirectionsResult. Some
* fields may be undefined. Note that though this object is
* "JSON-like," it is not strictly JSON, as it directly includes
* LatLng objects.
* @record
*/
google.maps.DirectionsStep = function() {};
/**
* The distance covered by this step. This property may be
* undefined as the distance may be unknown.
* @type {!google.maps.Distance|undefined}
*/
google.maps.DirectionsStep.prototype.distance;
/**
* The typical time required to perform this step in seconds and in text form.
* This property may be undefined as the duration may be unknown.
* @type {!google.maps.Duration|undefined}
*/
google.maps.DirectionsStep.prototype.duration;
/**
* An encoded
* polyline representation of the step. This is an approximate (smoothed)
* path of the step.
* @type {string}
*/
google.maps.DirectionsStep.prototype.encoded_lat_lngs;
/**
* The ending location of this step.
* @type {!google.maps.LatLng}
*/
google.maps.DirectionsStep.prototype.end_location;
/**
* Instructions for this step.
* @type {string}
*/
google.maps.DirectionsStep.prototype.instructions;
/**
* Contains the action to take for the current step (turn-left,
* merge, straight, etc.). Values are subject to
* change, and new values may be introduced without prior notice.
* @type {string}
*/
google.maps.DirectionsStep.prototype.maneuver;
/**
* A sequence of LatLngs describing the course of this step. This
* is an approximate (smoothed) path of the step.
* @type {!Array}
*/
google.maps.DirectionsStep.prototype.path;
/**
* The starting location of this step.
* @type {!google.maps.LatLng}
*/
google.maps.DirectionsStep.prototype.start_location;
/**
* Sub-steps of this step. Specified for non-transit sections of transit routes.
* @type {!Array|undefined}
*/
google.maps.DirectionsStep.prototype.steps;
/**
* Transit-specific details about this step. This property will be undefined
* unless the travel mode of this step is TRANSIT.
* @type {!google.maps.TransitDetails|undefined}
*/
google.maps.DirectionsStep.prototype.transit;
/**
* Details pertaining to this step if the travel mode is TRANSIT.
* @type {!google.maps.TransitDetails|undefined}
*/
google.maps.DirectionsStep.prototype.transit_details;
/**
* The mode of travel used in this step.
* @type {!google.maps.TravelMode}
*/
google.maps.DirectionsStep.prototype.travel_mode;
/**
* The starting location of this step.
* @type {!google.maps.LatLng}
* @deprecated Please use {@link google.maps.DirectionsStep.start_location}.
*/
google.maps.DirectionsStep.prototype.start_point;
/**
* The ending location of this step.
* @type {!google.maps.LatLng}
* @deprecated Please use {@link google.maps.DirectionsStep.end_location}.
*/
google.maps.DirectionsStep.prototype.end_point;
/**
* A sequence of LatLngs describing the course of this step. This
* is an approximate (smoothed) path of the step.
* @type {!Array}
* @deprecated Please use {@link google.maps.DirectionsStep.path}.
*/
google.maps.DirectionsStep.prototype.lat_lngs;
/**
* Contains an object with a single property, 'points', that holds an encoded
* polyline representation of the step. This polyline is an approximate
* (smoothed) path of the step.
* @type {!google.maps.DirectionsPolyline|undefined}
* @deprecated Please use {@link google.maps.DirectionsStep.encoded_lat_lngs}.
*/
google.maps.DirectionsStep.prototype.polyline;
/**
* @enum {?}
* @deprecated Deprecated as of 2011. Use {\@link
* mapsapi.directions.service.directionsConstants.TravelMode} instead.
*/
google.maps.DirectionsTravelMode = {};
/**
* @enum {?}
* @deprecated Deprecated as of 2011. Use {\@link
* mapsapi.directions.service.directionsConstants.UnitSystem} instead.
*/
google.maps.DirectionsUnitSystem = {};
/**
* A DirectionsWaypoint represents a location between origin and
* destination through which the trip should be routed.
* @record
*/
google.maps.DirectionsWaypoint = function() {};
/**
* Waypoint location. Can be an address string, a LatLng, or a
* Place. Optional.
* @type {string|!google.maps.LatLng|!google.maps.LatLngLiteral|!google.maps.Place|undefined}
*/
google.maps.DirectionsWaypoint.prototype.location;
/**
* If true, indicates that this waypoint is a stop between the
* origin and destination. This has the effect of splitting the route into two
* legs. If false, indicates that the route should be biased to go
* through this waypoint, but not split into two legs. This is useful if you
* want to create a route in response to the user dragging waypoints on a map.
* @default true
* @type {boolean|undefined}
*/
google.maps.DirectionsWaypoint.prototype.stopover;
/**
* A representation of distance as a numeric value and a display string.
* @record
*/
google.maps.Distance = function() {};
/**
* A string representation of the distance value, using the
* UnitSystem specified in the request.
* @type {string}
*/
google.maps.Distance.prototype.text;
/**
* The distance in meters.
* @type {number}
*/
google.maps.Distance.prototype.value;
/**
* The element-level status about a particular origin-destination pairing
* returned by the DistanceMatrixService upon completion of a
* distance matrix request. These values are specified as strings, for example,
* 'OK'.
*
* Access by calling `const {DistanceMatrixElementStatus} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.DistanceMatrixElementStatus = {
/**
* The origin and/or destination of this pairing could not be geocoded.
*/
NOT_FOUND: 'NOT_FOUND',
/**
* The response contains a valid result.
*/
OK: 'OK',
/**
* No route could be found between the origin and destination.
*/
ZERO_RESULTS: 'ZERO_RESULTS',
};
/**
* A distance matrix query sent by the DistanceMatrixService
* containing arrays of origin and destination locations, and various options
* for computing metrics.
* @record
*/
google.maps.DistanceMatrixRequest = function() {};
/**
* If true, instructs the Distance Matrix service to avoid ferries
* where possible. Optional.
* @type {boolean|undefined}
*/
google.maps.DistanceMatrixRequest.prototype.avoidFerries;
/**
* If true, instructs the Distance Matrix service to avoid highways
* where possible. Optional.
* @type {boolean|undefined}
*/
google.maps.DistanceMatrixRequest.prototype.avoidHighways;
/**
* If true, instructs the Distance Matrix service to avoid toll
* roads where possible. Optional.
* @type {boolean|undefined}
*/
google.maps.DistanceMatrixRequest.prototype.avoidTolls;
/**
* An array containing destination address strings, or LatLng, or
* Place objects, to which to calculate distance and time.
* Required.
* @type {!ArraytravelMode is
* DRIVING. This object will have no effect for other travel modes.
* @type {!google.maps.DrivingOptions|undefined}
*/
google.maps.DistanceMatrixRequest.prototype.drivingOptions;
/**
* A language identifier for the language in which results should be returned,
* when possible. See the list of
* supported languages.
* @type {string|null|undefined}
*/
google.maps.DistanceMatrixRequest.prototype.language;
/**
* An array containing origin address strings, or LatLng, or
* Place objects, from which to calculate distance and time.
* Required.
* @type {!Array.co.uk) while its
* ISO 3166-1 code is "gb" (technically for the entity of "The
* United Kingdom of Great Britain and Northern Ireland").
* @type {string|null|undefined}
*/
google.maps.DistanceMatrixRequest.prototype.region;
/**
* Settings that apply only to requests where travelMode is
* TRANSIT. This object will have no effect for other travel modes.
* @type {!google.maps.TransitOptions|undefined}
*/
google.maps.DistanceMatrixRequest.prototype.transitOptions;
/**
* Type of routing requested. Required.
* @type {!google.maps.TravelMode}
*/
google.maps.DistanceMatrixRequest.prototype.travelMode;
/**
* Preferred unit system to use when displaying distance. Optional; defaults to
* metric.
* @type {!google.maps.UnitSystem|undefined}
*/
google.maps.DistanceMatrixRequest.prototype.unitSystem;
/**
* The response to a DistanceMatrixService request, consisting of
* the formatted origin and destination addresses, and a sequence of
* DistanceMatrixResponseRows, one for each corresponding origin
* address.
* @record
*/
google.maps.DistanceMatrixResponse = function() {};
/**
* The formatted destination addresses.
* @type {!ArrayDistanceMatrixService
* request, which contains the duration and distance from one origin to one
* destination.
* @record
*/
google.maps.DistanceMatrixResponseElement = function() {};
/**
* The distance for this origin-destination pairing. This property may be
* undefined as the distance may be unknown.
* @type {!google.maps.Distance}
*/
google.maps.DistanceMatrixResponseElement.prototype.distance;
/**
* The duration for this origin-destination pairing. This property may be
* undefined as the duration may be unknown.
* @type {!google.maps.Duration}
*/
google.maps.DistanceMatrixResponseElement.prototype.duration;
/**
* The duration for this origin-destination pairing, taking into account the
* traffic conditions indicated by the trafficModel property. This
* property may be undefined as the duration may be unknown. Only
* available to Premium Plan customers when drivingOptions is
* defined when making the request.
* @type {!google.maps.Duration}
*/
google.maps.DistanceMatrixResponseElement.prototype.duration_in_traffic;
/**
* The total fare for this origin-destination pairing. Only applicable to
* transit requests.
* @type {!google.maps.TransitFare}
*/
google.maps.DistanceMatrixResponseElement.prototype.fare;
/**
* The status of this particular origin-destination pairing.
* @type {!google.maps.DistanceMatrixElementStatus}
*/
google.maps.DistanceMatrixResponseElement.prototype.status;
/**
* A row of the response to a DistanceMatrixService request,
* consisting of a sequence of DistanceMatrixResponseElements, one
* for each corresponding destination address.
* @record
*/
google.maps.DistanceMatrixResponseRow = function() {};
/**
* The row's elements, corresponding to the destination addresses.
* @type {!Array}
*/
google.maps.DistanceMatrixResponseRow.prototype.elements;
/**
* A service for computing distances between multiple origins and destinations.
*
* Access by calling `const {DistanceMatrixService} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.DistanceMatrixService = function() {};
/**
* Issues a distance matrix request.
* @param {!google.maps.DistanceMatrixRequest} request
* @param {(function(?google.maps.DistanceMatrixResponse,
* !google.maps.DistanceMatrixStatus): void)=} callback
* @return {!Promise}
*/
google.maps.DistanceMatrixService.prototype.getDistanceMatrix = function(
request, callback) {};
/**
* The top-level status about the request in general returned by the
* DistanceMatrixService upon completion of a distance matrix
* request. Specify these by value, or by using the constant's name. For
* example, 'OK' or
* google.maps.DistanceMatrixStatus.OK.
*
* Access by calling `const {DistanceMatrixStatus} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.DistanceMatrixStatus = {
/**
* The provided request was invalid.
*/
INVALID_REQUEST: 'INVALID_REQUEST',
/**
* The request contains more than 25 origins, or more than 25 destinations.
*/
MAX_DIMENSIONS_EXCEEDED: 'MAX_DIMENSIONS_EXCEEDED',
/**
* The product of origins and destinations exceeds the per-query limit.
*/
MAX_ELEMENTS_EXCEEDED: 'MAX_ELEMENTS_EXCEEDED',
/**
* The response contains a valid result.
*/
OK: 'OK',
/**
* Too many elements have been requested within the allowed time period. The
* request should succeed if you try again after some time.
*/
OVER_QUERY_LIMIT: 'OVER_QUERY_LIMIT',
/**
* The service denied use of the Distance Matrix service by your web page.
*/
REQUEST_DENIED: 'REQUEST_DENIED',
/**
* A Distance Matrix request could not be processed due to a server error. The
* request may succeed if you try again.
*/
UNKNOWN_ERROR: 'UNKNOWN_ERROR',
};
/**
* @record
*/
google.maps.DrawingLibrary = function() {};
/**
* @type {typeof google.maps.drawing.DrawingManager}
*/
google.maps.DrawingLibrary.prototype.DrawingManager;
/**
* @type {typeof google.maps.drawing.OverlayType}
*/
google.maps.DrawingLibrary.prototype.OverlayType;
/**
* Configures the DirectionsRequest when the travel mode
* is set to DRIVING.
* @record
*/
google.maps.DrivingOptions = function() {};
/**
* The desired departure time for the route, specified as a Date
* object. The Date object measures time in milliseconds since 1
* January 1970. This must be specified for a DrivingOptions to be
* valid. The departure time must be set to the current time or some time in the
* future. It cannot be in the past.
* @type {!Date}
*/
google.maps.DrivingOptions.prototype.departureTime;
/**
* The preferred assumption to use when predicting duration in traffic. The
* default is BEST_GUESS.
* @type {!google.maps.TrafficModel|undefined}
*/
google.maps.DrivingOptions.prototype.trafficModel;
/**
* A representation of duration as a numeric value and a display string.
* @record
*/
google.maps.Duration = function() {};
/**
* A string representation of the duration value.
* @type {string}
*/
google.maps.Duration.prototype.text;
/**
* The duration in seconds.
* @type {number}
*/
google.maps.Duration.prototype.value;
/**
* @record
*/
google.maps.ElevationLibrary = function() {};
/**
* @type {typeof google.maps.ElevationService}
*/
google.maps.ElevationLibrary.prototype.ElevationService;
/**
* @type {typeof google.maps.ElevationStatus}
*/
google.maps.ElevationLibrary.prototype.ElevationStatus;
/**
* The result of an ElevationService request, consisting of the set
* of elevation coordinates and their elevation values. Note that a single
* request may produce multiple ElevationResults.
* @record
*/
google.maps.ElevationResult = function() {};
/**
* The elevation of this point on Earth, in meters above sea level.
* @type {number}
*/
google.maps.ElevationResult.prototype.elevation;
/**
* The location of this elevation result.
* @type {!google.maps.LatLng|null}
*/
google.maps.ElevationResult.prototype.location;
/**
* The distance, in meters, between sample points from which the elevation was
* interpolated. This property will be missing if the resolution is not known.
* Note that elevation data becomes more coarse (larger resolution
* values) when multiple points are passed. To obtain the most accurate
* elevation value for a point, it should be queried independently.
* @type {number}
*/
google.maps.ElevationResult.prototype.resolution;
/**
* Defines a service class that talks directly to Google servers for requesting
* elevation data.
*
* Access by calling `const {ElevationService} = await
* google.maps.importLibrary("elevation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.ElevationService = function() {};
/**
* Makes an elevation request along a path, where the elevation data are
* returned as distance-based samples along that path.
* @param {!google.maps.PathElevationRequest} request
* @param {(function((!Array|null),
* !google.maps.ElevationStatus): void)=} callback
* @return {!Promise}
*/
google.maps.ElevationService.prototype.getElevationAlongPath = function(
request, callback) {};
/**
* Makes an elevation request for a list of discrete locations.
* @param {!google.maps.LocationElevationRequest} request
* @param {(function((!Array|null),
* !google.maps.ElevationStatus): void)=} callback
* @return {!Promise}
*/
google.maps.ElevationService.prototype.getElevationForLocations = function(
request, callback) {};
/**
* The status returned by the ElevationService upon completion of
* an elevation request. Specify these by value, or by using the constant's
* name. For example, 'OK' or
* google.maps.ElevationStatus.OK.
*
* Access by calling `const {ElevationStatus} = await
* google.maps.importLibrary("elevation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.ElevationStatus = {
/**
* The request was invalid.
*/
INVALID_REQUEST: 'INVALID_REQUEST',
/**
* The request did not encounter any errors.
*/
OK: 'OK',
/**
* The webpage has gone over the requests limit in too short a period of time.
*/
OVER_QUERY_LIMIT: 'OVER_QUERY_LIMIT',
/**
* The webpage is not allowed to use the elevation service.
*/
REQUEST_DENIED: 'REQUEST_DENIED',
/**
* The elevation request could not be successfully processed, yet the exact
* reason for the failure is not known.
*/
UNKNOWN_ERROR: 'UNKNOWN_ERROR',
};
/**
* An event with an associated Error.
* @record
*/
google.maps.ErrorEvent = function() {};
/**
* The Error related to the event.
* @type {!Error}
*/
google.maps.ErrorEvent.prototype.error;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* Extra computations to perform while completing a geocoding request.
*
* Access by calling `const {ExtraGeocodeComputation} = await
* google.maps.importLibrary("geocoding")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.ExtraGeocodeComputation = {
/**
* Generate an address descriptor.
*/
ADDRESS_DESCRIPTORS: 'ADDRESS_DESCRIPTORS',
};
/**
* An interface representing a vector map tile feature. These are inputs to the
* FeatureStyleFunction. Do not save a reference to a particular
* Feature object because the reference will not be stable.
* @record
*/
google.maps.Feature = function() {};
/**
* FeatureType of this Feature.
* @type {!google.maps.FeatureType}
*/
google.maps.Feature.prototype.featureType;
/**
* An interface representing a map layer containing features of a
* specific {@link google.maps.FeatureType} whose style can be overridden
* client-side, or have events attached.
* @record
*/
google.maps.FeatureLayer = function() {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* The Dataset ID for this FeatureLayer. Only present if the
* featureType is FeatureType.DATASET.
* @type {string|undefined}
*/
google.maps.FeatureLayer.prototype.datasetId;
/**
* The FeatureType associated with this FeatureLayer.
* @type {!google.maps.FeatureType}
*/
google.maps.FeatureLayer.prototype.featureType;
/**
* Whether this FeatureLayer is available, meaning whether
* Data-driven styling is available for this map (there is a map ID using vector
* tiles with this FeatureLayer enabled in the Google Cloud Console
* map style.) If this is false (or becomes false), styling on this
* FeatureLayer returns to default and events are not triggered.
* @type {boolean}
*/
google.maps.FeatureLayer.prototype.isAvailable;
/**
* The style of Features in the FeatureLayer. The
* style is applied when style is set. If your style function updates, you must
* set the style property again. A FeatureStyleFunction must return
* consistent results when it is applied over the map tiles, and should be
* optimized for performance. Asynchronous functions are not supported. If you
* use a FeatureStyleOptions, all features of that layer will be
* styled with the same FeatureStyleOptions. Set the style to
* null to remove the previously set style. If this
* FeatureLayer is not available, setting style does nothing and
* logs an error.
* @type {google.maps.FeatureStyleOptions|google.maps.FeatureStyleFunction|null|undefined}
*/
google.maps.FeatureLayer.prototype.style;
/**
* Adds the given listener function to the given event name. Returns an
* identifier for this listener that can be used with {@link
* google.maps.event.removeListener}.
* @param {string} eventName Observed event.
* @param {!Function} handler Function to handle events.
* @return {!google.maps.MapsEventListener} Resulting event listener.
*/
google.maps.FeatureLayer.prototype.addListener = function(
eventName, handler) {};
/**
* This object is returned from a mouse event on a FeatureLayer.
* @extends {google.maps.MapMouseEvent}
* @record
*/
google.maps.FeatureMouseEvent = function() {};
/**
* The Features at this mouse event.
* @type {!Array}
*/
google.maps.FeatureMouseEvent.prototype.features;
/**
* @typedef {function(!google.maps.FeatureStyleFunctionOptions):
* (google.maps.FeatureStyleOptions|null|undefined)}
*/
google.maps.FeatureStyleFunction;
/**
* Options passed to a FeatureStyleFunction.
* @record
*/
google.maps.FeatureStyleFunctionOptions = function() {};
/**
* Feature passed into the FeatureStyleFunction for
* styling.
* @type {!google.maps.Feature}
*/
google.maps.FeatureStyleFunctionOptions.prototype.feature;
/**
* These options specify the way the style of a Feature should be
* modified on a map.
* @record
*/
google.maps.FeatureStyleOptions = function() {};
/**
* Hex RGB string (like "#00FF00" for green). Only applies to polygon
* geometries.
* @type {string|undefined}
*/
google.maps.FeatureStyleOptions.prototype.fillColor;
/**
* The fill opacity between 0.0 and 1.0. Only applies to polygon geometries.
* @type {number|undefined}
*/
google.maps.FeatureStyleOptions.prototype.fillOpacity;
/**
* Hex RGB string (like "#00FF00" for green).
* @type {string|undefined}
*/
google.maps.FeatureStyleOptions.prototype.strokeColor;
/**
* The stroke opacity between 0.0 and 1.0. Only applies to line and polygon
* geometries.
* @type {number|undefined}
*/
google.maps.FeatureStyleOptions.prototype.strokeOpacity;
/**
* The stroke width in pixels. Only applies to line and polygon geometries.
* @type {number|undefined}
*/
google.maps.FeatureStyleOptions.prototype.strokeWeight;
/**
* Identifiers for feature types.
*
* Access by calling `const {FeatureType} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.FeatureType = {
/**
* Indicates a first-order civil entity below the country level.
*/
ADMINISTRATIVE_AREA_LEVEL_1: 'ADMINISTRATIVE_AREA_LEVEL_1',
/**
* Indicates a second-order civil entity below the country level.
*/
ADMINISTRATIVE_AREA_LEVEL_2: 'ADMINISTRATIVE_AREA_LEVEL_2',
/**
* Indicates the national political entity.
*/
COUNTRY: 'COUNTRY',
/**
* Indicates a third-party dataset.
*/
DATASET: 'DATASET',
/**
* Indicates an incorporated city or town political entity.
*/
LOCALITY: 'LOCALITY',
/**
* Indicates a postal code as used to address postal mail within the country.
* Includes zip codes.
*/
POSTAL_CODE: 'POSTAL_CODE',
/**
* Indicates a school district.
*/
SCHOOL_DISTRICT: 'SCHOOL_DISTRICT',
};
/**
* Options for the rendering of the fullscreen control.
* @record
*/
google.maps.FullscreenControlOptions = function() {};
/**
* Position id. Used to specify the position of the control on the map.
* @default {@link google.maps.ControlPosition.INLINE_END_BLOCK_START}
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.FullscreenControlOptions.prototype.position;
/**
* A service for converting between an address and a LatLng.
*
* Access by calling `const {Geocoder} = await
* google.maps.importLibrary("geocoding")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.Geocoder = function() {};
/**
* Geocode a request.
* @param {!google.maps.GeocoderRequest} request
* @param {((function((!Array|null),
* !google.maps.GeocoderStatus): void)|null)=} callback
* @return {!Promise}
*/
google.maps.Geocoder.prototype.geocode = function(request, callback) {};
/**
* A single address component within a GeocoderResult. A full
* address may consist of multiple address components.
* @record
*/
google.maps.GeocoderAddressComponent = function() {};
/**
* The full text of the address component
* @type {string}
*/
google.maps.GeocoderAddressComponent.prototype.long_name;
/**
* The abbreviated, short text of the given address component
* @type {string}
*/
google.maps.GeocoderAddressComponent.prototype.short_name;
/**
* An array of strings denoting the type of this address component. A list of
* valid types can be found here
* @type {!ArrayGeocoderComponentRestrictions represents a set of filters that
* resolve to a specific area. For details on how this works, see
* Geocoding Component Filtering.
* @record
*/
google.maps.GeocoderComponentRestrictions = function() {};
/**
* Matches all the administrative_area levels. Optional.
* @type {string|undefined}
*/
google.maps.GeocoderComponentRestrictions.prototype.administrativeArea;
/**
* Matches a country name or a two letter ISO 3166-1 country code. Optional.
* @type {string|undefined}
*/
google.maps.GeocoderComponentRestrictions.prototype.country;
/**
* Matches against both locality and sublocality
* types. Optional.
* @type {string|undefined}
*/
google.maps.GeocoderComponentRestrictions.prototype.locality;
/**
* Matches postal_code and postal_code_prefix.
* Optional.
* @type {string|undefined}
*/
google.maps.GeocoderComponentRestrictions.prototype.postalCode;
/**
* Matches the long or short name of a route. Optional.
* @type {string|undefined}
*/
google.maps.GeocoderComponentRestrictions.prototype.route;
/**
* Geometry information about this GeocoderResult
* @record
*/
google.maps.GeocoderGeometry = function() {};
/**
* The precise bounds of this GeocoderResult, if applicable
* @type {!google.maps.LatLngBounds|undefined}
*/
google.maps.GeocoderGeometry.prototype.bounds;
/**
* The latitude/longitude coordinates of this result
* @type {!google.maps.LatLng}
*/
google.maps.GeocoderGeometry.prototype.location;
/**
* The type of location returned in location
* @type {!google.maps.GeocoderLocationType}
*/
google.maps.GeocoderGeometry.prototype.location_type;
/**
* The bounds of the recommended viewport for displaying this
* GeocoderResult
* @type {!google.maps.LatLngBounds}
*/
google.maps.GeocoderGeometry.prototype.viewport;
/**
* Describes the type of location returned from a geocode. Specify these by
* value, or by using the constant's name. For example,
* 'ROOFTOP' or
* google.maps.GeocoderLocationType.ROOFTOP.
*
* Access by calling `const {GeocoderLocationType} = await
* google.maps.importLibrary("geocoding")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.GeocoderLocationType = {
/**
* The returned result is approximate.
*/
APPROXIMATE: 'APPROXIMATE',
/**
* The returned result is the geometric center of a result such a line (e.g.
* street) or polygon (region).
*/
GEOMETRIC_CENTER: 'GEOMETRIC_CENTER',
/**
* The returned result reflects an approximation (usually on a road)
* interpolated between two precise points (such as intersections).
* Interpolated results are generally returned when rooftop geocodes are
* unavailable for a street address.
*/
RANGE_INTERPOLATED: 'RANGE_INTERPOLATED',
/**
* The returned result reflects a precise geocode.
*/
ROOFTOP: 'ROOFTOP',
};
/**
* The specification for a geocoding request to be sent to the
* Geocoder.
* @record
*/
google.maps.GeocoderRequest = function() {};
/**
* Address to geocode. One, and only one, of address,
* location and placeId must be supplied.
* @type {string|null|undefined}
*/
google.maps.GeocoderRequest.prototype.address;
/**
* LatLngBounds within which to search. Optional.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.GeocoderRequest.prototype.bounds;
/**
* Components are used to restrict results to a specific area. A filter consists
* of one or more of: route, locality,
* administrativeArea, postalCode,
* country. Only the results that match all the filters will be
* returned. Filter values support the same methods of spelling correction and
* partial matching as other geocoding requests. Optional.
* @type {!google.maps.GeocoderComponentRestrictions|null|undefined}
*/
google.maps.GeocoderRequest.prototype.componentRestrictions;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* A list of extra computations which may be used to complete the request. Note:
* These extra computations may return extra fields on the response.
* @type {!Array|undefined}
*/
google.maps.GeocoderRequest.prototype.extraComputations;
/**
* Fulfill the promise on a ZERO_RESULT status in the response. This may be
* desired because even with zero geocoding results there may still be
* additional response level fields returned.
* @type {boolean|null|undefined}
*/
google.maps.GeocoderRequest.prototype.fulfillOnZeroResults;
/**
* A language identifier for the language in which results should be returned,
* when possible. See the list of
* supported languages.
* @type {string|null|undefined}
*/
google.maps.GeocoderRequest.prototype.language;
/**
* LatLng (or LatLngLiteral) for which to search. The
* geocoder performs a reverse geocode. See
* Reverse Geocoding for more information. One, and only one, of
* address, location and placeId must be
* supplied.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.GeocoderRequest.prototype.location;
/**
* The place ID associated with the location. Place IDs uniquely identify a
* place in the Google Places database and on Google Maps. Learn more about place
* IDs in the Places API developer guide. The geocoder performs a reverse
* geocode. See Reverse
* Geocoding for more information. One, and only one, of
* address, location and placeId must be
* supplied.
* @type {string|null|undefined}
*/
google.maps.GeocoderRequest.prototype.placeId;
/**
* Country code used to bias the search, specified as a two-character
* (non-numeric) Unicode region subtag / CLDR identifier. Optional. See Google Maps Platform
* Coverage Details for supported regions.
* @type {string|null|undefined}
*/
google.maps.GeocoderRequest.prototype.region;
/**
* A Geocoder response returned by the {@link google.maps.Geocoder} containing
* the list of {@link google.maps.GeocoderResult}s.
* @record
*/
google.maps.GeocoderResponse = function() {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* A relational description of a location. Includes a ranked set of nearby
* landmarks and the areas containing the target location. It is only populated
* for reverse geocoding requests and only when {@link
* google.maps.ExtraGeocodeComputation.ADDRESS_DESCRIPTORS} is enabled.
* @type {!google.maps.AddressDescriptor|null|undefined}
*/
google.maps.GeocoderResponse.prototype.address_descriptor;
/**
* The plus code associated with the location.
* @type {!google.maps.places.PlacePlusCode|null|undefined}
*/
google.maps.GeocoderResponse.prototype.plus_code;
/**
* The list of {@link google.maps.GeocoderResult}s.
* @type {!Array}
*/
google.maps.GeocoderResponse.prototype.results;
/**
* A single geocoder result retrieved from the geocode server. A geocode request
* may return multiple result objects. Note that though this result is
* "JSON-like," it is not strictly JSON, as it indirectly includes a
* LatLng object.
* @record
*/
google.maps.GeocoderResult = function() {};
/**
* An array of GeocoderAddressComponents
* @type {!Array}
*/
google.maps.GeocoderResult.prototype.address_components;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* A relational description of the location associated with this geocode.
* Includes a ranked set of nearby landmarks and the areas containing the target
* location. This will only be populated for forward geocoding and place ID
* lookup requests, only when {@link
* google.maps.ExtraGeocodeComputation.ADDRESS_DESCRIPTORS} is enabled, and only
* for certain localized places.
* @type {!google.maps.AddressDescriptor|undefined}
*/
google.maps.GeocoderResult.prototype.address_descriptor;
/**
* A string containing the human-readable address of this location.
* @type {string}
*/
google.maps.GeocoderResult.prototype.formatted_address;
/**
* A GeocoderGeometry object
* @type {!google.maps.GeocoderGeometry}
*/
google.maps.GeocoderResult.prototype.geometry;
/**
* Whether the geocoder did not return an exact match for the original request,
* though it was able to match part of the requested address. If an exact match,
* the value will be undefined.
* @type {boolean|undefined}
*/
google.maps.GeocoderResult.prototype.partial_match;
/**
* The place ID associated with the location. Place IDs uniquely identify a
* place in the Google Places database and on Google Maps. Learn more about Place
* IDs in the Places API developer guide.
* @type {string}
*/
google.maps.GeocoderResult.prototype.place_id;
/**
* The plus code associated with the location.
* @type {!google.maps.places.PlacePlusCode|undefined}
*/
google.maps.GeocoderResult.prototype.plus_code;
/**
* An array of strings denoting all the localities contained in a postal code.
* This is only present when the result is a postal code that contains multiple
* localities.
* @type {!ArrayGeocoder on the completion of a call
* to geocode(). Specify these by value, or by using the
* constant's name. For example, 'OK' or
* google.maps.GeocoderStatus.OK.
*
* Access by calling `const {GeocoderStatus} = await
* google.maps.importLibrary("geocoding")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.GeocoderStatus = {
/**
* There was a problem contacting the Google servers.
*/
ERROR: 'ERROR',
/**
* This GeocoderRequest was invalid.
*/
INVALID_REQUEST: 'INVALID_REQUEST',
/**
* The response contains a valid GeocoderResponse.
*/
OK: 'OK',
/**
* The webpage has gone over the requests limit in too short a period of time.
*/
OVER_QUERY_LIMIT: 'OVER_QUERY_LIMIT',
/**
* The webpage is not allowed to use the geocoder.
*/
REQUEST_DENIED: 'REQUEST_DENIED',
/**
* A geocoding request could not be processed due to a server error. The
* request may succeed if you try again.
*/
UNKNOWN_ERROR: 'UNKNOWN_ERROR',
/**
* No result was found for this GeocoderRequest.
*/
ZERO_RESULTS: 'ZERO_RESULTS',
};
/**
* @record
*/
google.maps.GeocodingLibrary = function() {};
/**
* @type {typeof google.maps.Containment}
*/
google.maps.GeocodingLibrary.prototype.Containment;
/**
* @type {typeof google.maps.ExtraGeocodeComputation}
*/
google.maps.GeocodingLibrary.prototype.ExtraGeocodeComputation;
/**
* @type {typeof google.maps.Geocoder}
*/
google.maps.GeocodingLibrary.prototype.Geocoder;
/**
* @type {typeof google.maps.GeocoderLocationType}
*/
google.maps.GeocodingLibrary.prototype.GeocoderLocationType;
/**
* @type {typeof google.maps.GeocoderStatus}
*/
google.maps.GeocodingLibrary.prototype.GeocoderStatus;
/**
* @type {typeof google.maps.SpatialRelationship}
*/
google.maps.GeocodingLibrary.prototype.SpatialRelationship;
/**
* @record
*/
google.maps.GeometryLibrary = function() {};
/**
* @type {typeof google.maps.geometry.encoding}
*/
google.maps.GeometryLibrary.prototype.encoding;
/**
* @type {typeof google.maps.geometry.poly}
*/
google.maps.GeometryLibrary.prototype.poly;
/**
* @type {typeof google.maps.geometry.spherical}
*/
google.maps.GeometryLibrary.prototype.spherical;
/**
* A rectangular image overlay on the map.
*
* Access by calling `const {GroundOverlay} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {string} url
* @param {google.maps.LatLngBounds|google.maps.LatLngBoundsLiteral} bounds
* @param {google.maps.GroundOverlayOptions=} opts
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.GroundOverlay = function(url, bounds, opts) {};
/**
* Gets the LatLngBounds of this overlay.
* @return {google.maps.LatLngBounds}
*/
google.maps.GroundOverlay.prototype.getBounds = function() {};
/**
* Returns the map on which this ground overlay is displayed.
* @return {google.maps.Map}
*/
google.maps.GroundOverlay.prototype.getMap = function() {};
/**
* Returns the opacity of this ground overlay.
* @return {number}
*/
google.maps.GroundOverlay.prototype.getOpacity = function() {};
/**
* Gets the url of the projected image.
* @return {string}
*/
google.maps.GroundOverlay.prototype.getUrl = function() {};
/**
* Renders the ground overlay on the specified map. If map is set to
* null, the overlay is removed.
* @param {google.maps.Map} map
* @return {undefined}
*/
google.maps.GroundOverlay.prototype.setMap = function(map) {};
/**
* Sets the opacity of this ground overlay.
* @param {number} opacity
* @return {undefined}
*/
google.maps.GroundOverlay.prototype.setOpacity = function(opacity) {};
/**
* This object defines the properties that can be set on a
* GroundOverlay object.
* @record
*/
google.maps.GroundOverlayOptions = function() {};
/**
* If true, the ground overlay can receive mouse events.
* @type {boolean|null|undefined}
*/
google.maps.GroundOverlayOptions.prototype.clickable;
/**
* The map on which to display the overlay.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.GroundOverlayOptions.prototype.map;
/**
* The opacity of the overlay, expressed as a number between 0 and 1. Optional.
* @default 1.0
* @type {number|null|undefined}
*/
google.maps.GroundOverlayOptions.prototype.opacity;
/**
* A structure representing a Marker icon image.
* @record
*/
google.maps.Icon = function() {};
/**
* The position at which to anchor an image in correspondence to the location of
* the marker on the map. By default, the anchor is located along the center
* point of the bottom of the image.
* @type {!google.maps.Point|null|undefined}
*/
google.maps.Icon.prototype.anchor;
/**
* The origin of the label relative to the top-left corner of the icon image, if
* a label is supplied by the marker. By default, the origin is located in the
* center point of the image.
* @type {!google.maps.Point|null|undefined}
*/
google.maps.Icon.prototype.labelOrigin;
/**
* The position of the image within a sprite, if any. By default, the origin is
* located at the top left corner of the image (0, 0).
* @type {!google.maps.Point|null|undefined}
*/
google.maps.Icon.prototype.origin;
/**
* The size of the entire image after scaling, if any. Use this property to
* stretch/shrink an image or a sprite.
* @type {!google.maps.Size|null|undefined}
*/
google.maps.Icon.prototype.scaledSize;
/**
* The display size of the sprite or image. When using sprites, you must specify
* the sprite size. If the size is not provided, it will be set when the image
* loads.
* @type {!google.maps.Size|null|undefined}
*/
google.maps.Icon.prototype.size;
/**
* The URL of the image or sprite sheet.
* @type {string}
*/
google.maps.Icon.prototype.url;
/**
* This object is sent in an event when a user clicks on an icon on the map. The
* place ID of this place is stored in the placeId member. To prevent the
* default info window from showing up, call the stop() method on this event to
* prevent it being propagated. Learn more about place
* IDs in the Places API developer guide.
* @extends {google.maps.MapMouseEvent}
* @record
*/
google.maps.IconMouseEvent = function() {};
/**
* The place ID of the place that was clicked. This place ID can be used to
* query more information about the feature that was clicked.
If your polyline
* is geodesic, then the distances specified for both offset and repeat are
* calculated in meters by default. Setting either offset or repeat to a pixel
* value will cause the distances to be calculated in pixels on the screen.
* @record
*/
google.maps.IconSequence = function() {};
/**
* If true, each icon in the sequence has the same fixed rotation
* regardless of the angle of the edge on which it lies. If false,
* case each icon in the sequence is rotated to align with its edge.
* @default false
* @type {boolean|undefined}
*/
google.maps.IconSequence.prototype.fixedRotation;
/**
* The icon to render on the line.
* @type {!google.maps.Symbol|null|undefined}
*/
google.maps.IconSequence.prototype.icon;
/**
* The distance from the start of the line at which an icon is to be rendered.
* This distance may be expressed as a percentage of line's length (e.g.
* '50%') or in pixels (e.g. '50px').
* @default '100%'
* @type {string|undefined}
*/
google.maps.IconSequence.prototype.offset;
/**
* The distance between consecutive icons on the line. This distance may be
* expressed as a percentage of the line's length (e.g. '50%') or in
* pixels (e.g. '50px'). To disable repeating of the icon, specify
* '0'.
* @default 0
* @type {string|undefined}
*/
google.maps.IconSequence.prototype.repeat;
/**
* This class implements the MapType interface and is provided for rendering
* image tiles.
*
* Access by calling `const {ImageMapType} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {google.maps.ImageMapTypeOptions} opts
* @implements {google.maps.MapType}
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.ImageMapType = function(opts) {};
/**
* @type {?string}
*/
google.maps.ImageMapType.prototype.alt;
/**
* @type {number}
*/
google.maps.ImageMapType.prototype.maxZoom;
/**
* @type {number}
*/
google.maps.ImageMapType.prototype.minZoom;
/**
* @type {?string}
*/
google.maps.ImageMapType.prototype.name;
/**
* @type {google.maps.Projection}
*/
google.maps.ImageMapType.prototype.projection;
/**
* @type {number}
*/
google.maps.ImageMapType.prototype.radius;
/**
* @type {google.maps.Size}
*/
google.maps.ImageMapType.prototype.tileSize;
/**
* Returns the opacity level (0 (transparent) to 1.0)
* of the ImageMapType tiles.
* @return {number} opacity The current opacity.
*/
google.maps.ImageMapType.prototype.getOpacity = function() {};
/**
* @param {google.maps.Point} tileCoord Tile coordinates.
* @param {number} zoom Tile zoom.
* @param {Document} ownerDocument The document which owns this tile.
* @return {?Element} Resulting tile.
* @override
*/
google.maps.ImageMapType.prototype.getTile = function(
tileCoord, zoom, ownerDocument) {};
/**
* @param {?Element} tileDiv Tile to release.
* @return {undefined}
* @override
*/
google.maps.ImageMapType.prototype.releaseTile = function(tileDiv) {};
/**
* Sets the opacity level (0 (transparent) to 1.0) of
* the ImageMapType tiles.
* @param {number} opacity The new opacity.
* @return {undefined}
*/
google.maps.ImageMapType.prototype.setOpacity = function(opacity) {};
/**
* This class is used to create a MapType that renders image tiles.
* @record
*/
google.maps.ImageMapTypeOptions = function() {};
/**
* Alt text to display when this MapType's button is hovered over in the
* MapTypeControl.
* @type {string|null|undefined}
*/
google.maps.ImageMapTypeOptions.prototype.alt;
/**
* Returns a string (URL) for given tile coordinate (x, y) and zoom level.
* @type {(function(!google.maps.Point, number): (string|null))|null|undefined}
*/
google.maps.ImageMapTypeOptions.prototype.getTileUrl;
/**
* The maximum zoom level for the map when displaying this MapType.
* @type {number|null|undefined}
*/
google.maps.ImageMapTypeOptions.prototype.maxZoom;
/**
* The minimum zoom level for the map when displaying this MapType. Optional.
* @type {number|null|undefined}
*/
google.maps.ImageMapTypeOptions.prototype.minZoom;
/**
* Name to display in the MapTypeControl.
* @type {string|null|undefined}
*/
google.maps.ImageMapTypeOptions.prototype.name;
/**
* The opacity to apply to the tiles. The opacity should be specified as a float
* value between 0 and 1.0, where 0 is fully transparent and 1 is fully opaque.
* @type {number|null|undefined}
*/
google.maps.ImageMapTypeOptions.prototype.opacity;
/**
* The tile size.
* @type {!google.maps.Size|null|undefined}
*/
google.maps.ImageMapTypeOptions.prototype.tileSize;
/**
* An overlay that looks like a bubble and is often connected to a marker.
*
* Access by calling `const {InfoWindow} = await
* google.maps.importLibrary("maps")` or `const {InfoWindow} = await
* google.maps.importLibrary("streetView")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {(!google.maps.InfoWindowOptions|null)=} opts
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.InfoWindow = function(opts) {};
/**
* Checks if the InfoWindow is open.
* @type {boolean}
*/
google.maps.InfoWindow.prototype.isOpen;
/**
* Closes this InfoWindow by removing it from the DOM structure.
* @return {undefined}
*/
google.maps.InfoWindow.prototype.close = function() {};
/**
* Sets focus on this InfoWindow. You may wish to consider using
* this method along with a visible event to make sure that
* InfoWindow is visible before setting focus on it. An
* InfoWindow that is not visible cannot be focused.
* @return {undefined}
*/
google.maps.InfoWindow.prototype.focus = function() {};
/**
* @return {string|!Element|!Text|null|undefined} The content of this
* InfoWindow. The same as what was previously set as the content.
*/
google.maps.InfoWindow.prototype.getContent = function() {};
/**
* @return {string|!Element|!Text|null|undefined} The header content of this
* InfoWindow. See {@link google.maps.InfoWindowOptions.headerContent}.
*/
google.maps.InfoWindow.prototype.getHeaderContent = function() {};
/**
* @return {boolean|undefined} Whether the whole header row is disabled or not.
* See {@link google.maps.InfoWindowOptions.headerDisabled}.
*/
google.maps.InfoWindow.prototype.getHeaderDisabled = function() {};
/**
* @return {!google.maps.LatLng|null|undefined} The LatLng position of this
* InfoWindow.
*/
google.maps.InfoWindow.prototype.getPosition = function() {};
/**
* @return {number} The zIndex of this InfoWindow.
*/
google.maps.InfoWindow.prototype.getZIndex = function() {};
/**
* Opens this InfoWindow on the given map. Optionally, an InfoWindow can be
* associated with an anchor. In the core API, the only anchor is the Marker
* class. However, an anchor can be any MVCObject that exposes a LatLng
* position property and optionally a Point
* anchorPoint property for calculating the
* pixelOffset (see InfoWindowOptions). The
* anchorPoint is the offset from the anchor's position to the
* tip of the InfoWindow. It is recommended to use the {@link
* google.maps.InfoWindowOpenOptions} interface as the single argument for this
* method. To prevent changing browser focus on open, set {@link
* google.maps.InfoWindowOpenOptions.shouldFocus} to false.
* @param {(!google.maps.InfoWindowOpenOptions|!google.maps.Map|!google.maps.StreetViewPanorama|null)=}
* options Either an InfoWindowOpenOptions object (recommended) or the
* map|panorama on which to render this InfoWindow.
* @param {(!google.maps.MVCObject|!google.maps.marker.AdvancedMarkerElement|null)=}
* anchor The anchor to which this InfoWindow will be positioned. If the
* anchor is non-null, the InfoWindow will be positioned at the top-center
* of the anchor. The InfoWindow will be rendered on the same map or
* panorama as the anchor (when available).
* @return {undefined}
*/
google.maps.InfoWindow.prototype.open = function(options, anchor) {};
/**
* @param {(string|!Element|!Text|null)=} content The content to be displayed by
* this InfoWindow.
* @return {undefined}
*/
google.maps.InfoWindow.prototype.setContent = function(content) {};
/**
* @param {(string|!Element|!Text|null)=} headerContent The header content to be
* displayed by this InfoWindow. See {@link
* google.maps.InfoWindowOptions.headerContent}.
* @return {undefined}
*/
google.maps.InfoWindow.prototype.setHeaderContent = function(headerContent) {};
/**
* @param {(boolean|null)=} headerDisabled Specifies whether to disable the
* whole header row. See {@link
* google.maps.InfoWindowOptions.headerDisabled}.
* @return {undefined}
*/
google.maps.InfoWindow.prototype.setHeaderDisabled = function(
headerDisabled) {};
/**
* @param {(!google.maps.InfoWindowOptions|null)=} options
* @return {undefined}
*/
google.maps.InfoWindow.prototype.setOptions = function(options) {};
/**
* @param {(!google.maps.LatLng|!google.maps.LatLngLiteral|null)=} position The
* LatLng position at which to display this InfoWindow.
* @return {undefined}
*/
google.maps.InfoWindow.prototype.setPosition = function(position) {};
/**
* @param {number} zIndex The z-index for this InfoWindow. An InfoWindow with a
* greater z-index will be displayed in front of all other InfoWindows with
* a lower z-index.
* @return {undefined}
*/
google.maps.InfoWindow.prototype.setZIndex = function(zIndex) {};
/**
* Options for opening an InfoWindow
* @record
*/
google.maps.InfoWindowOpenOptions = function() {};
/**
* The anchor to which this InfoWindow will be positioned. If the anchor is
* non-null, the InfoWindow will be positioned at the top-center of the anchor.
* The InfoWindow will be rendered on the same map or panorama as the anchor
* (when available).
* @type {!google.maps.MVCObject|!google.maps.marker.AdvancedMarkerElement|null|undefined}
*/
google.maps.InfoWindowOpenOptions.prototype.anchor;
/**
* The map or panorama on which to render this InfoWindow.
* @type {!google.maps.Map|!google.maps.StreetViewPanorama|null|undefined}
*/
google.maps.InfoWindowOpenOptions.prototype.map;
/**
* Whether or not focus should be moved inside the InfoWindow when it is opened.
* When this property is unset or when it is set to null or
* undefined, a heuristic is used to decide whether or not focus
* should be moved. It is recommended to explicitly set this property to fit
* your needs as the heuristic is subject to change and may not work well for
* all use cases.
* @type {boolean|null|undefined}
*/
google.maps.InfoWindowOpenOptions.prototype.shouldFocus;
/**
* InfoWindowOptions object used to define the properties that can be set on a
* InfoWindow.
* @record
*/
google.maps.InfoWindowOptions = function() {};
/**
* AriaLabel to assign to the InfoWindow.
* @type {string|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.ariaLabel;
/**
* Content to display in the InfoWindow. This can be an HTML element, a
* plain-text string, or a string containing HTML. The InfoWindow will be sized
* according to the content. To set an explicit size for the content, set
* content to be a HTML element with that size.
* @type {string|!Element|!Text|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.content;
/**
* Disable panning the map to make the InfoWindow fully visible when it opens.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.disableAutoPan;
/**
* The content to display in the InfoWindow header row. This can be an HTML
* element, or a string of plain text. The InfoWindow will be sized according to
* the content. To set an explicit size for the header content, set
* headerContent to be a HTML element with that size.
* @type {string|!Element|!Text|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.headerContent;
/**
* Disables the whole header row in the InfoWindow. When set to true, the header
* will be removed so that the header content and the close button will be
* hidden.
* @type {boolean|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.headerDisabled;
/**
* Maximum width of the InfoWindow, regardless of content's width. This
* value is only considered if it is set before a call to open().
* To change the maximum width when changing content, call close(),
* setOptions(), and then open().
* @type {number|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.maxWidth;
/**
* Minimum width of the InfoWindow, regardless of the content's width. When
* using this property, it is strongly recommended to set the
* minWidth to a value less than the width of the map (in pixels).
* This value is only considered if it is set before a call to
* open(). To change the minimum width when changing content, call
* close(), setOptions(), and then
* open().
* @type {number|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.minWidth;
/**
* The offset, in pixels, of the tip of the info window from the point on the
* map at whose geographical coordinates the info window is anchored. If an
* InfoWindow is opened with an anchor, the pixelOffset will be
* calculated from the anchor's anchorPoint property.
* @type {!google.maps.Size|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.pixelOffset;
/**
* The LatLng at which to display this InfoWindow. If the InfoWindow is opened
* with an anchor, the anchor's position will be used instead.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.position;
/**
* All InfoWindows are displayed on the map in order of their zIndex, with
* higher values displaying in front of InfoWindows with lower values. By
* default, InfoWindows are displayed according to their latitude, with
* InfoWindows of lower latitudes appearing in front of InfoWindows at higher
* latitudes. InfoWindows are always displayed in front of markers.
* @type {number|null|undefined}
*/
google.maps.InfoWindowOptions.prototype.zIndex;
/**
* @record
*/
google.maps.JourneySharingLibrary = function() {};
/**
* @type {typeof google.maps.journeySharing.AutomaticViewportMode}
*/
google.maps.JourneySharingLibrary.prototype.AutomaticViewportMode;
/**
* @type {typeof google.maps.journeySharing.DeliveryVehicleStopState}
*/
google.maps.JourneySharingLibrary.prototype.DeliveryVehicleStopState;
/**
* @type {typeof
* google.maps.journeySharing.FleetEngineDeliveryFleetLocationProvider}
*/
google.maps.JourneySharingLibrary.prototype
.FleetEngineDeliveryFleetLocationProvider;
/**
* @type {typeof
* google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider}
*/
google.maps.JourneySharingLibrary.prototype
.FleetEngineDeliveryVehicleLocationProvider;
/**
* @type {typeof google.maps.journeySharing.FleetEngineFleetLocationProvider}
*/
google.maps.JourneySharingLibrary.prototype.FleetEngineFleetLocationProvider;
/**
* @type {typeof google.maps.journeySharing.FleetEngineServiceType}
*/
google.maps.JourneySharingLibrary.prototype.FleetEngineServiceType;
/**
* @type {typeof google.maps.journeySharing.FleetEngineShipmentLocationProvider}
*/
google.maps.JourneySharingLibrary.prototype.FleetEngineShipmentLocationProvider;
/**
* @type {typeof google.maps.journeySharing.FleetEngineTripLocationProvider}
*/
google.maps.JourneySharingLibrary.prototype.FleetEngineTripLocationProvider;
/**
* @type {typeof google.maps.journeySharing.FleetEngineVehicleLocationProvider}
*/
google.maps.JourneySharingLibrary.prototype.FleetEngineVehicleLocationProvider;
/**
* @type {typeof google.maps.journeySharing.JourneySharingMapView}
*/
google.maps.JourneySharingLibrary.prototype.JourneySharingMapView;
/**
* @type {typeof google.maps.journeySharing.Speed}
*/
google.maps.JourneySharingLibrary.prototype.Speed;
/**
* @type {typeof google.maps.journeySharing.TripType}
*/
google.maps.JourneySharingLibrary.prototype.TripType;
/**
* @type {typeof google.maps.journeySharing.VehicleNavigationStatus}
*/
google.maps.JourneySharingLibrary.prototype.VehicleNavigationStatus;
/**
* @type {typeof google.maps.journeySharing.VehicleState}
*/
google.maps.JourneySharingLibrary.prototype.VehicleState;
/**
* @type {typeof google.maps.journeySharing.VehicleType}
*/
google.maps.JourneySharingLibrary.prototype.VehicleType;
/**
* @type {typeof google.maps.journeySharing.WaypointType}
*/
google.maps.JourneySharingLibrary.prototype.WaypointType;
/**
* Contains details of the author of a KML document or feature.
* @record
*/
google.maps.KmlAuthor = function() {};
/**
* The author's e-mail address, or an empty string if not specified.
* @type {string}
*/
google.maps.KmlAuthor.prototype.email;
/**
* The author's name, or an empty string if not specified.
* @type {string}
*/
google.maps.KmlAuthor.prototype.name;
/**
* The author's home page, or an empty string if not specified.
* @type {string}
*/
google.maps.KmlAuthor.prototype.uri;
/**
* Data for a single KML feature in JSON format, returned when a KML feature is
* clicked. The data contained in this object mirrors that associated with the
* feature in the KML or GeoRSS markup in which it is declared.
* @record
*/
google.maps.KmlFeatureData = function() {};
/**
* The feature's <atom:author>, extracted from the layer
* markup (if specified).
* @type {!google.maps.KmlAuthor}
*/
google.maps.KmlFeatureData.prototype.author;
/**
* The feature's <description>, extracted from the layer
* markup.
* @type {string}
*/
google.maps.KmlFeatureData.prototype.description;
/**
* The feature's <id>, extracted from the layer markup.
* If no <id> has been specified, a unique ID will be
* generated for this feature.
* @type {string}
*/
google.maps.KmlFeatureData.prototype.id;
/**
* The feature's balloon styled text, if set.
* @type {string}
*/
google.maps.KmlFeatureData.prototype.infoWindowHtml;
/**
* The feature's <name>, extracted from the layer markup.
* @type {string}
*/
google.maps.KmlFeatureData.prototype.name;
/**
* The feature's <Snippet>, extracted from the layer
* markup.
* @type {string}
*/
google.maps.KmlFeatureData.prototype.snippet;
/**
* A KmlLayer adds geographic markup to the map from a KML, KMZ or
* GeoRSS file that is hosted on a publicly accessible web server. A
* KmlFeatureData object is provided for each feature when clicked.
*
* Access by calling `const {KmlLayer} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {google.maps.KmlLayerOptions=} opts Options for this layer.
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.KmlLayer = function(opts) {};
/**
* Get the default viewport for the layer being displayed.
* @return {google.maps.LatLngBounds}
*/
google.maps.KmlLayer.prototype.getDefaultViewport = function() {};
/**
* Get the map on which the KML Layer is being rendered.
* @return {google.maps.Map}
*/
google.maps.KmlLayer.prototype.getMap = function() {};
/**
* Get the metadata associated with this layer, as specified in the layer
* markup.
* @return {google.maps.KmlLayerMetadata}
*/
google.maps.KmlLayer.prototype.getMetadata = function() {};
/**
* Get the status of the layer, set once the requested document has loaded.
* @return {google.maps.KmlLayerStatus}
*/
google.maps.KmlLayer.prototype.getStatus = function() {};
/**
* Gets the URL of the KML file being displayed.
* @return {string} URL
*/
google.maps.KmlLayer.prototype.getUrl = function() {};
/**
* Gets the z-index of the KML Layer.
* @return {number} The z-index.
*/
google.maps.KmlLayer.prototype.getZIndex = function() {};
/**
* Renders the KML Layer on the specified map. If map is set to
* null, the layer is removed.
* @param {google.maps.Map} map
* @return {undefined}
*/
google.maps.KmlLayer.prototype.setMap = function(map) {};
/**
* @param {google.maps.KmlLayerOptions} options
* @return {undefined}
*/
google.maps.KmlLayer.prototype.setOptions = function(options) {};
/**
* Sets the URL of the KML file to display.
* @param {string} url
* @return {undefined}
*/
google.maps.KmlLayer.prototype.setUrl = function(url) {};
/**
* Sets the z-index of the KML Layer.
* @param {number} zIndex The z-index to set.
* @return {undefined}
*/
google.maps.KmlLayer.prototype.setZIndex = function(zIndex) {};
/**
* Metadata for a single KML layer, in JSON format.
* @record
*/
google.maps.KmlLayerMetadata = function() {};
/**
* The layer's <atom:author>, extracted from the layer
* markup.
* @type {!google.maps.KmlAuthor|null}
*/
google.maps.KmlLayerMetadata.prototype.author;
/**
* The layer's <description>, extracted from the layer
* markup.
* @type {string}
*/
google.maps.KmlLayerMetadata.prototype.description;
/**
* Whether the layer has any screen overlays.
* @type {boolean}
*/
google.maps.KmlLayerMetadata.prototype.hasScreenOverlays;
/**
* The layer's <name>, extracted from the layer markup.
* @type {string}
*/
google.maps.KmlLayerMetadata.prototype.name;
/**
* The layer's <Snippet>, extracted from the layer markup
* @type {string}
*/
google.maps.KmlLayerMetadata.prototype.snippet;
/**
* This object defines the properties that can be set on a KmlLayer
* object.
* @record
*/
google.maps.KmlLayerOptions = function() {};
/**
* If true, the layer receives mouse events.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.KmlLayerOptions.prototype.clickable;
/**
* The map on which to display the layer.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.KmlLayerOptions.prototype.map;
/**
* If this option is set to true or if the map's center and
* zoom were never set, the input map is centered and zoomed to the bounding box
* of the contents of the layer.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.KmlLayerOptions.prototype.preserveViewport;
/**
* Whether to render the screen overlays.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.KmlLayerOptions.prototype.screenOverlays;
/**
* Suppress the rendering of info windows when layer features are clicked.
* @type {boolean|null|undefined}
*/
google.maps.KmlLayerOptions.prototype.suppressInfoWindows;
/**
* The URL of the KML document to display.
* @type {string|null|undefined}
*/
google.maps.KmlLayerOptions.prototype.url;
/**
* The z-index of the layer.
* @type {number|null|undefined}
*/
google.maps.KmlLayerOptions.prototype.zIndex;
/**
* The status returned by KmlLayer on the completion of loading a
* document. Specify these by value, or by using the constant's name. For
* example, 'OK' or google.maps.KmlLayerStatus.OK.
*
* Access by calling `const {KmlLayerStatus} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.KmlLayerStatus = {
/**
* The document could not be found. Most likely it is an invalid URL, or the
* document is not publicly available.
*/
DOCUMENT_NOT_FOUND: 'DOCUMENT_NOT_FOUND',
/**
* The document exceeds the file size limits of KmlLayer.
*/
DOCUMENT_TOO_LARGE: 'DOCUMENT_TOO_LARGE',
/**
* The document could not be fetched.
*/
FETCH_ERROR: 'FETCH_ERROR',
/**
* The document is not a valid KML, KMZ or GeoRSS document.
*/
INVALID_DOCUMENT: 'INVALID_DOCUMENT',
/**
* The KmlLayer is invalid.
*/
INVALID_REQUEST: 'INVALID_REQUEST',
/**
* The document exceeds the feature limits of KmlLayer.
*/
LIMITS_EXCEEDED: 'LIMITS_EXCEEDED',
/**
* The layer loaded successfully.
*/
OK: 'OK',
/**
* The document could not be loaded within a reasonable amount of time.
*/
TIMED_OUT: 'TIMED_OUT',
/**
* The document failed to load for an unknown reason.
*/
UNKNOWN: 'UNKNOWN',
};
/**
* The properties of a click event on a KML/KMZ or GeoRSS document.
* @record
*/
google.maps.KmlMouseEvent = function() {};
/**
* A KmlFeatureData object, containing information about the
* clicked feature.
* @type {!google.maps.KmlFeatureData}
*/
google.maps.KmlMouseEvent.prototype.featureData;
/**
* The position at which to anchor an infowindow on the clicked feature.
* @type {!google.maps.LatLng}
*/
google.maps.KmlMouseEvent.prototype.latLng;
/**
* The offset to apply to an infowindow anchored on the clicked feature.
* @type {!google.maps.Size}
*/
google.maps.KmlMouseEvent.prototype.pixelOffset;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* A place that represents a point of reference for the address.
* @record
*/
google.maps.Landmark = function() {};
/**
* The name for the landmark.
* @type {string}
*/
google.maps.Landmark.prototype.display_name;
/**
* The language of the name for the landmark.
* @type {string}
*/
google.maps.Landmark.prototype.display_name_language_code;
/**
* The Place ID of the underlying establishment serving as the landmark. Can be
* used to resolve more information about the landmark through Place Details or
* Place Id Lookup.
* @type {string}
*/
google.maps.Landmark.prototype.place_id;
/**
* Defines the spatial relationship between the target location and the
* landmark.
* @type {!google.maps.SpatialRelationship}
*/
google.maps.Landmark.prototype.spatial_relationship;
/**
* The straight line distance between the target location and the landmark.
* @type {number}
*/
google.maps.Landmark.prototype.straight_line_distance_meters;
/**
* The travel distance along the road network between the target location and
* the landmark. This can be unpopulated if the landmark is disconnected from
* the part of the road network the target is closest to OR if the target
* location was not actually considered to be on the road network.
* @type {number|undefined}
*/
google.maps.Landmark.prototype.travel_distance_meters;
/**
* One or more values indicating the type of the returned result. Please see Types
* for more detail.
* @type {!ArrayLatLng is a point in geographical coordinates: latitude and
* longitude.
Although the default map projection associates
* longitude with the x-coordinate of the map, and latitude with the
* y-coordinate, the latitude coordinate is always written first,
* followed by the longitude.
Notice that you cannot modify the coordinates
* of a LatLng. If you want to compute another point, you have to
* create a new one.
LatLng
* objects also accept a {@link google.maps.LatLngLiteral} object, so that the
* following are equivalent: map.setCenter(new google.maps.LatLng(-34,
* 151));
map.setCenter({lat: -34, lng: 151}); LatLng
* objects. If a LatLng instance is passed to the constructor, a
* copy is created.
* new google.maps.LatLng(-34, 151);
*
* Access by calling `const {LatLng} = await google.maps.importLibrary("core")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {number|!google.maps.LatLngLiteral|!google.maps.LatLng}
* latOrLatLngOrLatLngLiteral
* @param {?(number|boolean)=} lngOrNoClampNoWrap
* @param {boolean=} noClampNoWrap
* @constructor
*/
google.maps.LatLng = function(
latOrLatLngOrLatLngLiteral, lngOrNoClampNoWrap, noClampNoWrap) {};
/**
* Comparison function.
* @param {google.maps.LatLng} other
* @return {boolean}
*/
google.maps.LatLng.prototype.equals = function(other) {};
/**
* Returns the latitude in degrees.
* @return {number}
*/
google.maps.LatLng.prototype.lat = function() {};
/**
* Returns the longitude in degrees.
* @return {number}
*/
google.maps.LatLng.prototype.lng = function() {};
/**
* Converts to JSON representation. This function is intended to be used via
*
new google.maps.LatLng(-34, 151,
* true);
new google.maps.LatLng({lat: -34, lng: 151});
new
* google.maps.LatLng({lat: -34, lng: 151}, true);
new
* google.maps.LatLng(new google.maps.LatLng(-34, 151));
new
* google.maps.LatLng(new google.maps.LatLng(-34, 151), true);
JSON.stringify.
* @return {!google.maps.LatLngLiteral}
* @override
*/
google.maps.LatLng.prototype.toJSON = function() {};
/**
* Converts to string representation.
* @return {string}
* @override
*/
google.maps.LatLng.prototype.toString = function() {};
/**
* Returns a string of the form "lat,lng" for this LatLng. We round
* the lat/lng values to 6 decimal places by default.
* @param {number=} precision
* @return {string}
*/
google.maps.LatLng.prototype.toUrlValue = function(precision) {};
/**
* A LatLngAltitude is a 3D point in geographical coordinates:
* latitude, longitude, and altitude.
*
* Access by calling `const {LatLngAltitude} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|!google.maps.LatLng|!google.maps.LatLngLiteral}
* value The initializing value.
* @param {boolean=} noClampNoWrap Whether to preserve the initialization
* values, even if they may not necessarily be valid latitude values in the
* range of [-90, 90] or valid longitude values in the range of [-180, 180].
* The default is false which enables latitude clamping and
* longitude wrapping.
* @implements {google.maps.LatLngAltitudeLiteral}
* @implements {google.maps.LatLngLiteral}
* @constructor
*/
google.maps.LatLngAltitude = function(value, noClampNoWrap) {};
/**
* Returns the altitude.
* @type {number}
*/
google.maps.LatLngAltitude.prototype.altitude;
/**
* Returns the latitude.
* @type {number}
*/
google.maps.LatLngAltitude.prototype.lat;
/**
* Returns the longitude.
* @type {number}
*/
google.maps.LatLngAltitude.prototype.lng;
/**
* Comparison function.
* @param {!google.maps.LatLngAltitude|null} other Another LatLngAltitude
* object.
* @return {boolean} Whether the two objects are equal.
*/
google.maps.LatLngAltitude.prototype.equals = function(other) {};
/**
* @return {!google.maps.LatLngAltitudeLiteral} A JSON representation of this
* object.
* @override
*/
google.maps.LatLngAltitude.prototype.toJSON = function() {};
/**
* Object literals are accepted in place of LatLngAltitude objects,
* as a convenience, in many places. These are converted to
* LatLngAltitude objects when the Maps API encounters them.
* @extends {google.maps.LatLngLiteral}
* @record
*/
google.maps.LatLngAltitudeLiteral = function() {};
/**
* Distance (in meters) above the ground surface. Negative value means
* underneath the ground surface.
* @default 0
* @type {number}
*/
google.maps.LatLngAltitudeLiteral.prototype.altitude;
/**
* Latitude in degrees. Values will be clamped to the range [-90, 90]. This
* means that if the value specified is less than -90, it will be set to -90.
* And if the value is greater than 90, it will be set to 90.
* @type {number}
*/
google.maps.LatLngAltitudeLiteral.prototype.lat;
/**
* Longitude in degrees. Values outside the range [-180, 180] will be wrapped so
* that they fall within the range. For example, a value of -190 will be
* converted to 170. A value of 190 will be converted to -170. This reflects the
* fact that longitudes wrap around the globe.
* @type {number}
*/
google.maps.LatLngAltitudeLiteral.prototype.lng;
/**
* A LatLngBounds instance represents a
* rectangle in geographical coordinates, including one that crosses the 180
* degrees longitudinal meridian.
*
* Access by calling `const {LatLngBounds} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {(google.maps.LatLng|google.maps.LatLngLiteral|google.maps.LatLngBounds|google.maps.LatLngBoundsLiteral|null)=}
* swOrLatLngBounds
* @param {(google.maps.LatLng|google.maps.LatLngLiteral|null)=} ne
* @constructor
*/
google.maps.LatLngBounds = function(swOrLatLngBounds, ne) {};
/**
* Returns true if the given lat/lng is in this bounds.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} latLng
* @return {boolean}
*/
google.maps.LatLngBounds.prototype.contains = function(latLng) {};
/**
* Returns true if this bounds approximately equals the given
* bounds.
* @param {google.maps.LatLngBounds|google.maps.LatLngBoundsLiteral|null} other
* @return {boolean}
*/
google.maps.LatLngBounds.prototype.equals = function(other) {};
/**
* Extends this bounds to contain the given point.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} point
* @return {!google.maps.LatLngBounds}
*/
google.maps.LatLngBounds.prototype.extend = function(point) {};
/**
* Computes the center of this LatLngBounds
* @return {!google.maps.LatLng}
*/
google.maps.LatLngBounds.prototype.getCenter = function() {};
/**
* Returns the north-east corner of this bounds.
* @return {!google.maps.LatLng}
*/
google.maps.LatLngBounds.prototype.getNorthEast = function() {};
/**
* Returns the south-west corner of this bounds.
* @return {!google.maps.LatLng}
*/
google.maps.LatLngBounds.prototype.getSouthWest = function() {};
/**
* Returns true if this bounds shares any points with the other
* bounds.
* @param {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral} other
* @return {boolean}
*/
google.maps.LatLngBounds.prototype.intersects = function(other) {};
/**
* Returns if the bounds are empty.
* @return {boolean}
*/
google.maps.LatLngBounds.prototype.isEmpty = function() {};
/**
* Converts to JSON representation. This function is intended to be used via
* JSON.stringify.
* @return {!google.maps.LatLngBoundsLiteral}
* @override
*/
google.maps.LatLngBounds.prototype.toJSON = function() {};
/**
* Converts the given map bounds to a lat/lng span.
* @return {!google.maps.LatLng}
*/
google.maps.LatLngBounds.prototype.toSpan = function() {};
/**
* Converts to string.
* @return {string}
* @override
*/
google.maps.LatLngBounds.prototype.toString = function() {};
/**
* Returns a string of the form "lat_lo,lng_lo,lat_hi,lng_hi" for this
* bounds, where "lo" corresponds to the southwest corner of the
* bounding box, while "hi" corresponds to the northeast corner of
* that box.
* @param {number=} precision
* @return {string}
*/
google.maps.LatLngBounds.prototype.toUrlValue = function(precision) {};
/**
* Extends this bounds to contain the union of this and the given bounds.
* @param {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral} other
* @return {!google.maps.LatLngBounds}
*/
google.maps.LatLngBounds.prototype.union = function(other) {};
/**
* LatLngBounds for the max bounds of the Earth. These bounds will encompass the
* entire globe.
* @const
* @type {!google.maps.LatLngBounds}
*/
google.maps.LatLngBounds.MAX_BOUNDS;
/**
* Object literals are accepted in place of LatLngBounds objects
* throughout the API. These are automatically converted to
* LatLngBounds objects. All south, west,
* north and east must be set, otherwise an exception
* is thrown.
* @record
*/
google.maps.LatLngBoundsLiteral = function() {};
/**
* East longitude in degrees. Values outside the range [-180, 180] will be
* wrapped to the range [-180, 180). For example, a value of -190 will be
* converted to 170. A value of 190 will be converted to -170. This reflects the
* fact that longitudes wrap around the globe.
* @type {number}
*/
google.maps.LatLngBoundsLiteral.prototype.east;
/**
* North latitude in degrees. Values will be clamped to the range [-90, 90].
* This means that if the value specified is less than -90, it will be set to
* -90. And if the value is greater than 90, it will be set to 90.
* @type {number}
*/
google.maps.LatLngBoundsLiteral.prototype.north;
/**
* South latitude in degrees. Values will be clamped to the range [-90, 90].
* This means that if the value specified is less than -90, it will be set to
* -90. And if the value is greater than 90, it will be set to 90.
* @type {number}
*/
google.maps.LatLngBoundsLiteral.prototype.south;
/**
* West longitude in degrees. Values outside the range [-180, 180] will be
* wrapped to the range [-180, 180). For example, a value of -190 will be
* converted to 170. A value of 190 will be converted to -170. This reflects the
* fact that longitudes wrap around the globe.
* @type {number}
*/
google.maps.LatLngBoundsLiteral.prototype.west;
/**
* Object literals are accepted in place of LatLng objects, as a
* convenience, in many places. These are converted to LatLng
* objects when the Maps API encounters them.
* map.setCenter({lat: -34, lng: 151});
new
* google.maps.Marker({position: {lat: -34, lng: 151}, map: map}); ElevationService containing the
* list of discrete coordinates (LatLngs) for which to return
* elevation data.
* @record
*/
google.maps.LocationElevationRequest = function() {};
/**
* The discrete locations for which to retrieve elevations.
* @type {!Array|null|undefined}
*/
google.maps.LocationElevationRequest.prototype.locations;
/**
* An elevation response returned by the {@link google.maps.ElevationService}
* containing the list of {@link google.maps.ElevationResult}s matching the
* locations of the {@link google.maps.LocationElevationRequest}.
* @record
*/
google.maps.LocationElevationResponse = function() {};
/**
* The list of {@link google.maps.ElevationResult}s matching the locations of
* the {@link google.maps.LocationElevationRequest}.
* @type {!Array}
*/
google.maps.LocationElevationResponse.prototype.results;
/**
*
* Access by calling `const {MVCArray} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {Array
The MVCObject constructor
* is guaranteed to be an empty function, and so you may inherit from
* MVCObject by writing MySubclass.prototype = new
* google.maps.MVCObject();. Unless otherwise noted, this is not true of
* other classes in the API, and inheriting from other classes in the API is not
* supported.
*
* Access by calling `const {MVCObject} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.MVCObject = function() {};
/**
* Adds the given listener function to the given event name. Returns an
* identifier for this listener that can be used with
* google.maps.event.removeListener.
* @param {string} eventName
* @param {!Function} handler
* @return {!google.maps.MapsEventListener}
*/
google.maps.MVCObject.prototype.addListener = function(eventName, handler) {};
/**
* Binds a View to a Model.
* @param {string} key
* @param {!google.maps.MVCObject} target
* @param {?string=} targetKey
* @param {boolean=} noNotify
* @return {undefined}
*/
google.maps.MVCObject.prototype.bindTo = function(
key, target, targetKey, noNotify) {};
/**
* Gets a value.
* @param {string} key
* @return {?}
*/
google.maps.MVCObject.prototype.get = function(key) {};
/**
* Notify all observers of a change on this property. This notifies both objects
* that are bound to the object's property as well as the object that it is
* bound to.
* @param {string} key
* @return {undefined}
*/
google.maps.MVCObject.prototype.notify = function(key) {};
/**
* Sets a value.
* @param {string} key
* @param {*} value
* @return {undefined}
*/
google.maps.MVCObject.prototype.set = function(key, value) {};
/**
* Sets a collection of key-value pairs.
* @param {?Object=} values
* @return {undefined}
*/
google.maps.MVCObject.prototype.setValues = function(values) {};
/**
* Removes a binding. Unbinding will set the unbound property to the current
* value. The object will not be notified, as the value has not changed.
* @param {string} key
* @return {undefined}
*/
google.maps.MVCObject.prototype.unbind = function(key) {};
/**
* Removes all bindings.
* @return {undefined}
*/
google.maps.MVCObject.prototype.unbindAll = function() {};
/**
*
* Access by calling `const {Map} = await google.maps.importLibrary("maps")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!HTMLElement} mapDiv The map will render to fill this element.
* @param {!google.maps.MapOptions=} opts Options
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.Map = function(mapDiv, opts) {};
/**
* Additional controls to attach to the map. To add a control to the map, add
* the control's <div> to the MVCArray
* corresponding to the ControlPosition where it should be
* rendered.
* @type {!Array>}
*/
google.maps.Map.prototype.controls;
/**
* An instance of Data, bound to the map. Add features to this
* Data object to conveniently display them on this map.
* @type {!google.maps.Data}
*/
google.maps.Map.prototype.data;
/**
* A registry of MapType instances by string ID.
* @type {!google.maps.MapTypeRegistry}
*/
google.maps.Map.prototype.mapTypes;
/**
* Additional map types to overlay. Overlay map types will display on top of the
* base map they are attached to, in the order in which they appear in the
* overlayMapTypes array (overlays with higher index values are
* displayed in front of overlays with lower index values).
* @type {!google.maps.MVCArray}
*/
google.maps.Map.prototype.overlayMapTypes;
/**
* Sets the viewport to contain the given bounds. Note:
* When the map is set to display: none, the fitBounds
* function reads the map's size as 0x0, and therefore does not do anything.
* To change the viewport while the map is hidden, set the map to
* visibility: hidden, thereby ensuring the map div has an actual
* size. For vector maps, this method sets the map's tilt and heading to
* their default zero values. Calling this method may cause a smooth animation
* as the map pans and zooms to fit the bounds. Whether or not this method
* animates depends on an internal heuristic.
* @param {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral} bounds
* Bounds to show.
* @param {(number|!google.maps.Padding)=} padding Padding in pixels. The bounds
* will be fit in the part of the map that remains after padding is removed.
* A number value will yield the same padding on all 4 sides. Supply 0 here
* to make a fitBounds idempotent on the result of getBounds.
* @return {undefined}
*/
google.maps.Map.prototype.fitBounds = function(bounds, padding) {};
/**
* Returns the lat/lng bounds of the current viewport. If more than one copy of
* the world is visible, the bounds range in longitude from -180 to 180 degrees
* inclusive. If the map is not yet initialized or center and zoom have not been
* set then the result is undefined. For vector maps with non-zero
* tilt or heading, the returned lat/lng bounds represents the smallest bounding
* box that includes the visible region of the map's viewport. See {@link
* google.maps.MapCanvasProjection.getVisibleRegion} for getting the exact
* visible region of the map's viewport.
* @return {!google.maps.LatLngBounds|undefined} The lat/lng bounds of the
* current viewport.
*/
google.maps.Map.prototype.getBounds = function() {};
/**
* Returns the position displayed at the center of the map. Note that
* this {@link google.maps.LatLng} object is not wrapped. See LatLng for more information. If the center or
* bounds have not been set then the result is undefined.
* @return {!google.maps.LatLng|undefined}
*/
google.maps.Map.prototype.getCenter = function() {};
/**
* Returns the clickability of the map icons. A map icon represents a point of
* interest, also known as a POI. If the returned value is true,
* then the icons are clickable on the map.
* @return {boolean|undefined}
*/
google.maps.Map.prototype.getClickableIcons = function() {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* Returns the FeatureLayer for the specified
* datasetId. Dataset IDs must be configured in the Google Cloud
* Console. If the dataset ID is not associated with the map's map style, or
* if Data-driven styling is not available (no map ID, no vector tiles, no
* Data-Driven Styling feature layers or Datasets configured in the Map Style),
* this logs an error, and the resulting FeatureLayer.isAvailable
* will be false.
* @param {string} datasetId
* @return {!google.maps.FeatureLayer}
*/
google.maps.Map.prototype.getDatasetFeatureLayer = function(datasetId) {};
/**
* @return {!HTMLElement} The mapDiv of the map.
*/
google.maps.Map.prototype.getDiv = function() {};
/**
* Returns the FeatureLayer of the specific
* FeatureType. A FeatureLayer must be enabled in the
* Google Cloud Console. If a FeatureLayer of the specified
* FeatureType does not exist on this map, or if Data-driven
* styling is not available (no map ID, no vector tiles, and no
* FeatureLayer enabled in the map style), this logs an error, and
* the resulting FeatureLayer.isAvailable will be false.
* @param {!google.maps.FeatureType} featureType
* @return {!google.maps.FeatureLayer}
*/
google.maps.Map.prototype.getFeatureLayer = function(featureType) {};
/**
* Returns the compass heading of the map. The heading value is measured in
* degrees (clockwise) from cardinal direction North. If the map is not yet
* initialized then the result is undefined.
* @return {number|undefined}
*/
google.maps.Map.prototype.getHeading = function() {};
/**
* Returns whether heading interactions are enabled. This option is only in
* effect when the map is a vector map. If not set in code, then the cloud
* configuration for the map ID will be used (if available).
* @return {boolean|null}
*/
google.maps.Map.prototype.getHeadingInteractionEnabled = function() {};
/**
* Returns the list of usage attribution IDs, which help Google understand which
* libraries and samples are helpful to developers, such as usage of a marker
* clustering library.
* @return {!IterableProjection. If the map is not yet
* initialized then the result is undefined. Listen to the
* projection_changed event and check its value to ensure it is not
* undefined.
* @return {!google.maps.Projection|undefined}
*/
google.maps.Map.prototype.getProjection = function() {};
/**
* Returns the current RenderingType of the map.
* @return {!google.maps.RenderingType}
*/
google.maps.Map.prototype.getRenderingType = function() {};
/**
* Returns the default StreetViewPanorama bound to the map, which
* may be a default panorama embedded within the map, or the panorama set using
* setStreetView(). Changes to the map's
* streetViewControl will be reflected in the display of such a
* bound panorama.
* @return {!google.maps.StreetViewPanorama} The panorama bound to the map.
*/
google.maps.Map.prototype.getStreetView = function() {};
/**
* Returns the current angle of incidence of the map, in degrees from the
* viewport plane to the map plane. For raster maps, the result will be
* 0 for imagery taken directly overhead or 45 for
* 45° imagery. This method does not return the value set by
* setTilt. See setTilt for details.
* @return {number|undefined}
*/
google.maps.Map.prototype.getTilt = function() {};
/**
* Returns whether tilt interactions are enabled. This option is only in effect
* when the map is a vector map. If not set in code, then the cloud
* configuration for the map ID will be used (if available).
* @return {boolean|null}
*/
google.maps.Map.prototype.getTiltInteractionEnabled = function() {};
/**
* Returns the zoom of the map. If the zoom has not been set then the result is
* undefined.
* @return {number|undefined}
*/
google.maps.Map.prototype.getZoom = function() {};
/**
* Immediately sets the map's camera to the target camera options, without
* animation.
* @param {!google.maps.CameraOptions} cameraOptions
* @return {undefined}
*/
google.maps.Map.prototype.moveCamera = function(cameraOptions) {};
/**
* Changes the center of the map by the given distance in pixels. If the
* distance is less than both the width and height of the map, the transition
* will be smoothly animated. Note that the map coordinate system increases from
* west to east (for x values) and north to south (for y values).
* @param {number} x Number of pixels to move the map in the x direction.
* @param {number} y Number of pixels to move the map in the y direction.
* @return {undefined}
*/
google.maps.Map.prototype.panBy = function(x, y) {};
/**
* Changes the center of the map to the given LatLng. If the change
* is less than both the width and height of the map, the transition will be
* smoothly animated.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} latLng The new center
* latitude/longitude of the map.
* @return {undefined}
*/
google.maps.Map.prototype.panTo = function(latLng) {};
/**
* Pans the map by the minimum amount necessary to contain the given
* LatLngBounds. It makes no guarantee where on the map the bounds
* will be, except that the map will be panned to show as much of the bounds as
* possible inside {currentMapSizeInPx} - {padding}. For both
* raster and vector maps, the map's zoom, tilt, and heading will not be
* changed.
* @param {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral}
* latLngBounds The bounds to pan the map to.
* @param {(number|!google.maps.Padding)=} padding Padding in pixels. A number
* value will yield the same padding on all 4 sides. The default value is 0.
* @return {undefined}
*/
google.maps.Map.prototype.panToBounds = function(latLngBounds, padding) {};
/**
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} latlng
* @return {undefined}
*/
google.maps.Map.prototype.setCenter = function(latlng) {};
/**
* Controls whether the map icons are clickable or not. A map icon represents a
* point of interest, also known as a POI. To disable the clickability of map
* icons, pass a value of false to this method.
* @param {boolean} value
* @return {undefined}
*/
google.maps.Map.prototype.setClickableIcons = function(value) {};
/**
* Sets the compass heading for map measured in degrees from cardinal direction
* North. For raster maps, this method only applies to aerial imagery.
* @param {number} heading
* @return {undefined}
*/
google.maps.Map.prototype.setHeading = function(heading) {};
/**
* Sets whether heading interactions are enabled. This option is only in effect
* when the map is a vector map. If not set in code, then the cloud
* configuration for the map ID will be used (if available).
* @param {boolean} headingInteractionEnabled
* @return {undefined}
*/
google.maps.Map.prototype.setHeadingInteractionEnabled = function(
headingInteractionEnabled) {};
/**
* @param {!google.maps.MapTypeId|string} mapTypeId
* @return {undefined}
*/
google.maps.Map.prototype.setMapTypeId = function(mapTypeId) {};
/**
* @param {?google.maps.MapOptions} options
* @return {undefined}
*/
google.maps.Map.prototype.setOptions = function(options) {};
/**
* Sets the current RenderingType of the map.
* @param {!google.maps.RenderingType} renderingType
* @return {undefined}
*/
google.maps.Map.prototype.setRenderingType = function(renderingType) {};
/**
* Binds a StreetViewPanorama to the map. This panorama overrides
* the default StreetViewPanorama, allowing the map to bind to an
* external panorama outside of the map. Setting the panorama to
* null binds the default embedded panorama back to the map.
* @param {?google.maps.StreetViewPanorama} panorama The panorama to bind to the
* map.
* @return {undefined}
*/
google.maps.Map.prototype.setStreetView = function(panorama) {};
/**
* For vector maps, sets the angle of incidence of the map. The allowed values
* are restricted depending on the zoom level of the map.
For raster
* maps, controls the automatic switching behavior for the angle of incidence of
* the map. The only allowed values are 0 and 45.
* setTilt(0) causes the map to always use a 0° overhead view
* regardless of the zoom level and viewport. setTilt(45) causes
* the tilt angle to automatically switch to 45 whenever 45° imagery is
* available for the current zoom level and viewport, and switch back to 0
* whenever 45° imagery is not available (this is the default behavior).
* 45° imagery is only available for satellite and
* hybrid map types, within some locations, and at some zoom
* levels. Note: getTilt returns the current tilt angle, not
* the value set by setTilt. Because getTilt and
* setTilt refer to different things, do not bind()
* the tilt property; doing so may yield unpredictable effects.
* @param {number} tilt
* @return {undefined}
*/
google.maps.Map.prototype.setTilt = function(tilt) {};
/**
* Sets whether tilt interactions are enabled. This option is only in effect
* when the map is a vector map. If not set in code, then the cloud
* configuration for the map ID will be used (if available).
* @param {boolean} tiltInteractionEnabled
* @return {undefined}
*/
google.maps.Map.prototype.setTiltInteractionEnabled = function(
tiltInteractionEnabled) {};
/**
* Sets the zoom of the map.
* @param {number} zoom Larger zoom values correspond to a higher resolution.
* @return {undefined}
*/
google.maps.Map.prototype.setZoom = function(zoom) {};
/**
* Map ID which can be used for code samples which require a map ID. This map ID
* is not intended for use in production applications and cannot be used for
* features which require cloud configuration (such as Cloud Styling).
* @const
* @type {string}
*/
google.maps.Map.DEMO_MAP_ID;
/**
* This object is made available to the OverlayView from within the
* draw method. It is not guaranteed to be initialized until draw is called.
* @record
*/
google.maps.MapCanvasProjection = function() {};
/**
* Computes the geographical coordinates from pixel coordinates in the map's
* container.
* @param {!google.maps.Point|null} pixel
* @param {boolean=} noClampNoWrap
* @return {!google.maps.LatLng|null}
*/
google.maps.MapCanvasProjection.prototype.fromContainerPixelToLatLng = function(
pixel, noClampNoWrap) {};
/**
* Computes the geographical coordinates from pixel coordinates in the div that
* holds the draggable map.
* @param {!google.maps.Point|null} pixel
* @param {boolean=} noClampNoWrap
* @return {!google.maps.LatLng|null}
*/
google.maps.MapCanvasProjection.prototype.fromDivPixelToLatLng = function(
pixel, noClampNoWrap) {};
/**
* Computes the pixel coordinates of the given geographical location in the
* map's container element.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} latLng
* @return {!google.maps.Point|null}
*/
google.maps.MapCanvasProjection.prototype.fromLatLngToContainerPixel = function(
latLng) {};
/**
* Computes the pixel coordinates of the given geographical location in the DOM
* element that holds the draggable map.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral|null} latLng
* @return {!google.maps.Point|null}
*/
google.maps.MapCanvasProjection.prototype.fromLatLngToDivPixel = function(
latLng) {};
/**
* The visible region of the map. Returns null if the map has no
* size. Returns null if the OverlayView is on a
* StreetViewPanorama.
* @return {!google.maps.VisibleRegion|null}
*/
google.maps.MapCanvasProjection.prototype.getVisibleRegion = function() {};
/**
* The width of the world in pixels in the current zoom level. For projections
* with a heading angle of either 90 or 270 degrees, this corresponds to the
* pixel span in the Y-axis.
* @return {number}
*/
google.maps.MapCanvasProjection.prototype.getWorldWidth = function() {};
/**
* Object containing a snapshot of what capabilities are currently available for
* the Map. Note that this does not necessarily mean that relevant modules are
* loaded or initialized, but rather that the current map has permission to use
* these APIs. See the properties for a list of possible capabilities.
* @record
*/
google.maps.MapCapabilities = function() {};
/**
* If true, this map is configured properly to allow for the use of advanced
* markers. Note that you must still import the marker library in
* order to use advanced markers. See https://goo.gle/gmp-isAdvancedMarkersAvailable
* for more information.
* @type {boolean|undefined}
*/
google.maps.MapCapabilities.prototype.isAdvancedMarkersAvailable;
/**
* If true, this map is configured properly to allow for the use of data-driven
* styling for at least one FeatureLayer. See https://goo.gle/gmp-data-driven-styling
* and https://goo.gle/gmp-FeatureLayerIsAvailable
* for more information.
* @type {boolean|undefined}
*/
google.maps.MapCapabilities.prototype.isDataDrivenStylingAvailable;
/**
* If true, this map is configured properly to allow for the use of {@link
* google.maps.WebGLOverlayView}.
* @type {boolean|undefined}
*/
google.maps.MapCapabilities.prototype.isWebGLOverlayViewAvailable;
/**
* MapElement is an HTMLElement subclass for rendering maps. After
* loading the maps library, a map can be created in HTML. For
* example: <gmp-map center="37.4220656,-122.0840897"
* zoom="10"
* map-id="DEMO_MAP_ID">
<button
* slot="control-block-start-inline-end">Custom
* Control</button>
</gmp-map>
Internally, it
* uses {@link google.maps.Map}, which can be accessed with the {@link
* google.maps.MapElement.innerMap} property.
*
* Access by calling `const {MapElement} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.MapElementOptions=} options
* @implements {google.maps.MapElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.MapElement = function(options) {};
/**
* The center latitude/longitude of the map.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null}
*/
google.maps.MapElement.prototype.center;
/**
* Whether the map should allow user control of the camera heading (rotation).
* This option is only in effect when the map is a vector map. If not set in
* code, then the cloud configuration for the map ID will be used (if
* available).
* @default false
* @type {boolean|null}
*/
google.maps.MapElement.prototype.headingInteractionDisabled;
/**
* A reference to the {@link google.maps.Map} that the MapElement uses
* internally.
* @type {!google.maps.Map}
*/
google.maps.MapElement.prototype.innerMap;
/**
* Adds a usage attribution ID to the initializer, which helps Google understand
* which libraries and samples are helpful to developers, such as usage of a
* marker clustering library. To opt out of sending the usage attribution ID, it
* is safe to delete this property or replace the value with an empty string.
* Only unique values will be sent. Changes to this value after instantiation
* may be ignored.
* @default null
* @type {!Iterablefalse
* @type {boolean|null}
*/
google.maps.MapElement.prototype.tiltInteractionDisabled;
/**
* The zoom level of the map. Valid zoom values are numbers from zero up to the
* supported maximum
* zoom level. Larger zoom values correspond to a higher resolution.
* @type {number|null}
*/
google.maps.MapElement.prototype.zoom;
/**
* MapElementOptions object used to define the properties that can be set on a
* MapElement.
* @record
*/
google.maps.MapElementOptions = function() {};
/**
* See {@link google.maps.MapElement.center}.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.MapElementOptions.prototype.center;
/**
* See {@link google.maps.MapElement.headingInteractionDisabled}.
* @type {boolean|null|undefined}
*/
google.maps.MapElementOptions.prototype.headingInteractionDisabled;
/**
* See {@link google.maps.MapElement.internalUsageAttributionIds}.
* @type {!Iterabletarget, currentTarget, relatedTarget
* and path properties being defined and consistent. Developers
* should not also rely on the DOM structure of the internal implementation of
* the Maps API. Due to internal event mapping, the domEvent may
* have different semantics from the {@link google.maps.MapMouseEvent} (e.g.
* a {@link google.maps.MapMouseEvent} "click" may have a
* domEvent of type KeyboardEvent).
* @type {!MouseEvent|!TouchEvent|!PointerEvent|!KeyboardEvent|!Event}
*/
google.maps.MapMouseEvent.prototype.domEvent;
/**
* The latitude/longitude that was below the cursor when the event occurred.
* @type {!google.maps.LatLng|null}
*/
google.maps.MapMouseEvent.prototype.latLng;
/**
* Prevents this event from propagating further.
* @return {void}
*/
google.maps.MapMouseEvent.prototype.stop = function() {};
/**
* MapOptions object used to define the properties that can be set on a Map.
* @record
*/
google.maps.MapOptions = function() {};
/**
* Color used for the background of the Map div. This color will be visible when
* tiles have not yet loaded as the user pans. This option can only be set when
* the map is initialized.
* @type {string|null|undefined}
*/
google.maps.MapOptions.prototype.backgroundColor;
/**
* The enabled/disabled state of the Camera control.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.cameraControl;
/**
* The display options for the Camera control.
* @type {!google.maps.CameraControlOptions|null|undefined}
*/
google.maps.MapOptions.prototype.cameraControlOptions;
/**
* The initial Map center.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.MapOptions.prototype.center;
/**
* When false, map icons are not clickable. A map icon represents a
* point of interest, also known as a POI.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.clickableIcons;
/**
* The initial Map color scheme. This option can only be set when the map is
* initialized.
* @default {@link google.maps.ColorScheme.LIGHT}
* @type {!google.maps.ColorScheme|string|null|undefined}
*/
google.maps.MapOptions.prototype.colorScheme;
/**
* Size in pixels of the controls appearing on the map. This value must be
* supplied directly when creating the Map, updating this value later may bring
* the controls into an undefined state. Only governs the controls
* made by the Maps API itself. Does not scale developer created custom
* controls.
* @type {number|null|undefined}
*/
google.maps.MapOptions.prototype.controlSize;
/**
* Enables/disables all default UI buttons. May be overridden individually. Does
* not disable the keyboard controls, which are separately controlled by
* the {@link google.maps.MapOptions.keyboardShortcuts} option. Does not disable
* gesture controls, which are separately controlled by the {@link
* google.maps.MapOptions.gestureHandling} option.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.disableDefaultUI;
/**
* Enables/disables zoom and center on double click. Enabled by default.
* gestureHandling property, and set it to "none".
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.disableDoubleClickZoom;
/**
* The name or url of the cursor to display when mousing over a draggable map.
* This property uses the css cursor attribute to change the icon.
* As with the css property, you must specify at least one fallback cursor that
* is not a URL. For example: draggableCursor: 'url(http://www.example.com/icon.png),
* auto;'.
* @type {string|null|undefined}
*/
google.maps.MapOptions.prototype.draggableCursor;
/**
* The name or url of the cursor to display when the map is being dragged. This
* property uses the css cursor attribute to change the icon. As
* with the css property, you must specify at least one fallback cursor that is
* not a URL. For example: draggingCursor: 'url(http://www.example.com/icon.png),
* auto;'.
* @type {string|null|undefined}
*/
google.maps.MapOptions.prototype.draggingCursor;
/**
* The enabled/disabled state of the Fullscreen control.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.fullscreenControl;
/**
* The display options for the Fullscreen control.
* @type {!google.maps.FullscreenControlOptions|null|undefined}
*/
google.maps.MapOptions.prototype.fullscreenControlOptions;
/**
* This setting controls how the API handles gestures on the map. Allowed
* values:
* @type {string|null|undefined}
*/
google.maps.MapOptions.prototype.gestureHandling;
/**
* The heading for aerial imagery in degrees measured clockwise from cardinal
* direction North. Headings are snapped to the nearest available angle for
* which imagery is available.
* @type {number|null|undefined}
*/
google.maps.MapOptions.prototype.heading;
/**
* Whether the map should allow user control of the camera heading (rotation).
* This option is only in effect when the map is a vector map. If not set in
* code, then the cloud configuration for the map ID will be used (if
* available).
* @default "cooperative": Scroll events and one-finger
* touch gestures scroll the page, and do not zoom or pan the map. Two-finger
* touch gestures pan and zoom the map. Scroll events with a ctrl key or ⌘ key
* pressed zoom the map.
In this mode the map cooperates with the
* page. "greedy": All touch gestures and scroll events pan or
* zoom the map. "none": The map cannot be panned or zoomed by
* user gestures. "auto": (default) Gesture handling is either
* cooperative or greedy, depending on whether the page is scrollable or in an
* iframe. false
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.headingInteractionEnabled;
/**
* Adds a usage attribution ID to the initializer, which helps Google understand
* which libraries and samples are helpful to developers, such as usage of a
* marker clustering library. To opt out of sending the usage attribution ID, it
* is safe to delete this property or replace the value with an empty string.
* Only unique values will be sent. Changes to this value after instantiation
* may be ignored.
* @default null
* @type {!Iterableisfractionalzoomenabled_changed to know when the default has
* been set.
* @default true for vector maps and false for raster
* maps
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.isFractionalZoomEnabled;
/**
* If false, prevents the map from being controlled by the
* keyboard. Keyboard shortcuts are enabled by default.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.keyboardShortcuts;
/**
* The map
* ID of the map. This parameter cannot be set or changed after a map is
* instantiated. {@link google.maps.Map.DEMO_MAP_ID} can be used to try out
* features that require a map ID but which do not require cloud enablement.
* @type {string|null|undefined}
*/
google.maps.MapOptions.prototype.mapId;
/**
* The initial enabled/disabled state of the Map type control.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.mapTypeControl;
/**
* The initial display options for the Map type control.
* @type {!google.maps.MapTypeControlOptions|null|undefined}
*/
google.maps.MapOptions.prototype.mapTypeControlOptions;
/**
* The initial Map mapTypeId. Defaults to ROADMAP.
* @type {!google.maps.MapTypeId|string|null|undefined}
*/
google.maps.MapOptions.prototype.mapTypeId;
/**
* The maximum zoom level which will be displayed on the map. If omitted, or set
* to null, the maximum zoom from the current map type is used
* instead. Valid zoom values are numbers from zero up to the supported maximum
* zoom level.
* @type {number|null|undefined}
*/
google.maps.MapOptions.prototype.maxZoom;
/**
* The minimum zoom level which will be displayed on the map. If omitted, or set
* to null, the minimum zoom from the current map type is used
* instead. Valid zoom values are numbers from zero up to the supported maximum
* zoom level.
* @type {number|null|undefined}
*/
google.maps.MapOptions.prototype.minZoom;
/**
* If true, do not clear the contents of the Map div.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.noClear;
/**
* Whether the map should be a raster or vector map. This parameter cannot be
* set or changed after a map is instantiated. If not set, then the cloud
* configuration for the map ID will determine the rendering type (if
* available). Please note that vector maps may not be available for all devices
* and browsers and the map will fall back to a raster map as needed.
* @default {@link google.maps.RenderingType.RASTER}
* @type {!google.maps.RenderingType|null|undefined}
*/
google.maps.MapOptions.prototype.renderingType;
/**
* Defines a boundary that restricts the area of the map accessible to users.
* When set, a user can only pan and zoom while the camera view stays inside the
* limits of the boundary.
* @type {!google.maps.MapRestriction|null|undefined}
*/
google.maps.MapOptions.prototype.restriction;
/**
* The enabled/disabled state of the Rotate control.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.rotateControl;
/**
* The display options for the Rotate control.
* @type {!google.maps.RotateControlOptions|null|undefined}
*/
google.maps.MapOptions.prototype.rotateControlOptions;
/**
* The initial enabled/disabled state of the Scale control.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.scaleControl;
/**
* The initial display options for the Scale control.
* @type {!google.maps.ScaleControlOptions|null|undefined}
*/
google.maps.MapOptions.prototype.scaleControlOptions;
/**
* If false, disables zooming on the map using a mouse scroll
* wheel. The scrollwheel is enabled by default. gestureHandling property, and set
* it to either "cooperative" or "none".
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.scrollwheel;
/**
* A StreetViewPanorama to display when the Street View pegman is
* dropped on the map. If no panorama is specified, a default
* StreetViewPanorama will be displayed in the map's
* div when the pegman is dropped.
* @type {!google.maps.StreetViewPanorama|null|undefined}
*/
google.maps.MapOptions.prototype.streetView;
/**
* The initial enabled/disabled state of the Street View Pegman control. This
* control is part of the default UI, and should be set to false
* when displaying a map type on which the Street View road overlay should not
* appear (e.g. a non-Earth map type).
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.streetViewControl;
/**
* The initial display options for the Street View Pegman control.
* @type {!google.maps.StreetViewControlOptions|null|undefined}
*/
google.maps.MapOptions.prototype.streetViewControlOptions;
/**
* Styles to apply to each of the default map types. Note that for
* satellite/hybrid and terrain modes,
* these styles will only apply to labels and geometry. This feature is not
* available when using a map ID, or when using vector maps (use cloud-based
* maps styling instead).
* @type {!Array|null|undefined}
*/
google.maps.MapOptions.prototype.styles;
/**
* For vector maps, sets the angle of incidence of the map. The allowed values
* are restricted depending on the zoom level of the map. For raster maps,
* controls the automatic switching behavior for the angle of incidence of the
* map. The only allowed values are 0 and 45. The
* value 0 causes the map to always use a 0° overhead view
* regardless of the zoom level and viewport. The value 45 causes
* the tilt angle to automatically switch to 45 whenever 45° imagery is
* available for the current zoom level and viewport, and switch back to 0
* whenever 45° imagery is not available (this is the default behavior).
* 45° imagery is only available for satellite and
* hybrid map types, within some locations, and at some zoom
* levels. Note: getTilt returns the current tilt angle, not
* the value specified by this option. Because getTilt and this
* option refer to different things, do not bind() the
* tilt property; doing so may yield unpredictable effects.
* @type {number|null|undefined}
*/
google.maps.MapOptions.prototype.tilt;
/**
* Whether the map should allow user control of the camera tilt. This option is
* only in effect when the map is a vector map. If not set in code, then the
* cloud configuration for the map ID will be used (if available).
* @default false
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.tiltInteractionEnabled;
/**
* The initial Map zoom level. Valid zoom values are numbers from zero up to the
* supported maximum
* zoom level. Larger zoom values correspond to a higher resolution.
* @type {number|null|undefined}
*/
google.maps.MapOptions.prototype.zoom;
/**
* The enabled/disabled state of the Zoom control.
* @type {boolean|null|undefined}
*/
google.maps.MapOptions.prototype.zoomControl;
/**
* The display options for the Zoom control.
* @type {!google.maps.ZoomControlOptions|null|undefined}
*/
google.maps.MapOptions.prototype.zoomControlOptions;
/**
* If false, prevents the map from being dragged. Dragging is
* enabled by default.
* @type {boolean|null|undefined}
* @deprecated Deprecated in 2017. To disable dragging on the map, you can use
* the gestureHandling property, and set it to
* "none".
*/
google.maps.MapOptions.prototype.draggable;
/**
* The enabled/disabled state of the Pan control. latLngBounds: {north: northLat, south:
* southLat, west: -180, east: 180}.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral}
*/
google.maps.MapRestriction.prototype.latLngBounds;
/**
* Bounds can be made more restrictive by setting the strictBounds
* flag to true. This reduces how far a user can zoom out, ensuring
* that everything outside of the restricted bounds stays hidden. The default is
* false, meaning that a user can zoom out until the entire bounded
* area is in view, possibly including areas outside the bounded area.
* @type {boolean|undefined}
*/
google.maps.MapRestriction.prototype.strictBounds;
/**
* This interface defines the map type, and is typically used for custom map
* types. Immutable.
* @record
*/
google.maps.MapType = function() {};
/**
* Alt text to display when this MapType's button is hovered over in the
* MapTypeControl. Optional.
* @type {string|null}
*/
google.maps.MapType.prototype.alt;
/**
* The maximum zoom level for the map when displaying this MapType. Required for
* base MapTypes, ignored for overlay MapTypes.
* @type {number}
*/
google.maps.MapType.prototype.maxZoom;
/**
* The minimum zoom level for the map when displaying this MapType. Optional;
* defaults to 0.
* @type {number}
*/
google.maps.MapType.prototype.minZoom;
/**
* Name to display in the MapTypeControl. Optional.
* @type {string|null}
*/
google.maps.MapType.prototype.name;
/**
* The Projection used to render this MapType. Optional; defaults to Mercator.
* @type {!google.maps.Projection|null}
*/
google.maps.MapType.prototype.projection;
/**
* Radius of the planet for the map, in meters. Optional; defaults to
* Earth's equatorial radius of 6378137 meters.
* @type {number}
*/
google.maps.MapType.prototype.radius;
/**
* The dimensions of each tile. Required.
* @type {!google.maps.Size|null}
*/
google.maps.MapType.prototype.tileSize;
/**
* Returns a tile for the given tile coordinate (x, y) and zoom level. This tile
* will be appended to the given ownerDocument. Not available for base map
* types.
* @param {!google.maps.Point} tileCoord Tile coordinates.
* @param {number} zoom Tile zoom.
* @param {!Document} ownerDocument The document which owns this tile.
* @return {!Element|null} Resulting tile.
*/
google.maps.MapType.prototype.getTile = function(
tileCoord, zoom, ownerDocument) {};
/**
* Releases the given tile, performing any necessary cleanup. The provided tile
* will have already been removed from the document. Optional.
* @param {!Element|null} tile Tile to release.
* @return {void}
*/
google.maps.MapType.prototype.releaseTile = function(tile) {};
/**
* Options for the rendering of the map type control.
* @record
*/
google.maps.MapTypeControlOptions = function() {};
/**
* IDs of map types to show in the control.
* @type {!Array|null|undefined}
*/
google.maps.MapTypeControlOptions.prototype.mapTypeIds;
/**
* Position id. Used to specify the position of the control on the map.
* @default {@link google.maps.ControlPosition.BLOCK_START_INLINE_START}
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.MapTypeControlOptions.prototype.position;
/**
* Style id. Used to select what style of map type control to display.
* @type {!google.maps.MapTypeControlStyle|null|undefined}
*/
google.maps.MapTypeControlOptions.prototype.style;
/**
* Identifiers for common MapTypesControls.
*
* Access by calling `const {MapTypeControlStyle} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {number}
*/
google.maps.MapTypeControlStyle = {
/**
* Uses the default map type control. When the DEFAULT control is
* shown, it will vary according to window size and other factors. The
* DEFAULT control may change in future versions of the API.
*/
DEFAULT: 0,
/**
* A dropdown menu for the screen realestate conscious.
*/
DROPDOWN_MENU: 1,
/**
* The standard horizontal radio buttons bar.
*/
HORIZONTAL_BAR: 2,
};
/**
* Identifiers for common MapTypes. Specify these by value, or by using the
* constant's name. For example, 'satellite' or
* google.maps.MapTypeId.SATELLITE.
*
* Access by calling `const {MapTypeId} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.MapTypeId = {
/**
* This map type displays a transparent layer of major streets on satellite
* images.
*/
HYBRID: 'hybrid',
/**
* This map type displays a normal street map.
*/
ROADMAP: 'roadmap',
/**
* This map type displays satellite images.
*/
SATELLITE: 'satellite',
/**
* This map type displays maps with physical features such as terrain and
* vegetation.
*/
TERRAIN: 'terrain',
};
/**
* A registry for MapType instances, keyed by MapType id.
*
* Access by calling `const {MapTypeRegistry} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.MapTypeRegistry = function() {};
/**
* Sets the registry to associate the passed string identifier with the passed
* MapType.
* @param {string} id Identifier of the MapType to add to the registry.
* @param {!google.maps.MapType|?} mapType MapType object to add to the
* registry.
* @return {undefined}
*/
google.maps.MapTypeRegistry.prototype.set = function(id, mapType) {};
/**
* The MapTypeStyle is a collection of selectors and stylers that
* define how the map should be styled. Selectors specify the map features
* and/or elements that should be affected, and stylers specify how those
* features and elements should be modified. For details, see the style
* reference.
* @record
*/
google.maps.MapTypeStyle = function() {};
/**
* The element to which a styler should be applied. An element is a visual
* aspect of a feature on the map. Example: a label, an icon, the stroke or fill
* applied to the geometry, and more. Optional. If elementType is
* not specified, the value is assumed to be 'all'. For details of
* usage and allowed values, see the style
* reference.
* @type {string|null|undefined}
*/
google.maps.MapTypeStyle.prototype.elementType;
/**
* The feature, or group of features, to which a styler should be applied.
* Optional. If featureType is not specified, the value is assumed
* to be 'all'. For details of usage and allowed values, see the style
* reference.
* @type {string|null|undefined}
*/
google.maps.MapTypeStyle.prototype.featureType;
/**
* The style rules to apply to the selected map features and elements. The rules
* are applied in the order that you specify in this array. For guidelines on
* usage and allowed values, see the style
* reference.
* @type {!Array}
*/
google.maps.MapTypeStyle.prototype.stylers;
/**
* @record
*/
google.maps.Maps3DLibrary = function() {};
/**
* @type {typeof google.maps.maps3d.AltitudeMode}
*/
google.maps.Maps3DLibrary.prototype.AltitudeMode;
/**
* @type {typeof google.maps.maps3d.GestureHandling}
*/
google.maps.Maps3DLibrary.prototype.GestureHandling;
/**
* @type {typeof google.maps.maps3d.LocationClickEvent}
*/
google.maps.Maps3DLibrary.prototype.LocationClickEvent;
/**
* @type {typeof google.maps.maps3d.Map3DElement}
*/
google.maps.Maps3DLibrary.prototype.Map3DElement;
/**
* @type {typeof google.maps.maps3d.MapMode}
*/
google.maps.Maps3DLibrary.prototype.MapMode;
/**
* @type {typeof google.maps.maps3d.Marker3DElement}
*/
google.maps.Maps3DLibrary.prototype.Marker3DElement;
/**
* @type {typeof google.maps.maps3d.Marker3DInteractiveElement}
*/
google.maps.Maps3DLibrary.prototype.Marker3DInteractiveElement;
/**
* @type {typeof google.maps.maps3d.Model3DElement}
*/
google.maps.Maps3DLibrary.prototype.Model3DElement;
/**
* @type {typeof google.maps.maps3d.Model3DInteractiveElement}
*/
google.maps.Maps3DLibrary.prototype.Model3DInteractiveElement;
/**
* @type {typeof google.maps.maps3d.PlaceClickEvent}
*/
google.maps.Maps3DLibrary.prototype.PlaceClickEvent;
/**
* @type {typeof google.maps.maps3d.Polygon3DElement}
*/
google.maps.Maps3DLibrary.prototype.Polygon3DElement;
/**
* @type {typeof google.maps.maps3d.Polygon3DInteractiveElement}
*/
google.maps.Maps3DLibrary.prototype.Polygon3DInteractiveElement;
/**
* @type {typeof google.maps.maps3d.Polyline3DElement}
*/
google.maps.Maps3DLibrary.prototype.Polyline3DElement;
/**
* @type {typeof google.maps.maps3d.Polyline3DInteractiveElement}
*/
google.maps.Maps3DLibrary.prototype.Polyline3DInteractiveElement;
/**
* @type {typeof google.maps.maps3d.PopoverElement}
*/
google.maps.Maps3DLibrary.prototype.PopoverElement;
/**
* @type {typeof google.maps.maps3d.SteadyChangeEvent}
*/
google.maps.Maps3DLibrary.prototype.SteadyChangeEvent;
/**
* Describes a Firebase App Check token result.
* @record
*/
google.maps.MapsAppCheckTokenResult = function() {};
/**
* An event listener, created by google.maps.event.addListener() and friends.
* @record
*/
google.maps.MapsEventListener = function() {};
/**
* Removes the listener. listener.remove() is equivalent
* to google.maps.event.removeListener(listener).
* @return {void}
*/
google.maps.MapsEventListener.prototype.remove = function() {};
/**
* @record
*/
google.maps.MapsLibrary = function() {};
/**
* @type {typeof google.maps.BicyclingLayer}
*/
google.maps.MapsLibrary.prototype.BicyclingLayer;
/**
* @type {typeof google.maps.Circle}
*/
google.maps.MapsLibrary.prototype.Circle;
/**
* @type {typeof google.maps.Data}
*/
google.maps.MapsLibrary.prototype.Data;
/**
* @type {typeof google.maps.FeatureType}
*/
google.maps.MapsLibrary.prototype.FeatureType;
/**
* @type {typeof google.maps.GroundOverlay}
*/
google.maps.MapsLibrary.prototype.GroundOverlay;
/**
* @type {typeof google.maps.ImageMapType}
*/
google.maps.MapsLibrary.prototype.ImageMapType;
/**
* @type {typeof google.maps.InfoWindow}
*/
google.maps.MapsLibrary.prototype.InfoWindow;
/**
* @type {typeof google.maps.KmlLayer}
*/
google.maps.MapsLibrary.prototype.KmlLayer;
/**
* @type {typeof google.maps.KmlLayerStatus}
*/
google.maps.MapsLibrary.prototype.KmlLayerStatus;
/**
* @type {typeof google.maps.Map}
*/
google.maps.MapsLibrary.prototype.Map;
/**
* @type {typeof google.maps.MapElement}
*/
google.maps.MapsLibrary.prototype.MapElement;
/**
* @type {typeof google.maps.MapTypeControlStyle}
*/
google.maps.MapsLibrary.prototype.MapTypeControlStyle;
/**
* @type {typeof google.maps.MapTypeId}
*/
google.maps.MapsLibrary.prototype.MapTypeId;
/**
* @type {typeof google.maps.MapTypeRegistry}
*/
google.maps.MapsLibrary.prototype.MapTypeRegistry;
/**
* @type {typeof google.maps.MaxZoomService}
*/
google.maps.MapsLibrary.prototype.MaxZoomService;
/**
* @type {typeof google.maps.MaxZoomStatus}
*/
google.maps.MapsLibrary.prototype.MaxZoomStatus;
/**
* @type {typeof google.maps.OverlayView}
*/
google.maps.MapsLibrary.prototype.OverlayView;
/**
* @type {typeof google.maps.Polygon}
*/
google.maps.MapsLibrary.prototype.Polygon;
/**
* @type {typeof google.maps.Polyline}
*/
google.maps.MapsLibrary.prototype.Polyline;
/**
* @type {typeof google.maps.Rectangle}
*/
google.maps.MapsLibrary.prototype.Rectangle;
/**
* @type {typeof google.maps.RenderingType}
*/
google.maps.MapsLibrary.prototype.RenderingType;
/**
* @type {typeof google.maps.StrokePosition}
*/
google.maps.MapsLibrary.prototype.StrokePosition;
/**
* @type {typeof google.maps.StyledMapType}
*/
google.maps.MapsLibrary.prototype.StyledMapType;
/**
* @type {typeof google.maps.TrafficLayer}
*/
google.maps.MapsLibrary.prototype.TrafficLayer;
/**
* @type {typeof google.maps.TransitLayer}
*/
google.maps.MapsLibrary.prototype.TransitLayer;
/**
* @type {typeof google.maps.WebGLOverlayView}
*/
google.maps.MapsLibrary.prototype.WebGLOverlayView;
/**
* @type {typeof google.maps.ZoomChangeEvent}
*/
google.maps.MapsLibrary.prototype.ZoomChangeEvent;
/**
* Base class for managing network errors in Maps.
*
* Access by calling `const {MapsNetworkError} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {Error}
* @constructor
*/
google.maps.MapsNetworkError = function() {};
/**
* Identifies the type of error produced by the API.
* @type {!google.maps.DirectionsStatus|!google.maps.DistanceMatrixStatus|!google.maps.ElevationStatus|!google.maps.GeocoderStatus|!google.maps.MaxZoomStatus|!google.maps.places.PlacesServiceStatus|!google.maps.RPCStatus|!google.maps.StreetViewStatus}
*/
google.maps.MapsNetworkError.prototype.code;
/**
* Represents the network service that responded with the error.
* @type {!google.maps.MapsNetworkErrorEndpoint}
*/
google.maps.MapsNetworkError.prototype.endpoint;
/**
* Identifiers for API endpoints used by {@link google.maps.MapsNetworkError}
* instances.
*
* Access by calling `const {MapsNetworkErrorEndpoint} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.MapsNetworkErrorEndpoint = {
/**
* Identifies the Routes API within the Directions API.
*/
DIRECTIONS_ROUTE: 'DIRECTIONS_ROUTE',
/**
* Identifies the DistanceMatrix API.
*/
DISTANCE_MATRIX: 'DISTANCE_MATRIX',
/**
* Identifies the getElevationsAlongPath API within the Elevation API.
*/
ELEVATION_ALONG_PATH: 'ELEVATION_ALONG_PATH',
/**
* Identifies the getElevationForLocations API within the Elevation API.
*/
ELEVATION_LOCATIONS: 'ELEVATION_LOCATIONS',
/**
* Identifies the Get DeliveryVehicle API within Fleet Engine.
*/
FLEET_ENGINE_GET_DELIVERY_VEHICLE: 'FLEET_ENGINE_GET_DELIVERY_VEHICLE',
/**
* Identifies the Get Trip API within Fleet Engine.
*/
FLEET_ENGINE_GET_TRIP: 'FLEET_ENGINE_GET_TRIP',
/**
* Identifies the Get Vehicle API within Fleet Engine.
*/
FLEET_ENGINE_GET_VEHICLE: 'FLEET_ENGINE_GET_VEHICLE',
/**
* Identifies the List DeliveryVehicles API within Fleet Engine.
*/
FLEET_ENGINE_LIST_DELIVERY_VEHICLES: 'FLEET_ENGINE_LIST_DELIVERY_VEHICLES',
/**
* Identifies the List Tasks API within Fleet Engine.
*/
FLEET_ENGINE_LIST_TASKS: 'FLEET_ENGINE_LIST_TASKS',
/**
* Identifies the List Vehicles API within Fleet Engine.
*/
FLEET_ENGINE_LIST_VEHICLES: 'FLEET_ENGINE_LIST_VEHICLES',
/**
* Identifies the Search Tasks API within Fleet Engine.
*/
FLEET_ENGINE_SEARCH_TASKS: 'FLEET_ENGINE_SEARCH_TASKS',
/**
* Identifies the geocode API within the Geocoder.
*/
GEOCODER_GEOCODE: 'GEOCODER_GEOCODE',
/**
* Identifies the MaximumZoomImageryService API within the Maps API.
*/
MAPS_MAX_ZOOM: 'MAPS_MAX_ZOOM',
/**
* Identifies the Autocomplete API within the Places API.
*/
PLACES_AUTOCOMPLETE: 'PLACES_AUTOCOMPLETE',
/**
* Identifies the Details API within the Places API.
*/
PLACES_DETAILS: 'PLACES_DETAILS',
/**
* Identifies the findPlaceFromPhoneNumber API within the Places API.
*/
PLACES_FIND_PLACE_FROM_PHONE_NUMBER: 'PLACES_FIND_PLACE_FROM_PHONE_NUMBER',
/**
* Identifies the findPlaceFromQuery API within the Places API.
*/
PLACES_FIND_PLACE_FROM_QUERY: 'PLACES_FIND_PLACE_FROM_QUERY',
/**
* Identifies the Gateway API within the Places API.
*/
PLACES_GATEWAY: 'PLACES_GATEWAY',
/**
* Identifies the Get Place API within the Places API.
*/
PLACES_GET_PLACE: 'PLACES_GET_PLACE',
/**
* Identifies the LocalContextSearch API within the Places API.
*/
PLACES_LOCAL_CONTEXT_SEARCH: 'PLACES_LOCAL_CONTEXT_SEARCH',
/**
* Identifies the NearbySearch API within the Places API.
*/
PLACES_NEARBY_SEARCH: 'PLACES_NEARBY_SEARCH',
/**
* Identifies the Search Text API within the Places API.
*/
PLACES_SEARCH_TEXT: 'PLACES_SEARCH_TEXT',
/**
* Identifies the getPanorama method within the Streetview service.
*/
STREETVIEW_GET_PANORAMA: 'STREETVIEW_GET_PANORAMA',
};
/**
* Represents a request error from a web service (i.e. the equivalent of a 4xx
* code in HTTP).
*
* Access by calling `const {MapsRequestError} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.MapsNetworkError}
* @constructor
*/
google.maps.MapsRequestError = function() {};
/**
* Represents a server-side error from a web service (i.e. the equivalent of a
* 5xx code in HTTP).
*
* Access by calling `const {MapsServerError} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.MapsNetworkError}
* @constructor
*/
google.maps.MapsServerError = function() {};
/**
*
* Access by calling `const {Marker} = await
* google.maps.importLibrary("marker")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.MarkerOptions=} opts
* @extends {google.maps.MVCObject}
* @constructor
* @deprecated As of February 21st, 2024, google.maps.Marker is deprecated.
* Please use {@link google.maps.marker.AdvancedMarkerElement} instead. At
* this time, google.maps.Marker is not scheduled to be discontinued,
* but {@link google.maps.marker.AdvancedMarkerElement} is recommended over
* google.maps.Marker. While google.maps.Marker will continue to receive bug
* fixes for any major regressions, existing bugs in google.maps.Marker will
* not be addressed. At least 12 months notice will be given before support
* is discontinued. Please see https://developers.google.com/maps/deprecations
* for additional details and https://developers.google.com/maps/documentation/javascript/advanced-markers/migration
* for the migration guide.
*/
google.maps.Marker = function(opts) {};
/**
* Get the currently running animation.
* @return {google.maps.Animation|null|undefined}
*/
google.maps.Marker.prototype.getAnimation = function() {};
/**
* Get the clickable status of the {@link google.maps.Marker}.
* @return {boolean} True if the Marker is clickable.
*/
google.maps.Marker.prototype.getClickable = function() {};
/**
* Get the mouse cursor type shown on hover.
* @return {string|null|undefined}
*/
google.maps.Marker.prototype.getCursor = function() {};
/**
* Get the draggable status of the {@link google.maps.Marker}.
* @return {boolean} True if the Marker is draggable.
*/
google.maps.Marker.prototype.getDraggable = function() {};
/**
* Get the icon of the {@link google.maps.Marker}. See {@link
* google.maps.MarkerOptions.icon}.
* @return {string|google.maps.Icon|google.maps.Symbol|null|undefined}
*/
google.maps.Marker.prototype.getIcon = function() {};
/**
* Get the label of the {@link google.maps.Marker}. See {@link
* google.maps.MarkerOptions.label}.
* @return {google.maps.MarkerLabel|string|null|undefined}
*/
google.maps.Marker.prototype.getLabel = function() {};
/**
* Get the map or panaroama the {@link google.maps.Marker} is rendered on.
* @return {!google.maps.Map|!google.maps.StreetViewPanorama|null}
*/
google.maps.Marker.prototype.getMap = function() {};
/**
* Get the opacity of the {@link google.maps.Marker}.
* @return {number|null|undefined} A number between 0.0 and 1.0.
*/
google.maps.Marker.prototype.getOpacity = function() {};
/**
* Get the position of the {@link google.maps.Marker}.
* @return {google.maps.LatLng|null|undefined}
*/
google.maps.Marker.prototype.getPosition = function() {};
/**
* Get the shape of the {@link google.maps.Marker} used for interaction.
* See {@link google.maps.MarkerOptions.shape} and {@link
* google.maps.MarkerShape}.
* @return {google.maps.MarkerShape|null|undefined}
*/
google.maps.Marker.prototype.getShape = function() {};
/**
* Get the title of the {@link google.maps.Marker} tooltip. See {@link
* google.maps.MarkerOptions.title}.
* @return {string|null|undefined}
*/
google.maps.Marker.prototype.getTitle = function() {};
/**
* Get the visibility of the {@link google.maps.Marker}.
* @return {boolean} True if the Marker is visible.
*/
google.maps.Marker.prototype.getVisible = function() {};
/**
* Get the zIndex of the {@link google.maps.Marker}. See {@link
* google.maps.MarkerOptions.zIndex}.
* @return {number|null|undefined} zIndex of the Marker.
*/
google.maps.Marker.prototype.getZIndex = function() {};
/**
* Start an animation. Any ongoing animation will be cancelled. Currently
* supported animations are: {@link google.maps.Animation.BOUNCE}, {@link
* google.maps.Animation.DROP}. Passing in null will cause any
* animation to stop.
* @param {?google.maps.Animation=} animation The animation to play.
* @return {undefined}
*/
google.maps.Marker.prototype.setAnimation = function(animation) {};
/**
* Set if the {@link google.maps.Marker} is clickable.
* @param {boolean} flag If true, the Marker can be clicked.
* @return {undefined}
*/
google.maps.Marker.prototype.setClickable = function(flag) {};
/**
* Set the mouse cursor type shown on hover.
* @param {?string=} cursor Mouse cursor type.
* @return {undefined}
*/
google.maps.Marker.prototype.setCursor = function(cursor) {};
/**
* Set if the {@link google.maps.Marker} is draggable.
* @param {?boolean} flag If true, the Marker can be dragged.
* @return {undefined}
*/
google.maps.Marker.prototype.setDraggable = function(flag) {};
/**
* Set the icon for the {@link google.maps.Marker}. See {@link
* google.maps.MarkerOptions.icon}.
* @param {(string|google.maps.Icon|google.maps.Symbol|null)=} icon
* @return {undefined}
*/
google.maps.Marker.prototype.setIcon = function(icon) {};
/**
* Set the label for the {@link google.maps.Marker}. See {@link
* google.maps.MarkerOptions.label}.
* @param {(string|google.maps.MarkerLabel|null)=} label The label can either be
* a character string or a {@link google.maps.MarkerLabel} object.
* @return {undefined}
*/
google.maps.Marker.prototype.setLabel = function(label) {};
/**
* Renders the {@link google.maps.Marker} on the specified map or panorama. If
* map is set to null, the marker will be removed.
* @param {!google.maps.Map|!google.maps.StreetViewPanorama|null} map
* @return {undefined}
*/
google.maps.Marker.prototype.setMap = function(map) {};
/**
* Set the opacity of the {@link google.maps.Marker}.
* @param {?number=} opacity A number between 0.0, transparent, and 1.0, opaque.
* @return {undefined}
*/
google.maps.Marker.prototype.setOpacity = function(opacity) {};
/**
* Set the options for the {@link google.maps.Marker}.
* @param {!google.maps.MarkerOptions|null} options
* @return {undefined}
*/
google.maps.Marker.prototype.setOptions = function(options) {};
/**
* Set the postition for the {@link google.maps.Marker}.
* @param {(google.maps.LatLng|google.maps.LatLngLiteral|null)=} latlng The new
* position.
* @return {undefined}
*/
google.maps.Marker.prototype.setPosition = function(latlng) {};
/**
* Set the shape of the {@link google.maps.Marker} used for interaction.
* See {@link google.maps.MarkerOptions.shape} and {@link
* google.maps.MarkerShape}.
* @param {?google.maps.MarkerShape=} shape
* @return {undefined}
*/
google.maps.Marker.prototype.setShape = function(shape) {};
/**
* Set the title of the {@link google.maps.Marker} tooltip. See {@link
* google.maps.MarkerOptions.title}.
* @param {?string=} title
* @return {undefined}
*/
google.maps.Marker.prototype.setTitle = function(title) {};
/**
* Set if the {@link google.maps.Marker} is visible.
* @param {boolean} visible If true, the Marker is visible
* @return {undefined}
*/
google.maps.Marker.prototype.setVisible = function(visible) {};
/**
* Set the zIndex of the {@link google.maps.Marker}. See {@link
* google.maps.MarkerOptions.zIndex}.
* @param {?number=} zIndex
* @return {undefined}
*/
google.maps.Marker.prototype.setZIndex = function(zIndex) {};
/**
* The maximum default z-index that the API will assign to a marker. You may set
* a higher z-index to bring a marker to the front.
* @const
* @type {number}
*/
google.maps.Marker.MAX_ZINDEX;
/**
* These options specify the appearance of a marker label. A marker label is a
* string (often a single character) which will appear inside the marker. If you
* are using it with a custom marker, you can reposition it with the
* labelOrigin property in the Icon class.
* @record
*/
google.maps.MarkerLabel = function() {};
/**
* The className property of the label's element (equivalent to the
* element's class attribute). Multiple space-separated CSS classes can be
* added. The font color, size, weight, and family can only be set via the other
* properties of MarkerLabel. CSS classes should not be used to
* change the position nor orientation of the label (e.g. using translations and
* rotations) if also using marker
* collision management.
* @default '' (empty string)
* @type {string|undefined}
*/
google.maps.MarkerLabel.prototype.className;
/**
* The color of the label text.
* @default 'black'
* @type {string|undefined}
*/
google.maps.MarkerLabel.prototype.color;
/**
* The font family of the label text (equivalent to the CSS font-family
* property).
* @type {string|undefined}
*/
google.maps.MarkerLabel.prototype.fontFamily;
/**
* The font size of the label text (equivalent to the CSS font-size property).
* @default '14px'
* @type {string|undefined}
*/
google.maps.MarkerLabel.prototype.fontSize;
/**
* The font weight of the label text (equivalent to the CSS font-weight
* property).
* @type {string|undefined}
*/
google.maps.MarkerLabel.prototype.fontWeight;
/**
* The text to be displayed in the label.
* @type {string}
*/
google.maps.MarkerLabel.prototype.text;
/**
* @record
*/
google.maps.MarkerLibrary = function() {};
/**
* @type {typeof google.maps.marker.AdvancedMarkerClickEvent}
*/
google.maps.MarkerLibrary.prototype.AdvancedMarkerClickEvent;
/**
* @type {typeof google.maps.marker.AdvancedMarkerElement}
*/
google.maps.MarkerLibrary.prototype.AdvancedMarkerElement;
/**
* @type {typeof google.maps.Animation}
*/
google.maps.MarkerLibrary.prototype.Animation;
/**
* @type {typeof google.maps.CollisionBehavior}
*/
google.maps.MarkerLibrary.prototype.CollisionBehavior;
/**
* @type {typeof google.maps.Marker}
*/
google.maps.MarkerLibrary.prototype.Marker;
/**
* @type {typeof google.maps.marker.PinElement}
*/
google.maps.MarkerLibrary.prototype.PinElement;
/**
* MarkerOptions object used to define the properties that can be set on a
* Marker.
* @record
* @deprecated As of February 21st, 2024, google.maps.Marker is deprecated.
* Please use google.maps.marker.AdvancedMarkerElement instead. Please see
* https://developers.google.com/maps/deprecations
* for deprecation details and https://developers.google.com/maps/documentation/javascript/advanced-markers/migration
* for the migration guide.
*/
google.maps.MarkerOptions = function() {};
/**
* The offset from the marker's position to the tip of an InfoWindow that
* has been opened with the marker as anchor.
* @type {!google.maps.Point|null|undefined}
*/
google.maps.MarkerOptions.prototype.anchorPoint;
/**
* Which animation to play when marker is added to a map.
* @default null
* @type {!google.maps.Animation|null|undefined}
*/
google.maps.MarkerOptions.prototype.animation;
/**
* If true, the marker receives mouse and touch events.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.MarkerOptions.prototype.clickable;
/**
* If false, disables cross that appears beneath the marker when
* dragging.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.MarkerOptions.prototype.crossOnDrag;
/**
* Mouse cursor type to show on hover.
* @default pointer
* @type {string|null|undefined}
*/
google.maps.MarkerOptions.prototype.cursor;
/**
* If true, the marker can be dragged. Note: Setting this to
* true will make the marker clickable even if
* clickable is set to false.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.MarkerOptions.prototype.draggable;
/**
* Icon for the foreground. If a string is provided, it is treated as though it
* were an Icon with the string as url.
* @type {string|!google.maps.Icon|!google.maps.Symbol|null|undefined}
*/
google.maps.MarkerOptions.prototype.icon;
/**
* Adds a label to the marker. A marker label is a letter or number that appears
* inside a marker. The label can either be a string, or a
* MarkerLabel object. If provided and {@link
* google.maps.MarkerOptions.title} is not provided, an accessibility text (e.g.
* for use with screen readers) will be added to the marker with the provided
* label's text. Please note that the label is currently only
* used for accessibility text for non-optimized markers.
* @default null
* @type {string|!google.maps.MarkerLabel|null|undefined}
*/
google.maps.MarkerOptions.prototype.label;
/**
* Map on which to display Marker. The map is required to display the marker and
* can be provided with {@link google.maps.Marker.setMap} if not provided at
* marker construction.
* @type {!google.maps.Map|!google.maps.StreetViewPanorama|null|undefined}
*/
google.maps.MarkerOptions.prototype.map;
/**
* A number between 0.0, transparent, and 1.0, opaque.
* @default 1.0
* @type {number|null|undefined}
*/
google.maps.MarkerOptions.prototype.opacity;
/**
* Optimization enhances performance by rendering many markers as a single
* static element. This is useful in cases where a large number of markers is
* required. Read more about marker
* optimization. Note: This optimization has no effect for markers on
* vector maps.
* @type {boolean|null|undefined}
*/
google.maps.MarkerOptions.prototype.optimized;
/**
* Sets the marker position. A marker may be constructed but not displayed until
* its position is provided - for example, by a user's actions or choices. A
* marker position can be provided with {@link google.maps.Marker.setPosition}
* if not provided at marker construction.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.MarkerOptions.prototype.position;
/**
* Image map region definition used for drag/click.
* @type {!google.maps.MarkerShape|null|undefined}
*/
google.maps.MarkerOptions.prototype.shape;
/**
* Rollover text. If provided, an accessibility text (e.g. for use with screen
* readers) will be added to the marker with the provided value. Please note
* that the title is currently only used for accessibility text for
* non-optimized markers.
* @default undefined
* @type {string|null|undefined}
*/
google.maps.MarkerOptions.prototype.title;
/**
* If true, the marker is visible.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.MarkerOptions.prototype.visible;
/**
* All markers are displayed on the map in order of their zIndex, with higher
* values displaying in front of markers with lower values. By default, markers
* are displayed according to their vertical position on screen, with lower
* markers appearing in front of markers further up the screen.
* @type {number|null|undefined}
*/
google.maps.MarkerOptions.prototype.zIndex;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* Set a collision behavior for markers on vector maps.
* @default null
* @type {string|!google.maps.CollisionBehavior|null|undefined}
* @deprecated collisionBehavior is deprecated as of July 2023.
* Use {@link google.maps.marker.AdvancedMarkerElement.collisionBehavior}
* instead.
*/
google.maps.MarkerOptions.prototype.collisionBehavior;
/**
* This object defines the clickable region of a marker image. The shape
* consists of two properties — type and coord
* — which define the non-transparent region of an image.
* @record
*/
google.maps.MarkerShape = function() {};
/**
* The format of this attribute depends on the value of the type
* and follows the w3 AREA coords specification found at
* http://www.w3.org/TR/REC-html40/struct/objects.html#adef-coords.
The
* coords attribute is an array of integers that specify the pixel
* position of the shape relative to the top-left corner of the target image.
* The coordinates depend on the value of type as follows:
*
- circle: coords is [x1,y1,r] where
* x1,y2 are the coordinates of the center of the circle, and r is the radius of
* the circle.
- poly: coords is
* [x1,y1,x2,y2...xn,yn] where each x,y pair contains the
* coordinates of one vertex of the polygon.
-
* rect: coords is [x1,y1,x2,y2] where x1,y1 are the
* coordinates of the upper-left corner of the rectangle and x2,y2 are the
* coordinates of the lower-right coordinates of the rectangle.
* @type {!Arraycircle,
* poly or rect.
* @type {string}
*/
google.maps.MarkerShape.prototype.type;
/**
* A MaxZoom result in JSON format retrieved from the MaxZoomService.
* @record
*/
google.maps.MaxZoomResult = function() {};
/**
* Status of the request. This property is only defined when using callbacks
* with {@link google.maps.MaxZoomService.getMaxZoomAtLatLng} (it is not defined
* when using Promises).
* @type {!google.maps.MaxZoomStatus|null}
*/
google.maps.MaxZoomResult.prototype.status;
/**
* The maximum zoom level found at the given LatLng.
* @type {number}
*/
google.maps.MaxZoomResult.prototype.zoom;
/**
* A service for obtaining the highest zoom level at which satellite imagery is
* available for a given location.
*
* Access by calling `const {MaxZoomService} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.MaxZoomService = function() {};
/**
* Returns the maximum zoom level for which detailed imagery is available at a
* particular LatLng for the satellite map type. As
* this request is asynchronous, you must pass a callback function
* which will be executed upon completion of the request, being passed a
* MaxZoomResult.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} latlng
* @param {(function(!google.maps.MaxZoomResult): void)=} callback
* @return {!Promise}
*/
google.maps.MaxZoomService.prototype.getMaxZoomAtLatLng = function(
latlng, callback) {};
/**
* The status returned by the MaxZoomService on the completion of a
* call to getMaxZoomAtLatLng(). Specify these by value, or by
* using the constant's name. For example, 'OK' or
* google.maps.MaxZoomStatus.OK.
*
* Access by calling `const {MaxZoomStatus} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.MaxZoomStatus = {
/**
* An unknown error occurred.
*/
ERROR: 'ERROR',
/**
* The response contains a valid MaxZoomResult.
*/
OK: 'OK',
};
/**
* Options for the rendering of the motion tracking control.
* @record
*/
google.maps.MotionTrackingControlOptions = function() {};
/**
* Position id. This is used to specify the position of this control on the
* panorama.
* @default {@link google.maps.ControlPosition.INLINE_END_BLOCK_END}
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.MotionTrackingControlOptions.prototype.position;
/**
* A Orientation3D is a three-dimensional vector used for standard
* mathematical rotation transformations along heading, tilt, and roll.
*
*
* Access by calling `const {Orientation3D} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.Orientation3D|!google.maps.Orientation3DLiteral} value
* The initializing value.
* @implements {google.maps.Orientation3DLiteral}
* @constructor
*/
google.maps.Orientation3D = function(value) {};
/**
* Rotation about the z-axis (normal to the Earth's surface). A value of 0
* (the default) equals North. A positive rotation is clockwise around the
* z-axis and specified in degrees from 0 to 360. Values above or below this
* range will be wrapped so that they fall within the range. For example, a
* value of -190 will be converted to 170. A value of 530 will be converted to
* 170 as well.
* @default 0
* @type {number}
*/
google.maps.Orientation3D.prototype.heading;
/**
* Rotation about the y-axis. A positive rotation is clockwise around the y-axis
* and specified in degrees from 0 to 360. Values above or below this range will
* be wrapped so that they fall within the range. For example, a value of -190
* will be converted to 170. A value of 530 will be converted to 170 as well.
* @default 0
* @type {number}
*/
google.maps.Orientation3D.prototype.roll;
/**
* Rotation about the x-axis. A positive rotation is clockwise around the x-axis
* and specified in degrees from 0 to 360. Values above or below this range will
* be wrapped so that they fall within the range. For example, a value of -190
* will be converted to 170. A value of 530 will be converted to 170 as well.
* @default 0
* @type {number}
*/
google.maps.Orientation3D.prototype.tilt;
/**
* Comparison function.
* @param {!google.maps.Orientation3D|!google.maps.Orientation3DLiteral|null}
* other Another Orientation3D object.
* @return {boolean} Whether the two objects are equal.
*/
google.maps.Orientation3D.prototype.equals = function(other) {};
/**
* Converts to JSON representation. This function is intended to be used via
* JSON.stringify.
* @return {!google.maps.Orientation3DLiteral}
*/
google.maps.Orientation3D.prototype.toJSON = function() {};
/**
* Object literals are accepted in place of Orientation3D objects,
* as a convenience, in many places. These are converted to
* Orientation3D objects when the Maps API encounters them.
* @record
*/
google.maps.Orientation3DLiteral = function() {};
/**
* Rotation about the z-axis (normal to the Earth's surface). A value of 0
* (the default) equals North. A positive rotation is clockwise around the
* z-axis and specified in degrees from 0 to 360.
* @type {number|null|undefined}
*/
google.maps.Orientation3DLiteral.prototype.heading;
/**
* Rotation about the y-axis. A positive rotation is clockwise around the y-axis
* and specified in degrees from 0 to 360.
* @type {number|null|undefined}
*/
google.maps.Orientation3DLiteral.prototype.roll;
/**
* Rotation about the x-axis. A positive rotation is clockwise around the x-axis
* and specified in degrees from 0 to 360.
* @type {number|null|undefined}
*/
google.maps.Orientation3DLiteral.prototype.tilt;
/**
* You can implement this class if you want to display custom types of overlay
* objects on the map.
Inherit from this class by setting your
* overlay's prototype: MyOverlay.prototype = new
* google.maps.OverlayView();. The OverlayView constructor
* is guaranteed to be an empty function.
You must implement three
* methods: onAdd(), draw(), and
* onRemove().
You must call onAdd() method, you
* should create DOM objects and append them as children of the panes.draw() method, you should position these
* elements.onRemove() method, you should remove
* the objects from the DOM.setMap() with
* a valid Map object to trigger the call to the
* onAdd() method and setMap(null) in order to trigger
* the onRemove() method. The setMap() method can be
* called at the time of construction or at any point afterward when the overlay
* should be re-shown after removing. The draw() method will then
* be called whenever a map property changes that could change the position of
* the element, such as zoom, center, or map type.
*
* Access by calling `const {OverlayView} = await
* google.maps.importLibrary("maps")` or `const {OverlayView} = await
* google.maps.importLibrary("streetView")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.OverlayView = function() {};
/**
* Stops click, tap, drag, and wheel events on the element from bubbling up to
* the map. Use this to prevent map dragging and zooming, as well as map
* "click" events.
* @param {!Element} element
* @return {undefined}
*/
google.maps.OverlayView.preventMapHitsAndGesturesFrom = function(element) {};
/**
* Stops click or tap on the element from bubbling up to the map. Use this to
* prevent the map from triggering "click" events.
* @param {!Element} element
* @return {undefined}
*/
google.maps.OverlayView.preventMapHitsFrom = function(element) {};
/**
* Implement this method to draw or update the overlay. Use the position from
* projection.fromLatLngToDivPixel() to correctly position the overlay relative
* to the MapPanes. This method is called after onAdd(), and is called on change
* of zoom or center. It is not recommended to do computationally expensive work
* in this method.
* @return {undefined}
*/
google.maps.OverlayView.prototype.draw = function() {};
/**
* @return {google.maps.Map|google.maps.StreetViewPanorama}
*/
google.maps.OverlayView.prototype.getMap = function() {};
/**
* Returns the panes in which this OverlayView can be rendered. The panes are
* not initialized until onAdd is called by the API.
* @return {?google.maps.MapPanes}
*/
google.maps.OverlayView.prototype.getPanes = function() {};
/**
* Returns the MapCanvasProjection object associated with this
* OverlayView. The projection is not initialized until
* onAdd is called by the API.
* @return {!google.maps.MapCanvasProjection}
*/
google.maps.OverlayView.prototype.getProjection = function() {};
/**
* Implement this method to initialize the overlay DOM elements. This method is
* called once after setMap() is called with a valid map. At this point, panes
* and projection will have been initialized.
* @return {undefined}
*/
google.maps.OverlayView.prototype.onAdd = function() {};
/**
* Implement this method to remove your elements from the DOM. This method is
* called once following a call to setMap(null).
* @return {undefined}
*/
google.maps.OverlayView.prototype.onRemove = function() {};
/**
* Adds the overlay to the map or panorama.
* @param {google.maps.Map|google.maps.StreetViewPanorama|null} map The map or
* panorama. If null, the layer will be removed.
* @return {undefined}
*/
google.maps.OverlayView.prototype.setMap = function(map) {};
/**
* @record
*/
google.maps.Padding = function() {};
/**
* Padding for the bottom, in pixels.
* @type {number|undefined}
*/
google.maps.Padding.prototype.bottom;
/**
* Padding for the left, in pixels.
* @type {number|undefined}
*/
google.maps.Padding.prototype.left;
/**
* Padding for the right, in pixels.
* @type {number|undefined}
*/
google.maps.Padding.prototype.right;
/**
* Padding for the top, in pixels.
* @type {number|undefined}
*/
google.maps.Padding.prototype.top;
/**
* Options for the rendering of the pan control.
* @record
*/
google.maps.PanControlOptions = function() {};
/**
* Position id. Used to specify the position of the control on the map.
* @default {@link google.maps.ControlPosition.INLINE_END_BLOCK_END}
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.PanControlOptions.prototype.position;
/**
* Options for the Custom Pano Provider.
* @record
*/
google.maps.PanoProviderOptions = function() {};
/**
* If set, the renderer will use technologies (like webgl) that only work when
* cors headers are appropriately set on the provided images. It is the
* developer's task to serve the images correctly in combination with this
* flag, which might otherwise lead to SecurityErrors.
* @type {boolean|undefined}
*/
google.maps.PanoProviderOptions.prototype.cors;
/**
* An elevation query sent by the ElevationService containing the
* path along which to return sampled data. This request defines a continuous
* path along the earth along which elevation samples should be taken at
* evenly-spaced distances. All paths from vertex to vertex use segments of the
* great circle between those two points.
* @record
*/
google.maps.PathElevationRequest = function() {};
/**
* The path along which to collect elevation values.
* @type {!Array|null|undefined}
*/
google.maps.PathElevationRequest.prototype.path;
/**
* Required. The number of equidistant points along the given path for which to
* retrieve elevation data, including the endpoints. The number of samples must
* be a value between 2 and 512 inclusive.
* @type {number}
*/
google.maps.PathElevationRequest.prototype.samples;
/**
* An elevation response returned by the {@link google.maps.ElevationService}
* containing the list of {@link google.maps.ElevationResult}s evenly-spaced
* along the path of the {@link google.maps.PathElevationRequest}.
* @record
*/
google.maps.PathElevationResponse = function() {};
/**
* The list of {@link google.maps.ElevationResult}s matching the samples of
* the {@link google.maps.PathElevationRequest}.
* @type {!Array}
*/
google.maps.PathElevationResponse.prototype.results;
/**
* Contains information needed to locate, identify, or describe a place for
* a {@link google.maps.DirectionsRequest} or {@link
* google.maps.DistanceMatrixRequest}. In this context, "place" means
* a business, point of interest, or geographic location. For fetching
* information about a place, see {@link google.maps.places.PlacesService}.
* @record
*/
google.maps.Place = function() {};
/**
* The LatLng of the entity described by this place.
* @type {google.maps.LatLng|google.maps.LatLngLiteral|null|undefined}
*/
google.maps.Place.prototype.location;
/**
* The place ID of the place (such as a business or point of interest). The
* place ID is a unique identifier of a place in the Google Maps database. Note
* that the placeId is the most accurate way of identifying a
* place. If possible, you should specify the placeId rather than a
* query. A place ID can be retrieved from any request to the
* Places API, such as a TextSearch.
* Place IDs can also be retrieved from requests to the Geocoding API. For more
* information, see the overview
* of place IDs.
* @type {string|undefined}
*/
google.maps.Place.prototype.placeId;
/**
* A search query describing the place (such as a business or point of
* interest). An example query is "Quay, Upper Level, Overseas Passenger
* Terminal 5 Hickson Road, The Rocks NSW". If possible, you should specify
* the placeId rather than a query. The API does not
* guarantee the accuracy of resolving the query string to a place. If both the
* placeId and query are provided, an error occurs.
* @type {string|undefined}
*/
google.maps.Place.prototype.query;
/**
* An interface representing a feature with a place ID which includes features
* of type {@link google.maps.FeatureType.ADMINISTRATIVE_AREA_LEVEL_1}, {@link
* google.maps.FeatureType.ADMINISTRATIVE_AREA_LEVEL_2}, {@link
* google.maps.FeatureType.COUNTRY}, {@link
* google.maps.FeatureType.LOCALITY}, {@link
* google.maps.FeatureType.POSTAL_CODE}, and {@link
* google.maps.FeatureType.SCHOOL_DISTRICT}.
* @extends {google.maps.Feature}
* @record
*/
google.maps.PlaceFeature = function() {};
/**
* The {@link google.maps.places.PlaceResult.place_id}.
* @type {string}
*/
google.maps.PlaceFeature.prototype.placeId;
/**
* Fetches a Place for this PlaceFeature. In the
* resulting Place object, the id and the
* displayName properties will be populated. The display name will
* be in the language the end user sees on the map. (Additional fields can be
* subsequently requested via Place.fetchFields() subject to normal
* Places API enablement and billing.) Do not call this from a
* FeatureStyleFunction since only synchronous
* FeatureStyleFunctions are supported. The promise is rejected if there was an
* error fetching the Place.
* @return {!Promise}
*/
google.maps.PlaceFeature.prototype.fetchPlace = function() {};
/**
* @record
*/
google.maps.PlacesLibrary = function() {};
/**
* @type {typeof google.maps.places.AccessibilityOptions}
*/
google.maps.PlacesLibrary.prototype.AccessibilityOptions;
/**
* @type {typeof google.maps.places.AddressComponent}
*/
google.maps.PlacesLibrary.prototype.AddressComponent;
/**
* @type {typeof google.maps.places.Attribution}
*/
google.maps.PlacesLibrary.prototype.Attribution;
/**
* @type {typeof google.maps.places.AuthorAttribution}
*/
google.maps.PlacesLibrary.prototype.AuthorAttribution;
/**
* @type {typeof google.maps.places.Autocomplete}
*/
google.maps.PlacesLibrary.prototype.Autocomplete;
/**
* @type {typeof google.maps.places.AutocompleteService}
*/
google.maps.PlacesLibrary.prototype.AutocompleteService;
/**
* @type {typeof google.maps.places.AutocompleteSessionToken}
*/
google.maps.PlacesLibrary.prototype.AutocompleteSessionToken;
/**
* @type {typeof google.maps.places.AutocompleteSuggestion}
*/
google.maps.PlacesLibrary.prototype.AutocompleteSuggestion;
/**
* @type {typeof google.maps.places.BusinessStatus}
*/
google.maps.PlacesLibrary.prototype.BusinessStatus;
/**
* @type {typeof google.maps.places.ConnectorAggregation}
*/
google.maps.PlacesLibrary.prototype.ConnectorAggregation;
/**
* @type {typeof google.maps.places.ConsumerAlert}
*/
google.maps.PlacesLibrary.prototype.ConsumerAlert;
/**
* @type {typeof google.maps.places.ConsumerAlertDetails}
*/
google.maps.PlacesLibrary.prototype.ConsumerAlertDetails;
/**
* @type {typeof google.maps.places.EVChargeOptions}
*/
google.maps.PlacesLibrary.prototype.EVChargeOptions;
/**
* @type {typeof google.maps.places.EVConnectorType}
*/
google.maps.PlacesLibrary.prototype.EVConnectorType;
/**
* @type {typeof google.maps.places.FormattableText}
*/
google.maps.PlacesLibrary.prototype.FormattableText;
/**
* @type {typeof google.maps.places.FuelOptions}
*/
google.maps.PlacesLibrary.prototype.FuelOptions;
/**
* @type {typeof google.maps.places.FuelPrice}
*/
google.maps.PlacesLibrary.prototype.FuelPrice;
/**
* @type {typeof google.maps.places.FuelType}
*/
google.maps.PlacesLibrary.prototype.FuelType;
/**
* @type {typeof google.maps.places.GoogleMapsLinks}
*/
google.maps.PlacesLibrary.prototype.GoogleMapsLinks;
/**
* @type {typeof google.maps.places.Money}
*/
google.maps.PlacesLibrary.prototype.Money;
/**
* @type {typeof google.maps.places.OpeningHours}
*/
google.maps.PlacesLibrary.prototype.OpeningHours;
/**
* @type {typeof google.maps.places.OpeningHoursPeriod}
*/
google.maps.PlacesLibrary.prototype.OpeningHoursPeriod;
/**
* @type {typeof google.maps.places.OpeningHoursPoint}
*/
google.maps.PlacesLibrary.prototype.OpeningHoursPoint;
/**
* @type {typeof google.maps.places.ParkingOptions}
*/
google.maps.PlacesLibrary.prototype.ParkingOptions;
/**
* @type {typeof google.maps.places.PaymentOptions}
*/
google.maps.PlacesLibrary.prototype.PaymentOptions;
/**
* @type {typeof google.maps.places.Photo}
*/
google.maps.PlacesLibrary.prototype.Photo;
/**
* @type {typeof google.maps.places.Place}
*/
google.maps.PlacesLibrary.prototype.Place;
/**
* @type {typeof google.maps.places.PlaceContextualElement}
*/
google.maps.PlacesLibrary.prototype.PlaceContextualElement;
/**
* @type {typeof google.maps.places.PlaceContextualListConfigElement}
*/
google.maps.PlacesLibrary.prototype.PlaceContextualListConfigElement;
/**
* @type {typeof google.maps.places.PlaceContextualListLayout}
*/
google.maps.PlacesLibrary.prototype.PlaceContextualListLayout;
/**
* @type {typeof google.maps.places.PlacePrediction}
*/
google.maps.PlacesLibrary.prototype.PlacePrediction;
/**
* @type {typeof google.maps.places.PlacesService}
*/
google.maps.PlacesLibrary.prototype.PlacesService;
/**
* @type {typeof google.maps.places.PlacesServiceStatus}
*/
google.maps.PlacesLibrary.prototype.PlacesServiceStatus;
/**
* @type {typeof google.maps.places.PlusCode}
*/
google.maps.PlacesLibrary.prototype.PlusCode;
/**
* @type {typeof google.maps.places.PostalAddress}
*/
google.maps.PlacesLibrary.prototype.PostalAddress;
/**
* @type {typeof google.maps.places.PriceLevel}
*/
google.maps.PlacesLibrary.prototype.PriceLevel;
/**
* @type {typeof google.maps.places.PriceRange}
*/
google.maps.PlacesLibrary.prototype.PriceRange;
/**
* @type {typeof google.maps.places.RankBy}
*/
google.maps.PlacesLibrary.prototype.RankBy;
/**
* @type {typeof google.maps.places.Review}
*/
google.maps.PlacesLibrary.prototype.Review;
/**
* @type {typeof google.maps.places.SearchBox}
*/
google.maps.PlacesLibrary.prototype.SearchBox;
/**
* @type {typeof google.maps.places.SearchByTextRankPreference}
*/
google.maps.PlacesLibrary.prototype.SearchByTextRankPreference;
/**
* @type {typeof google.maps.places.SearchNearbyRankPreference}
*/
google.maps.PlacesLibrary.prototype.SearchNearbyRankPreference;
/**
* @type {typeof google.maps.places.StringRange}
*/
google.maps.PlacesLibrary.prototype.StringRange;
/**
*
* Access by calling `const {Point} = await google.maps.importLibrary("core")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {number} x
* @param {number} y
* @constructor
*/
google.maps.Point = function(x, y) {};
/**
* The X coordinate
* @type {number}
*/
google.maps.Point.prototype.x;
/**
* The Y coordinate
* @type {number}
*/
google.maps.Point.prototype.y;
/**
* Compares two Points
* @param {!google.maps.Point|null} other
* @return {boolean}
*/
google.maps.Point.prototype.equals = function(other) {};
/**
* Returns a string representation of this Point.
* @return {string}
* @override
*/
google.maps.Point.prototype.toString = function() {};
/**
* This object is returned from mouse events on polylines and polygons.
* @extends {google.maps.MapMouseEvent}
* @record
*/
google.maps.PolyMouseEvent = function() {};
/**
* The index of the edge within the path beneath the cursor when the event
* occurred, if the event occurred on a mid-point on an editable polygon.
* @type {number|undefined}
*/
google.maps.PolyMouseEvent.prototype.edge;
/**
* The index of the path beneath the cursor when the event occurred, if the
* event occurred on a vertex and the polygon is editable. Otherwise
* undefined.
* @type {number|undefined}
*/
google.maps.PolyMouseEvent.prototype.path;
/**
* The index of the vertex beneath the cursor when the event occurred, if the
* event occurred on a vertex and the polyline or polygon is editable. If the
* event does not occur on a vertex, the value is undefined.
* @type {number|undefined}
*/
google.maps.PolyMouseEvent.prototype.vertex;
/**
* A polygon (like a polyline) defines a series of connected coordinates in an
* ordered sequence. Additionally, polygons form a closed loop and define a
* filled region. See the samples in the developer's guide, starting with a
* simple
* polygon, a polygon
* with a hole, and more. Note that you can also use the Data
* layer to create a polygon. The Data layer offers a simpler way of
* creating holes because it handles the order of the inner and outer paths for
* you.
*
* Access by calling `const {Polygon} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {(!google.maps.PolygonOptions|null)=} opts
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.Polygon = function(opts) {};
/**
* Returns whether this shape can be dragged by the user.
* @return {boolean}
*/
google.maps.Polygon.prototype.getDraggable = function() {};
/**
* Returns whether this shape can be edited by the user.
* @return {boolean}
*/
google.maps.Polygon.prototype.getEditable = function() {};
/**
* Returns the map on which this shape is attached.
* @return {!google.maps.Map|null}
*/
google.maps.Polygon.prototype.getMap = function() {};
/**
* Retrieves the first path.
* @return {!google.maps.MVCArray}
*/
google.maps.Polygon.prototype.getPath = function() {};
/**
* Retrieves the paths for this polygon.
* @return {!google.maps.MVCArray>}
*/
google.maps.Polygon.prototype.getPaths = function() {};
/**
* Returns whether this poly is visible on the map.
* @return {boolean}
*/
google.maps.Polygon.prototype.getVisible = function() {};
/**
* If set to true, the user can drag this shape over the map. The
* geodesic property defines the mode of dragging.
* @param {boolean} draggable
* @return {undefined}
*/
google.maps.Polygon.prototype.setDraggable = function(draggable) {};
/**
* If set to true, the user can edit this shape by dragging the
* control points shown at the vertices and on each segment.
* @param {boolean} editable
* @return {undefined}
*/
google.maps.Polygon.prototype.setEditable = function(editable) {};
/**
* Renders this shape on the specified map. If map is set to null,
* the shape will be removed.
* @param {!google.maps.Map|null} map
* @return {undefined}
*/
google.maps.Polygon.prototype.setMap = function(map) {};
/**
* @param {!google.maps.PolygonOptions|null} options
* @return {undefined}
*/
google.maps.Polygon.prototype.setOptions = function(options) {};
/**
* Sets the first path. See PolygonOptions for more details.
* @param {!google.maps.MVCArray|!Array}
* path
* @return {undefined}
*/
google.maps.Polygon.prototype.setPath = function(path) {};
/**
* Sets the path for this polygon.
* @param {!google.maps.MVCArray>|!google.maps.MVCArray|!Array>|!Array}
* paths
* @return {undefined}
*/
google.maps.Polygon.prototype.setPaths = function(paths) {};
/**
* Hides this poly if set to false.
* @param {boolean} visible
* @return {undefined}
*/
google.maps.Polygon.prototype.setVisible = function(visible) {};
/**
* PolygonOptions object used to define the properties that can be set on a
* Polygon.
* @record
*/
google.maps.PolygonOptions = function() {};
/**
* Indicates whether this Polygon handles mouse events.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.PolygonOptions.prototype.clickable;
/**
* If set to true, the user can drag this shape over the map. The
* geodesic property defines the mode of dragging.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.PolygonOptions.prototype.draggable;
/**
* If set to true, the user can edit this shape by dragging the
* control points shown at the vertices and on each segment.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.PolygonOptions.prototype.editable;
/**
* The fill color. All CSS3 colors are supported except for extended named
* colors.
* @type {string|null|undefined}
*/
google.maps.PolygonOptions.prototype.fillColor;
/**
* The fill opacity between 0.0 and 1.0
* @type {number|null|undefined}
*/
google.maps.PolygonOptions.prototype.fillOpacity;
/**
* When true, edges of the polygon are interpreted as geodesic and
* will follow the curvature of the Earth. When false, edges of the
* polygon are rendered as straight lines in screen space. Note that the shape
* of a geodesic polygon may appear to change when dragged, as the dimensions
* are maintained relative to the surface of the earth.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.PolygonOptions.prototype.geodesic;
/**
* Map on which to display Polygon.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.PolygonOptions.prototype.map;
/**
* The ordered sequence of coordinates that designates a closed loop. Unlike
* polylines, a polygon may consist of one or more paths. As a result, the paths
* property may specify one or more arrays of LatLng coordinates.
* Paths are closed automatically; do not repeat the first vertex of the path as
* the last vertex. Simple polygons may be defined using a single array of
* LatLngs. More complex polygons may specify an array of arrays.
* Any simple arrays are converted into MVCArrays. Inserting or removing
* LatLngs from the MVCArray will automatically update
* the polygon on the map.
* @type {!google.maps.MVCArray>|!google.maps.MVCArray|!Array>|!Array|null|undefined}
*/
google.maps.PolygonOptions.prototype.paths;
/**
* The stroke color. All CSS3 colors are supported except for extended named
* colors.
* @type {string|null|undefined}
*/
google.maps.PolygonOptions.prototype.strokeColor;
/**
* The stroke opacity between 0.0 and 1.0
* @type {number|null|undefined}
*/
google.maps.PolygonOptions.prototype.strokeOpacity;
/**
* The stroke position.
* @default {@link google.maps.StrokePosition.CENTER}
* @type {!google.maps.StrokePosition|null|undefined}
*/
google.maps.PolygonOptions.prototype.strokePosition;
/**
* The stroke width in pixels.
* @type {number|null|undefined}
*/
google.maps.PolygonOptions.prototype.strokeWeight;
/**
* Whether this polygon is visible on the map.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.PolygonOptions.prototype.visible;
/**
* The zIndex compared to other polys.
* @type {number|null|undefined}
*/
google.maps.PolygonOptions.prototype.zIndex;
/**
* A polyline is a linear overlay of connected line segments on the map.
*
* Access by calling `const {Polyline} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {(!google.maps.PolylineOptions|null)=} opts
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.Polyline = function(opts) {};
/**
* Returns whether this shape can be dragged by the user.
* @return {boolean}
*/
google.maps.Polyline.prototype.getDraggable = function() {};
/**
* Returns whether this shape can be edited by the user.
* @return {boolean}
*/
google.maps.Polyline.prototype.getEditable = function() {};
/**
* Returns the map on which this shape is attached.
* @return {!google.maps.Map|null}
*/
google.maps.Polyline.prototype.getMap = function() {};
/**
* Retrieves the path.
* @return {!google.maps.MVCArray}
*/
google.maps.Polyline.prototype.getPath = function() {};
/**
* Returns whether this poly is visible on the map.
* @return {boolean}
*/
google.maps.Polyline.prototype.getVisible = function() {};
/**
* If set to true, the user can drag this shape over the map. The
* geodesic property defines the mode of dragging.
* @param {boolean} draggable
* @return {undefined}
*/
google.maps.Polyline.prototype.setDraggable = function(draggable) {};
/**
* If set to true, the user can edit this shape by dragging the
* control points shown at the vertices and on each segment.
* @param {boolean} editable
* @return {undefined}
*/
google.maps.Polyline.prototype.setEditable = function(editable) {};
/**
* Renders this shape on the specified map. If map is set to null,
* the shape will be removed.
* @param {!google.maps.Map|null} map
* @return {undefined}
*/
google.maps.Polyline.prototype.setMap = function(map) {};
/**
* @param {!google.maps.PolylineOptions|null} options
* @return {undefined}
*/
google.maps.Polyline.prototype.setOptions = function(options) {};
/**
* Sets the path. See PolylineOptions for more details.
* @param {!google.maps.MVCArray|!Array}
* path
* @return {undefined}
*/
google.maps.Polyline.prototype.setPath = function(path) {};
/**
* Hides this poly if set to false.
* @param {boolean} visible
* @return {undefined}
*/
google.maps.Polyline.prototype.setVisible = function(visible) {};
/**
* PolylineOptions object used to define the properties that can be set on a
* Polyline.
* @record
*/
google.maps.PolylineOptions = function() {};
/**
* Indicates whether this Polyline handles mouse events.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.PolylineOptions.prototype.clickable;
/**
* If set to true, the user can drag this shape over the map. The
* geodesic property defines the mode of dragging.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.PolylineOptions.prototype.draggable;
/**
* If set to true, the user can edit this shape by dragging the
* control points shown at the vertices and on each segment.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.PolylineOptions.prototype.editable;
/**
* When true, edges of the polygon are interpreted as geodesic and
* will follow the curvature of the Earth. When false, edges of the
* polygon are rendered as straight lines in screen space. Note that the shape
* of a geodesic polygon may appear to change when dragged, as the dimensions
* are maintained relative to the surface of the earth.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.PolylineOptions.prototype.geodesic;
/**
* The icons to be rendered along the polyline.
* @type {!Array|null|undefined}
*/
google.maps.PolylineOptions.prototype.icons;
/**
* Map on which to display Polyline.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.PolylineOptions.prototype.map;
/**
* The ordered sequence of coordinates of the Polyline. This path may be
* specified using either a simple array of LatLngs, or an
* MVCArray of LatLngs. Note that if you pass a simple
* array, it will be converted to an MVCArray Inserting or removing
* LatLngs in the MVCArray will automatically update the polyline
* on the map.
* @type {!google.maps.MVCArray|!Array|null|undefined}
*/
google.maps.PolylineOptions.prototype.path;
/**
* The stroke color. All CSS3 colors are supported except for extended named
* colors.
* @type {string|null|undefined}
*/
google.maps.PolylineOptions.prototype.strokeColor;
/**
* The stroke opacity between 0.0 and 1.0.
* @type {number|null|undefined}
*/
google.maps.PolylineOptions.prototype.strokeOpacity;
/**
* The stroke width in pixels.
* @type {number|null|undefined}
*/
google.maps.PolylineOptions.prototype.strokeWeight;
/**
* Whether this polyline is visible on the map.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.PolylineOptions.prototype.visible;
/**
* The zIndex compared to other polys.
* @type {number|null|undefined}
*/
google.maps.PolylineOptions.prototype.zIndex;
/**
* Projection interface.
* @record
*/
google.maps.Projection = function() {};
/**
* Translates from the LatLng cylinder to the Point plane. This interface
* specifies a function which implements translation from given
* LatLng values to world coordinates on the map projection. The
* Maps API calls this method when it needs to plot locations on screen.
* Projection objects must implement this method, but may return
* null if the projection cannot calculate the Point.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} latLng
* @param {!google.maps.Point=} point
* @return {!google.maps.Point|null}
*/
google.maps.Projection.prototype.fromLatLngToPoint = function(latLng, point) {};
/**
* This interface specifies a function which implements translation from world
* coordinates on a map projection to LatLng values. The Maps API
* calls this method when it needs to translate actions on screen to positions
* on the map. Projection objects must implement this method, but
* may return null if the projection cannot calculate the
* LatLng.
* @param {!google.maps.Point} pixel
* @param {boolean=} noClampNoWrap
* @return {!google.maps.LatLng|null}
*/
google.maps.Projection.prototype.fromPointToLatLng = function(
pixel, noClampNoWrap) {};
/**
* The status returned by a web service. See https://grpc.github.io/grpc/core/md_doc_statuscodes.html.
*
* Access by calling `const {RPCStatus} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.RPCStatus = {
/**
* The operation was aborted, typically due to a concurrency issue such as a
* sequencer check failure or transaction abort.
*/
ABORTED: 'ABORTED',
/**
* The entity that a client attempted to create (e.g., file or directory)
* already exists.
*/
ALREADY_EXISTS: 'ALREADY_EXISTS',
/**
* The operation was cancelled, typically by the caller.
*/
CANCELLED: 'CANCELLED',
/**
* Unrecoverable data loss or corruption.
*/
DATA_LOSS: 'DATA_LOSS',
/**
* The deadline expired before the operation could complete. For operations
* that change the state of the system, this error may be returned even if the
* operation has completed successfully. For example, a successful response
* from a server could have been delayed long.
*/
DEADLINE_EXCEEDED: 'DEADLINE_EXCEEDED',
/**
* The operation was rejected because the system is not in a state required
* for the operation's execution.
*/
FAILED_PRECONDITION: 'FAILED_PRECONDITION',
/**
* Internal errors. This means that some invariants expected by the underlying
* system have been broken. This error code is reserved for serious errors.
*/
INTERNAL: 'INTERNAL',
/**
* The client specified an invalid argument. Note that this differs from
* FAILED_PRECONDITION. INVALID_ARGUMENT indicates
* arguments that are problematic regardless of the state of the system (e.g.,
* a malformed file name).
*/
INVALID_ARGUMENT: 'INVALID_ARGUMENT',
/**
* Some requested entity (e.g., file or directory) was not found.
*/
NOT_FOUND: 'NOT_FOUND',
/**
* Not an error; returned on success.
*/
OK: 'OK',
/**
* The operation was attempted past the valid range. E.g., seeking or reading
* past end-of-file. Unlike INVALID_ARGUMENT, this error
* indicates a problem that may be fixed if the system state changes. For
* example, a 32-bit file system will generate INVALID_ARGUMENT
* if asked to read at an offset that is not in the range [0,2^32-1], but it
* will generate OUT_OF_RANGE if asked to read from an offset
* past the current file size.
*/
OUT_OF_RANGE: 'OUT_OF_RANGE',
/**
* The caller does not have permission to execute the specified operation.
* This error code does not imply the request is valid or the requested entity
* exists or satisfies other pre-conditions.
*/
PERMISSION_DENIED: 'PERMISSION_DENIED',
/**
* Some resource has been exhausted, perhaps a per-user quota, or perhaps the
* entire file system is out of space.
*/
RESOURCE_EXHAUSTED: 'RESOURCE_EXHAUSTED',
/**
* The request does not have valid authentication credentials for the
* operation.
*/
UNAUTHENTICATED: 'UNAUTHENTICATED',
/**
* The service is currently unavailable. This is most likely a transient
* condition, which can be corrected by retrying with a backoff. Note that it
* is not always safe to retry non-idempotent operations.
*/
UNAVAILABLE: 'UNAVAILABLE',
/**
* Operation is not implemented or not supported/enabled in this service.
*/
UNIMPLEMENTED: 'UNIMPLEMENTED',
/**
* Unknown error. For example, this error may be returned when a status
* received from another address space belongs to an error space that is not
* known in this address space. Also errors raised by APIs that do not return
* enough error information may be converted to this error.
*/
UNKNOWN: 'UNKNOWN',
};
/**
* A rectangle overlay.
*
* Access by calling `const {Rectangle} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {(!google.maps.RectangleOptions|null)=} opts
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.Rectangle = function(opts) {};
/**
* Returns the bounds of this rectangle.
* @return {!google.maps.LatLngBounds|null}
*/
google.maps.Rectangle.prototype.getBounds = function() {};
/**
* Returns whether this rectangle can be dragged by the user.
* @return {boolean}
*/
google.maps.Rectangle.prototype.getDraggable = function() {};
/**
* Returns whether this rectangle can be edited by the user.
* @return {boolean}
*/
google.maps.Rectangle.prototype.getEditable = function() {};
/**
* Returns the map on which this rectangle is displayed.
* @return {!google.maps.Map|null}
*/
google.maps.Rectangle.prototype.getMap = function() {};
/**
* Returns whether this rectangle is visible on the map.
* @return {boolean}
*/
google.maps.Rectangle.prototype.getVisible = function() {};
/**
* Sets the bounds of this rectangle.
* @param {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null}
* bounds
* @return {undefined}
*/
google.maps.Rectangle.prototype.setBounds = function(bounds) {};
/**
* If set to true, the user can drag this rectangle over the map.
* @param {boolean} draggable
* @return {undefined}
*/
google.maps.Rectangle.prototype.setDraggable = function(draggable) {};
/**
* If set to true, the user can edit this rectangle by dragging the
* control points shown at the corners and on each edge.
* @param {boolean} editable
* @return {undefined}
*/
google.maps.Rectangle.prototype.setEditable = function(editable) {};
/**
* Renders the rectangle on the specified map. If map is set to
* null, the rectangle will be removed.
* @param {!google.maps.Map|null} map
* @return {undefined}
*/
google.maps.Rectangle.prototype.setMap = function(map) {};
/**
* @param {!google.maps.RectangleOptions|null} options
* @return {undefined}
*/
google.maps.Rectangle.prototype.setOptions = function(options) {};
/**
* Hides this rectangle if set to false.
* @param {boolean} visible
* @return {undefined}
*/
google.maps.Rectangle.prototype.setVisible = function(visible) {};
/**
* RectangleOptions object used to define the properties that can be set on a
* Rectangle.
* @record
*/
google.maps.RectangleOptions = function() {};
/**
* The bounds.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.RectangleOptions.prototype.bounds;
/**
* Indicates whether this Rectangle handles mouse events.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.RectangleOptions.prototype.clickable;
/**
* If set to true, the user can drag this rectangle over the map.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.RectangleOptions.prototype.draggable;
/**
* If set to true, the user can edit this rectangle by dragging the
* control points shown at the corners and on each edge.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.RectangleOptions.prototype.editable;
/**
* The fill color. All CSS3 colors are supported except for extended named
* colors.
* @type {string|null|undefined}
*/
google.maps.RectangleOptions.prototype.fillColor;
/**
* The fill opacity between 0.0 and 1.0
* @type {number|null|undefined}
*/
google.maps.RectangleOptions.prototype.fillOpacity;
/**
* Map on which to display Rectangle.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.RectangleOptions.prototype.map;
/**
* The stroke color. All CSS3 colors are supported except for extended named
* colors.
* @type {string|null|undefined}
*/
google.maps.RectangleOptions.prototype.strokeColor;
/**
* The stroke opacity between 0.0 and 1.0
* @type {number|null|undefined}
*/
google.maps.RectangleOptions.prototype.strokeOpacity;
/**
* The stroke position.
* @default {@link google.maps.StrokePosition.CENTER}
* @type {!google.maps.StrokePosition|null|undefined}
*/
google.maps.RectangleOptions.prototype.strokePosition;
/**
* The stroke width in pixels.
* @type {number|null|undefined}
*/
google.maps.RectangleOptions.prototype.strokeWeight;
/**
* Whether this rectangle is visible on the map.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.RectangleOptions.prototype.visible;
/**
* The zIndex compared to other polys.
* @type {number|null|undefined}
*/
google.maps.RectangleOptions.prototype.zIndex;
/**
*
* Access by calling `const {RenderingType} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.RenderingType = {
/**
* Indicates that the map is a raster map.
*/
RASTER: 'RASTER',
/**
* Indicates that it is unknown yet whether the map is vector or raster,
* because the map has not finished initializing yet.
*/
UNINITIALIZED: 'UNINITIALIZED',
/**
* Indicates that the map is a vector map.
*/
VECTOR: 'VECTOR',
};
/**
* Options for the rendering of the rotate control.
* @record
*/
google.maps.RotateControlOptions = function() {};
/**
* Position id. Used to specify the position of the control on the map.
* @default {@link google.maps.ControlPosition.INLINE_END_BLOCK_END}
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.RotateControlOptions.prototype.position;
/**
* @record
*/
google.maps.RoutesLibrary = function() {};
/**
* @type {typeof google.maps.routes.ComputeRouteMatrixExtraComputation}
*/
google.maps.RoutesLibrary.prototype.ComputeRouteMatrixExtraComputation;
/**
* @type {typeof google.maps.routes.ComputeRoutesExtraComputation}
*/
google.maps.RoutesLibrary.prototype.ComputeRoutesExtraComputation;
/**
* @type {typeof google.maps.routes.DirectionalLocation}
*/
google.maps.RoutesLibrary.prototype.DirectionalLocation;
/**
* @type {typeof google.maps.DirectionsRenderer}
*/
google.maps.RoutesLibrary.prototype.DirectionsRenderer;
/**
* @type {typeof google.maps.DirectionsService}
*/
google.maps.RoutesLibrary.prototype.DirectionsService;
/**
* @type {typeof google.maps.DirectionsStatus}
*/
google.maps.RoutesLibrary.prototype.DirectionsStatus;
/**
* @type {typeof google.maps.DistanceMatrixElementStatus}
*/
google.maps.RoutesLibrary.prototype.DistanceMatrixElementStatus;
/**
* @type {typeof google.maps.DistanceMatrixService}
*/
google.maps.RoutesLibrary.prototype.DistanceMatrixService;
/**
* @type {typeof google.maps.DistanceMatrixStatus}
*/
google.maps.RoutesLibrary.prototype.DistanceMatrixStatus;
/**
* @type {typeof google.maps.routes.FallbackInfo}
*/
google.maps.RoutesLibrary.prototype.FallbackInfo;
/**
* @type {typeof google.maps.routes.FallbackReason}
*/
google.maps.RoutesLibrary.prototype.FallbackReason;
/**
* @type {typeof google.maps.routes.FallbackRoutingMode}
*/
google.maps.RoutesLibrary.prototype.FallbackRoutingMode;
/**
* @type {typeof google.maps.routes.GeocodedWaypoint}
*/
google.maps.RoutesLibrary.prototype.GeocodedWaypoint;
/**
* @type {typeof google.maps.routes.GeocodingResults}
*/
google.maps.RoutesLibrary.prototype.GeocodingResults;
/**
* @type {typeof google.maps.routes.MultiModalSegment}
*/
google.maps.RoutesLibrary.prototype.MultiModalSegment;
/**
* @type {typeof google.maps.routes.PolylineDetailInfo}
*/
google.maps.RoutesLibrary.prototype.PolylineDetailInfo;
/**
* @type {typeof google.maps.routes.PolylineDetails}
*/
google.maps.RoutesLibrary.prototype.PolylineDetails;
/**
* @type {typeof google.maps.routes.PolylineQuality}
*/
google.maps.RoutesLibrary.prototype.PolylineQuality;
/**
* @type {typeof google.maps.routes.ReferenceRoute}
*/
google.maps.RoutesLibrary.prototype.ReferenceRoute;
/**
* @type {typeof google.maps.routes.RoadFeatureState}
*/
google.maps.RoutesLibrary.prototype.RoadFeatureState;
/**
* @type {typeof google.maps.routes.Route}
*/
google.maps.RoutesLibrary.prototype.Route;
/**
* @type {typeof google.maps.routes.RouteLabel}
*/
google.maps.RoutesLibrary.prototype.RouteLabel;
/**
* @type {typeof google.maps.routes.RouteLeg}
*/
google.maps.RoutesLibrary.prototype.RouteLeg;
/**
* @type {typeof google.maps.routes.RouteLegLocalizedValues}
*/
google.maps.RoutesLibrary.prototype.RouteLegLocalizedValues;
/**
* @type {typeof google.maps.routes.RouteLegStep}
*/
google.maps.RoutesLibrary.prototype.RouteLegStep;
/**
* @type {typeof google.maps.routes.RouteLegStepLocalizedValues}
*/
google.maps.RoutesLibrary.prototype.RouteLegStepLocalizedValues;
/**
* @type {typeof google.maps.routes.RouteLegTravelAdvisory}
*/
google.maps.RoutesLibrary.prototype.RouteLegTravelAdvisory;
/**
* @type {typeof google.maps.routes.RouteLocalizedValues}
*/
google.maps.RoutesLibrary.prototype.RouteLocalizedValues;
/**
* @type {typeof google.maps.routes.RouteMatrix}
*/
google.maps.RoutesLibrary.prototype.RouteMatrix;
/**
* @type {typeof google.maps.routes.RouteMatrixItem}
*/
google.maps.RoutesLibrary.prototype.RouteMatrixItem;
/**
* @type {typeof google.maps.routes.RouteMatrixItemCondition}
*/
google.maps.RoutesLibrary.prototype.RouteMatrixItemCondition;
/**
* @type {typeof google.maps.routes.RouteMatrixItemError}
*/
google.maps.RoutesLibrary.prototype.RouteMatrixItemError;
/**
* @type {typeof google.maps.routes.RouteMatrixItemLocalizedValues}
*/
google.maps.RoutesLibrary.prototype.RouteMatrixItemLocalizedValues;
/**
* @type {typeof google.maps.routes.RouteMatrixRow}
*/
google.maps.RoutesLibrary.prototype.RouteMatrixRow;
/**
* @type {typeof google.maps.routes.RouteTravelAdvisory}
*/
google.maps.RoutesLibrary.prototype.RouteTravelAdvisory;
/**
* @type {typeof google.maps.routes.RoutingPreference}
*/
google.maps.RoutesLibrary.prototype.RoutingPreference;
/**
* @type {typeof google.maps.routes.Speed}
*/
google.maps.RoutesLibrary.prototype.Speed;
/**
* @type {typeof google.maps.routes.SpeedReadingInterval}
*/
google.maps.RoutesLibrary.prototype.SpeedReadingInterval;
/**
* @type {typeof google.maps.routes.StepsOverview}
*/
google.maps.RoutesLibrary.prototype.StepsOverview;
/**
* @type {typeof google.maps.routes.TollInfo}
*/
google.maps.RoutesLibrary.prototype.TollInfo;
/**
* @type {typeof google.maps.TrafficModel}
*/
google.maps.RoutesLibrary.prototype.TrafficModel;
/**
* @type {typeof google.maps.routes.TransitAgency}
*/
google.maps.RoutesLibrary.prototype.TransitAgency;
/**
* @type {typeof google.maps.routes.TransitDetails}
*/
google.maps.RoutesLibrary.prototype.TransitDetails;
/**
* @type {typeof google.maps.routes.TransitLine}
*/
google.maps.RoutesLibrary.prototype.TransitLine;
/**
* @type {typeof google.maps.TransitMode}
*/
google.maps.RoutesLibrary.prototype.TransitMode;
/**
* @type {typeof google.maps.TransitRoutePreference}
*/
google.maps.RoutesLibrary.prototype.TransitRoutePreference;
/**
* @type {typeof google.maps.routes.TransitStop}
*/
google.maps.RoutesLibrary.prototype.TransitStop;
/**
* @type {typeof google.maps.routes.TransitVehicle}
*/
google.maps.RoutesLibrary.prototype.TransitVehicle;
/**
* @type {typeof google.maps.TravelMode}
*/
google.maps.RoutesLibrary.prototype.TravelMode;
/**
* @type {typeof google.maps.routes.VehicleEmissionType}
*/
google.maps.RoutesLibrary.prototype.VehicleEmissionType;
/**
* @type {typeof google.maps.VehicleType}
*/
google.maps.RoutesLibrary.prototype.VehicleType;
/**
* Options for the rendering of the scale control.
* @record
*/
google.maps.ScaleControlOptions = function() {};
/**
* Style id. Used to select what style of scale control to display.
* @type {!google.maps.ScaleControlStyle|null|undefined}
*/
google.maps.ScaleControlOptions.prototype.style;
/**
* Identifiers for scale control ids.
* @enum {number}
*/
google.maps.ScaleControlStyle = {
/**
* The standard scale control.
*/
DEFAULT: 0,
};
/**
* Settings which control the behavior of the Maps JavaScript API as a whole.
*
* Access by calling `const {Settings} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.Settings = function() {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* A collection of unique experience IDs to which to attribute Maps JS API
* calls. The returned value is a copy of the internal value that is stored in
* the Settings class singleton instance. Operations on
* google.maps.Settings.getInstance().experienceIds will therefore
* only modify the copy and not the internal value.
To update the
* internal value, set the property equal to the new value on the singleton
* instance (ex: google.maps.Settings.getInstance().experienceIds =
* [experienceId];).
* @type {!Iterablegoogle.maps.Settings.
* @return {!google.maps.Settings}
*/
google.maps.Settings.getInstance = function() {};
/**
*
* Access by calling `const {Size} = await google.maps.importLibrary("core")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @param {number} width
* @param {number} height
* @param {string=} widthUnit
* @param {string=} heightUnit
* @constructor
*/
google.maps.Size = function(width, height, widthUnit, heightUnit) {};
/**
* The height along the y-axis, in pixels.
* @type {number}
*/
google.maps.Size.prototype.height;
/**
* The width along the x-axis, in pixels.
* @type {number}
*/
google.maps.Size.prototype.width;
/**
* Compares two Sizes.
* @param {!google.maps.Size|null} other
* @return {boolean}
*/
google.maps.Size.prototype.equals = function(other) {};
/**
* Returns a string representation of this Size.
* @return {string}
* @override
*/
google.maps.Size.prototype.toString = function() {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* An enum representing the relationship in space between the landmark and the
* target.
*
* Access by calling `const {SpatialRelationship} = await
* google.maps.importLibrary("geocoding")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.SpatialRelationship = {
/**
* The target is directly opposite the landmark on the other side of the road.
*/
ACROSS_THE_ROAD: 'ACROSS_THE_ROAD',
/**
* Not on the same route as the landmark but a single turn away.
*/
AROUND_THE_CORNER: 'AROUND_THE_CORNER',
/**
* Close to the landmark's structure but further away from its access
* point.
*/
BEHIND: 'BEHIND',
/**
* The target is directly adjacent to the landmark.
*/
BESIDE: 'BESIDE',
/**
* On the same route as the landmark but not besides or across.
*/
DOWN_THE_ROAD: 'DOWN_THE_ROAD',
/**
* This is the default relationship when nothing more specific below applies.
*/
NEAR: 'NEAR',
/**
* The landmark has a spatial geometry and the target is within its bounds.
*/
WITHIN: 'WITHIN',
};
/**
* Options for the rendering of the Street View address control.
* @record
*/
google.maps.StreetViewAddressControlOptions = function() {};
/**
* Position id. This id is used to specify the position of the control on the
* map. The default position is TOP_LEFT.
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.StreetViewAddressControlOptions.prototype.position;
/**
* Options for the rendering of the Street View pegman control on the map.
* @record
*/
google.maps.StreetViewControlOptions = function() {};
/**
* Position id. Used to specify the position of the control on the map. The
* default position is embedded within the navigation (zoom and pan) controls.
* If this position is empty or the same as that specified in the
* zoomControlOptions or panControlOptions, the Street
* View control will be displayed as part of the navigation controls. Otherwise,
* it will be displayed separately.
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.StreetViewControlOptions.prototype.position;
/**
* Specifies the sources of panoramas to search. This allows a restriction to
* search for just official Google panoramas for example. Setting multiple
* sources will be evaluated as the intersection of those sources. Note:
* the {@link google.maps.StreetViewSource.OUTDOOR} source is not supported at
* this time.
* @default [{@link google.maps.StreetViewSource.DEFAULT}]
* @type {!Iterable|null|undefined}
*/
google.maps.StreetViewControlOptions.prototype.sources;
/**
* A layer that illustrates the locations where Street View is available.
*
* Access by calling `const {StreetViewCoverageLayer} = await
* google.maps.importLibrary("streetView")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.StreetViewCoverageLayer = function() {};
/**
* Returns the map on which this layer is displayed.
* @return {!google.maps.Map|null}
*/
google.maps.StreetViewCoverageLayer.prototype.getMap = function() {};
/**
* Renders the layer on the specified map. If the map is set to null, the layer
* will be removed.
* @param {!google.maps.Map|null} map
* @return {undefined}
*/
google.maps.StreetViewCoverageLayer.prototype.setMap = function(map) {};
/**
* @record
*/
google.maps.StreetViewLibrary = function() {};
/**
* @type {typeof google.maps.InfoWindow}
*/
google.maps.StreetViewLibrary.prototype.InfoWindow;
/**
* @type {typeof google.maps.OverlayView}
*/
google.maps.StreetViewLibrary.prototype.OverlayView;
/**
* @type {typeof google.maps.StreetViewCoverageLayer}
*/
google.maps.StreetViewLibrary.prototype.StreetViewCoverageLayer;
/**
* @type {typeof google.maps.StreetViewPanorama}
*/
google.maps.StreetViewLibrary.prototype.StreetViewPanorama;
/**
* @type {typeof google.maps.StreetViewPreference}
*/
google.maps.StreetViewLibrary.prototype.StreetViewPreference;
/**
* @type {typeof google.maps.StreetViewService}
*/
google.maps.StreetViewLibrary.prototype.StreetViewService;
/**
* @type {typeof google.maps.StreetViewSource}
*/
google.maps.StreetViewLibrary.prototype.StreetViewSource;
/**
* @type {typeof google.maps.StreetViewStatus}
*/
google.maps.StreetViewLibrary.prototype.StreetViewStatus;
/**
* A collection of references to adjacent Street View panos.
* @record
*/
google.maps.StreetViewLink = function() {};
/**
* A localized string describing the link.
* @type {string|null}
*/
google.maps.StreetViewLink.prototype.description;
/**
* The heading of the link.
* @type {number|null}
*/
google.maps.StreetViewLink.prototype.heading;
/**
* A unique identifier for the panorama. This id is stable within a session but
* unstable across sessions.
* @type {string|null}
*/
google.maps.StreetViewLink.prototype.pano;
/**
* A representation of a location in the Street View panorama.
* @record
*/
google.maps.StreetViewLocation = function() {};
/**
* A localized string describing the location.
* @type {string|null|undefined}
*/
google.maps.StreetViewLocation.prototype.description;
/**
* The latlng of the panorama.
* @type {!google.maps.LatLng|null|undefined}
*/
google.maps.StreetViewLocation.prototype.latLng;
/**
* A unique identifier for the panorama. This is stable within a session but
* unstable across sessions.
* @type {string}
*/
google.maps.StreetViewLocation.prototype.pano;
/**
* Short description of the location.
* @type {string|null|undefined}
*/
google.maps.StreetViewLocation.prototype.shortDescription;
/**
* A Street View request to be sent with getPanorama.
* StreetViewLocationRequest lets you search for a Street View
* panoroma at a specified location.
* @record
*/
google.maps.StreetViewLocationRequest = function() {};
/**
* Specifies the location where to search for a Street View panorama.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.StreetViewLocationRequest.prototype.location;
/**
* Sets a preference for which panorama should be found within the radius: the
* one nearest to the provided location, or the best one within the radius.
* @type {!google.maps.StreetViewPreference|null|undefined}
*/
google.maps.StreetViewLocationRequest.prototype.preference;
/**
* Sets a radius in meters in which to search for a panorama.
* @default 50
* @type {number|null|undefined}
*/
google.maps.StreetViewLocationRequest.prototype.radius;
/**
* Specifies the sources of panoramas to search. This allows a restriction to
* search for just outdoor panoramas for example. Setting multiple sources will
* be evaluated as the intersection of those sources.
* @default [{@link google.maps.StreetViewSource.DEFAULT}]
* @type {!Iterable|null|undefined}
*/
google.maps.StreetViewLocationRequest.prototype.sources;
/**
* Specifies the source of panoramas to search. This allows a restriction to
* search for just outdoor panoramas for example.
* @default {@link google.maps.StreetViewSource.DEFAULT}
* @type {!google.maps.StreetViewSource|null|undefined}
* @deprecated Use sources instead.
*/
google.maps.StreetViewLocationRequest.prototype.source;
/**
* A StreetViewPanoRequest is used with the
* getPanorama to find a panorama with a specified ID.
* @record
*/
google.maps.StreetViewPanoRequest = function() {};
/**
* Specifies the pano ID to search for.
* @type {string|null|undefined}
*/
google.maps.StreetViewPanoRequest.prototype.pano;
/**
* Displays the panorama for a given LatLng or panorama ID. A
* StreetViewPanorama object provides a Street View
* "viewer" which can be stand-alone within a separate
* <div> or bound to a Map.
*
* Access by calling `const {StreetViewPanorama} = await
* google.maps.importLibrary("streetView")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!HTMLElement} container
* @param {?google.maps.StreetViewPanoramaOptions=} opts
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.StreetViewPanorama = function(container, opts) {};
/**
* Additional controls to attach to the panorama. To add a control to the
* panorama, add the control's <div> to the
* MVCArray corresponding to the {@link
* google.maps.ControlPosition} where it should be rendered.
* @type {!Array>}
*/
google.maps.StreetViewPanorama.prototype.controls;
/**
* Sets focus on this StreetViewPanorama. You may wish to consider
* using this method along with a visible_changed event to make
* sure that StreetViewPanorama is visible before setting focus on
* it. A StreetViewPanorama that is not visible cannot be focused.
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.focus = function() {};
/**
* Returns the set of navigation links for the Street View panorama.
* @return {Arraytrue when the user
* physically moves the device and the browser supports it, the Street View
* Panorama tracks the physical movements.
* @return {boolean}
*/
google.maps.StreetViewPanorama.prototype.getMotionTracking = function() {};
/**
* Returns the current panorama ID for the Street View panorama. This id is
* stable within the browser's current session only.
* @return {string}
*/
google.maps.StreetViewPanorama.prototype.getPano = function() {};
/**
* Returns the heading and pitch of the photographer when this panorama was
* taken. For Street View panoramas on the road, this also reveals in which
* direction the car was travelling. This data is available after the
* pano_changed event.
* @return {!google.maps.StreetViewPov}
*/
google.maps.StreetViewPanorama.prototype.getPhotographerPov = function() {};
/**
* Returns the current LatLng position for the Street View
* panorama.
* @return {?google.maps.LatLng}
*/
google.maps.StreetViewPanorama.prototype.getPosition = function() {};
/**
* Returns the current point of view for the Street View panorama.
* @return {!google.maps.StreetViewPov}
*/
google.maps.StreetViewPanorama.prototype.getPov = function() {};
/**
* Returns the status of the panorama on completion of the
* setPosition() or setPano() request.
* @return {!google.maps.StreetViewStatus}
*/
google.maps.StreetViewPanorama.prototype.getStatus = function() {};
/**
* Returns true if the panorama is visible. It does not specify
* whether Street View imagery is available at the specified position.
* @return {boolean}
*/
google.maps.StreetViewPanorama.prototype.getVisible = function() {};
/**
* Returns the zoom level of the panorama. Fully zoomed-out is level 0, where
* the field of view is 180 degrees. Zooming in increases the zoom level.
* @return {number}
*/
google.maps.StreetViewPanorama.prototype.getZoom = function() {};
/**
* Set the custom panorama provider called on pano change to load custom
* panoramas.
* @param {function(string): ?google.maps.StreetViewPanoramaData} provider
* @param {!google.maps.PanoProviderOptions=} opt_options
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.registerPanoProvider = function(
provider, opt_options) {};
/**
* Sets the set of navigation links for the Street View panorama.
* @param {Arraytrue when the user
* physically moves the device and the browser supports it, the Street View
* Panorama tracks the physical movements.
* @param {boolean} motionTracking
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.setMotionTracking = function(
motionTracking) {};
/**
* Sets a collection of key-value pairs.
* @param {?google.maps.StreetViewPanoramaOptions} options
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.setOptions = function(options) {};
/**
* Sets the current panorama ID for the Street View panorama.
* @param {string} pano
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.setPano = function(pano) {};
/**
* Sets the current LatLng position for the Street View panorama.
* @param {google.maps.LatLng|google.maps.LatLngLiteral|null} latLng
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.setPosition = function(latLng) {};
/**
* Sets the point of view for the Street View panorama.
* @param {!google.maps.StreetViewPov} pov
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.setPov = function(pov) {};
/**
* Sets to true to make the panorama visible. If set to
* false, the panorama will be hidden whether it is embedded in the
* map or in its own <div>.
* @param {boolean} flag
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.setVisible = function(flag) {};
/**
* Sets the zoom level of the panorama. Fully zoomed-out is level 0, where the
* field of view is 180 degrees. Zooming in increases the zoom level.
* @param {number} zoom
* @return {undefined}
*/
google.maps.StreetViewPanorama.prototype.setZoom = function(zoom) {};
/**
* The representation of a panorama returned from the provider defined using
* registerPanoProvider.
* @record
*/
google.maps.StreetViewPanoramaData = function() {};
/**
* Specifies the copyright text for this panorama.
* @type {string|undefined}
*/
google.maps.StreetViewPanoramaData.prototype.copyright;
/**
* Specifies the year and month in which the imagery in this panorama was
* acquired. The date string is in the form YYYY-MM.
* @type {string|undefined}
*/
google.maps.StreetViewPanoramaData.prototype.imageDate;
/**
* Specifies the navigational links to adjacent panoramas.
* @type {!Array|undefined}
*/
google.maps.StreetViewPanoramaData.prototype.links;
/**
* Specifies the location meta-data for this panorama.
* @type {!google.maps.StreetViewLocation|undefined}
*/
google.maps.StreetViewPanoramaData.prototype.location;
/**
* Specifies the custom tiles for this panorama.
* @type {!google.maps.StreetViewTileData}
*/
google.maps.StreetViewPanoramaData.prototype.tiles;
/**
* Options defining the properties of a StreetViewPanorama object.
* @record
*/
google.maps.StreetViewPanoramaOptions = function() {};
/**
* The enabled/disabled state of the address control.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.addressControl;
/**
* The display options for the address control.
* @type {!google.maps.StreetViewAddressControlOptions|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.addressControlOptions;
/**
* The enabled/disabled state of click-to-go. Not applicable to custom
* panoramas.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.clickToGo;
/**
* Size in pixels of the controls appearing on the panorama. This value must be
* supplied directly when creating the Panorama, updating this value later may
* bring the controls into an undefined state. Only governs the controls made by
* the Maps API itself. Does not scale developer created custom controls.
* @type {number|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.controlSize;
/**
* Enables/disables all default UI. May be overridden individually.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.disableDefaultUI;
/**
* Enables/disables zoom on double click.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.disableDoubleClickZoom;
/**
* If true, the close button is displayed.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.enableCloseButton;
/**
* The enabled/disabled state of the fullscreen control.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.fullscreenControl;
/**
* The display options for the fullscreen control.
* @type {!google.maps.FullscreenControlOptions|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.fullscreenControlOptions;
/**
* The enabled/disabled state of the imagery acquisition date control. Disabled
* by default.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.imageDateControl;
/**
* The enabled/disabled state of the links control.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.linksControl;
/**
* Whether motion tracking is on or off. Enabled by default when the motion
* tracking control is present and permission is granted by a user or not
* required, so that the POV (point of view) follows the orientation of the
* device. This is primarily applicable to mobile devices. If
* motionTracking is set to false while
* motionTrackingControl is enabled, the motion tracking control
* appears but tracking is off. The user can tap the motion tracking control to
* toggle this option. If motionTracking is set to
* true while permission is required but not yet requested, the
* motion tracking control appears but tracking is off. The user can tap the
* motion tracking control to request permission. If motionTracking
* is set to true while permission is denied by a user, the motion
* tracking control appears disabled with tracking turned off.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.motionTracking;
/**
* The enabled/disabled state of the motion tracking control. Enabled by default
* when the device has motion data, so that the control appears on the map. This
* is primarily applicable to mobile devices.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.motionTrackingControl;
/**
* The display options for the motion tracking control.
* @type {!google.maps.MotionTrackingControlOptions|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.motionTrackingControlOptions;
/**
* The enabled/disabled state of the pan control.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.panControl;
/**
* The display options for the pan control.
* @type {!google.maps.PanControlOptions|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.panControlOptions;
/**
* The panorama ID, which should be set when specifying a custom panorama.
* @type {string|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.pano;
/**
* The LatLng position of the Street View panorama.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.position;
/**
* The camera orientation, specified as heading and pitch, for the panorama.
* @type {!google.maps.StreetViewPov|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.pov;
/**
* If false, disables scrollwheel zooming in Street View.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.scrollwheel;
/**
* The display of street names on the panorama. If this value is not specified,
* or is set to true, street names are displayed on the panorama.
* If set to false, street names are not displayed.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.showRoadLabels;
/**
* If true, the Street View panorama is visible on load.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.visible;
/**
* The zoom of the panorama, specified as a number. A zoom of 0 gives a 180
* degrees Field of View.
* @type {number|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.zoom;
/**
* The enabled/disabled state of the zoom control.
* @type {boolean|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.zoomControl;
/**
* The display options for the zoom control.
* @type {!google.maps.ZoomControlOptions|null|undefined}
*/
google.maps.StreetViewPanoramaOptions.prototype.zoomControlOptions;
/**
* A point of view object which specifies the camera's orientation at the
* Street View panorama's position. The point of view is defined as heading
* and pitch.
* @record
*/
google.maps.StreetViewPov = function() {};
/**
* The camera heading in degrees relative to true north. True north
* is 0°, east is 90°, south is 180°, west is 270°.
* @type {number}
*/
google.maps.StreetViewPov.prototype.heading;
/**
* The camera pitch in degrees, relative to the street view vehicle. Ranges from
* 90° (directly upwards) to -90° (directly downwards).
* @type {number}
*/
google.maps.StreetViewPov.prototype.pitch;
/**
* Options that bias a search result towards returning a Street View panorama
* that is nearest to the request location, or a panorama that is considered
* most likely to be what the user wants to see. Specify these by value, or by
* using the constant's name. For example, 'best' or
* google.maps.StreetViewPreference.BEST.
*
* Access by calling `const {StreetViewPreference} = await
* google.maps.importLibrary("streetView")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.StreetViewPreference = {
/**
* Return the Street View panorama that is considered most likely to be what
* the user wants to see. The best result is determined by algorithms based on
* user research and parameters such as recognised points of interest, image
* quality, and distance from the given location.
*/
BEST: 'best',
/**
* Return the Street View panorama that is the shortest distance from the
* provided location. This works well only within a limited radius. The
* recommended radius is 1km or less.
*/
NEAREST: 'nearest',
};
/**
* The response resolved for a Promise from {@link
* google.maps.StreetViewService.getPanorama}.
* @record
*/
google.maps.StreetViewResponse = function() {};
/**
* The representation of a panorama.
* @type {!google.maps.StreetViewPanoramaData}
*/
google.maps.StreetViewResponse.prototype.data;
/**
* A StreetViewService object performs searches for Street View
* data.
*
* Access by calling `const {StreetViewService} = await
* google.maps.importLibrary("streetView")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.StreetViewService = function() {};
/**
* Retrieves the StreetViewPanoramaData for a panorama that matches
* the supplied Street View query request. The
* StreetViewPanoramaData is passed to the provided callback.
* @param {!google.maps.StreetViewLocationRequest|!google.maps.StreetViewPanoRequest}
* request
* @param {(function((!google.maps.StreetViewPanoramaData|null),
* !google.maps.StreetViewStatus): void)=} callback
* @return {!Promise}
*/
google.maps.StreetViewService.prototype.getPanorama = function(
request, callback) {};
/**
* Identifiers to limit Street View searches to selected sources. These values
* are specified as strings. For example, 'outdoor'.
*
* Access by calling `const {StreetViewSource} = await
* google.maps.importLibrary("streetView")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.StreetViewSource = {
/**
* Uses the default sources of Street View, searches will not be limited to
* specific sources.
*/
DEFAULT: 'default',
/**
* Limits Street View searches to official Google collections.
*/
GOOGLE: 'google',
/**
* Limits Street View searches to outdoor collections. Indoor collections are
* not included in search results. Note also that the search only returns
* panoramas where it's possible to determine whether they're indoors
* or outdoors. For example, PhotoSpheres are not returned because it's
* unknown whether they are indoors or outdoors.
*/
OUTDOOR: 'outdoor',
};
/**
* The status returned by the StreetViewService on completion of a
* Street View request. These can be specified by value, or by using the
* constant's name. For example, 'OK' or
* google.maps.StreetViewStatus.OK.
*
* Access by calling `const {StreetViewStatus} = await
* google.maps.importLibrary("streetView")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.StreetViewStatus = {
/**
* The request was successful.
*/
OK: 'OK',
/**
* The request could not be successfully processed, yet the exact reason for
* failure is unknown.
*/
UNKNOWN_ERROR: 'UNKNOWN_ERROR',
/**
* There are no panoramas found that match the search criteria.
*/
ZERO_RESULTS: 'ZERO_RESULTS',
};
/**
* The properties of the tile set used in a Street View panorama.
* @record
*/
google.maps.StreetViewTileData = function() {};
/**
* The heading (in degrees) at the center of the panoramic tiles.
* @type {number}
*/
google.maps.StreetViewTileData.prototype.centerHeading;
/**
* The size (in pixels) at which tiles will be rendered.
* @type {!google.maps.Size}
*/
google.maps.StreetViewTileData.prototype.tileSize;
/**
* The size (in pixels) of the whole panorama's "world".
* @type {!google.maps.Size}
*/
google.maps.StreetViewTileData.prototype.worldSize;
/**
* Gets the tile image URL for the specified tile.
This is a custom method
* which you must implement, to supply your custom tiles. The API calls this
* method, supplying the following parameters: pano is the
* panorama ID of the Street View tile.
tileZoom is the zoom
* level of the tile.
tileX is the x-coordinate of the
* tile.
tileY is the y-coordinate of the tile.
Your
* custom method must return the URL for the tile image.
* @param {string} pano
* @param {number} tileZoom
* @param {number} tileX
* @param {number} tileY
* @return {string}
*/
google.maps.StreetViewTileData.prototype.getTileUrl = function(
pano, tileZoom, tileX, tileY) {};
/**
* The possible positions of the stroke on a polygon.
*
* Access by calling `const {StrokePosition} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {number}
*/
google.maps.StrokePosition = {
/**
* The stroke is centered on the polygon's path, with half the stroke
* inside the polygon and half the stroke outside the polygon.
*/
CENTER: 0,
/**
* The stroke lies inside the polygon.
*/
INSIDE: 1,
/**
* The stroke lies outside the polygon.
*/
OUTSIDE: 2,
};
/**
* Creates a MapType with a custom style.
*
* Access by calling `const {StyledMapType} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {ArrayStyledMapType. These options cannot be changed after the
* StyledMapType is instantiated.
* @record
*/
google.maps.StyledMapTypeOptions = function() {};
/**
* Text to display when this MapType's button is hovered over
* in the map type control.
* @type {string|null|undefined}
*/
google.maps.StyledMapTypeOptions.prototype.alt;
/**
* The maximum zoom level for the map when displaying this MapType.
* Optional.
* @type {number|null|undefined}
*/
google.maps.StyledMapTypeOptions.prototype.maxZoom;
/**
* The minimum zoom level for the map when displaying this MapType.
* Optional.
* @type {number|null|undefined}
*/
google.maps.StyledMapTypeOptions.prototype.minZoom;
/**
* The name to display in the map type control.
* @type {string|null|undefined}
*/
google.maps.StyledMapTypeOptions.prototype.name;
/**
* Describes a symbol, which consists of a vector path with styling. A symbol
* can be used as the icon of a marker, or placed on a polyline.
* @record
*/
google.maps.Symbol = function() {};
/**
* The position of the symbol relative to the marker or polyline. The
* coordinates of the symbol's path are translated left and up by the
* anchor's x and y coordinates respectively. The position is expressed in
* the same coordinate system as the symbol's path.
* @default google.maps.Point(0,0)
* @type {!google.maps.Point|null|undefined}
*/
google.maps.Symbol.prototype.anchor;
/**
* The symbol's fill color. All CSS3 colors are supported except for
* extended named colors. For symbol markers, this defaults to 'black'.
* For symbols on polylines, this defaults to the stroke color of the
* corresponding polyline.
* @type {string|null|undefined}
*/
google.maps.Symbol.prototype.fillColor;
/**
* The symbol's fill opacity.
* @default 0
* @type {number|null|undefined}
*/
google.maps.Symbol.prototype.fillOpacity;
/**
* The origin of the label relative to the origin of the path, if label is
* supplied by the marker. The origin is expressed in the same coordinate system
* as the symbol's path. This property is unused for symbols on polylines.
* @default google.maps.Point(0,0)
* @type {!google.maps.Point|null|undefined}
*/
google.maps.Symbol.prototype.labelOrigin;
/**
* The symbol's path, which is a built-in symbol path, or a custom path
* expressed using SVG
* path notation. Required.
* @type {!google.maps.SymbolPath|string}
*/
google.maps.Symbol.prototype.path;
/**
* The angle by which to rotate the symbol, expressed clockwise in degrees. A
* symbol in an IconSequence where fixedRotation is
* false is rotated relative to the angle of the edge on which it
* lies.
* @default 0
* @type {number|null|undefined}
*/
google.maps.Symbol.prototype.rotation;
/**
* The amount by which the symbol is scaled in size. For symbol markers, this
* defaults to 1; after scaling, the symbol may be of any size. For symbols on a
* polyline, this defaults to the stroke weight of the polyline; after scaling,
* the symbol must lie inside a square 22 pixels in size centered at the
* symbol's anchor.
* @type {number|null|undefined}
*/
google.maps.Symbol.prototype.scale;
/**
* The symbol's stroke color. All CSS3 colors are supported except for
* extended named colors. For symbol markers, this defaults to 'black'.
* For symbols on a polyline, this defaults to the stroke color of the polyline.
* @type {string|null|undefined}
*/
google.maps.Symbol.prototype.strokeColor;
/**
* The symbol's stroke opacity. For symbol markers, this defaults to 1. For
* symbols on a polyline, this defaults to the stroke opacity of the polyline.
* @type {number|null|undefined}
*/
google.maps.Symbol.prototype.strokeOpacity;
/**
* The symbol's stroke weight.
* @default The {@link google.maps.Symbol.scale} of the symbol.
* @type {number|null|undefined}
*/
google.maps.Symbol.prototype.strokeWeight;
/**
* Built-in symbol paths.
*
* Access by calling `const {SymbolPath} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {number}
*/
google.maps.SymbolPath = {
/**
* A backward-pointing closed arrow.
*/
BACKWARD_CLOSED_ARROW: 0,
/**
* A backward-pointing open arrow.
*/
BACKWARD_OPEN_ARROW: 1,
/**
* A circle.
*/
CIRCLE: 2,
/**
* A forward-pointing closed arrow.
*/
FORWARD_CLOSED_ARROW: 3,
/**
* A forward-pointing open arrow.
*/
FORWARD_OPEN_ARROW: 4,
};
/**
* A representation of time as a Date object, a localized string, and a time
* zone.
* @record
*/
google.maps.Time = function() {};
/**
* A string representing the time's value. The time is displayed in the time
* zone of the transit stop.
* @type {string}
*/
google.maps.Time.prototype.text;
/**
* The time zone in which this stop lies. The value is the name of the time zone
* as defined in the IANA Time Zone Database, e.g. "America/New_York".
* @type {string}
*/
google.maps.Time.prototype.time_zone;
/**
* The time of this departure or arrival, specified as a JavaScript Date object.
* @type {!Date}
*/
google.maps.Time.prototype.value;
/**
* A traffic layer.
*
* Access by calling `const {TrafficLayer} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.TrafficLayerOptions=} opts
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.TrafficLayer = function(opts) {};
/**
* Returns the map on which this layer is displayed.
* @return {!google.maps.Map|null}
*/
google.maps.TrafficLayer.prototype.getMap = function() {};
/**
* Renders the layer on the specified map. If map is set to null,
* the layer will be removed.
* @param {!google.maps.Map|null} map
* @return {undefined}
*/
google.maps.TrafficLayer.prototype.setMap = function(map) {};
/**
* @param {!google.maps.TrafficLayerOptions|null} options
* @return {undefined}
*/
google.maps.TrafficLayer.prototype.setOptions = function(options) {};
/**
* TrafficLayerOptions object used to define the properties that can be set on a
* TrafficLayer.
* @record
*/
google.maps.TrafficLayerOptions = function() {};
/**
* Whether the traffic layer refreshes with updated information automatically.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.TrafficLayerOptions.prototype.autoRefresh;
/**
* Map on which to display the traffic layer.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.TrafficLayerOptions.prototype.map;
/**
* The assumptions to use when predicting duration in traffic. Specified as part
* of a DirectionsRequest or
* DistanceMatrixRequest.
* Specify these by value, or by using the constant's name. For example,
* 'bestguess' or google.maps.TrafficModel.BEST_GUESS.
*
* Access by calling `const {TrafficModel} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.TrafficModel = {
/**
* Use historical traffic data to best estimate the time spent in traffic.
*/
BEST_GUESS: 'bestguess',
/**
* Use historical traffic data to make an optimistic estimate of what the
* duration in traffic will be.
*/
OPTIMISTIC: 'optimistic',
/**
* Use historical traffic data to make a pessimistic estimate of what the
* duration in traffic will be.
*/
PESSIMISTIC: 'pessimistic',
};
/**
* Information about an agency that operates a transit line.
* @record
*/
google.maps.TransitAgency = function() {};
/**
* The name of this transit agency.
* @type {string}
*/
google.maps.TransitAgency.prototype.name;
/**
* The transit agency's phone number.
* @type {string}
*/
google.maps.TransitAgency.prototype.phone;
/**
* The transit agency's URL.
* @type {string}
*/
google.maps.TransitAgency.prototype.url;
/**
* Details about the departure, arrival, and mode of transit used in this step.
* @record
*/
google.maps.TransitDetails = function() {};
/**
* The arrival stop of this transit step.
* @type {!google.maps.TransitStop}
*/
google.maps.TransitDetails.prototype.arrival_stop;
/**
* The arrival time of this step, specified as a Time object.
* @type {!google.maps.Time}
*/
google.maps.TransitDetails.prototype.arrival_time;
/**
* The departure stop of this transit step.
* @type {!google.maps.TransitStop}
*/
google.maps.TransitDetails.prototype.departure_stop;
/**
* The departure time of this step, specified as a Time object.
* @type {!google.maps.Time}
*/
google.maps.TransitDetails.prototype.departure_time;
/**
* The direction in which to travel on this line, as it is marked on the vehicle
* or at the departure stop.
* @type {string}
*/
google.maps.TransitDetails.prototype.headsign;
/**
* The expected number of seconds between equivalent vehicles at this stop.
* @type {number}
*/
google.maps.TransitDetails.prototype.headway;
/**
* Details about the transit line used in this step.
* @type {!google.maps.TransitLine}
*/
google.maps.TransitDetails.prototype.line;
/**
* The number of stops on this step. Includes the arrival stop, but not the
* departure stop.
* @type {number}
*/
google.maps.TransitDetails.prototype.num_stops;
/**
* The text that appears in schedules and sign boards to identify a transit trip
* to passengers, for example, to identify train numbers for commuter rail
* trips. The text uniquely identifies a trip within a service day.
* @type {string}
*/
google.maps.TransitDetails.prototype.trip_short_name;
/**
* A fare of a DirectionsRoute
* consisting of value and currency.
* @record
*/
google.maps.TransitFare = function() {};
/**
* An ISO 4217 currency code
* indicating the currency in which the fare is expressed.
* @type {string}
*/
google.maps.TransitFare.prototype.currency;
/**
* The value of the fare, expressed in the given currency, as a
* string.
* @type {string}
*/
google.maps.TransitFare.prototype.text;
/**
* The numerical value of the fare, expressed in the given
* currency.
* @type {number}
*/
google.maps.TransitFare.prototype.value;
/**
* A transit layer.
*
* Access by calling `const {TransitLayer} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.TransitLayer = function() {};
/**
* Returns the map on which this layer is displayed.
* @return {!google.maps.Map|null}
*/
google.maps.TransitLayer.prototype.getMap = function() {};
/**
* Renders the layer on the specified map. If map is set to null,
* the layer will be removed.
* @param {!google.maps.Map|null} map
* @return {void}
*/
google.maps.TransitLayer.prototype.setMap = function(map) {};
/**
* Information about the transit line that operates this transit step.
* @record
*/
google.maps.TransitLine = function() {};
/**
* The transit agency that operates this transit line.
* @type {!Array}
*/
google.maps.TransitLine.prototype.agencies;
/**
* The color commonly used in signage for this transit line, represented as a
* hex string.
* @type {string}
*/
google.maps.TransitLine.prototype.color;
/**
* The URL for an icon associated with this line.
* @type {string}
*/
google.maps.TransitLine.prototype.icon;
/**
* The full name of this transit line, e.g. "8 Avenue Local".
* @type {string}
*/
google.maps.TransitLine.prototype.name;
/**
* The short name of this transit line, e.g. "E".
* @type {string}
*/
google.maps.TransitLine.prototype.short_name;
/**
* The text color commonly used in signage for this transit line, represented as
* a hex string.
* @type {string}
*/
google.maps.TransitLine.prototype.text_color;
/**
* The agency's URL which is specific to this transit line.
* @type {string}
*/
google.maps.TransitLine.prototype.url;
/**
* The type of vehicle used, e.g. train or bus.
* @type {!google.maps.TransitVehicle}
*/
google.maps.TransitLine.prototype.vehicle;
/**
* The valid transit mode e.g. bus that can be specified in a TransitOptions. Specify these by value,
* or by using the constant's name. For example, 'BUS' or
* google.maps.TransitMode.BUS.
*
* Access by calling `const {TransitMode} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.TransitMode = {
/**
* Specifies bus as a preferred mode of transit.
*/
BUS: 'BUS',
/**
* Specifies light rail as a preferred mode of transit.
*/
LIGHT_RAIL: 'LIGHT_RAIL',
/**
* Specifies rail as a preferred mode of transit.
*/
RAIL: 'RAIL',
/**
* Specifies subway as a preferred mode of transit.
*/
SUBWAY: 'SUBWAY',
/**
* Specifies train as a preferred mode of transit.
*/
TRAIN: 'TRAIN',
/**
* Specifies tram as a preferred mode of transit.
*/
TRAM: 'TRAM',
};
/**
* The TransitOptions object to be included in a DirectionsRequest when the travel mode
* is set to TRANSIT.
* @record
*/
google.maps.TransitOptions = function() {};
/**
* The desired arrival time for the route, specified as a Date object. The Date
* object measures time in milliseconds since 1 January 1970. If arrival time is
* specified, departure time is ignored.
* @type {!Date|null|undefined}
*/
google.maps.TransitOptions.prototype.arrivalTime;
/**
* The desired departure time for the route, specified as a Date object. The
* Date object measures time in milliseconds since 1 January 1970. If neither
* departure time nor arrival time is specified, the time is assumed to be
* "now".
* @type {!Date|null|undefined}
*/
google.maps.TransitOptions.prototype.departureTime;
/**
* One or more preferred modes of transit, such as bus or train. If no
* preference is given, the API returns the default best route.
* @type {!Array|null|undefined}
*/
google.maps.TransitOptions.prototype.modes;
/**
* A preference that can bias the choice of transit route, such as less walking.
* If no preference is given, the API returns the default best route.
* @type {!google.maps.TransitRoutePreference|null|undefined}
*/
google.maps.TransitOptions.prototype.routingPreference;
/**
* The valid transit route type that can be specified in a TransitOptions. Specify these by value,
* or by using the constant's name. For example, 'LESS_WALKING'
* or google.maps.TransitRoutePreference.LESS_WALKING.
*
* Access by calling `const {TransitRoutePreference} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.TransitRoutePreference = {
/**
* Specifies that the calculated route should prefer a limited number of
* transfers.
*/
FEWER_TRANSFERS: 'FEWER_TRANSFERS',
/**
* Specifies that the calculated route should prefer limited amounts of
* walking.
*/
LESS_WALKING: 'LESS_WALKING',
};
/**
* Details about a transit stop or station.
* @record
*/
google.maps.TransitStop = function() {};
/**
* The location of this stop.
* @type {!google.maps.LatLng}
*/
google.maps.TransitStop.prototype.location;
/**
* The name of this transit stop.
* @type {string}
*/
google.maps.TransitStop.prototype.name;
/**
* Information about the vehicle that operates on a transit line.
* @record
*/
google.maps.TransitVehicle = function() {};
/**
* A URL for an icon that corresponds to the type of vehicle used on this line.
* @type {string}
*/
google.maps.TransitVehicle.prototype.icon;
/**
* A URL for an icon that corresponds to the type of vehicle used in this region
* instead of the more general icon.
* @type {string}
*/
google.maps.TransitVehicle.prototype.local_icon;
/**
* A name for this type of TransitVehicle, e.g. "Train" or
* "Bus".
* @type {string}
*/
google.maps.TransitVehicle.prototype.name;
/**
* The type of vehicle used, e.g. train, bus, or ferry.
* @type {!google.maps.VehicleType}
*/
google.maps.TransitVehicle.prototype.type;
/**
* The valid travel modes that can be specified in a
* DirectionsRequest as well as the travel modes returned in a
* DirectionsStep. Specify these by value, or by using the
* constant's name. For example, 'BICYCLING' or
* google.maps.TravelMode.BICYCLING.
*
* Access by calling `const {TravelMode} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.TravelMode = {
/**
* Specifies a bicycling directions request.
*/
BICYCLING: 'BICYCLING',
/**
* Specifies a driving directions request.
*/
DRIVING: 'DRIVING',
/**
* Specifies a transit directions request.
*/
TRANSIT: 'TRANSIT',
/**
* Specifies a two-wheeler directions request.
*/
TWO_WHEELER: 'TWO_WHEELER',
/**
* Specifies a walking directions request.
*/
WALKING: 'WALKING',
};
/**
* The valid unit systems that can be specified in a DirectionsRequest.
*
* Access by calling `const {UnitSystem} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {number}
*/
google.maps.UnitSystem = {
/**
* Specifies that distances in the DirectionsResult should be
* expressed in imperial units.
*/
IMPERIAL: 0,
/**
* Specifies that distances in the DirectionsResult should be
* expressed in metric units.
*/
METRIC: 1,
};
/**
* A Vector3D is a three-dimensional vector used for standard
* mathematical operations such as scaling the bounds of three-dimensional
* object along local x-, y-, and z-axes.
*
* Access by calling `const {Vector3D} = await
* google.maps.importLibrary("core")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.Vector3D|!google.maps.Vector3DLiteral} value The
* initializing value.
* @implements {google.maps.Vector3DLiteral}
* @constructor
*/
google.maps.Vector3D = function(value) {};
/**
* X-component of the three-dimensional vector.
* @type {number}
*/
google.maps.Vector3D.prototype.x;
/**
* Y-component of the three-dimensional vector.
* @type {number}
*/
google.maps.Vector3D.prototype.y;
/**
* Z-component of the three-dimensional vector.
* @type {number}
*/
google.maps.Vector3D.prototype.z;
/**
* Comparison function.
* @param {!google.maps.Vector3D|!google.maps.Vector3DLiteral|null} other
* Another Vector3D or Vector3DLiteral object.
* @return {boolean}
*/
google.maps.Vector3D.prototype.equals = function(other) {};
/**
* Converts to JSON representation. This function is intended to be used via
* JSON.stringify.
* @return {!google.maps.Vector3DLiteral}
*/
google.maps.Vector3D.prototype.toJSON = function() {};
/**
* Object literals are accepted in place of Vector3D objects, as a
* convenience, in many places. These are converted to Vector3D
* objects when the Maps API encounters them.
* @record
*/
google.maps.Vector3DLiteral = function() {};
/**
* X-component of the three-dimensional vector.
* @type {number}
*/
google.maps.Vector3DLiteral.prototype.x;
/**
* Y-component of the three-dimensional vector.
* @type {number}
*/
google.maps.Vector3DLiteral.prototype.y;
/**
* Z-component of the three-dimensional vector.
* @type {number}
*/
google.maps.Vector3DLiteral.prototype.z;
/**
* Possible values for vehicle types.
*
* Access by calling `const {VehicleType} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.VehicleType = {
/**
* Bus.
*/
BUS: 'BUS',
/**
* A vehicle that operates on a cable, usually on the ground. Aerial cable
* cars may be of the type GONDOLA_LIFT.
*/
CABLE_CAR: 'CABLE_CAR',
/**
* Commuter rail.
*/
COMMUTER_TRAIN: 'COMMUTER_TRAIN',
/**
* Ferry.
*/
FERRY: 'FERRY',
/**
* A vehicle that is pulled up a steep incline by a cable.
*/
FUNICULAR: 'FUNICULAR',
/**
* An aerial cable car.
*/
GONDOLA_LIFT: 'GONDOLA_LIFT',
/**
* Heavy rail.
*/
HEAVY_RAIL: 'HEAVY_RAIL',
/**
* High speed train.
*/
HIGH_SPEED_TRAIN: 'HIGH_SPEED_TRAIN',
/**
* Intercity bus.
*/
INTERCITY_BUS: 'INTERCITY_BUS',
/**
* Light rail.
*/
METRO_RAIL: 'METRO_RAIL',
/**
* Monorail.
*/
MONORAIL: 'MONORAIL',
/**
* Other vehicles.
*/
OTHER: 'OTHER',
/**
* Rail.
*/
RAIL: 'RAIL',
/**
* Share taxi is a sort of bus transport with ability to drop off and pick up
* passengers anywhere on its route. Generally share taxi uses minibus
* vehicles.
*/
SHARE_TAXI: 'SHARE_TAXI',
/**
* Underground light rail.
*/
SUBWAY: 'SUBWAY',
/**
* Above ground light rail.
*/
TRAM: 'TRAM',
/**
* Trolleybus.
*/
TROLLEYBUS: 'TROLLEYBUS',
};
/**
* Contains the four points defining the four-sided polygon that is the visible
* region of the map. On a vector map this polygon can be a trapezoid instead of
* a rectangle, when a vector map has tilt.
* @record
*/
google.maps.VisibleRegion = function() {};
/**
* @type {!google.maps.LatLng}
*/
google.maps.VisibleRegion.prototype.farLeft;
/**
* @type {!google.maps.LatLng}
*/
google.maps.VisibleRegion.prototype.farRight;
/**
* The smallest bounding box that includes the visible region.
* @type {!google.maps.LatLngBounds}
*/
google.maps.VisibleRegion.prototype.latLngBounds;
/**
* @type {!google.maps.LatLng}
*/
google.maps.VisibleRegion.prototype.nearLeft;
/**
* @type {!google.maps.LatLng}
*/
google.maps.VisibleRegion.prototype.nearRight;
/**
* @record
*/
google.maps.VisualizationLibrary = function() {};
/**
* @type {typeof google.maps.visualization.HeatmapLayer}
*/
google.maps.VisualizationLibrary.prototype.HeatmapLayer;
/**
* Drawing options.
* @record
*/
google.maps.WebGLDrawOptions = function() {};
/**
* The WebGLRenderingContext on which to render this WebGLOverlayView.
* @type {!WebGLRenderingContext}
*/
google.maps.WebGLDrawOptions.prototype.gl;
/**
* The matrix transformation from camera space to latitude/longitude
* coordinates.
* @type {!google.maps.CoordinateTransformer}
*/
google.maps.WebGLDrawOptions.prototype.transformer;
/**
* The WebGL Overlay View provides direct access to the same WebGL rendering
* context Google Maps Platform uses to render the vector basemap. This use of a
* shared rendering context provides benefits such as depth occlusion with 3D
* building geometry, and the ability to sync 2D/3D content with basemap
* rendering.
With WebGL Overlay View you can add content to your maps
* using WebGL directly, or popular Graphics libraries like Three.js or deck.gl.
* To use the overlay, you can extend google.maps.WebGLOverlayView
* and provide an implementation for each of the following lifecycle
* hooks: {@link google.maps.WebGLOverlayView.onAdd}, {@link
* google.maps.WebGLOverlayView.onContextRestored}, {@link
* google.maps.WebGLOverlayView.onDraw}, {@link
* google.maps.WebGLOverlayView.onContextLost} and {@link
* google.maps.WebGLOverlayView.onRemove}.
You must call {@link
* google.maps.WebGLOverlayView.setMap} with a valid {@link google.maps.Map}
* object to trigger the call to the onAdd() method and
* setMap(null) in order to trigger the onRemove()
* method. The setMap() method can be called at the time of
* construction or at any point afterward when the overlay should be re-shown
* after removing. The onDraw() method will then be called whenever
* a map property changes that could change the position of the element, such as
* zoom, center, or map type. WebGLOverlayView may only be added to a vector map
* having a {@link google.maps.MapOptions.mapId} (including maps set to
* the {@link google.maps.RenderingType.VECTOR} {@link
* google.maps.MapOptions.renderingType} and using {@link
* google.maps.Map.DEMO_MAP_ID} as the {@link google.maps.MapOptions.mapId}).
*
* Access by calling `const {WebGLOverlayView} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.MVCObject}
* @constructor
*/
google.maps.WebGLOverlayView = function() {};
/**
* @return {google.maps.Map|null|undefined}
*/
google.maps.WebGLOverlayView.prototype.getMap = function() {};
/**
* Implement this method to fetch or create intermediate data structures before
* the overlay is drawn that don’t require immediate access to the WebGL
* rendering context. This method must be implemented to render.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.onAdd = function() {};
/**
* This method is called when the rendering context is lost for any reason, and
* is where you should clean up any pre-existing GL state, since it is no longer
* needed.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.onContextLost = function() {};
/**
* This method is called once the rendering context is available. Use it to
* initialize or bind any WebGL state such as shaders or buffer objects.
* @param {!google.maps.WebGLStateOptions} options that allow developers to
* restore the GL context.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.onContextRestored = function(options) {};
/**
* Implement this method to draw WebGL content directly on the map. Note that if
* the overlay needs a new frame drawn then call {@link
* google.maps.WebGLOverlayView.requestRedraw}.
* @param {!google.maps.WebGLDrawOptions} options that allow developers to
* render content to an associated Google basemap.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.onDraw = function(options) {};
/**
* This method is called when the overlay is removed from the map with
* WebGLOverlayView.setMap(null), and is where you should remove
* all intermediate objects. This method must be implemented to render.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.onRemove = function() {};
/**
* Implement this method to handle any GL state updates outside of the render
* animation frame.
* @param {!google.maps.WebGLStateOptions} options that allow developerse to
* restore the GL context.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.onStateUpdate = function(options) {};
/**
* Triggers the map to redraw a frame.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.requestRedraw = function() {};
/**
* Triggers the map to update GL state.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.requestStateUpdate = function() {};
/**
* Adds the overlay to the map.
* @param {?google.maps.Map=} map The map to access the div, model and view
* state.
* @return {undefined}
*/
google.maps.WebGLOverlayView.prototype.setMap = function(map) {};
/**
* GL state options.
* @record
*/
google.maps.WebGLStateOptions = function() {};
/**
* The WebGLRenderingContext on which to render this WebGLOverlayView.
* @type {!WebGLRenderingContext}
*/
google.maps.WebGLStateOptions.prototype.gl;
/**
* This event is created from monitoring zoom change.
*
* Access by calling `const {ZoomChangeEvent} = await
* google.maps.importLibrary("maps")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {Event}
* @constructor
*/
google.maps.ZoomChangeEvent = function() {};
/**
* Options for the rendering of the zoom control.
* @record
*/
google.maps.ZoomControlOptions = function() {};
/**
* Position id. Used to specify the position of the control on the map.
* @default {@link google.maps.ControlPosition.INLINE_END_BLOCK_END}
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.ZoomControlOptions.prototype.position;
/**
* Namespace for all public event functions
*
* Access by calling `const {event} = await google.maps.importLibrary("core")`.
* See https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.event = function() {};
/**
* Adds the given listener function to the given event name for the given object
* instance. Returns an identifier for this listener that can be used with
* removeListener().
* @param {!Object} instance
* @param {string} eventName
* @param {!Function} handler
* @return {!google.maps.MapsEventListener}
*/
google.maps.event.addListener = function(instance, eventName, handler) {};
/**
* Like addListener, but the handler removes itself after handling the first
* event.
* @param {!Object} instance
* @param {string} eventName
* @param {!Function} handler
* @return {!google.maps.MapsEventListener}
*/
google.maps.event.addListenerOnce = function(instance, eventName, handler) {};
/**
* Removes all listeners for all events for the given instance.
* @param {!Object} instance
* @return {void}
*/
google.maps.event.clearInstanceListeners = function(instance) {};
/**
* Removes all listeners for the given event for the given instance.
* @param {!Object} instance
* @param {string} eventName
* @return {void}
*/
google.maps.event.clearListeners = function(instance, eventName) {};
/**
* Returns if there are listeners for the given event on the given instance. Can
* be used to save the computation of expensive event details.
* @param {!Object} instance
* @param {string} eventName
* @return {boolean}
*/
google.maps.event.hasListeners = function(instance, eventName) {};
/**
* Removes the given listener, which should have been returned by addListener
* above. Equivalent to calling listener.remove().
* @param {!google.maps.MapsEventListener} listener
* @return {void}
*/
google.maps.event.removeListener = function(listener) {};
/**
* Triggers the given event. All arguments after eventName are passed as
* arguments to the listeners.
* @param {!Object} instance
* @param {string} eventName
* @param {...?} eventArgs
* @return {void}
*/
google.maps.event.trigger = function(instance, eventName, eventArgs) {};
/**
* Cross browser event handler registration. This listener is removed by calling
* removeListener(handle) for the handle that is returned by this function.
* @param {!Object} instance
* @param {string} eventName
* @param {!Function} handler
* @param {boolean=} capture
* @return {!google.maps.MapsEventListener}
* @deprecated google.maps.event.addDomListener() is deprecated,
* use the standard addEventListener()
* method instead. The feature will continue to work and there is no plan to
* decommission it.
*/
google.maps.event.addDomListener = function(
instance, eventName, handler, capture) {};
/**
* Wrapper around addDomListener that removes the listener after the first
* event.
* @param {!Object} instance
* @param {string} eventName
* @param {!Function} handler
* @param {boolean=} capture
* @return {!google.maps.MapsEventListener}
* @deprecated google.maps.event.addDomListenerOnce() is
* deprecated, use the standard addEventListener()
* method instead. The feature will continue to work and there is no plan to
* decommission it.
*/
google.maps.event.addDomListenerOnce = function(
instance, eventName, handler, capture) {};
/**
* @const
*/
google.maps.addressValidation = {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* Details of the post-processed address. Post-processing includes correcting
* misspelled parts of the address, replacing incorrect parts, and inferring
* missing parts.
*
* Access by calling `const {Address} = await
* google.maps.importLibrary("addressValidation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.addressValidation.Address = function() {};
/**
* The individual address components of the formatted and corrected address,
* along with validation information. This provides information on the
* validation status of the individual components.
* @type {!Array}
*/
google.maps.addressValidation.Address.prototype.components;
/**
* The post-processed address, formatted as a single-line address following the
* address-formatting rules of the region where the address is located.
* @type {string|null}
*/
google.maps.addressValidation.Address.prototype.formattedAddress;
/**
* The types of components that were expected to be present in a correctly
* formatted mailing address but were not found in the input AND could not be
* inferred. Components of this type are not present in
* formatted_address, postal_address, or
* address_components. An example might be
* ['street_number', 'route'] for an input like
* "Boulder, Colorado, 80301, USA". The list of possible types can be
* found here.
* @type {!Arrayaddress_components but could not be confirmed to be correct.
* This field is provided for the sake of convenience: its contents are
* equivalent to iterating through the address_components to find
* the types of all the components where the {@link
* google.maps.addressValidation.AddressComponent.confirmationLevel} is
* not {@link google.maps.addressValidation.ConfirmationLevel.CONFIRMED} or
* the {@link google.maps.addressValidation.AddressComponent.inferred} flag is
* not set to true. The list of possible types can be found here.
* @type {!Array["123235253253"] since
* that does not look like a valid street number.
* @type {!Arraymetadata is not
* guaranteed to be fully populated for every address sent to the Address
* Validation API.
* @type {!google.maps.addressValidation.AddressMetadata|null}
*/
google.maps.addressValidation.AddressValidation.prototype.metadata;
/**
* The UUID that identifies this response. If the address needs to be
* re-validated, this UUID must accompany the new request.
* @type {string|null}
*/
google.maps.addressValidation.AddressValidation.prototype.responseId;
/**
* Extra deliverability flags provided by USPS. Only provided in region
* US and PR.
* @type {!google.maps.addressValidation.USPSData|null}
*/
google.maps.addressValidation.AddressValidation.prototype.uspsData;
/**
* Overall verdict flags
* @type {!google.maps.addressValidation.Verdict|null}
*/
google.maps.addressValidation.AddressValidation.prototype.verdict;
/**
* Validates an address. See https://developers.google.com/maps/documentation/javascript/address-validation/validate-address.
* @param {!google.maps.addressValidation.AddressValidationRequest} request
* @return {!Promise}
*/
google.maps.addressValidation.AddressValidation.fetchAddressValidation =
function(request) {};
/**
* Converts the AddressValidation class to a JSON object with the same
* properties.
* @return {!Object}
*/
google.maps.addressValidation.AddressValidation.prototype.toJSON =
function() {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* Request interface for {@link
* google.maps.addressValidation.AddressValidation.fetchAddressValidation}.
* @record
*/
google.maps.addressValidation.AddressValidationRequest = function() {};
/**
* The address being validated. Unformatted addresses should be submitted
* via {@link google.maps.places.PostalAddress.addressLines}.
* @type {!google.maps.places.PostalAddressLiteral}
*/
google.maps.addressValidation.AddressValidationRequest.prototype.address;
/**
* If using a PlaceAutocompleteElement, include it here to link the
* AddressValidation API calls with the autocomplete session token.
* @type {!google.maps.places.PlaceAutocompleteElement|undefined}
*/
google.maps.addressValidation.AddressValidationRequest.prototype
.placeAutocompleteElement;
/**
* This field must not be set for the first address validation request. If more
* requests are necessary to fully validate a single address (for example if the
* changes the user makes after the initial validation need to be re-validated),
* then each followup request must populate this field with the {@link
* google.maps.addressValidation.AddressValidation.responseId} from the very
* first response in the validation sequence.
* @type {string|undefined}
*/
google.maps.addressValidation.AddressValidationRequest.prototype
.previousResponseId;
/**
* A token which identifies an Autocomplete session for billing purposes.
* @type {!google.maps.places.AutocompleteSessionToken|undefined}
*/
google.maps.addressValidation.AddressValidationRequest.prototype.sessionToken;
/**
* Enables USPS CASS compatible mode. This affects only the {@link
* google.maps.addressValidation.AddressValidation.uspsData} field of {@link
* google.maps.addressValidation.AddressValidation}. Note: for USPS CASS enabled
* requests for addresses in Puerto Rico, a {@link
* google.maps.places.PostalAddress.regionCode} of the address must
* be provided as "PR", or an {@link
* google.maps.places.PostalAddress.administrativeArea} of the
* address must be provided as "Puerto Rico"
* (case-insensitive) or "PR".
* @type {boolean|undefined}
*/
google.maps.addressValidation.AddressValidationRequest.prototype
.uspsCASSEnabled;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* The different possible values indicating the level of certainty that the
* component is correct.
*
* Access by calling `const {ConfirmationLevel} = await
* google.maps.importLibrary("addressValidation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.addressValidation.ConfirmationLevel = {
CONFIRMED: 'CONFIRMED',
UNCONFIRMED_AND_SUSPICIOUS: 'UNCONFIRMED_AND_SUSPICIOUS',
UNCONFIRMED_BUT_PLAUSIBLE: 'UNCONFIRMED_BUT_PLAUSIBLE',
};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* Contains information about the place the input was geocoded to.
*
* Access by calling `const {Geocode} = await
* google.maps.importLibrary("addressValidation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.addressValidation.Geocode = function() {};
/**
* The bounds of the geocoded place.
* @type {!google.maps.LatLngBounds|null}
*/
google.maps.addressValidation.Geocode.prototype.bounds;
/**
* The size of the geocoded place, in meters. This is another measure of the
* coarseness of the geocoded location, but in physical size rather than in
* semantic meaning.
* @type {number|null}
*/
google.maps.addressValidation.Geocode.prototype.featureSizeMeters;
/**
* The geocoded location of the input.
* @type {!google.maps.LatLngAltitude|null}
*/
google.maps.addressValidation.Geocode.prototype.location;
/**
* The Place ID of the geocoded place. Using Place is preferred over using
* addresses, latitude/longitude coordinates, or plus codes. Using coordinates
* for routing or calculating driving directions will always result in the point
* being snapped to the road nearest to those coordinates. This may not be a
* road that will quickly or safely lead to the destination and may not be near
* an access point to the property. Additionally, when a location is reverse
* geocoded, there is no guarantee that the returned address will match the
* original.
* @type {string|null}
*/
google.maps.addressValidation.Geocode.prototype.placeId;
/**
* The type(s) of place that the input geocoded to. For example,
* ['locality', 'political']. The full list of
* types can be found in the Geocoding
* API documentation.
* @type {!Arraylocation.
* @type {!google.maps.places.PlusCode|null}
*/
google.maps.addressValidation.Geocode.prototype.plusCode;
/**
* Returns a Place representation of this Geocode. To get full place details, a
* call to place.fetchFields() should be made.
* @return {undefined}
*/
google.maps.addressValidation.Geocode.prototype.fetchPlace = function() {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* The various granularities that an address or a geocode can have. When used to
* indicate granularity for an address, these values indicate with how
* fine a granularity the address identifies a mailing destination. For example,
* an address such as "123 Main Street, Redwood City, CA, 94061"
* identifies a PREMISE while something like "Redwood City,
* CA, 94061" identifies a LOCALITY. However, if we are unable
* to find a geocode for "123 Main Street" in Redwood City, the
* geocode returned might be of LOCALITY granularity even though
* the address is more granular.
*
* Access by calling `const {Granularity} = await
* google.maps.importLibrary("addressValidation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.addressValidation.Granularity = {
/**
* The address or geocode indicates a block. Only used in regions which have
* block-level addressing, such as Japan.
*/
BLOCK: 'BLOCK',
/**
* All other granularities, which are bucketed together since they are not
* deliverable.
*/
OTHER: 'OTHER',
/**
* Building-level result.
*/
PREMISE: 'PREMISE',
/**
* A geocode that approximates the building-level location of the address.
*/
PREMISE_PROXIMITY: 'PREMISE_PROXIMITY',
/**
* The geocode or address is granular to route, such as a street, road, or
* highway.
*/
ROUTE: 'ROUTE',
/**
* Below-building level result, such as an apartment.
*/
SUB_PREMISE: 'SUB_PREMISE',
};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* Offers an interpretive summary of the API response, intended to assist in
* determining a potential subsequent action to take. This field is derived from
* other fields in the API response and should not be considered as a guarantee
* of address accuracy or deliverability.
*
* Access by calling `const {PossibleNextAction} = await
* google.maps.importLibrary("addressValidation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.addressValidation.PossibleNextAction = {
/**
* The API response does not contain signals that warrant one of the other
* PossibleNextAction values. You might consider using the post-processed
* address without further prompting your customer, though this does not
* guarantee the address is valid, and the address might still contain
* corrections. It is your responsibility to determine if and how to prompt
* your customer, depending on your own risk assessment.
*/
ACCEPT: 'ACCEPT',
/**
* One or more fields of the API response indicate potential minor issues with
* the post-processed address, for example the postal_code
* address component was replaced. Prompting your customer to
* review the address could help improve the quality of the address.
*/
CONFIRM: 'CONFIRM',
/**
* The API response indicates the post-processed address might be missing a
* subpremises. Prompting your customer to review the address and consider
* adding a unit number could help improve the quality of the address. The
* post-processed address might also have other minor issues. Note: this enum
* value can only be returned for US addresses.
*/
CONFIRM_ADD_SUBPREMISES: 'CONFIRM_ADD_SUBPREMISES',
/**
* One or more fields of the API response indicate a potential issue with the
* post-processed address, for example the
* verdict.validation_granularity is OTHER.
* Prompting your customer to edit the address could help improve the quality
* of the address.
*/
FIX: 'FIX',
};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* USPS representation of a US address.
*
* Access by calling `const {USPSAddress} = await
* google.maps.importLibrary("addressValidation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.addressValidation.USPSAddress = function() {};
/**
* The city name.
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.city;
/**
* The address line containing the city, state, and zip code.
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.cityStateZipAddressLine;
/**
* The name of the firm.
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.firm;
/**
* The first line of the address.
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.firstAddressLine;
/**
* The second line of the address.
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.secondAddressLine;
/**
* The 2-letter state code.
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.state;
/**
* The Puerto Rican urbanization name.
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.urbanization;
/**
* The Postal code, e.g. "10009".
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.zipCode;
/**
* The 4-digit postal code extension, e.g. "5023".
* @type {string|null}
*/
google.maps.addressValidation.USPSAddress.prototype.zipCodeExtension;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* The USPS data for the address. USPSData is not guaranteed to be fully
* populated for every US or PR address sent to the Address Validation API.
* It's recommended to integrate the backup address fields in the response
* if you utilize uspsData as the primary part of the response.
*
* Access by calling `const {USPSData} = await
* google.maps.importLibrary("addressValidation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.addressValidation.USPSData = function() {};
/**
* Abbreviated city.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.abbreviatedCity;
/**
* Type of the address record that matches the input address.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.addressRecordType;
/**
* The carrier route code. A four character code consisting of a one letter
* prefix and a three digit route designator.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.carrierRoute;
/**
* Carrier route rate sort indicator.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.carrierRouteIndicator;
/**
* Indicator that the request has been CASS processed.
* @type {boolean}
*/
google.maps.addressValidation.USPSData.prototype.cassProcessed;
/**
* County name.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.county;
/**
* The delivery point check digit. This number is added to the end of the
* delivery_point_barcode for mechanically scanned mail. Adding all the digits
* of the delivery_point_barcode, delivery_point_check_digit, postal code, and
* ZIP+4 together should yield a number divisible by 10.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.deliveryPointCheckDigit;
/**
* The 2-digit delivery point code.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.deliveryPointCode;
/**
* Indicates if the address is a CMRA (Commercial Mail Receiving Agency)--a
* private business receiving mail for clients. Returns a single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvCMRA;
/**
* The possible values for DPV confirmation. Returns a single character or
* returns no value.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvConfirmation;
/**
* Flag indicates addresses where USPS cannot knock on a door to deliver mail.
* Returns a single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvDoorNotAccessible;
/**
* Flag indicates mail is delivered to a single receptable at a site. Returns a
* single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvDrop;
/**
* Indicates that more than one DPV return code is valid for the address.
* Returns a single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvEnhancedDeliveryCode;
/**
* The footnotes from delivery point validation. Multiple footnotes may be
* strung together in the same string.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvFootnote;
/**
* Flag indicates mail delivery is not performed every day of the week. Returns
* a single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvNonDeliveryDays;
/**
* Integer identifying non-delivery days. It can be interrogated using bit
* flags: 0x40 – Sunday is a non-delivery day 0x20 – Monday is a non-delivery
* day 0x10 – Tuesday is a non-delivery day 0x08 – Wednesday is a non-delivery
* day 0x04 – Thursday is a non-delivery day 0x02 – Friday is a non-delivery day
* 0x01 – Saturday is a non-delivery day
* @type {number|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvNonDeliveryDaysValues;
/**
* Flag indicates door is accessible, but package will not be left due to
* security concerns. Returns a single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvNoSecureLocation;
/**
* Indicates whether the address is a no stat address or an active address. No
* stat addresses are ones which are not continuously occupied or addresses that
* the USPS does not service. Returns a single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvNoStat;
/**
* Indicates the NoStat type. Returns a reason code as int.
* @type {number|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvNoStatReasonCode;
/**
* Indicates the address was matched to PBSA record. Returns a single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvPBSA;
/**
* Indicates that mail is not delivered to the street address. Returns a single
* character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvThrowback;
/**
* Indicates whether the address is vacant. Returns a single character.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.dpvVacant;
/**
* eLOT Ascending/Descending Flag (A/D).
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.elotFlag;
/**
* Enhanced Line of Travel (eLOT) number.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.elotNumber;
/**
* Error message for USPS data retrieval. This is populated when USPS processing
* is suspended because of the detection of artificially created addresses.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.errorMessage;
/**
* FIPS county code.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.fipsCountyCode;
/**
* Indicator that a default address was found, but more specific addresses
* exist.
* @type {boolean}
*/
google.maps.addressValidation.USPSData.prototype.hasDefaultAddress;
/**
* The delivery address is matchable, but the EWS file indicates that an exact
* match will be available soon.
* @type {boolean}
*/
google.maps.addressValidation.USPSData.prototype.hasNoEWSMatch;
/**
* LACSLink indicator.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.lacsLinkIndicator;
/**
* LACSLink return code.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.lacsLinkReturnCode;
/**
* PMB (Private Mail Box) unit designator.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.pmbDesignator;
/**
* PMB (Private Mail Box) number.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.pmbNumber;
/**
* PO Box only postal code.
* @type {boolean}
*/
google.maps.addressValidation.USPSData.prototype.poBoxOnlyPostalCode;
/**
* Main post office city.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.postOfficeCity;
/**
* Main post office state.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.postOfficeState;
/**
* USPS standardized address.
* @type {!google.maps.addressValidation.USPSAddress|null}
*/
google.maps.addressValidation.USPSData.prototype.standardizedAddress;
/**
* Footnotes from matching a street or highrise record to suite information. If
* business name match is found, the secondary number is returned.
* @type {string|null}
*/
google.maps.addressValidation.USPSData.prototype.suiteLinkFootnote;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
*
* Represents the post-processed address for the supplied address.
*
* Access by calling `const {Verdict} = await
* google.maps.importLibrary("addressValidation")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.addressValidation.Verdict = function() {};
/**
* The address is considered complete if there are no unresolved tokens, no
* unexpected or missing address components. If unset, indicates that the value
* is false. See {@link
* google.maps.addressValidation.Address.missingComponentTypes}, {@link
* google.maps.addressValidation.Address.unresolvedTokens} or {@link
* google.maps.addressValidation.AddressComponent.unexpected} fields for more
* details.
* @type {boolean}
*/
google.maps.addressValidation.Verdict.prototype.addressComplete;
/**
* Information about the granularity of the {@link
* google.maps.addressValidation.Geocode}. This can be understood as the
* semantic meaning of how coarse or fine the geocoded location is.
* @type {!google.maps.addressValidation.Granularity|null}
*/
google.maps.addressValidation.Verdict.prototype.geocodeGranularity;
/**
* At least one address component was inferred (i.e. added) that wasn't in
* the input, see {@link google.maps.addressValidation.AddressComponent} for
* details.
* @type {boolean}
*/
google.maps.addressValidation.Verdict.prototype.hasInferredComponents;
/**
* At least one address component was replaced - see {@link
* google.maps.addressValidation.AddressComponent} for details.
* @type {boolean|null}
*/
google.maps.addressValidation.Verdict.prototype.hasReplacedComponents;
/**
* At least one address component cannot be categorized or validated, see {@link
* google.maps.addressValidation.AddressComponent} for details.
* @type {boolean}
*/
google.maps.addressValidation.Verdict.prototype.hasUnconfirmedComponents;
/**
* The granularity of the input address. This is the result of
* parsing the input address and does not give any validation signals. For
* validation signals, refer to validationGranularity.
* @type {!google.maps.addressValidation.Granularity|null}
*/
google.maps.addressValidation.Verdict.prototype.inputGranularity;
/**
* A possible next action to take based on other fields in the API response.
* See {@link google.maps.addressValidation.PossibleNextAction} for details.
* @type {!google.maps.addressValidation.PossibleNextAction|null}
*/
google.maps.addressValidation.Verdict.prototype.possibleNextAction;
/**
* The granularity level that the API can fully validate the
* address to. For example, a validationGranularity of
* PREMISE indicates all address components at the level of
* PREMISE and broader can be validated.
* @type {!google.maps.addressValidation.Granularity|null}
*/
google.maps.addressValidation.Verdict.prototype.validationGranularity;
/**
* @const
*/
google.maps.airQuality = {};
/**
* Available only in the v=alpha channel: https://goo.gle/js-alpha-channel.
*
* Displays air quality information for a given location.
*
* Access by calling `const {AirQualityMeterElement} = await
* google.maps.importLibrary("airQuality")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.airQuality.AirQualityMeterElementOptions=} options
* @implements {google.maps.airQuality.AirQualityMeterElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.airQuality.AirQualityMeterElement = function(options) {};
/**
* The location to render the air quality meter for. Normalizes to a
* LatLngAltitude.
* @default null
* @type {!google.maps.LatLngLiteral|!google.maps.LatLng|!google.maps.LatLngAltitudeLiteral|!google.maps.LatLngAltitude|null|undefined}
*/
google.maps.airQuality.AirQualityMeterElement.prototype.location;
/**
* An override for the language to request from the Air
* Quality API. See the list of
* supported languages.
* @default null
* @type {string|null}
*/
google.maps.airQuality.AirQualityMeterElement.prototype.requestedLanguage;
/**
* AirQualityMeterElement options.
* @record
*/
google.maps.airQuality.AirQualityMeterElementOptions = function() {};
/**
* See {@link google.maps.airQuality.AirQualityMeterElement.location}
* @type {!google.maps.LatLngLiteral|!google.maps.LatLng|!google.maps.LatLngAltitudeLiteral|!google.maps.LatLngAltitude|null|undefined}
*/
google.maps.airQuality.AirQualityMeterElementOptions.prototype.location;
/**
* See {@link google.maps.airQuality.AirQualityMeterElement.requestedLanguage}
* @type {string|null|undefined}
*/
google.maps.airQuality.AirQualityMeterElementOptions.prototype
.requestedLanguage;
/**
* @const
*/
google.maps.drawing = {};
/**
* Options for the rendering of the drawing control.
* @record
*/
google.maps.drawing.DrawingControlOptions = function() {};
/**
* The drawing modes to display in the drawing control, in the order in which
* they are to be displayed. The hand icon (which corresponds to the
* null drawing mode) is always available and is not to be
* specified in this array.
* @default [{@link google.maps.drawing.OverlayType.MARKER}, {@link
* google.maps.drawing.OverlayType.POLYLINE}, {@link
* google.maps.drawing.OverlayType.RECTANGLE}, {@link
* google.maps.drawing.OverlayType.CIRCLE}, {@link
* google.maps.drawing.OverlayType.POLYGON}]
* @type {!Array|null|undefined}
*/
google.maps.drawing.DrawingControlOptions.prototype.drawingModes;
/**
* Position id. Used to specify the position of the control on the map.
* @default {@link google.maps.ControlPosition.TOP_LEFT}
* @type {!google.maps.ControlPosition|null|undefined}
*/
google.maps.drawing.DrawingControlOptions.prototype.position;
/**
* Allows users to draw markers, polygons, polylines, rectangles, and circles on
* the map. The DrawingManager's drawing mode defines the type
* of overlay that will be created by the user. Adds a control to the map,
* allowing the user to switch drawing mode.
*
* Access by calling `const {DrawingManager} = await
* google.maps.importLibrary("drawing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {google.maps.drawing.DrawingManagerOptions=} options
* @extends {google.maps.MVCObject}
* @constructor
* @deprecated Drawing library functionality in the Maps JavaScript API is
* deprecated. This API was deprecated in August 2025 and will be made
* unavailable in a later version of the Maps JavaScript API, releasing in
* May 2026. For more info, see https://developers.google.com/maps/deprecations
*/
google.maps.drawing.DrawingManager = function(options) {};
/**
* Returns the DrawingManager's drawing mode.
* @return {?google.maps.drawing.OverlayType}
*/
google.maps.drawing.DrawingManager.prototype.getDrawingMode = function() {};
/**
* Returns the Map to which the DrawingManager is
* attached, which is the Map on which the overlays created will be
* placed.
* @return {google.maps.Map}
*/
google.maps.drawing.DrawingManager.prototype.getMap = function() {};
/**
* Changes the DrawingManager's drawing mode, which defines the
* type of overlay to be added on the map. Accepted values are
* 'marker', 'polygon', 'polyline',
* 'rectangle', 'circle', or null. A
* drawing mode of null means that the user can interact with the
* map as normal, and clicks do not draw anything.
* @param {?google.maps.drawing.OverlayType} drawingMode
* @return {undefined}
*/
google.maps.drawing.DrawingManager.prototype.setDrawingMode = function(
drawingMode) {};
/**
* Attaches the DrawingManager object to the specified
* Map.
* @param {google.maps.Map} map
* @return {undefined}
*/
google.maps.drawing.DrawingManager.prototype.setMap = function(map) {};
/**
* Sets the DrawingManager's options.
* @param {google.maps.drawing.DrawingManagerOptions} options
* @return {undefined}
*/
google.maps.drawing.DrawingManager.prototype.setOptions = function(options) {};
/**
* Options for the drawing manager.
* @record
*/
google.maps.drawing.DrawingManagerOptions = function() {};
/**
* Options to apply to any new circles created with this
* DrawingManager. The center and radius
* properties are ignored, and the map property of a new circle is
* always set to the DrawingManager's map.
* @type {!google.maps.CircleOptions|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.circleOptions;
/**
* The enabled/disabled state of the drawing control.
* @default true
* @type {boolean|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.drawingControl;
/**
* The display options for the drawing control.
* @type {!google.maps.drawing.DrawingControlOptions|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.drawingControlOptions;
/**
* The DrawingManager's drawing mode, which defines the type of
* overlay to be added on the map. Accepted values are 'marker',
* 'polygon', 'polyline', 'rectangle',
* 'circle', or null. A drawing mode of
* null means that the user can interact with the map as normal,
* and clicks do not draw anything.
* @type {!google.maps.drawing.OverlayType|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.drawingMode;
/**
* The Map to which the DrawingManager is attached,
* which is the Map on which the overlays created will be placed.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.map;
/**
* Options to apply to any new markers created with this
* DrawingManager. The position property is ignored,
* and the map property of a new marker is always set to the
* DrawingManager's map.
* @type {!google.maps.MarkerOptions|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.markerOptions;
/**
* Options to apply to any new polygons created with this
* DrawingManager. The paths property is ignored, and
* the map property of a new polygon is always set to the
* DrawingManager's map.
* @type {!google.maps.PolygonOptions|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.polygonOptions;
/**
* Options to apply to any new polylines created with this
* DrawingManager. The path property is ignored, and
* the map property of a new polyline is always set to the
* DrawingManager's map.
* @type {!google.maps.PolylineOptions|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.polylineOptions;
/**
* Options to apply to any new rectangles created with this
* DrawingManager. The bounds property is ignored, and
* the map property of a new rectangle is always set to the
* DrawingManager's map.
* @type {!google.maps.RectangleOptions|null|undefined}
*/
google.maps.drawing.DrawingManagerOptions.prototype.rectangleOptions;
/**
* The properties of an overlaycomplete event on a DrawingManager.
* @record
*/
google.maps.drawing.OverlayCompleteEvent = function() {};
/**
* The completed overlay.
* @type {!google.maps.Marker|!google.maps.Polygon|!google.maps.Polyline|!google.maps.Rectangle|!google.maps.Circle}
*/
google.maps.drawing.OverlayCompleteEvent.prototype.overlay;
/**
* The completed overlay's type.
* @type {!google.maps.drawing.OverlayType}
*/
google.maps.drawing.OverlayCompleteEvent.prototype.type;
/**
* The types of overlay that may be created by the DrawingManager.
* Specify these by value, or by using the constant's name. For example,
* 'polygon' or
* google.maps.drawing.OverlayType.POLYGON.
*
* Access by calling `const {OverlayType} = await
* google.maps.importLibrary("drawing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.drawing.OverlayType = {
/**
* Specifies that the DrawingManager creates circles, and that
* the overlay given in the overlaycomplete event is a circle.
*/
CIRCLE: 'circle',
/**
* Specifies that the DrawingManager creates markers, and that
* the overlay given in the overlaycomplete event is a marker.
*/
MARKER: 'marker',
/**
* Specifies that the DrawingManager creates polygons, and that
* the overlay given in the overlaycomplete event is a polygon.
*/
POLYGON: 'polygon',
/**
* Specifies that the DrawingManager creates polylines, and that
* the overlay given in the overlaycomplete event is a polyline.
*/
POLYLINE: 'polyline',
/**
* Specifies that the DrawingManager creates rectangles, and that
* the overlay given in the overlaycomplete event is a rectangle.
*/
RECTANGLE: 'rectangle',
};
/**
* @const
*/
google.maps.geometry = {};
/**
* Utilities for polyline encoding and decoding.
*
* Access by calling `const {encoding} = await
* google.maps.importLibrary("geometry")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.geometry.encoding = function() {};
/**
* Decodes an encoded path string into a sequence of LatLngs.
* @param {string} encodedPath
* @return {!Array}
*/
google.maps.geometry.encoding.decodePath = function(encodedPath) {};
/**
* Encodes a sequence of LatLngs into an encoded path string.
* @param {!Array|!google.maps.MVCArray}
* path
* @return {string}
*/
google.maps.geometry.encoding.encodePath = function(path) {};
/**
* Utility functions for computations involving polygons and polylines.
*
* Access by calling `const {poly} = await
* google.maps.importLibrary("geometry")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.geometry.poly = function() {};
/**
* Computes whether the given point lies inside the specified polygon.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} point
* @param {!google.maps.Polygon} polygon
* @return {boolean}
*/
google.maps.geometry.poly.containsLocation = function(point, polygon) {};
/**
* Computes whether the given point lies on or near to a polyline, or the edge
* of a polygon, within a specified tolerance. Returns true when
* the difference between the latitude and longitude of the supplied point, and
* the closest point on the edge, is less than the tolerance. The tolerance
* defaults to 10-9 degrees.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} point
* @param {!google.maps.Polygon|!google.maps.Polyline} poly
* @param {number=} tolerance
* @return {boolean}
*/
google.maps.geometry.poly.isLocationOnEdge = function(
point, poly, tolerance) {};
/**
* Utility functions for computing geodesic angles, distances and areas. The
* default radius is Earth's radius of 6378137 meters.
*
* Access by calling `const {spherical} = await
* google.maps.importLibrary("geometry")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.geometry.spherical = function() {};
/**
* Returns the unsigned area of a closed path, in the range [0, 2×pi×radius²].
* The computed area uses the same units as the radius. The
* radiusOfSphere defaults to the Earth's radius in meters, in
* which case the area is in square meters. Passing a Circle
* requires the radius to be set to a non-negative value.
* Additionally, the Circle must not cover more than 100% of the sphere. And
* when passing a LatLngBounds, the southern LatLng cannot be more
* north than the northern LatLng.
* @param {!Array|!google.maps.MVCArray|!google.maps.Circle|!google.maps.CircleLiteral|!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral}
* path
* @param {number=} radiusOfSphere
* @return {number}
*/
google.maps.geometry.spherical.computeArea = function(path, radiusOfSphere) {};
/**
* Returns the distance, in meters, between two LatLngs. You can optionally
* specify a custom radius. The radius defaults to the radius of the Earth.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} from
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} to
* @param {number=} radius
* @return {number}
*/
google.maps.geometry.spherical.computeDistanceBetween = function(
from, to, radius) {};
/**
* Returns the heading from one LatLng to another LatLng. Headings are expressed
* in degrees clockwise from North within the range [-180,180).
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} from
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} to
* @return {number}
*/
google.maps.geometry.spherical.computeHeading = function(from, to) {};
/**
* Returns the length of the given path.
* @param {!Array|!google.maps.MVCArray}
* path
* @param {number=} radius
* @return {number}
*/
google.maps.geometry.spherical.computeLength = function(path, radius) {};
/**
* Returns the LatLng resulting from moving a distance from an origin in the
* specified heading (expressed in degrees clockwise from north).
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} from
* @param {number} distance
* @param {number} heading
* @param {number=} radius
* @return {!google.maps.LatLng}
*/
google.maps.geometry.spherical.computeOffset = function(
from, distance, heading, radius) {};
/**
* Returns the location of origin when provided with a LatLng destination,
* meters travelled and original heading. Headings are expressed in degrees
* clockwise from North. This function returns null when no
* solution is available.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} to
* @param {number} distance
* @param {number} heading
* @param {number=} radius
* @return {!google.maps.LatLng|null}
*/
google.maps.geometry.spherical.computeOffsetOrigin = function(
to, distance, heading, radius) {};
/**
* Returns the signed area of a closed path, where counterclockwise is positive,
* in the range [-2×pi×radius², 2×pi×radius²]. The computed area uses the same
* units as the radius. The radius defaults to the Earth's radius in meters,
* in which case the area is in square meters.
The area is computed
* using the parallel
* transport method; the parallel transport around a closed path on the unit
* sphere twists by an angle that is equal to the area enclosed by the path.
* This is simpler and more accurate and robust than triangulation using Girard,
* l'Huilier, or Eriksson on each triangle. In particular, since it
* doesn't triangulate, it suffers no instability except in the unavoidable
* case when an edge (not a diagonal) of the polygon spans 180 degrees.
* @param {!Array|!google.maps.MVCArray}
* loop
* @param {number=} radius
* @return {number}
*/
google.maps.geometry.spherical.computeSignedArea = function(loop, radius) {};
/**
* Returns the LatLng which lies the given fraction of the way between the
* origin LatLng and the destination LatLng.
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} from
* @param {!google.maps.LatLng|!google.maps.LatLngLiteral} to
* @param {number} fraction
* @return {!google.maps.LatLng}
*/
google.maps.geometry.spherical.interpolate = function(from, to, fraction) {};
/**
* @const
*/
google.maps.journeySharing = {};
/**
* The auth token returned by the token fetcher.
* @record
*/
google.maps.journeySharing.AuthToken = function() {};
/**
* The expiration time in seconds. A token expires in this amount of time after
* fetching.
* @type {number}
*/
google.maps.journeySharing.AuthToken.prototype.expiresInSeconds;
/**
* The token.
* @type {string}
*/
google.maps.journeySharing.AuthToken.prototype.token;
/**
* Contains additional information needed to mint JSON Web Tokens.
* @record
*/
google.maps.journeySharing.AuthTokenContext = function() {};
/**
* When provided, the minted token should have a private
* DeliveryVehicleId claim for the provided deliveryVehicleId.
* @type {string|null|undefined}
*/
google.maps.journeySharing.AuthTokenContext.prototype.deliveryVehicleId;
/**
* When provided, the minted token should have a private TaskId
* claim for the provided taskId.
* @type {string|null|undefined}
*/
google.maps.journeySharing.AuthTokenContext.prototype.taskId;
/**
* When provided, the minted token should have a private TrackingId
* claim for the provided trackingId.
* @type {string|null|undefined}
*/
google.maps.journeySharing.AuthTokenContext.prototype.trackingId;
/**
* When provided, the minted token should have a private TripId
* claim for the provided tripId.
* @type {string|null|undefined}
*/
google.maps.journeySharing.AuthTokenContext.prototype.tripId;
/**
* When provided, the minted token should have a private VehicleId
* claim for the provided vehicleId.
* @type {string|null|undefined}
*/
google.maps.journeySharing.AuthTokenContext.prototype.vehicleId;
/**
* @typedef {function(!google.maps.journeySharing.AuthTokenFetcherOptions):
* !Promise}
*/
google.maps.journeySharing.AuthTokenFetcher;
/**
* Options for the auth token fetcher.
* @record
*/
google.maps.journeySharing.AuthTokenFetcherOptions = function() {};
/**
* The auth token context. IDs specified in the context should be added to the
* request sent to the JSON Web Token minting endpoint.
* @type {!google.maps.journeySharing.AuthTokenContext}
*/
google.maps.journeySharing.AuthTokenFetcherOptions.prototype.context;
/**
* The Fleet Engine service type.
* @type {!google.maps.journeySharing.FleetEngineServiceType}
*/
google.maps.journeySharing.AuthTokenFetcherOptions.prototype.serviceType;
/**
* Automatic viewport mode.
*
* Access by calling `const {AutomaticViewportMode} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.journeySharing.AutomaticViewportMode = {
/**
* Automatically adjust the viewport to fit markers and any visible
* anticipated route polylines. This is the default.
*/
FIT_ANTICIPATED_ROUTE: 'FIT_ANTICIPATED_ROUTE',
/**
* Do not automatically adjust the viewport.
*/
NONE: 'NONE',
};
/**
* MarkerSetup default options.
* @record
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead.
*/
google.maps.journeySharing.DefaultMarkerSetupOptions = function() {};
/**
* Default marker options.
* @type {!google.maps.MarkerOptions}
*/
google.maps.journeySharing.DefaultMarkerSetupOptions.prototype
.defaultMarkerOptions;
/**
* PolylineSetup default options.
* @record
* @deprecated Polyline setup is deprecated. Use the
* PolylineCustomizationFunction methods for your location
* provider instead.
*/
google.maps.journeySharing.DefaultPolylineSetupOptions = function() {};
/**
* Default polyline options.
* @type {!google.maps.PolylineOptions}
*/
google.maps.journeySharing.DefaultPolylineSetupOptions.prototype
.defaultPolylineOptions;
/**
* Default polyline visibility.
* @type {boolean}
*/
google.maps.journeySharing.DefaultPolylineSetupOptions.prototype.defaultVisible;
/**
* The details for a delivery vehicle returned by Fleet Engine.
* @record
*/
google.maps.journeySharing.DeliveryVehicle = function() {};
/**
* Custom delivery vehicle attributes.
* @type {!Object
* @type {!Array}
*/
google.maps.journeySharing.DeliveryVehicleStop.prototype.tasks;
/**
* The current state of a {@link
* google.maps.journeySharing.DeliveryVehicleStop}.
*
* Access by calling `const {DeliveryVehicleStopState} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.journeySharing.DeliveryVehicleStopState = {
/**
* Arrived at stop. Assumes that when the vehicle is routing to the next stop,
* that all previous stops have been completed.
*/
ARRIVED: 'ARRIVED',
/**
* Assigned and actively routing.
*/
ENROUTE: 'ENROUTE',
/**
* Created, but not actively routing.
*/
NEW: 'NEW',
/**
* Unknown.
*/
UNSPECIFIED: 'UNSPECIFIED',
};
/**
* Delivery Fleet Location Provider.
*
* Access by calling `const {FleetEngineDeliveryFleetLocationProvider} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderOptions}
* options Options to pass to the location provider.
* @extends {google.maps.journeySharing.PollingLocationProvider}
* @constructor
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProvider = function(
options) {};
/**
* The filter applied when fetching the delivery vehicles.
* @type {string|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProvider.prototype
.deliveryVehicleFilter;
/**
* The bounds within which to track delivery vehicles. If no bounds are set, no
* delivery vehicles will be tracked. To track all delivery vehicles regardless
* of location, set bounds equivalent to the entire earth.
* @type {google.maps.LatLngBounds|google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProvider.prototype
.locationRestriction;
/**
* This Field is read-only. Threshold for stale vehicle location. If the last
* updated location for the vehicle is older than this threshold, the vehicle
* will not be displayed.
* @type {number}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProvider.prototype
.staleLocationThresholdMillis;
/**
* Options for delivery fleet location provider.
* @record
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderOptions =
function() {};
/**
* Provides JSON Web Tokens for authenticating the client to Fleet Engine.
* @type {!google.maps.journeySharing.AuthTokenFetcher}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderOptions
.prototype.authTokenFetcher;
/**
* A filter query to apply when fetching delivery vehicles. This filter is
* passed directly to Fleet Engine. id: the
* ID of the task. extraDurationMillis: the extra time it takes
* to perform the task, in milliseconds.
See ListDeliveryVehiclesRequest.filter for
* supported formats.
Note that valid filters for attributes must have
* the "attributes" prefix. For example, attributes.x =
* "y" or attributes."x y" =
* "z".
* @type {?string}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderOptions
.prototype.deliveryVehicleFilter;
/**
* Customization applied to a delivery vehicle marker.
Use this field to
* specify custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.DeliveryVehicleMarkerCustomizationFunctionParams):
* void)|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderOptions
.prototype.deliveryVehicleMarkerCustomization;
/**
* The latitude/longitude bounds within which to track vehicles immediately
* after the location provider is instantiated. If not set, the location
* provider does not start tracking any vehicles; use {@link
* google.maps.journeySharing.FleetEngineDeliveryFleetLocationProvider.locationRestriction}
* to set the bounds and begin tracking. To track all delivery vehicles
* regardless of location, set bounds equivalent to the entire earth.
* @type {google.maps.LatLngBounds|google.maps.LatLngBoundsLiteral|null}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderOptions
.prototype.locationRestriction;
/**
* The consumer's project ID from Google Cloud Console.
* @type {string}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderOptions
.prototype.projectId;
/**
* Threshold for stale vehicle location. If the last updated location for the
* vehicle is older this threshold, the vehicle will not be displayed. Defaults
* to 24 hours in milliseconds. If the threshold is less than zero, or
* Infinity, the threshold will be ignored and the vehicle location will
* not be considered stale.
* @type {?number}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderOptions
.prototype.staleLocationThresholdMillis;
/**
* The event object passed to the event handler when the {@link
* google.maps.journeySharing.FleetEngineDeliveryFleetLocationProvider.update}
* event is triggered.
* @record
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderUpdateEvent =
function() {};
/**
* The list of delivery vehicles returned by the query. Unmodifiable.
* @type {?Array}
*/
google.maps.journeySharing.FleetEngineDeliveryFleetLocationProviderUpdateEvent
.prototype.deliveryVehicles;
/**
* Delivery Vehicle Location Provider.
*
* Access by calling `const {FleetEngineDeliveryVehicleLocationProvider} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions}
* options Options to pass to the location provider.
* @extends {google.maps.journeySharing.PollingLocationProvider}
* @constructor
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider =
function(options) {};
/**
* ID for the vehicle that this location provider observes. Set this field to
* track a vehicle.
* @type {string}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider.prototype
.deliveryVehicleId;
/**
* Optionally allow users to display the task's outcome location.
* @type {?boolean}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider.prototype
.shouldShowOutcomeLocations;
/**
* Optionally allow users to display fetched tasks.
* @type {?boolean}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider.prototype
.shouldShowTasks;
/**
* This Field is read-only. Threshold for stale vehicle location. If the last
* updated location for the vehicle is older than this threshold, the vehicle
* will not be displayed.
* @type {number}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider.prototype
.staleLocationThresholdMillis;
/**
* Returns the filter options to apply when fetching tasks.
* @type {!google.maps.journeySharing.FleetEngineTaskFilterOptions}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider.prototype
.taskFilterOptions;
/**
* Options for delivery vehicle location provider.
* @record
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions =
function() {};
/**
* Customization applied to the active polyline. An active polyline corresponds
* to a portion of the route the vehicle is currently traversing through.
* isNew
* parameter in the function parameters object is set to true.)
* Additionally, this function is invoked when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* marker have changed.
See {@link
* google.maps.journeySharing.DeliveryVehicleMarkerCustomizationFunctionParams}
* for a list of supplied parameters and their uses.
Use this field to specify custom styling (such as polyline color) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.DeliveryVehiclePolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.activePolylineCustomization;
/**
* Provides JSON Web Tokens for authenticating the client to Fleet Engine.
* @type {!google.maps.journeySharing.AuthTokenFetcher}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.authTokenFetcher;
/**
* The delivery vehicle ID to track immediately after the location provider is
* instantiated. If not specified, the location provider does not start tracking
* any vehicle; use {@link
* google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider.deliveryVehicleId}
* to set the ID and begin tracking.
* @type {?string}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.deliveryVehicleId;
/**
* Customization applied to the delivery vehicle marker. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the
* polyline's coordinates change, or when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* polyline have changed.
See {@link
* google.maps.journeySharing.DeliveryVehiclePolylineCustomizationFunctionParams}
* for a list of supplied parameters and their uses.
Use this field
* to specify custom styling (such as marker icon) and interactivity (such as
* click handling).
* @type {(function(!google.maps.journeySharing.DeliveryVehicleMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.deliveryVehicleMarkerCustomization;
/**
* Customization applied to a planned stop marker. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the location
* provider receives data from Fleet Engine, regardless of whether the data
* corresponding to this marker have changed.
See {@link
* google.maps.journeySharing.DeliveryVehicleMarkerCustomizationFunctionParams}
* for a list of supplied parameters and their uses.
Use this field to
* specify custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.PlannedStopMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.plannedStopMarkerCustomization;
/**
* Minimum time between fetching location updates in milliseconds. If it takes
* longer than isNew
* parameter in the function parameters object is set to true.)
* Additionally, this function is invoked when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* marker have changed.
See {@link
* google.maps.journeySharing.PlannedStopMarkerCustomizationFunctionParams} for
* a list of supplied parameters and their uses.pollingIntervalMillis to fetch a location update,
* the next location update is not started until the current one finishes.
*
Setting this value to 0 disables recurring location updates. A new
* location update is fetched if any of the parameters observed by the location
* provider changes.
The default polling interval is 5000 milliseconds,
* the minimum interval. If you set the polling interval to a lower non-zero
* value, 5000 is used.
* @type {?number}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.pollingIntervalMillis;
/**
* The consumer's project ID from Google Cloud Console.
* @type {string}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.projectId;
/**
* Customization applied to the remaining polyline. A remaining polyline
* corresponds to a portion of the route the vehicle has not yet started
* traversing through.
Use this field to specify custom styling (such as
* polyline color) and interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.DeliveryVehiclePolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.remainingPolylineCustomization;
/**
* Boolean to show or hide outcome locations for the fetched tasks.
* @type {?boolean}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.shouldShowOutcomeLocations;
/**
* Boolean to show or hide tasks. Setting this to false will prevent the
* ListTasks endpoint from being called to fetch the tasks. Only the upcoming
* vehicle stops will be displayed.
* @type {?boolean}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.shouldShowTasks;
/**
* Threshold for stale vehicle location. If the last updated location for the
* vehicle is older this threshold, the vehicle will not be displayed. Defaults
* to 24 hours in milliseconds. If the threshold is less than 0, or
* Infinity, the threshold will be ignored and the vehicle location will
* not be considered stale.
* @type {?number}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.staleLocationThresholdMillis;
/**
* Customization applied to the taken polyline. A taken polyline corresponds to
* a portion of the route the vehicle has already traversed through. isNew parameter in the function parameters
* object is set to true.) Additionally, this function is invoked
* when the polyline's coordinates change, or when the location provider
* receives data from Fleet Engine, regardless of whether the data corresponding
* to this polyline have changed.
See {@link
* google.maps.journeySharing.DeliveryVehiclePolylineCustomizationFunctionParams}
* for a list of supplied parameters and their uses.
Use
* this field to specify custom styling (such as polyline color) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.DeliveryVehiclePolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.takenPolylineCustomization;
/**
* Filter options to apply when fetching tasks. The options can include specific
* vehicle, time, and task status.
* @type {?google.maps.journeySharing.FleetEngineTaskFilterOptions}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.taskFilterOptions;
/**
* Customization applied to a task marker. A task marker is rendered at the
* planned location of each task assigned to the delivery vehicle. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the
* polyline's coordinates change, or when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* polyline have changed.
See {@link
* google.maps.journeySharing.DeliveryVehiclePolylineCustomizationFunctionParams}
* for a list of supplied parameters and their uses.
Use
* this field to specify custom styling (such as marker icon) and interactivity
* (such as click handling).
* @type {(function(!google.maps.journeySharing.TaskMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.taskMarkerCustomization;
/**
* Customization applied to a task outcome marker. A task outcome marker is
* rendered at the actual outcome location of each task assigned to the delivery
* vehicle. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the location
* provider receives data from Fleet Engine, regardless of whether the data
* corresponding to this marker have changed.
See {@link
* google.maps.journeySharing.TaskMarkerCustomizationFunctionParams} for a list
* of supplied parameters and their uses.
Use this field to specify custom styling (such as marker
* icon) and interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.TaskMarkerCustomizationFunctionParams):
* void)|null|undefined}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions
.prototype.taskOutcomeMarkerCustomization;
/**
* The event object passed to the event handler when the {@link
* google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProvider.update}
* event is triggered.
* @record
*/
google.maps.journeySharing
.FleetEngineDeliveryVehicleLocationProviderUpdateEvent = function() {};
/**
* The journey segments that have been completed by this vehicle. Unmodifiable.
* @type {?Array}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderUpdateEvent
.prototype.completedVehicleJourneySegments;
/**
* The delivery vehicle data structure returned by the update. Unmodifiable.
* @type {?google.maps.journeySharing.DeliveryVehicle}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderUpdateEvent
.prototype.deliveryVehicle;
/**
* The list of tasks served by this delivery vehicle. Unmodifiable.
* @type {?Array}
*/
google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderUpdateEvent
.prototype.tasks;
/**
* Fleet Location Provider.
*
* Access by calling `const {FleetEngineFleetLocationProvider} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.journeySharing.FleetEngineFleetLocationProviderOptions}
* options Options to pass to the location provider.
* @extends {google.maps.journeySharing.PollingLocationProvider}
* @constructor
*/
google.maps.journeySharing.FleetEngineFleetLocationProvider = function(
options) {};
/**
* The bounds within which to track vehicles. If no bounds are set, no vehicles
* will be tracked. To track all vehicles regardless of location, set bounds
* equivalent to the entire earth.
* @type {google.maps.LatLngBounds|google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.journeySharing.FleetEngineFleetLocationProvider.prototype
.locationRestriction;
/**
* This Field is read-only. Threshold for stale vehicle location. If the last
* updated location for the vehicle is older than this threshold, the vehicle
* will not be displayed.
* @type {number}
*/
google.maps.journeySharing.FleetEngineFleetLocationProvider.prototype
.staleLocationThresholdMillis;
/**
* The filter applied when fetching the vehicles.
* @type {string|null|undefined}
*/
google.maps.journeySharing.FleetEngineFleetLocationProvider.prototype
.vehicleFilter;
/**
* Options for fleet location provider.
* @record
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderOptions =
function() {};
/**
* Provides JSON Web Tokens for authenticating the client to Fleet Engine.
* @type {!google.maps.journeySharing.AuthTokenFetcher}
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderOptions.prototype
.authTokenFetcher;
/**
* The latitude/longitude bounds within which to track vehicles immediately
* after the location provider is instantiated. If not set, the location
* provider does not start tracking any vehicles; use {@link
* google.maps.journeySharing.FleetEngineFleetLocationProvider.locationRestriction}
* to set the bounds and begin tracking. To track all vehicles regardless of
* location, set bounds equivalent to the entire earth.
* @type {google.maps.LatLngBounds|google.maps.LatLngBoundsLiteral|null}
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderOptions.prototype
.locationRestriction;
/**
* The consumer's project ID from Google Cloud Console.
* @type {string}
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderOptions.prototype
.projectId;
/**
* Threshold for stale vehicle location. If the last updated location for the
* vehicle is older than this threshold, the vehicle will not be displayed.
* Defaults to 24 hours in milliseconds. If the threshold is less than zero, or
* Infinity, the threshold will be ignored and the vehicle location will
* not be considered stale.
* @type {?number}
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderOptions.prototype
.staleLocationThresholdMillis;
/**
* A filter query to apply when fetching vehicles. This filter is passed
* directly to Fleet Engine. isNew parameter in the function
* parameters object is set to true.) Additionally, this function
* is invoked when the location provider receives data from Fleet Engine,
* regardless of whether the data corresponding to this marker have
* changed.
See {@link
* google.maps.journeySharing.TaskMarkerCustomizationFunctionParams} for a list
* of supplied parameters and their uses.
See ListVehiclesRequest.filter
* for supported formats.
Note that valid filters for attributes must
* have the "attributes" prefix. For example, attributes.x =
* "y" or attributes."x y" =
* "z".
* @type {?string}
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderOptions.prototype
.vehicleFilter;
/**
* Customization applied to a vehicle marker.
Use this field to specify
* custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.VehicleMarkerCustomizationFunctionParams):
* void)|null|undefined}
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderOptions.prototype
.vehicleMarkerCustomization;
/**
* The event object passed to the event handler when the {@link
* google.maps.journeySharing.FleetEngineFleetLocationProvider.update} event is
* triggered.
* @record
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderUpdateEvent =
function() {};
/**
* The list of vehicles returned by the query. Unmodifiable.
* @type {?Array}
*/
google.maps.journeySharing.FleetEngineFleetLocationProviderUpdateEvent.prototype
.vehicles;
/**
* Types of Fleet Engine services.
*
* Access by calling `const {FleetEngineServiceType} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.journeySharing.FleetEngineServiceType = {
/**
* Fleet Engine service used to access delivery vehicles.
*/
DELIVERY_VEHICLE_SERVICE: 'DELIVERY_VEHICLE_SERVICE',
/**
* Fleet Engine service used to access task information.
*/
TASK_SERVICE: 'TASK_SERVICE',
/**
* Fleet Engine service used to access trip information.
*/
TRIP_SERVICE: 'TRIP_SERVICE',
/**
* Unknown Fleet Engine service.
*/
UNKNOWN_SERVICE: 'UNKNOWN_SERVICE',
};
/**
* Shipment location provider.
*
* Access by calling `const {FleetEngineShipmentLocationProvider} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions}
* options Options for the location provider.
* @extends {google.maps.journeySharing.PollingLocationProvider}
* @constructor
*/
google.maps.journeySharing.FleetEngineShipmentLocationProvider = function(
options) {};
/**
* The tracking ID for the task that this location provider observes. Set this
* field to begin tracking.
* @type {string}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProvider.prototype
.trackingId;
/**
* Explicitly refreshes the tracked location.
* @return {void}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProvider.prototype
.refresh = function() {};
/**
* Options for shipment location provider.
* @record
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions =
function() {};
/**
* Customization applied to the active polyline. An active polyline corresponds
* to a portion of the route the vehicle is currently traversing through.
* isNew
* parameter in the function parameters object is set to true.)
* Additionally, this function is invoked when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* marker have changed.
See {@link
* google.maps.journeySharing.VehicleMarkerCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use this field to specify custom styling (such as polyline color) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.ShipmentPolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.activePolylineCustomization;
/**
* Provides JSON Web Tokens for authenticating the client to Fleet Engine.
* @type {!google.maps.journeySharing.AuthTokenFetcher}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.authTokenFetcher;
/**
* Customization applied to the delivery vehicle marker. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the
* polyline's coordinates change, or when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* polyline have changed.
See {@link
* google.maps.journeySharing.ShipmentPolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use this field
* to specify custom styling (such as marker icon) and interactivity (such as
* click handling).
* @type {(function(!google.maps.journeySharing.ShipmentMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.deliveryVehicleMarkerCustomization;
/**
* Customization applied to the destination marker. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the location
* provider receives data from Fleet Engine, regardless of whether the data
* corresponding to this marker have changed.
See {@link
* google.maps.journeySharing.ShipmentMarkerCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use this field to
* specify custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.ShipmentMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.destinationMarkerCustomization;
/**
* Minimum time between fetching location updates in milliseconds. If it takes
* longer than isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the location
* provider receives data from Fleet Engine, regardless of whether the data
* corresponding to this marker have changed.
See {@link
* google.maps.journeySharing.ShipmentMarkerCustomizationFunctionParams} for a
* list of supplied parameters and their uses.pollingIntervalMillis to fetch a location update,
* the next location update is not started until the current one finishes.
*
Setting this value to 0, Infinity, or a negative value disables
* automatic location updates. A new location update is fetched once if the
* tracking ID parameter (for example, the shipment tracking ID of the shipment
* location provider), or a filtering option (for example, viewport bounds or
* attribute filters for fleet location providers) changes.
The default,
* and minimum, polling interval is 5000 milliseconds. If you set the polling
* interval to a lower positive value, 5000 is stored and used.
* @type {?number}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.pollingIntervalMillis;
/**
* The consumer's project ID from Google Cloud Console.
* @type {string}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.projectId;
/**
* Customization applied to the remaining polyline. A remaining polyline
* corresponds to a portion of the route the vehicle has not yet started
* traversing through.
Use this field to specify custom styling (such as
* polyline color) and interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.ShipmentPolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.remainingPolylineCustomization;
/**
* Customization applied to the taken polyline. A taken polyline corresponds to
* a portion of the route the vehicle has already traversed through. isNew parameter in the function parameters
* object is set to true.) Additionally, this function is invoked
* when the polyline's coordinates change, or when the location provider
* receives data from Fleet Engine, regardless of whether the data corresponding
* to this polyline have changed.
See {@link
* google.maps.journeySharing.ShipmentPolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use
* this field to specify custom styling (such as polyline color) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.ShipmentPolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.takenPolylineCustomization;
/**
* The tracking ID of the task to track immediately after the location provider
* is instantiated. If not specified, the location provider does not start
* tracking any task; use {@link
* google.maps.journeySharing.FleetEngineShipmentLocationProvider.trackingId} to
* set the tracking ID and begin tracking.
* @type {?string}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.prototype
.trackingId;
/**
* The event object passed to the event handler when the {@link
* google.maps.journeySharing.FleetEngineShipmentLocationProvider.update} event
* is triggered.
* @record
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderUpdateEvent =
function() {};
/**
* The task tracking info structure returned by the update. Unmodifiable.
* @type {?google.maps.journeySharing.TaskTrackingInfo}
*/
google.maps.journeySharing.FleetEngineShipmentLocationProviderUpdateEvent
.prototype.taskTrackingInfo;
/**
* Filtering options for tasks in the Delivery Vehicle Location Provider.
* @record
*/
google.maps.journeySharing.FleetEngineTaskFilterOptions = function() {};
/**
* Exclusive lower bound for the completion time of the task. Used to filter for
* tasks that were completed after the specified time.
* @type {?Date}
*/
google.maps.journeySharing.FleetEngineTaskFilterOptions.prototype
.completionTimeFrom;
/**
* Exclusive upper bound for the completion time of the task. Used to filter for
* tasks that were completed before the specified time.
* @type {?Date}
*/
google.maps.journeySharing.FleetEngineTaskFilterOptions.prototype
.completionTimeTo;
/**
* The state of the task. Valid values are OPEN or CLOSED.
* @type {?string}
*/
google.maps.journeySharing.FleetEngineTaskFilterOptions.prototype.state;
/**
* Trip location provider.
*
* Access by calling `const {FleetEngineTripLocationProvider} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.journeySharing.FleetEngineTripLocationProviderOptions}
* options Options for the location provider.
* @extends {google.maps.journeySharing.PollingLocationProvider}
* @constructor
*/
google.maps.journeySharing.FleetEngineTripLocationProvider = function(
options) {};
/**
* The ID for the trip that this location provider observes. Set this field to
* begin tracking.
* @type {string}
*/
google.maps.journeySharing.FleetEngineTripLocationProvider.prototype.tripId;
/**
* Polyline customization function that colors the active polyline according to
* its speed reading. Specify this function as the {@link
* google.maps.journeySharing.FleetEngineTripLocationProviderOptions.activePolylineCustomization}
* to render a traffic-aware polyline for the active polyline.
* @param {!google.maps.journeySharing.TripPolylineCustomizationFunctionParams}
* params The parameters provided to the polyline customization function.
* @return {undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProvider
.TRAFFIC_AWARE_ACTIVE_POLYLINE_CUSTOMIZATION_FUNCTION = function(params) {};
/**
* Polyline customization function that colors the remaining polyline according
* to its speed reading. Specify this function as the {@link
* google.maps.journeySharing.FleetEngineTripLocationProviderOptions.remainingPolylineCustomization}
* to render a traffic-aware polyline for the remaining polyline.
* @param {!google.maps.journeySharing.TripPolylineCustomizationFunctionParams}
* params The parameters provided to the polyline customization function.
* @return {undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProvider
.TRAFFIC_AWARE_REMAINING_POLYLINE_CUSTOMIZATION_FUNCTION = function(
params) {};
/**
* Explicitly refreshes the tracked location.
* @return {void}
*/
google.maps.journeySharing.FleetEngineTripLocationProvider.prototype.refresh =
function() {};
/**
* Options for trip location provider.
* @record
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions =
function() {};
/**
* Customization applied to the active polyline. An active polyline corresponds
* to a portion of the route the vehicle is currently traversing through.
* isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the
* polyline's coordinates change, or when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* polyline have changed.
See {@link
* google.maps.journeySharing.ShipmentPolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use this field to specify custom styling (such as polyline color) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.TripPolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.activePolylineCustomization;
/**
* Provides JSON Web Tokens for authenticating the client to Fleet Engine.
* @type {!google.maps.journeySharing.AuthTokenFetcher}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.authTokenFetcher;
/**
* Customization applied to the destination marker. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the
* polyline's coordinates change, or when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* polyline have changed.
See {@link
* google.maps.journeySharing.TripPolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use this field to
* specify custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.TripMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.destinationMarkerCustomization;
/**
* Customization applied to the origin marker. isNew
* parameter in the function parameters object is set to true.)
* Additionally, this function is invoked when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* marker have changed.
See {@link
* google.maps.journeySharing.TripMarkerCustomizationFunctionParams} for a list
* of supplied parameters and their uses.
Use this field to specify
* custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.TripMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.originMarkerCustomization;
/**
* Minimum time between fetching location updates in milliseconds. If it takes
* longer than isNew
* parameter in the function parameters object is set to true.)
* Additionally, this function is invoked when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* marker have changed.
See {@link
* google.maps.journeySharing.TripMarkerCustomizationFunctionParams} for a list
* of supplied parameters and their uses.pollingIntervalMillis to fetch a location update,
* the next location update is not started until the current one finishes.
*
Setting this value to 0 disables recurring location updates. A new
* location update is fetched if any of the parameters observed by the location
* provider changes.
The default polling interval is 5000 milliseconds,
* the minimum interval. If you set the polling interval to a lower non-zero
* value, 5000 is used.
* @type {?number}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.pollingIntervalMillis;
/**
* The consumer's project ID from Google Cloud Console.
* @type {string}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.projectId;
/**
* Customization applied to the remaining polyline. A remaining polyline
* corresponds to a portion of the route the vehicle has not yet started
* traversing through.
Use this field to specify custom styling (such as
* polyline color) and interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.TripPolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.remainingPolylineCustomization;
/**
* Customization applied to the taken polyline. A taken polyline corresponds to
* a portion of the route the vehicle has already traversed through. isNew parameter in the function parameters
* object is set to true.) Additionally, this function is invoked
* when the polyline's coordinates change, or when the location provider
* receives data from Fleet Engine, regardless of whether the data corresponding
* to this polyline have changed.
See {@link
* google.maps.journeySharing.TripPolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use
* this field to specify custom styling (such as polyline color) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.TripPolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.takenPolylineCustomization;
/**
* The trip ID to track immediately after the location provider is instantiated.
* If not specified, the location provider does not start tracking any trip;
* use {@link google.maps.journeySharing.FleetEngineTripLocationProvider.tripId}
* to set the ID and begin tracking.
* @type {?string}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.tripId;
/**
* Customization applied to the vehicle marker. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the
* polyline's coordinates change, or when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* polyline have changed.
See {@link
* google.maps.journeySharing.TripPolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use this field to
* specify custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.TripMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.vehicleMarkerCustomization;
/**
* Customization applied to a waypoint marker. isNew
* parameter in the function parameters object is set to true.)
* Additionally, this function is invoked when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* marker have changed.
See {@link
* google.maps.journeySharing.TripMarkerCustomizationFunctionParams} for a list
* of supplied parameters and their uses.
Use this field to specify
* custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.TripWaypointMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderOptions.prototype
.waypointMarkerCustomization;
/**
* The event object passed to the event handler when the {@link
* google.maps.journeySharing.FleetEngineTripLocationProvider.update} event is
* triggered.
* @record
*/
google.maps.journeySharing.FleetEngineTripLocationProviderUpdateEvent =
function() {};
/**
* The trip structure returned by the update. Unmodifiable.
* @type {?google.maps.journeySharing.Trip}
*/
google.maps.journeySharing.FleetEngineTripLocationProviderUpdateEvent.prototype
.trip;
/**
* Vehicle Location Provider.
*
* Access by calling `const {FleetEngineVehicleLocationProvider} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions}
* options Options to pass to the location provider.
* @extends {google.maps.journeySharing.PollingLocationProvider}
* @constructor
*/
google.maps.journeySharing.FleetEngineVehicleLocationProvider = function(
options) {};
/**
* This Field is read-only. Threshold for stale vehicle location. If the last
* updated location for the vehicle is older than this threshold, the vehicle
* will not be displayed.
* @type {number}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProvider.prototype
.staleLocationThresholdMillis;
/**
* ID for the vehicle that this location provider observes. Set this field to
* track a vehicle.
* @type {string}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProvider.prototype
.vehicleId;
/**
* Polyline customization function that colors the active polyline according to
* its speed reading. Specify this function as the {@link
* google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.activePolylineCustomization}
* to render a traffic-aware polyline for the active polyline.
* @param {!google.maps.journeySharing.VehiclePolylineCustomizationFunctionParams}
* params The parameters provided to the polyline customization function.
* @return {undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProvider
.TRAFFIC_AWARE_ACTIVE_POLYLINE_CUSTOMIZATION_FUNCTION = function(params) {};
/**
* Polyline customization function that colors the remaining polyline according
* to its speed reading. Specify this function as the {@link
* google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.remainingPolylineCustomization}
* to render a traffic-aware polyline for the remaining polyline.
* @param {!google.maps.journeySharing.VehiclePolylineCustomizationFunctionParams}
* params The parameters provided to the polyline customization function.
* @return {undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProvider
.TRAFFIC_AWARE_REMAINING_POLYLINE_CUSTOMIZATION_FUNCTION = function(
params) {};
/**
* Options for vehicle location provider.
* @record
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions =
function() {};
/**
* Customization applied to the active polyline. An active polyline corresponds
* to a portion of the route the vehicle is currently traversing through.
* isNew
* parameter in the function parameters object is set to true.)
* Additionally, this function is invoked when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* marker have changed.
See {@link
* google.maps.journeySharing.TripWaypointMarkerCustomizationFunctionParams} for
* a list of supplied parameters and their uses.
Use this field to specify custom styling (such as polyline color) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.VehiclePolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.activePolylineCustomization;
/**
* Provides JSON Web Tokens for authenticating the client to Fleet Engine.
* @type {!google.maps.journeySharing.AuthTokenFetcher}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.authTokenFetcher;
/**
* Customization applied to the vehicle trip destination marker. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the
* polyline's coordinates change, or when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* polyline have changed.
See {@link
* google.maps.journeySharing.VehiclePolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use
* this field to specify custom styling (such as marker icon) and interactivity
* (such as click handling).
* @type {(function(!google.maps.journeySharing.VehicleWaypointMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.destinationMarkerCustomization;
/**
* Customization applied to the vehicle trip intermediate destination markers.
* isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the location
* provider receives data from Fleet Engine, regardless of whether the data
* corresponding to this marker have changed.
See {@link
* google.maps.journeySharing.VehicleWaypointMarkerCustomizationFunctionParams}
* for a list of supplied parameters and their uses.
Use this field to specify custom styling (such as marker icon) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.VehicleWaypointMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.intermediateDestinationMarkerCustomization;
/**
* Customization applied to the vehicle trip origin marker. isNew parameter in the function
* parameters object is set to true.) Additionally, this function
* is invoked when the location provider receives data from Fleet Engine,
* regardless of whether the data corresponding to this marker have
* changed.
See {@link
* google.maps.journeySharing.VehicleWaypointMarkerCustomizationFunctionParams}
* for a list of supplied parameters and their uses.
Use this
* field to specify custom styling (such as marker icon) and interactivity (such
* as click handling).
* @type {(function(!google.maps.journeySharing.VehicleWaypointMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.originMarkerCustomization;
/**
* Minimum time between fetching location updates in milliseconds. If it takes
* longer than isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the location
* provider receives data from Fleet Engine, regardless of whether the data
* corresponding to this marker have changed.
See {@link
* google.maps.journeySharing.VehicleWaypointMarkerCustomizationFunctionParams}
* for a list of supplied parameters and their uses.pollingIntervalMillis to fetch a location update,
* the next location update is not started until the current one finishes.
*
Setting this value to 0 disables recurring location updates. A new
* location update is fetched if any of the parameters observed by the location
* provider changes.
The default polling interval is 5000 milliseconds,
* the minimum interval. If you set the polling interval to a lower non-zero
* value, 5000 is used.
* @type {?number}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.pollingIntervalMillis;
/**
* The consumer's project ID from Google Cloud Console.
* @type {string}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.projectId;
/**
* Customization applied to the remaining polyline. A remaining polyline
* corresponds to a portion of the route the vehicle has not yet started
* traversing through.
Use this field to specify custom styling (such as
* polyline color) and interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.VehiclePolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.remainingPolylineCustomization;
/**
* Threshold for stale vehicle location. If the last updated location for the
* vehicle is older this threshold, the vehicle will not be displayed. Defaults
* to 24 hours in milliseconds. If the threshold is less than 0, or
* Infinity, the threshold will be ignored and the vehicle location will
* not be considered stale.
* @type {?number}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.staleLocationThresholdMillis;
/**
* Customization applied to the taken polyline. A taken polyline corresponds to
* a portion of the route the vehicle has already traversed through. isNew parameter in the function parameters
* object is set to true.) Additionally, this function is invoked
* when the polyline's coordinates change, or when the location provider
* receives data from Fleet Engine, regardless of whether the data corresponding
* to this polyline have changed.
See {@link
* google.maps.journeySharing.VehiclePolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use
* this field to specify custom styling (such as polyline color) and
* interactivity (such as click handling).
* @type {(function(!google.maps.journeySharing.VehiclePolylineCustomizationFunctionParams):
* void)|google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.takenPolylineCustomization;
/**
* The vehicle ID to track immediately after the location provider is
* instantiated. If not specified, the location provider does not start tracking
* any vehicle; use {@link
* google.maps.journeySharing.FleetEngineVehicleLocationProvider.vehicleId} to
* set the ID and begin tracking.
* @type {?string}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.vehicleId;
/**
* Customization applied to the vehicle marker. isNew parameter in the function parameters object is set to
* true.) Additionally, this function is invoked when the
* polyline's coordinates change, or when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* polyline have changed.
See {@link
* google.maps.journeySharing.VehiclePolylineCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
Use this field to
* specify custom styling (such as marker icon) and interactivity (such as click
* handling).
* @type {(function(!google.maps.journeySharing.VehicleMarkerCustomizationFunctionParams):
* void)|google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderOptions.prototype
.vehicleMarkerCustomization;
/**
* The event object passed to the event handler when the {@link
* google.maps.journeySharing.FleetEngineVehicleLocationProvider.update} event
* is triggered.
* @record
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderUpdateEvent =
function() {};
/**
* The list of trips completed by this vehicle. Unmodifiable.
* @type {?Array}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderUpdateEvent
.prototype.trips;
/**
* The vehicle data structure returned by the update. Unmodifiable.
* @type {?google.maps.journeySharing.Vehicle}
*/
google.maps.journeySharing.FleetEngineVehicleLocationProviderUpdateEvent
.prototype.vehicle;
/**
* The map view.
*
* Access by calling `const {JourneySharingMapView} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.journeySharing.JourneySharingMapViewOptions} options
* Options for the map view.
* @constructor
*/
google.maps.journeySharing.JourneySharingMapView = function(options) {};
/**
* This Field is read-only. Automatic viewport mode.
* @type {!google.maps.journeySharing.AutomaticViewportMode}
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.automaticViewportMode;
/**
* This Field is read-only. The DOM element backing the view.
* @type {!Element}
*/
google.maps.journeySharing.JourneySharingMapView.prototype.element;
/**
* Enables or disables the traffic layer.
* @type {boolean}
*/
google.maps.journeySharing.JourneySharingMapView.prototype.enableTraffic;
/**
* This field is read-only. Sources of tracked locations to be shown in the
* tracking map view. To add or remove location providers, use the {@link
* google.maps.journeySharing.JourneySharingMapView.addLocationProvider}
* and {@link
* google.maps.journeySharing.JourneySharingMapView.removeLocationProvider}
* methods.
* @type {?Array}
*/
google.maps.journeySharing.JourneySharingMapView.prototype.locationProviders;
/**
* This Field is read-only. The map object contained in the map view.
* @type {!google.maps.Map}
*/
google.maps.journeySharing.JourneySharingMapView.prototype.map;
/**
* This Field is read-only. The map options passed into the map via the map
* view.
* @type {!google.maps.MapOptions}
*/
google.maps.journeySharing.JourneySharingMapView.prototype.mapOptions;
/**
* This Field is read-only. A source of tracked locations to be shown in the
* tracking map view.
* @type {?google.maps.journeySharing.LocationProvider}
* @deprecated Use {@link
* google.maps.journeySharing.JourneySharingMapView.locationProviders}
* instead.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.locationProvider;
/**
* Configures options for a destination location marker. Invoked whenever a new
* destination marker is rendered. isNew
* parameter in the function parameters object is set to true.)
* Additionally, this function is invoked when the location provider receives
* data from Fleet Engine, regardless of whether the data corresponding to this
* marker have changed.
See {@link
* google.maps.journeySharing.VehicleMarkerCustomizationFunctionParams} for a
* list of supplied parameters and their uses.
If specifying a function, the
* function can and should modify the input's defaultMarkerOptions field
* containing a google.maps.MarkerOptions object, and return it as markerOptions
* in the output MarkerSetupOptions object.
Specifying a
* MarkerSetupOptions object has the same effect as specifying a function that
* returns that static object.
Do not reuse the same MarkerSetupOptions
* object in different MarkerSetup functions or static values, and do not reuse
* the same google.maps.MarkerOptions object for the markerOptions key in
* different MarkerSetupOptions objects. If markerOptions is unset or null, it
* will be overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {!google.maps.journeySharing.MarkerSetup}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.destinationMarkerSetup;
/**
* Configures options for an origin location marker. Invoked whenever a new
* origin marker is rendered.
If specifying a function, the function can
* and should modify the input's defaultMarkerOptions field containing a
* google.maps.MarkerOptions object, and return it as markerOptions in the
* output MarkerSetupOptions object.
Specifying a MarkerSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same MarkerSetupOptions object in different
* MarkerSetup functions or static values, and do not reuse the same
* google.maps.MarkerOptions object for the markerOptions key in different
* MarkerSetupOptions objects. If markerOptions is unset or null, it will be
* overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {!google.maps.journeySharing.MarkerSetup}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.originMarkerSetup;
/**
* Configures options for a task outcome location marker. Invoked whenever a new
* task outcome location marker is rendered.
If specifying a function,
* the function can and should modify the input's defaultMarkerOptions field
* containing a google.maps.MarkerOptions object, and return it as markerOptions
* in the output MarkerSetupOptions object.
Specifying a
* MarkerSetupOptions object has the same effect as specifying a function that
* returns that static object.
Do not reuse the same MarkerSetupOptions
* object in different MarkerSetup functions or static values, and do not reuse
* the same google.maps.MarkerOptions object for the markerOptions key in
* different MarkerSetupOptions objects. If markerOptions is unset or null, it
* will be overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {!google.maps.journeySharing.MarkerSetup}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.taskOutcomeMarkerSetup;
/**
* Configures options for an unsuccessful task location marker. Invoked whenever
* a new unsuccessful task marker is rendered.
If specifying a function,
* the function can and should modify the input's defaultMarkerOptions field
* containing a google.maps.MarkerOptions object, and return it as markerOptions
* in the output MarkerSetupOptions object.
Specifying a
* MarkerSetupOptions object has the same effect as specifying a function that
* returns that static object.
Do not reuse the same MarkerSetupOptions
* object in different MarkerSetup functions or static values, and do not reuse
* the same google.maps.MarkerOptions object for the markerOptions key in
* different MarkerSetupOptions objects. If markerOptions is unset or null, it
* will be overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {!google.maps.journeySharing.MarkerSetup}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.unsuccessfulTaskMarkerSetup;
/**
* Configures options for a vehicle location marker. Invoked whenever a new
* vehicle marker is rendered.
If specifying a function, the function
* can and should modify the input's defaultMarkerOptions field containing a
* google.maps.MarkerOptions object, and return it as markerOptions in the
* output MarkerSetupOptions object.
Specifying a MarkerSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same MarkerSetupOptions object in different
* MarkerSetup functions or static values, and do not reuse the same
* google.maps.MarkerOptions object for the markerOptions key in different
* MarkerSetupOptions objects. If markerOptions is unset or null, it will be
* overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {!google.maps.journeySharing.MarkerSetup}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.vehicleMarkerSetup;
/**
* Configures options for a waypoint location marker. Invoked whenever a new
* waypoint marker is rendered.
If specifying a function, the function
* can and should modify the input's defaultMarkerOptions field containing a
* google.maps.MarkerOptions object, and return it as markerOptions in the
* output MarkerSetupOptions object.
Specifying a MarkerSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same MarkerSetupOptions object in different
* MarkerSetup functions or static values, and do not reuse the same
* google.maps.MarkerOptions object for the markerOptions key in different
* MarkerSetupOptions objects. If markerOptions is unset or null, it will be
* overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {!google.maps.journeySharing.MarkerSetup}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.waypointMarkerSetup;
/**
* Configures options for an anticipated route polyline. Invoked whenever a new
* anticipated route polyline is rendered.
If specifying a function, the
* function can and should modify the input's defaultPolylineOptions field
* containing a google.maps.PolylineOptions object, and return it as
* polylineOptions in the output PolylineSetupOptions object.
Specifying
* a PolylineSetupOptions object has the same effect as specifying a function
* that returns that static object.
Do not reuse the same
* PolylineSetupOptions object in different PolylineSetup functions or static
* values, and do not reuse the same google.maps.PolylineOptions object for the
* polylineOptions key in different PolylineSetupOptions objects. If
* polylineOptions or visible is unset or null, it will be overwritten with the
* default. Any values set for polylineOptions.map or polylineOptions.path will
* be ignored.
* @type {!google.maps.journeySharing.PolylineSetup}
* @deprecated Polyline setup is deprecated. Use the
* PolylineCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.anticipatedRoutePolylineSetup;
/**
* Configures options for a taken route polyline. Invoked whenever a new taken
* route polyline is rendered.
If specifying a function, the function
* can and should modify the input's defaultPolylineOptions field containing
* a google.maps.PolylineOptions object, and return it as polylineOptions in the
* output PolylineSetupOptions object.
Specifying a PolylineSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same PolylineSetupOptions object in
* different PolylineSetup functions or static values, and do not reuse the same
* google.maps.PolylineOptions object for the polylineOptions key in different
* PolylineSetupOptions objects.
Any values set for polylineOptions.map
* or polylineOptions.path will be ignored. Any unset or null value will be
* overwritten with the default.
* @type {!google.maps.journeySharing.PolylineSetup}
* @deprecated Polyline setup is deprecated. Use the
* PolylineCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.takenRoutePolylineSetup;
/**
* Configures options for a ping location marker. Invoked whenever a new ping
* marker is rendered.
If specifying a function, the function can and
* should modify the input's defaultMarkerOptions field containing a
* google.maps.MarkerOptions object, and return it as markerOptions in the
* output MarkerSetupOptions object.
Specifying a MarkerSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same MarkerSetupOptions object in different
* MarkerSetup functions or static values, and do not reuse the same
* google.maps.MarkerOptions object for the markerOptions key in different
* MarkerSetupOptions objects. If markerOptions is unset or null, it will be
* overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {!google.maps.journeySharing.MarkerSetup}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.pingMarkerSetup;
/**
* Configures options for a successful task location marker. Invoked whenever a
* new successful task marker is rendered.
If specifying a function, the
* function can and should modify the input's defaultMarkerOptions field
* containing a google.maps.MarkerOptions object, and return it as markerOptions
* in the output MarkerSetupOptions object.
Specifying a
* MarkerSetupOptions object has the same effect as specifying a function that
* returns that static object.
Do not reuse the same MarkerSetupOptions
* object in different MarkerSetup functions or static values, and do not reuse
* the same google.maps.MarkerOptions object for the markerOptions key in
* different MarkerSetupOptions objects. If markerOptions is unset or null, it
* will be overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {!google.maps.journeySharing.MarkerSetup}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.successfulTaskMarkerSetup;
/**
* Returns the destination markers, if any.
* @type {!Array}
* @deprecated getting a list of markers via the MapView is
* deprecated. Use the MarkerCustomizationFunctions for your
* location provider to receive callbacks when a marker is added to the map
* or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.destinationMarkers;
/**
* Returns the origin markers, if any.
* @type {!Array}
* @deprecated getting a list of markers via the MapView is
* deprecated. Use the MarkerCustomizationFunctions for your
* location provider to receive callbacks when a marker is added to the map
* or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.originMarkers;
/**
* Returns the successful task markers, if any.
* @type {!Array}
* @deprecated getting a list of markers via the MapView is
* deprecated. Use the MarkerCustomizationFunctions for your
* location provider to receive callbacks when a marker is added to the map
* or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.successfulTaskMarkers;
/**
* Returns the task outcome markers, if any.
* @type {!Array}
* @deprecated getting a list of markers via the MapView is
* deprecated. Use the MarkerCustomizationFunctions for your
* location provider to receive callbacks when a marker is added to the map
* or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.taskOutcomeMarkers;
/**
* Returns the unsuccessful task markers, if any.
* @type {!Array}
* @deprecated getting a list of markers via the MapView is
* deprecated. Use the MarkerCustomizationFunctions for your
* location provider to receive callbacks when a marker is added to the map
* or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.unsuccessfulTaskMarkers;
/**
* Returns the vehicle markers, if any.
* @type {!Array}
* @deprecated getting a list of markers via the MapView is
* deprecated. Use the MarkerCustomizationFunctions for your
* location provider to receive callbacks when a marker is added to the map
* or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.vehicleMarkers;
/**
* Returns the waypoint markers, if any.
* @type {!Array}
* @deprecated getting a list of markers via the MapView is
* deprecated. Use the MarkerCustomizationFunctions for your
* location provider to receive callbacks when a marker is added to the map
* or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.waypointMarkers;
/**
* Returns the anticipated route polylines, if any.
* @type {!Array}
* @deprecated getting a list of polylines via the MapView is
* deprecated. Use the PolylineCustomizationFunctions for your
* location provider to receive callbacks when a polyline is added to the
* map or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.anticipatedRoutePolylines;
/**
* Returns the taken route polylines, if any.
* @type {!Array}
* @deprecated getting a list of polylines via the MapView is
* deprecated. Use the PolylineCustomizationFunctions for your
* location provider to receive callbacks when a polyline is added to the
* map or updated.
*/
google.maps.journeySharing.JourneySharingMapView.prototype.takenRoutePolylines;
/**
* Adds a location provider to the map view. If the location provider is already
* added, no action is performed.
* @param {!google.maps.journeySharing.LocationProvider} locationProvider the
* location provider to add.
* @return {undefined}
*/
google.maps.journeySharing.JourneySharingMapView.prototype.addLocationProvider =
function(locationProvider) {};
/**
* Removes a location provider from the map view. If the location provider is
* not already added to the map view, no action is performed.
* @param {!google.maps.journeySharing.LocationProvider} locationProvider the
* location provider to remove.
* @return {undefined}
*/
google.maps.journeySharing.JourneySharingMapView.prototype
.removeLocationProvider = function(locationProvider) {};
/**
* Options for the map view.
* @record
*/
google.maps.journeySharing.JourneySharingMapViewOptions = function() {};
/**
* Automatic viewport mode. Default value is FIT_ANTICIPATED_ROUTE, which
* enables the map view to automatically adjust the viewport to fit vehicle
* markers, location markers, and any visible anticipated route polylines. Set
* this to NONE to turn off automatic fitting.
* @type {google.maps.journeySharing.AutomaticViewportMode|null|undefined}
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.automaticViewportMode;
/**
* The DOM element backing the view. Required.
* @type {!Element}
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype.element;
/**
* Sources of tracked locations to be shown in the tracking map view. Optional.
* @type {?Array}
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.locationProviders;
/**
* Map options passed into the google.maps.Map constructor.
* @type {google.maps.MapOptions|null|undefined}
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype.mapOptions;
/**
* A source of tracked locations to be shown in the tracking map view. Optional.
* @type {?google.maps.journeySharing.LocationProvider}
* @deprecated Use {@link
* google.maps.journeySharing.JourneySharingMapViewOptions.locationProviders}
* instead.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.locationProvider;
/**
* Configures options for a destination location marker. Invoked whenever a new
* destination marker is rendered.
If specifying a function, the
* function can and should modify the input's defaultMarkerOptions field
* containing a google.maps.MarkerOptions object, and return it as markerOptions
* in the output MarkerSetupOptions object.
Specifying a
* MarkerSetupOptions object has the same effect as specifying a function that
* returns that static object.
Do not reuse the same MarkerSetupOptions
* object in different MarkerSetup functions or static values, and do not reuse
* the same google.maps.MarkerOptions object for the markerOptions key in
* different MarkerSetupOptions objects. If markerOptions is unset or null, it
* will be overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {google.maps.journeySharing.MarkerSetup|null|undefined}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.destinationMarkerSetup;
/**
* Configures options for an origin location marker. Invoked whenever a new
* origin marker is rendered.
If specifying a function, the function can
* and should modify the input's defaultMarkerOptions field containing a
* google.maps.MarkerOptions object, and return it as markerOptions in the
* output MarkerSetupOptions object.
Specifying a MarkerSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same MarkerSetupOptions object in different
* MarkerSetup functions or static values, and do not reuse the same
* google.maps.MarkerOptions object for the markerOptions key in different
* MarkerSetupOptions objects. If markerOptions is unset or null, it will be
* overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {google.maps.journeySharing.MarkerSetup|null|undefined}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.originMarkerSetup;
/**
* Configures options for a task outcome location marker. Invoked whenever a new
* task outcome location marker is rendered.
If specifying a function,
* the function can and should modify the input's defaultMarkerOptions field
* containing a google.maps.MarkerOptions object, and return it as markerOptions
* in the output MarkerSetupOptions object.
Specifying a
* MarkerSetupOptions object has the same effect as specifying a function that
* returns that static object.
Do not reuse the same MarkerSetupOptions
* object in different MarkerSetup functions or static values, and do not reuse
* the same google.maps.MarkerOptions object for the markerOptions key in
* different MarkerSetupOptions objects. If markerOptions is unset or null, it
* will be overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {google.maps.journeySharing.MarkerSetup|null|undefined}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.taskOutcomeMarkerSetup;
/**
* Configures options for an unsuccessful task location marker. Invoked whenever
* a new unsuccessful task marker is rendered.
If specifying a function,
* the function can and should modify the input's defaultMarkerOptions field
* containing a google.maps.MarkerOptions object, and return it as markerOptions
* in the output MarkerSetupOptions object.
Specifying a
* MarkerSetupOptions object has the same effect as specifying a function that
* returns that static object.
Do not reuse the same MarkerSetupOptions
* object in different MarkerSetup functions or static values, and do not reuse
* the same google.maps.MarkerOptions object for the markerOptions key in
* different MarkerSetupOptions objects. If markerOptions is unset or null, it
* will be overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {google.maps.journeySharing.MarkerSetup|null|undefined}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.unsuccessfulTaskMarkerSetup;
/**
* Configures options for a vehicle location marker. Invoked whenever a new
* vehicle marker is rendered.
If specifying a function, the function
* can and should modify the input's defaultMarkerOptions field containing a
* google.maps.MarkerOptions object, and return it as markerOptions in the
* output MarkerSetupOptions object.
Specifying a MarkerSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same MarkerSetupOptions object in different
* MarkerSetup functions or static values, and do not reuse the same
* google.maps.MarkerOptions object for the markerOptions key in different
* MarkerSetupOptions objects. If markerOptions is unset or null, it will be
* overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {google.maps.journeySharing.MarkerSetup|null|undefined}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.vehicleMarkerSetup;
/**
* Configures options for a waypoint location marker. Invoked whenever a new
* waypoint marker is rendered.
If specifying a function, the function
* can and should modify the input's defaultMarkerOptions field containing a
* google.maps.MarkerOptions object, and return it as markerOptions in the
* output MarkerSetupOptions object.
Specifying a MarkerSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same MarkerSetupOptions object in different
* MarkerSetup functions or static values, and do not reuse the same
* google.maps.MarkerOptions object for the markerOptions key in different
* MarkerSetupOptions objects. If markerOptions is unset or null, it will be
* overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {google.maps.journeySharing.MarkerSetup|null|undefined}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.waypointMarkerSetup;
/**
* Configures options for an anticipated route polyline. Invoked whenever a new
* anticipated route polyline is rendered.
If specifying a function, the
* function can and should modify the input's defaultPolylineOptions field
* containing a google.maps.PolylineOptions object, and return it as
* polylineOptions in the output PolylineSetupOptions object.
Specifying
* a PolylineSetupOptions object has the same effect as specifying a function
* that returns that static object.
Do not reuse the same
* PolylineSetupOptions object in different PolylineSetup functions or static
* values, and do not reuse the same google.maps.PolylineOptions object for the
* polylineOptions key in different PolylineSetupOptions objects. If
* polylineOptions or visible is unset or null, it will be overwritten with the
* default. Any values set for polylineOptions.map or polylineOptions.path will
* be ignored.
* @type {google.maps.journeySharing.PolylineSetup|null|undefined}
* @deprecated Polyline setup is deprecated. Use the
* PolylineCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.anticipatedRoutePolylineSetup;
/**
* Configures options for a taken route polyline. Invoked whenever a new taken
* route polyline is rendered.
If specifying a function, the function
* can and should modify the input's defaultPolylineOptions field containing
* a google.maps.PolylineOptions object, and return it as polylineOptions in the
* output PolylineSetupOptions object.
Specifying a PolylineSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same PolylineSetupOptions object in
* different PolylineSetup functions or static values, and do not reuse the same
* google.maps.PolylineOptions object for the polylineOptions key in different
* PolylineSetupOptions objects.
Any values set for polylineOptions.map
* or polylineOptions.path will be ignored. Any unset or null value will be
* overwritten with the default.
* @type {google.maps.journeySharing.PolylineSetup|null|undefined}
* @deprecated Polyline setup is deprecated. Use the
* PolylineCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.takenRoutePolylineSetup;
/**
* Configures options for a ping location marker. Invoked whenever a new ping
* marker is rendered.
If specifying a function, the function can and
* should modify the input's defaultMarkerOptions field containing a
* google.maps.MarkerOptions object, and return it as markerOptions in the
* output MarkerSetupOptions object.
Specifying a MarkerSetupOptions
* object has the same effect as specifying a function that returns that static
* object.
Do not reuse the same MarkerSetupOptions object in different
* MarkerSetup functions or static values, and do not reuse the same
* google.maps.MarkerOptions object for the markerOptions key in different
* MarkerSetupOptions objects. If markerOptions is unset or null, it will be
* overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {google.maps.journeySharing.MarkerSetup|null|undefined}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.pingMarkerSetup;
/**
* Configures options for a successful task location marker. Invoked whenever a
* new successful task marker is rendered.
If specifying a function, the
* function can and should modify the input's defaultMarkerOptions field
* containing a google.maps.MarkerOptions object, and return it as markerOptions
* in the output MarkerSetupOptions object.
Specifying a
* MarkerSetupOptions object has the same effect as specifying a function that
* returns that static object.
Do not reuse the same MarkerSetupOptions
* object in different MarkerSetup functions or static values, and do not reuse
* the same google.maps.MarkerOptions object for the markerOptions key in
* different MarkerSetupOptions objects. If markerOptions is unset or null, it
* will be overwritten with the default. Any value set for markerOptions.map or
* markerOptions.position will be ignored.
* @type {google.maps.journeySharing.MarkerSetup|null|undefined}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead. This field will be removed in the future.
*/
google.maps.journeySharing.JourneySharingMapViewOptions.prototype
.successfulTaskMarkerSetup;
/**
* Parent class of all location providers.
* @abstract
* @constructor
*/
google.maps.journeySharing.LocationProvider = function() {};
/**
* Adds a {@link google.maps.MapsEventListener} for an event fired by this
* location provider. Returns an identifier for this listener that can be used
* with {@link google.maps.event.removeListener}.
* @param {string} eventName The name of the event to listen for.
* @param {!Function} handler The event handler.
* @return {!google.maps.MapsEventListener}
*/
google.maps.journeySharing.LocationProvider.prototype.addListener = function(
eventName, handler) {};
/**
* Parameters that are common to all marker customization functions. No object
* of this class is provided directly to any marker customization function; an
* object of one of its descendent classes is provided instead.
* @record
*/
google.maps.journeySharing.MarkerCustomizationFunctionParams = function() {};
/**
* The default options used to create this marker.
* @type {!google.maps.MarkerOptions}
*/
google.maps.journeySharing.MarkerCustomizationFunctionParams.prototype
.defaultOptions;
/**
* If true, the marker was newly created, and the marker customization function
* is being called for the first time, before the marker has been added to the
* map view. False otherwise.
* @type {boolean}
*/
google.maps.journeySharing.MarkerCustomizationFunctionParams.prototype.isNew;
/**
* The marker. Any customizations should be made to this object directly.
* @type {!google.maps.Marker}
*/
google.maps.journeySharing.MarkerCustomizationFunctionParams.prototype.marker;
/**
* @typedef {!google.maps.journeySharing.MarkerSetupOptions|(function(!google.maps.journeySharing.DefaultMarkerSetupOptions):
* !google.maps.journeySharing.MarkerSetupOptions)}
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead.
*/
google.maps.journeySharing.MarkerSetup;
/**
* MarkerSetup options.
* @record
* @deprecated Marker setup is deprecated. Use the
* MarkerCustomizationFunction methods for your location
* provider instead.
*/
google.maps.journeySharing.MarkerSetupOptions = function() {};
/**
* Marker options.
* @type {google.maps.MarkerOptions|null|undefined}
*/
google.maps.journeySharing.MarkerSetupOptions.prototype.markerOptions;
/**
* Parameters specific to marker customization functions that apply options to
* markers representing planned stops. Used by {@link
* google.maps.journeySharing.FleetEngineDeliveryVehicleLocationProviderOptions.plannedStopMarkerCustomization}.
* @extends {google.maps.journeySharing.DeliveryVehicleMarkerCustomizationFunctionParams}
* @record
*/
google.maps.journeySharing.PlannedStopMarkerCustomizationFunctionParams =
function() {};
/**
* The 0-based index of this stop in the list of remaining stops.
* @type {number}
*/
google.maps.journeySharing.PlannedStopMarkerCustomizationFunctionParams
.prototype.stopIndex;
/**
* Parent class of polling location providers.
* @extends {google.maps.journeySharing.LocationProvider}
* @abstract
* @constructor
*/
google.maps.journeySharing.PollingLocationProvider = function() {};
/**
* True if this location provider is polling. Read only.
* @type {boolean}
*/
google.maps.journeySharing.PollingLocationProvider.prototype.isPolling;
/**
* Minimum time between fetching location updates in milliseconds. If it takes
* longer than pollingIntervalMillis to fetch a location update,
* the next location update is not started until the current one finishes.
*
Setting this value to 0, Infinity, or a negative value disables
* automatic location updates. A new location update is fetched once if the
* tracking ID parameter (for example, the shipment tracking ID of the shipment
* location provider), or a filtering option (for example, viewport bounds or
* attribute filters for fleet location providers) changes.
The default,
* and minimum, polling interval is 5000 milliseconds. If you set the polling
* interval to a lower positive value, 5000 is stored and used.
* @type {number}
*/
google.maps.journeySharing.PollingLocationProvider.prototype
.pollingIntervalMillis;
/**
* The event object passed to the event handler when the {@link
* google.maps.journeySharing.PollingLocationProvider.ispollingchange} event is
* triggered.
* @record
*/
google.maps.journeySharing.PollingLocationProviderIsPollingChangeEvent =
function() {};
/**
* The error that caused the polling state to change, if the state change was
* caused by an error. Undefined if the state change was due to normal
* operations.
* @type {?Error}
*/
google.maps.journeySharing.PollingLocationProviderIsPollingChangeEvent.prototype
.error;
/**
* Parameters that are common to all polyline customization functions. No object
* of this class is provided directly to any polyline customization function; an
* object of one of its descendent classes is provided instead.
* @record
*/
google.maps.journeySharing.PolylineCustomizationFunctionParams = function() {};
/**
* The default options used to create this set of polylines.
* @type {!google.maps.PolylineOptions}
*/
google.maps.journeySharing.PolylineCustomizationFunctionParams.prototype
.defaultOptions;
/**
* If true, the list of polylines was newly created, and the polyline
* customization function is being called for the first time. False otherwise.
* @type {boolean}
*/
google.maps.journeySharing.PolylineCustomizationFunctionParams.prototype.isNew;
/**
* The list of polylines created. They are arranged sequentially to form the
* rendered route.
* @type {!Array}
*/
google.maps.journeySharing.PolylineCustomizationFunctionParams.prototype
.polylines;
/**
* @typedef {!google.maps.journeySharing.PolylineSetupOptions|(function(!google.maps.journeySharing.DefaultPolylineSetupOptions):
* !google.maps.journeySharing.PolylineSetupOptions)}
* @deprecated Polyline setup is deprecated. Use the
* PolylineCustomizationFunction methods for your location
* provider instead.
*/
google.maps.journeySharing.PolylineSetup;
/**
* PolylineSetup options.
* @record
* @deprecated Polyline setup is deprecated. Use the
* PolylineCustomizationFunction methods for your location
* provider instead.
*/
google.maps.journeySharing.PolylineSetupOptions = function() {};
/**
* Polyline options.
* @type {google.maps.PolylineOptions|null|undefined}
*/
google.maps.journeySharing.PolylineSetupOptions.prototype.polylineOptions;
/**
* Polyline visibility.
* @type {boolean|null|undefined}
*/
google.maps.journeySharing.PolylineSetupOptions.prototype.visible;
/**
* Parameters specific to marker customization functions that apply options to
* markers representing shipment delivery vehicle and destination locations.
* Used by {@link
* google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.deliveryVehicleMarkerCustomization}
* and {@link
* google.maps.journeySharing.FleetEngineShipmentLocationProviderOptions.destinationMarkerCustomization}.
* @extends {google.maps.journeySharing.MarkerCustomizationFunctionParams}
* @record
*/
google.maps.journeySharing.ShipmentMarkerCustomizationFunctionParams =
function() {};
/**
* Information for the task associated with this marker.
* @type {!google.maps.journeySharing.TaskTrackingInfo}
*/
google.maps.journeySharing.ShipmentMarkerCustomizationFunctionParams.prototype
.taskTrackingInfo;
/**
* Parameters specific to polyline customization functions for {@link
* google.maps.journeySharing.FleetEngineShipmentLocationProvider}.
* @extends {google.maps.journeySharing.PolylineCustomizationFunctionParams}
* @record
*/
google.maps.journeySharing.ShipmentPolylineCustomizationFunctionParams =
function() {};
/**
* Information for the task associated with this polyline.
* @type {!google.maps.journeySharing.TaskTrackingInfo}
*/
google.maps.journeySharing.ShipmentPolylineCustomizationFunctionParams.prototype
.taskTrackingInfo;
/**
* The classification of polyline speed based on traffic data.
*
* Access by calling `const {Speed} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.journeySharing.Speed = {
/**
* Normal speed, no slowdown is detected.
*/
NORMAL: 'NORMAL',
/**
* Slowdown detected, but no traffic jam formed.
*/
SLOW: 'SLOW',
/**
* Traffic jam detected.
*/
TRAFFIC_JAM: 'TRAFFIC_JAM',
};
/**
* Traffic density indicator on a contiguous path segment. The interval defines
* the starting and ending points of the segment via their indices.
* @record
*/
google.maps.journeySharing.SpeedReadingInterval = function() {};
/**
* The zero-based index of the ending point of the interval in the path.
* @type {number}
*/
google.maps.journeySharing.SpeedReadingInterval.prototype.endPolylinePointIndex;
/**
* Traffic speed in this interval.
* @type {!google.maps.journeySharing.Speed}
*/
google.maps.journeySharing.SpeedReadingInterval.prototype.speed;
/**
* The zero-based index of the starting point of the interval in the path.
* @type {number}
*/
google.maps.journeySharing.SpeedReadingInterval.prototype
.startPolylinePointIndex;
/**
* The details for a task returned by Fleet Engine.
* @record
*/
google.maps.journeySharing.Task = function() {};
/**
* Attributes assigned to the task.
* @type {!Objecttracking_id represents the tracking ID.
* @type {string}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.name;
/**
* The location where the Task will be completed.
* @type {?google.maps.LatLng}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.plannedLocation;
/**
* The total remaining distance in meters to the VehicleStop of
* interest.
* @type {?number}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype
.remainingDrivingDistanceMeters;
/**
* Indicates the number of stops the vehicle remaining until the task stop is
* reached, including the task stop. For example, if the vehicle's next stop
* is the task stop, the value will be 1.
* @type {?number}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.remainingStopCount;
/**
* A list of points which when connected forms a polyline of the vehicle's
* expected route to the location of this task.
* @type {?Array}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.routePolylinePoints;
/**
* The current execution state of the Task.
* @type {?string}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.state;
/**
* The time window during which the task should be completed.
* @type {?google.maps.journeySharing.TimeWindow}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.targetTimeWindow;
/**
* The outcome of attempting to execute a Task.
* @type {?string}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.taskOutcome;
/**
* The time when the Task's outcome was set by the provider.
* @type {?Date}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.taskOutcomeTime;
/**
* The tracking ID of a Task.
* @type {string}
*/
google.maps.journeySharing.TaskTrackingInfo.prototype.trackingId;
/**
* A time range.
* @record
*/
google.maps.journeySharing.TimeWindow = function() {};
/**
* The end time of the time window (inclusive).
* @type {!Date}
*/
google.maps.journeySharing.TimeWindow.prototype.endTime;
/**
* The start time of the time window (inclusive).
* @type {!Date}
*/
google.maps.journeySharing.TimeWindow.prototype.startTime;
/**
* The details for a trip returned by Fleet Engine.
* @record
*/
google.maps.journeySharing.Trip = function() {};
/**
* Location where the customer was dropped off.
* @type {?google.maps.LatLngLiteral}
*/
google.maps.journeySharing.Trip.prototype.actualDropOffLocation;
/**
* Location where the customer was picked up.
* @type {?google.maps.LatLngLiteral}
*/
google.maps.journeySharing.Trip.prototype.actualPickupLocation;
/**
* The estimated future time when the passengers will be dropped off, or the
* actual time when they were dropped off.
* @type {?Date}
*/
google.maps.journeySharing.Trip.prototype.dropOffTime;
/**
* Information specific to the last location update.
* @type {?google.maps.journeySharing.VehicleLocationUpdate}
*/
google.maps.journeySharing.Trip.prototype.latestVehicleLocationUpdate;
/**
* In the format "providers/{provider_id}/trips/{trip_id}". The
* trip_id must be a unique identifier.
* @type {string}
*/
google.maps.journeySharing.Trip.prototype.name;
/**
* Number of passengers on this trip; does not include the driver.
* @type {number}
*/
google.maps.journeySharing.Trip.prototype.passengerCount;
/**
* The estimated future time when the passengers will be picked up, or the
* actual time when they were picked up.
* @type {?Date}
*/
google.maps.journeySharing.Trip.prototype.pickupTime;
/**
* Location where the customer indicates they will be dropped off.
* @type {?google.maps.LatLngLiteral}
*/
google.maps.journeySharing.Trip.prototype.plannedDropOffLocation;
/**
* Location where customer indicates they will be picked up.
* @type {?google.maps.LatLngLiteral}
*/
google.maps.journeySharing.Trip.prototype.plannedPickupLocation;
/**
* An array of waypoints indicating the path from the current location to the
* drop-off point.
* @type {!Array}
*/
google.maps.journeySharing.Trip.prototype.remainingWaypoints;
/**
* Current status of the trip. Possible values are UNKNOWN_TRIP_STATUS, NEW,
* ENROUTE_TO_PICKUP, ARRIVED_AT_PICKUP, ARRIVED_AT_INTERMEDIATE_DESTINATION,
* ENROUTE_TO_INTERMEDIATE_DESTINATION, ENROUTE_TO_DROPOFF, COMPLETE, or
* CANCELED.
* @type {string}
*/
google.maps.journeySharing.Trip.prototype.status;
/**
* The type of the trip. Possible values are UNKNOWN_TRIP_TYPE, SHARED or
* EXCLUSIVE.
* @type {string}
*/
google.maps.journeySharing.Trip.prototype.type;
/**
* ID of the vehicle making this trip.
* @type {string}
*/
google.maps.journeySharing.Trip.prototype.vehicleId;
/**
* Parameters specific to marker customization functions that apply options to
* markers representing trip vehicle, origin and destination locations. Used
* by {@link
* google.maps.journeySharing.FleetEngineTripLocationProviderOptions.vehicleMarkerCustomization}, {@link
* google.maps.journeySharing.FleetEngineTripLocationProviderOptions.originMarkerCustomization},
* and {@link
* google.maps.journeySharing.FleetEngineTripLocationProviderOptions.destinationMarkerCustomization}.
* @extends {google.maps.journeySharing.MarkerCustomizationFunctionParams}
* @record
*/
google.maps.journeySharing.TripMarkerCustomizationFunctionParams =
function() {};
/**
* The trip associated with this marker.
For information about the
* vehicle servicing this trip, use {@link
* google.maps.journeySharing.Trip.latestVehicleLocationUpdate} and {@link
* google.maps.journeySharing.Trip.remainingWaypoints}.
* @type {!google.maps.journeySharing.Trip}
*/
google.maps.journeySharing.TripMarkerCustomizationFunctionParams.prototype.trip;
/**
* Parameters specific to polyline customization functions for {@link
* google.maps.journeySharing.FleetEngineTripLocationProvider}.
* @extends {google.maps.journeySharing.PolylineCustomizationFunctionParams}
* @record
*/
google.maps.journeySharing.TripPolylineCustomizationFunctionParams =
function() {};
/**
* The trip associated with this polyline.
* @type {!google.maps.journeySharing.Trip}
*/
google.maps.journeySharing.TripPolylineCustomizationFunctionParams.prototype
.trip;
/**
* Trip types supported by a {@link google.maps.journeySharing.Vehicle}.
*
* Access by calling `const {TripType} = await
* google.maps.importLibrary("journeySharing")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.journeySharing.TripType = {
/**
* The trip is exclusive to a vehicle.
*/
EXCLUSIVE: 'EXCLUSIVE',
/**
* The trip may share a vehicle with other trips.
*/
SHARED: 'SHARED',
/**
* Unknown trip type.
*/
UNKNOWN_TRIP_TYPE: 'UNKNOWN_TRIP_TYPE',
};
/**
* TripWaypoint type.
* @record
*/
google.maps.journeySharing.TripWaypoint = function() {};
/**
* The path distance between the previous waypoint (or the vehicle's current
* location, if this waypoint is the first in the list of waypoints) to this
* waypoint in meters.
* @type {?number}
*/
google.maps.journeySharing.TripWaypoint.prototype.distanceMeters;
/**
* Travel time between the previous waypoint (or the vehicle's current
* location, if this waypoint is the first in the list of waypoints) to this
* waypoint in milliseconds.
* @type {?number}
*/
google.maps.journeySharing.TripWaypoint.prototype.durationMillis;
/**
* The location of the waypoint.
* @type {?google.maps.LatLng}
*/
google.maps.journeySharing.TripWaypoint.prototype.location;
/**
* The path from the previous stop (or the vehicle's current location, if
* this stop is the first in the list of stops) to this stop.
* @type {?Array}
*/
google.maps.journeySharing.TripWaypoint.prototype.path;
/**
* The list of traffic speeds along the path from the previous waypoint (or
* vehicle location) to the current waypoint. Each interval in the list
* describes the traffic on a contiguous segment on the path; the interval
* defines the starting and ending points of the segment via their indices. See
* the definition of {@link google.maps.journeySharing.SpeedReadingInterval} for
* more details.
* @type {?Array}
*/
google.maps.journeySharing.TripWaypoint.prototype.speedReadingIntervals;
/**
* The trip associated with this waypoint.
* @type {?string}
*/
google.maps.journeySharing.TripWaypoint.prototype.tripId;
/**
* The role this waypoint plays in this trip, such as pickup or dropoff.
* @type {?google.maps.journeySharing.WaypointType}
*/
google.maps.journeySharing.TripWaypoint.prototype.waypointType;
/**
* Parameters specific to marker customization functions that apply options to
* markers representing trip waypoint locations. Used by {@link
* google.maps.journeySharing.FleetEngineTripLocationProviderOptions.waypointMarkerCustomization}.
* @extends {google.maps.journeySharing.TripMarkerCustomizationFunctionParams}
* @record
*/
google.maps.journeySharing.TripWaypointMarkerCustomizationFunctionParams =
function() {};
/**
* The 0-based waypoint index associated with this marker. Use this index
* on {@link google.maps.journeySharing.Trip.remainingWaypoints} to retrieve
* information about the waypoint.
* @type {number}
*/
google.maps.journeySharing.TripWaypointMarkerCustomizationFunctionParams
.prototype.waypointIndex;
/**
* The details for a vehicle returned by Fleet Engine.
* @record
*/
google.maps.journeySharing.Vehicle = function() {};
/**
* Custom vehicle attributes.
* @type {!Object
This
* will cause the map to enter cooperative mode if the map is dominating its
* scroll parent (usually the host page) to where the user cannot scroll away
* from the map to other content.
*/
AUTO: 'AUTO',
/**
* This forces cooperative mode, where modifier keys or two-finger gestures
* are required to scroll the map.
*/
COOPERATIVE: 'COOPERATIVE',
/**
* This forces greedy mode, where the host page cannot be scrolled from user
* events on the map element.
*/
GREEDY: 'GREEDY',
};
/**
* This event is created from clicking a Map3DElement.
*
* Access by calling `const {LocationClickEvent} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {Event}
* @constructor
*/
google.maps.maps3d.LocationClickEvent = function() {};
/**
* The latitude/longitude/altitude that was below the cursor when the event
* occurred. Please note, that at coarser levels, less accurate data will be
* returned. Also, sea floor elevation may be returned for the altitude value
* when clicking at the water surface from higher camera positions. This event
* bubbles up through the DOM tree.
* @type {!google.maps.LatLngAltitude|null}
*/
google.maps.maps3d.LocationClickEvent.prototype.position;
/**
* Map3DElement is an HTML interface for the 3D Map view. Note that the
* mode must be set for the 3D Map to start rendering.
*
* Access by calling `const {Map3DElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Map3DElementOptions=} options
* @implements {google.maps.maps3d.Map3DElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.maps3d.Map3DElement = function(options) {};
/**
* When set, restricts the position of the camera within the specified lat/lng
* bounds. Note that objects outside the bounds are still rendered. Bounds can
* restrict both longitude and latitude, or can restrict either latitude or
* longitude only. For latitude-only bounds use west and east longitudes of
* -180 and 180, respectively. For longitude-only
* bounds use north and south latitudes of 90 and -90,
* respectively.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.bounds;
/**
* The center of the map given as a LatLngAltitude, where altitude is in meters
* above ground level. Note that this is not necessarily where the camera is
* located, as the range field affects the camera's distance
* from the map center. If not set, defaults to {lat: 0, lng: 0, altitude:
* 63170000}. 63170000 meters is a maximum allowed altitude (Earth radius
* multiplied by 10).
* @type {!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.center;
/**
* When true, all default UI buttons are hidden.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.defaultUIHidden;
/**
* If provided, an accessibility description (e.g. for use with screen readers)
* will be added to the map with the provided value.
* @type {string|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.description;
/**
* Controls cooperative gesture handling. When set to COOPERATIVE,
* modifier keys or two-finger gestures are required to scroll the map. When set
* to GREEDY, the host page cannot be scrolled from user events on
* the map element. When set to AUTO, the gesture handling is
* determined by the scrollability of the host page.
* @default {@link google.maps.maps3d.GestureHandling.GREEDY}
* @type {!google.maps.maps3d.GestureHandling|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.gestureHandling;
/**
* The compass heading of the map, in degrees, where due north is zero. When
* there is no tilt, any roll will be interpreted as heading.
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.heading;
/**
* Adds a usage attribution ID to the initializer, which helps Google understand
* which libraries and samples are helpful to developers, such as usage of a
* marker clustering library. To opt out of sending the usage attribution ID, it
* is safe to delete this property. Only unique values will be sent. Changes to
* this value after instantiation may be ignored.
* @type {!Iterable
This must be set when the element is created, and cannot be
* updated after the map has loaded.
* @type {string|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.language;
/**
* Specifies a map ID which will be used to fetch cloud-based map style for the
* map. This should not be set after the map has been initialized. Therefore we
* ensure the mapId is only set during initialization and do not publish this
* attribute to public-facing channels.
* @type {string|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.mapId;
/**
* The maximum altitude above the ground which will be displayed on the map. A
* valid value is between 0 and 63170000 meters (Earth
* radius multiplied by 10).
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.maxAltitude;
/**
* The maximum angle of heading (rotation) of the map. A valid value is between
* 0 and 360 degrees. minHeading and
* maxHeading represent an interval of <= 360
* degrees in which heading gestures will be allowed. minHeading =
* 180 and maxHeading = 90 will allow heading in [0,
* 90] and heading in [180, 360]. minHeading =
* 90 and maxHeading = 180 will allow heading in [90,
* 180].
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.maxHeading;
/**
* The maximum angle of incidence of the map. A valid value is between
* 0 and 90 degrees.
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.maxTilt;
/**
* The minimum altitude above the ground which will be displayed on the map. A
* valid value is between 0 and 63170000 meters (Earth
* radius multiplied by 10).
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.minAltitude;
/**
* The minimum angle of heading (rotation) of the map. A valid value is between
* 0 and 360 degrees. minHeading and
* maxHeading represent an interval of <= 360
* degrees in which heading gestures will be allowed. minHeading =
* 180 and maxHeading = 90 will allow heading in [0,
* 90] and heading in [180, 360]. minHeading =
* 90 and maxHeading = 180 will allow heading in [90,
* 180].
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.minHeading;
/**
* The minimum angle of incidence of the map. A valid value is between
* 0 and 90 degrees.
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.minTilt;
/**
* Specifies a mode the map should be rendered in. If not set, the map won't
* be rendered.
* @type {!google.maps.maps3d.MapMode|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.mode;
/**
* The distance from camera to the center of the map, in meters.
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.range;
/**
* Region with which to attempt to render the base map's POIs. Will default
* to the region requested by the developer when loading the Maps JS
* API.
This must be set when the element is created, and cannot be
* updated after the map has loaded.
* @type {string|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.region;
/**
* The roll of the camera around the view vector in degrees. To resolve
* ambiguities, when there is no tilt, any roll will be interpreted as heading.
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.roll;
/**
* The tilt of the camera's view vector in degrees. A view vector looking
* directly down at the earth would have a tilt of zero degrees. A view vector
* pointing away from the earth would have a tilt of 180 degrees.
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElement.prototype.tilt;
/**
* When true, all default UI buttons are disabled. Does not disable
* the keyboard and gesture controls.
* @default false
* @type {boolean|null|undefined}
* @deprecated Please use {@link
* google.maps.maps3d.Map3DElement.defaultUIHidden} instead. This property
* will be removed in a future release.
*/
google.maps.maps3d.Map3DElement.prototype.defaultUIDisabled;
/**
* This method orbits the camera around a given location for a given duration.
* The animation can be repeated by the given number of {@link
* google.maps.maps3d.FlyAroundAnimationOptions.repeatCount} times.
* The camera will move in a clockwise direction.
The method is
* asynchronous because animations can only start after the map has loaded a
* minimum amount. The method returns once the animation has been started.
If the number of {@link
* google.maps.maps3d.FlyAroundAnimationOptions.repeatCount} times is zero, no
* spin will occur, and the animation will complete immediately after it starts.
* @param {!google.maps.maps3d.FlyAroundAnimationOptions} options
* @return {undefined}
*/
google.maps.maps3d.Map3DElement.prototype.flyCameraAround = function(
options) {};
/**
* This method moves the camera parabolically from the current location to a
* given end location over a given duration.
The method is
* asynchronous because animations can only start after the map has loaded a
* minimum amount. The method returns once the animation has been started.
* @param {!google.maps.maps3d.FlyToAnimationOptions} options
* @return {undefined}
*/
google.maps.maps3d.Map3DElement.prototype.flyCameraTo = function(options) {};
/**
* This method stops any fly animation that might happen to be running. The
* camera stays wherever it is mid-animation; it does not teleport to the end
* point.
The method is asynchronous because animations can only
* start or stop after the map has loaded a minimum amount. The method returns
* once the animation has stopped.
* @return {undefined}
*/
google.maps.maps3d.Map3DElement.prototype.stopCameraAnimation = function() {};
/**
* Map3DElementOptions object used to define the properties that can be set on a
* Map3DElement.
* @record
*/
google.maps.maps3d.Map3DElementOptions = function() {};
/**
* See {@link google.maps.maps3d.Map3DElement.bounds}.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.maps3d.Map3DElementOptions.prototype.bounds;
/**
* See {@link google.maps.maps3d.Map3DElement.center}.
* @type {!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.maps3d.Map3DElementOptions.prototype.center;
/**
* See {@link google.maps.maps3d.Map3DElement.defaultUIHidden}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Map3DElementOptions.prototype.defaultUIHidden;
/**
* See {@link google.maps.maps3d.Map3DElement.description}.
* @type {string|null|undefined}
*/
google.maps.maps3d.Map3DElementOptions.prototype.description;
/**
* See {@link google.maps.maps3d.Map3DElement.gestureHandling}.
* @type {!google.maps.maps3d.GestureHandling|null|undefined}
*/
google.maps.maps3d.Map3DElementOptions.prototype.gestureHandling;
/**
* See {@link google.maps.maps3d.Map3DElement.heading}.
* @type {number|null|undefined}
*/
google.maps.maps3d.Map3DElementOptions.prototype.heading;
/**
* See {@link google.maps.maps3d.Map3DElement.internalUsageAttributionIds}.
* @type {!Iterableposition must be set
* for the Marker3DElement to display.
*
* Access by calling `const {Marker3DElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Marker3DElementOptions=} options
* @implements {google.maps.maps3d.Marker3DElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.maps3d.Marker3DElement = function(options) {};
/**
* Specifies how the altitude component of the position is interpreted.
* @default {@link google.maps.maps3d.AltitudeMode.CLAMP_TO_GROUND}
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.Marker3DElement.prototype.altitudeMode;
/**
* An enumeration specifying how a Marker3DElement should behave when it
* collides with another Marker3DElement or with the basemap labels.
* @default {@link google.maps.CollisionBehavior.REQUIRED}
* @type {!google.maps.CollisionBehavior|null|undefined}
*/
google.maps.maps3d.Marker3DElement.prototype.collisionBehavior;
/**
* Specifies whether this marker should be drawn or not when it's occluded.
* The marker can be occluded by map geometry (e.g. buildings).
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Marker3DElement.prototype.drawsWhenOccluded;
/**
* Specifies whether to connect the marker to the ground. To extrude a marker,
* the altitudeMode must be either RELATIVE_TO_GROUND
* or ABSOLUTE.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Marker3DElement.prototype.extruded;
/**
* Text to be displayed by this marker.
* @type {string|null|undefined}
*/
google.maps.maps3d.Marker3DElement.prototype.label;
/**
* The location of the tip of the marker. Altitude is ignored in certain modes
* and thus optional.
* @type {!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.maps3d.Marker3DElement.prototype.position;
/**
* Specifies whether this marker should preserve its size or not regardless of
* distance from camera. By default, the marker is scaled based on distance from
* camera/tilt.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Marker3DElement.prototype.sizePreserved;
/**
* The zIndex compared to other markers.
* @type {number|null|undefined}
*/
google.maps.maps3d.Marker3DElement.prototype.zIndex;
/**
* Marker3DElementOptions object used to define the properties that can be set
* on a Marker3DElement.
* @record
*/
google.maps.maps3d.Marker3DElementOptions = function() {};
/**
* See {@link google.maps.maps3d.Marker3DElement.altitudeMode}.
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.Marker3DElementOptions.prototype.altitudeMode;
/**
* See {@link google.maps.maps3d.Marker3DElement.collisionBehavior}.
* @type {!google.maps.CollisionBehavior|null|undefined}
*/
google.maps.maps3d.Marker3DElementOptions.prototype.collisionBehavior;
/**
* See {@link google.maps.maps3d.Marker3DElement.drawsWhenOccluded}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Marker3DElementOptions.prototype.drawsWhenOccluded;
/**
* See {@link google.maps.maps3d.Marker3DElement.extruded}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Marker3DElementOptions.prototype.extruded;
/**
* See {@link google.maps.maps3d.Marker3DElement.label}.
* @type {string|null|undefined}
*/
google.maps.maps3d.Marker3DElementOptions.prototype.label;
/**
* See {@link google.maps.maps3d.Marker3DElement.position}.
* @type {!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.maps3d.Marker3DElementOptions.prototype.position;
/**
* See {@link google.maps.maps3d.Marker3DElement.sizePreserved}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Marker3DElementOptions.prototype.sizePreserved;
/**
* See {@link google.maps.maps3d.Marker3DElement.zIndex}.
* @type {number|null|undefined}
*/
google.maps.maps3d.Marker3DElementOptions.prototype.zIndex;
/**
* Shows a position on a 3D map. Note that the position must be set
* for the Marker3DInteractiveElement to display. Unlike
* Marker3DElement, Marker3DInteractiveElement
* receives a gmp-click event.
*
* Access by calling `const {Marker3DInteractiveElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Marker3DInteractiveElementOptions=} options
* @implements {google.maps.maps3d.Marker3DInteractiveElementOptions}
* @extends {google.maps.maps3d.Marker3DElement}
* @constructor
*/
google.maps.maps3d.Marker3DInteractiveElement = function(options) {};
/**
* When set, the popover element will be open on this marker's click.
* @type {!google.maps.maps3d.PopoverElement|null|undefined}
*/
google.maps.maps3d.Marker3DInteractiveElement.prototype.gmpPopoverTargetElement;
/**
* Rollover text. If provided, an accessibility text (e.g. for use with screen
* readers) will be added to the Marker3DInteractiveElement with
* the provided value.
* @type {string}
*/
google.maps.maps3d.Marker3DInteractiveElement.prototype.title;
/**
* Marker3DInteractiveElementOptions object used to define the properties that
* can be set on a Marker3DInteractiveElement.
* @extends {google.maps.maps3d.Marker3DElementOptions}
* @record
*/
google.maps.maps3d.Marker3DInteractiveElementOptions = function() {};
/**
* See {@link
* google.maps.maps3d.Marker3DInteractiveElement.gmpPopoverTargetElement}.
* @type {!google.maps.maps3d.PopoverElement|null|undefined}
*/
google.maps.maps3d.Marker3DInteractiveElementOptions.prototype
.gmpPopoverTargetElement;
/**
* See {@link google.maps.maps3d.Marker3DInteractiveElement.title}.
* @type {string|undefined}
*/
google.maps.maps3d.Marker3DInteractiveElementOptions.prototype.title;
/**
* A 3D model which allows the rendering of gLTF models. Note that the
* position and the src must be set for the
* Model3DElement to display.
Core properties of the
* gLTF PBR should be supported.
* No extensions or extension properties are currently supported.
*
* Access by calling `const {Model3DElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Model3DElementOptions=} options
* @implements {google.maps.maps3d.Model3DElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.maps3d.Model3DElement = function(options) {};
/**
* Specifies how altitude in the position is interpreted.
* @default {@link google.maps.maps3d.AltitudeMode.CLAMP_TO_GROUND}
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.Model3DElement.prototype.altitudeMode;
/**
* Describes rotation of a 3D model's coordinate system to position the
* model on the 3D Map.
Rotations are applied to the model in the
* following order: roll, tilt and then heading.
* @type {!google.maps.Orientation3D|!google.maps.Orientation3DLiteral|null|undefined}
*/
google.maps.maps3d.Model3DElement.prototype.orientation;
/**
* Sets the Model3DElement's position. Altitude is ignored in
* certain modes and thus optional.
* @type {!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.maps3d.Model3DElement.prototype.position;
/**
* Scales the model along the x, y, and z axes in the model's coordinate
* space.
* @default 1
* @type {number|!google.maps.Vector3D|!google.maps.Vector3DLiteral|null|undefined}
*/
google.maps.maps3d.Model3DElement.prototype.scale;
/**
* Specifies the url of the 3D model. At this time, only models in the
* .glb format are supported.
Any relative HTTP urls
* will be resolved to their corresponding absolute ones.
Please
* note that If you're hosting your .glb model files on a
* different website or server than your main application, make sure to set up
* the correct CORS HTTP headers. This allows your application to securely
* access the model files from the other domain.
* @type {string|!URL|null|undefined}
*/
google.maps.maps3d.Model3DElement.prototype.src;
/**
* Model3DElementOptions object used to define the properties that can be set on
* a Model3DElement.
* @record
*/
google.maps.maps3d.Model3DElementOptions = function() {};
/**
* See {@link google.maps.maps3d.Model3DElement.altitudeMode}.
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.Model3DElementOptions.prototype.altitudeMode;
/**
* See {@link google.maps.maps3d.Model3DElement.orientation}.
* @type {!google.maps.Orientation3D|!google.maps.Orientation3DLiteral|null|undefined}
*/
google.maps.maps3d.Model3DElementOptions.prototype.orientation;
/**
* See {@link google.maps.maps3d.Model3DElement.position}.
* @type {!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.maps3d.Model3DElementOptions.prototype.position;
/**
* See {@link google.maps.maps3d.Model3DElement.scale}.
* @type {number|!google.maps.Vector3D|!google.maps.Vector3DLiteral|null|undefined}
*/
google.maps.maps3d.Model3DElementOptions.prototype.scale;
/**
* See {@link google.maps.maps3d.Model3DElement.src}.
* @type {string|!URL|null|undefined}
*/
google.maps.maps3d.Model3DElementOptions.prototype.src;
/**
* A 3D model which allows the rendering of gLTF models. Note that the
* position and the src must be set for the
* Model3DElement to display.
Core properties of the
* gLTF PBR should be supported.
* No extensions or extension properties are currently supported.
* Unlike Model3DElement, Model3DInteractiveElement
* receives a gmp-click event.
*
* Access by calling `const {Model3DInteractiveElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Model3DElementOptions=} options
* @implements {google.maps.maps3d.Model3DInteractiveElementOptions}
* @extends {google.maps.maps3d.Model3DElement}
* @constructor
*/
google.maps.maps3d.Model3DInteractiveElement = function(options) {};
/**
* Model3DInteractiveElementOptions object used to define the properties that
* can be set on a Model3DInteractiveElement.
* @extends {google.maps.maps3d.Model3DElementOptions}
* @record
*/
google.maps.maps3d.Model3DInteractiveElementOptions = function() {};
/**
* This event is created from clicking on a place icon on a
* Map3DElement. To prevent the default popover from showing up,
* call the preventDefault() method on this event to prevent it
* being handled by the Map3DElement.
*
* Access by calling `const {PlaceClickEvent} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {google.maps.maps3d.LocationClickEvent}
* @constructor
*/
google.maps.maps3d.PlaceClickEvent = function() {};
/**
* The place id of the map feature.
* @type {string}
*/
google.maps.maps3d.PlaceClickEvent.prototype.placeId;
/**
* Fetches a Place for this place id. In the resulting
* Place object, the id property will be populated. Additional
* fields can be subsequently requested via Place.fetchFields()
* subject to normal Places API enablement and billing. The promise is rejected
* if there was an error fetching the Place.
* @return {!Promise}
*/
google.maps.maps3d.PlaceClickEvent.prototype.fetchPlace = function() {};
/**
* A 3D polygon (like a 3D polyline) defines a series of connected coordinates
* in an ordered sequence. Additionally, polygons form a closed loop and define
* a filled region.
*
* Access by calling `const {Polygon3DElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Polygon3DElementOptions=} options
* @implements {google.maps.maps3d.Polygon3DElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.maps3d.Polygon3DElement = function(options) {};
/**
* Specifies how altitude components in the coordinates are interpreted.
* @default {@link google.maps.maps3d.AltitudeMode.CLAMP_TO_GROUND}
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.altitudeMode;
/**
* Specifies whether parts of the polygon which could be occluded are drawn or
* not. Polygons can be occluded by map geometry (e.g. buildings).
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.drawsOccludedSegments;
/**
* Specifies whether to connect the polygon to the ground. To extrude a polygon,
* the altitudeMode must be either RELATIVE_TO_GROUND
* or ABSOLUTE.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.extruded;
/**
* The fill color. All CSS3 colors are supported.
* @type {string|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.fillColor;
/**
* When true, edges of the polygon are interpreted as geodesic and
* will follow the curvature of the Earth. When false, edges of the
* polygon are rendered as straight lines in screen space.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.geodesic;
/**
* The ordered sequence of coordinates that designates a closed loop. Unlike
* polylines, a polygon may consist of one or more paths, which create multiple
* cut-outs inside the polygon.
* @type {!Iterable>|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.innerPaths;
/**
* The ordered sequence of coordinates that designates a closed loop. Altitude
* is ignored in certain modes and thus optional.
* @type {!Iterable|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.path;
/**
* The stroke color. All CSS3 colors are supported.
* @type {string|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.strokeColor;
/**
* The stroke width in pixels.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.strokeWidth;
/**
* The zIndex compared to other polys.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polygon3DElement.prototype.zIndex;
/**
* The ordered sequence of coordinates that designates a closed loop. Altitude
* is ignored in certain modes and thus optional.
* @type {!Iterable|null|undefined}
* @deprecated Use path instead. This property will be removed in a
* future release.
*/
google.maps.maps3d.Polygon3DElement.prototype.outerCoordinates;
/**
* The ordered sequence of coordinates that designates a closed loop. Unlike
* polylines, a polygon may consist of one or more paths, which create multiple
* cut-outs inside the polygon.
* @type {!Iterable>|null|undefined}
* @deprecated Use innerPaths instead. This property will be
* removed in a future release.
*/
google.maps.maps3d.Polygon3DElement.prototype.innerCoordinates;
/**
* Polygon3DElementOptions object used to define the properties that can be set
* on a Polygon3DElement.
* @record
*/
google.maps.maps3d.Polygon3DElementOptions = function() {};
/**
* See {@link google.maps.maps3d.Polygon3DElement.altitudeMode}.
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.altitudeMode;
/**
* See {@link google.maps.maps3d.Polygon3DElement.drawsOccludedSegments}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.drawsOccludedSegments;
/**
* See {@link google.maps.maps3d.Polygon3DElement.extruded}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.extruded;
/**
* See {@link google.maps.maps3d.Polygon3DElement.fillColor}.
* @type {string|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.fillColor;
/**
* See {@link google.maps.maps3d.Polygon3DElement.geodesic}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.geodesic;
/**
* See {@link google.maps.maps3d.Polygon3DElement.innerCoordinates}.
* @type {!Iterable|!Iterable>|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.innerCoordinates;
/**
* See {@link google.maps.maps3d.Polygon3DElement.outerCoordinates}.
* @type {!Iterable|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.outerCoordinates;
/**
* See {@link google.maps.maps3d.Polygon3DElement.strokeColor}.
* @type {string|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.strokeColor;
/**
* See {@link google.maps.maps3d.Polygon3DElement.strokeWidth}.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.strokeWidth;
/**
* See {@link google.maps.maps3d.Polygon3DElement.zIndex}.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polygon3DElementOptions.prototype.zIndex;
/**
* A 3D polygon (like a 3D polyline) defines a series of connected coordinates
* in an ordered sequence. Additionally, polygons form a closed loop and define
* a filled region. Unlike Polygon3DElement,
* Polygon3DInteractiveElement receives a gmp-click
* event.
*
* Access by calling `const {Polygon3DInteractiveElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Polygon3DElementOptions=} options
* @implements {google.maps.maps3d.Polygon3DInteractiveElementOptions}
* @extends {google.maps.maps3d.Polygon3DElement}
* @constructor
*/
google.maps.maps3d.Polygon3DInteractiveElement = function(options) {};
/**
* Polygon3DInteractiveElementOptions object used to define the properties that
* can be set on a Polygon3DInteractiveElement.
* @extends {google.maps.maps3d.Polygon3DElementOptions}
* @record
*/
google.maps.maps3d.Polygon3DInteractiveElementOptions = function() {};
/**
* A 3D polyline is a linear overlay of connected line segments on a 3D map.
*
* Access by calling `const {Polyline3DElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Polyline3DElementOptions=} options
* @implements {google.maps.maps3d.Polyline3DElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.maps3d.Polyline3DElement = function(options) {};
/**
* Specifies how altitude components in the coordinates are interpreted.
* @default {@link google.maps.maps3d.AltitudeMode.CLAMP_TO_GROUND}
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.altitudeMode;
/**
* Specifies whether parts of the polyline which could be occluded are drawn or
* not. Polylines can be occluded by map geometry (e.g. buildings).
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.drawsOccludedSegments;
/**
* Specifies whether to connect the polyline to the ground. To extrude a
* polyline, the altitudeMode must be either
* RELATIVE_TO_GROUND or ABSOLUTE.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.extruded;
/**
* When true, edges of the polyline are interpreted as geodesic and
* will follow the curvature of the Earth. When false, edges of the
* polyline are rendered as straight lines in screen space.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.geodesic;
/**
* The outer color. All CSS3 colors are supported.
* @type {string|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.outerColor;
/**
* The outer width is between 0.0 and 1.0. This is a
* percentage of the strokeWidth.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.outerWidth;
/**
* The ordered sequence of coordinates of the Polyline. Altitude is ignored in
* certain modes and thus optional.
* @type {!Iterable|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.path;
/**
* The stroke color. All CSS3 colors are supported.
* @type {string|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.strokeColor;
/**
* The stroke width in pixels.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.strokeWidth;
/**
* The zIndex compared to other polys.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polyline3DElement.prototype.zIndex;
/**
* The ordered sequence of coordinates of the Polyline. Altitude is ignored in
* certain modes and thus optional.
* @type {!Iterable|null|undefined}
* @deprecated Use path instead. This property will be removed in a
* future release.
*/
google.maps.maps3d.Polyline3DElement.prototype.coordinates;
/**
* Polyline3DElementOptions object used to define the properties that can be set
* on a Polyline3DElement.
* @record
*/
google.maps.maps3d.Polyline3DElementOptions = function() {};
/**
* See {@link google.maps.maps3d.Polyline3DElement.altitudeMode}.
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.altitudeMode;
/**
* See {@link google.maps.maps3d.Polyline3DElement.coordinates}.
* @type {!Iterable|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.coordinates;
/**
* See {@link google.maps.maps3d.Polyline3DElement.drawsOccludedSegments}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.drawsOccludedSegments;
/**
* See {@link google.maps.maps3d.Polyline3DElement.extruded}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.extruded;
/**
* See {@link google.maps.maps3d.Polyline3DElement.geodesic}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.geodesic;
/**
* See {@link google.maps.maps3d.Polyline3DElement.outerColor}.
* @type {string|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.outerColor;
/**
* See {@link google.maps.maps3d.Polyline3DElement.outerWidth}.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.outerWidth;
/**
* See {@link google.maps.maps3d.Polyline3DElement.strokeColor}.
* @type {string|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.strokeColor;
/**
* See {@link google.maps.maps3d.Polyline3DElement.strokeWidth}.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.strokeWidth;
/**
* See {@link google.maps.maps3d.Polyline3DElement.zIndex}.
* @type {number|null|undefined}
*/
google.maps.maps3d.Polyline3DElementOptions.prototype.zIndex;
/**
* A 3D polyline is a linear overlay of connected line segments on a 3D map.
* Unlike Polyline3DElement,
* Polyline3DInteractiveElement receives a gmp-click
* event.
*
* Access by calling `const {Polyline3DInteractiveElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.Polyline3DElementOptions=} options
* @implements {google.maps.maps3d.Polyline3DInteractiveElementOptions}
* @extends {google.maps.maps3d.Polyline3DElement}
* @constructor
*/
google.maps.maps3d.Polyline3DInteractiveElement = function(options) {};
/**
* Polyline3DInteractiveElementOptions object used to define the properties that
* can be set on a Polyline3DInteractiveElement.
* @extends {google.maps.maps3d.Polyline3DElementOptions}
* @record
*/
google.maps.maps3d.Polyline3DInteractiveElementOptions = function() {};
/**
* A custom HTML element that renders a popover. It looks like a bubble and is
* often connected to a marker.
*
* Access by calling `const {PopoverElement} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.maps3d.PopoverElementOptions=} options
* @implements {google.maps.maps3d.PopoverElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.maps3d.PopoverElement = function(options) {};
/**
* Specifies how the altitude component of the position is interpreted.
* @default {@link google.maps.maps3d.AltitudeMode.CLAMP_TO_GROUND}
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.PopoverElement.prototype.altitudeMode;
/**
* Specifies whether this popover should be "light dismissed" or not.
* The "light dismiss" behavior is similar to setting the
* popover="auto" attribute which is part of the browser
* Popover
* API.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.PopoverElement.prototype.lightDismissDisabled;
/**
* Specifies whether this popover should be open or not.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.maps3d.PopoverElement.prototype.open;
/**
* The position at which to display this popover. If the popover is anchored to
* an interactive marker, the marker's position will be used instead.
* @type {!google.maps.LatLngLiteral|!google.maps.LatLngAltitudeLiteral|!google.maps.maps3d.Marker3DInteractiveElement|string|null|undefined}
*/
google.maps.maps3d.PopoverElement.prototype.positionAnchor;
/**
* PopoverElementOptions object used to define the properties that can be set on
* a PopoverElement.
* @record
*/
google.maps.maps3d.PopoverElementOptions = function() {};
/**
* See {@link google.maps.maps3d.PopoverElement.altitudeMode}.
* @type {!google.maps.maps3d.AltitudeMode|null|undefined}
*/
google.maps.maps3d.PopoverElementOptions.prototype.altitudeMode;
/**
* See {@link google.maps.maps3d.PopoverElement.lightDismissDisabled}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.PopoverElementOptions.prototype.lightDismissDisabled;
/**
* See {@link google.maps.maps3d.PopoverElement.open}.
* @type {boolean|null|undefined}
*/
google.maps.maps3d.PopoverElementOptions.prototype.open;
/**
* See {@link google.maps.maps3d.PopoverElement.positionAnchor}.
* @type {!google.maps.LatLngLiteral|!google.maps.LatLngAltitudeLiteral|string|!google.maps.maps3d.Marker3DInteractiveElement|null|undefined}
*/
google.maps.maps3d.PopoverElementOptions.prototype.positionAnchor;
/**
* This event is created from monitoring a steady state of
* Map3DElement. This event bubbles up through the DOM tree.
*
* Access by calling `const {SteadyChangeEvent} = await
* google.maps.importLibrary("maps3d")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {Event}
* @constructor
*/
google.maps.maps3d.SteadyChangeEvent = function() {};
/**
* Indicates whether Map3DElement is steady (i.e. all rendering for the current
* scene has completed) or not.
* @type {boolean}
*/
google.maps.maps3d.SteadyChangeEvent.prototype.isSteady;
/**
* @const
*/
google.maps.marker = {};
/**
* This event is created from clicking an Advanced Marker. Access the
* marker's position with event.target.position.
*
* Access by calling `const {AdvancedMarkerClickEvent} = await
* google.maps.importLibrary("marker")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {Event}
* @constructor
*/
google.maps.marker.AdvancedMarkerClickEvent = function() {};
/**
* Shows a position on a map. Note that the position must be set
* for the AdvancedMarkerElement to display.
*
* Access by calling `const {AdvancedMarkerElement} = await
* google.maps.importLibrary("marker")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.marker.AdvancedMarkerElementOptions=} options
* @implements {google.maps.marker.AdvancedMarkerElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.marker.AdvancedMarkerElement = function(options) {};
/**
* A CSS
* length-percentage value which is used to offset the anchor point of the
* marker from the top left corner of the marker. This is useful when using a
* visual which has an anchor point that is different than the typical bottom
* center point of the default marker.
* @default "-50%"
* @type {string|null|undefined}
*/
google.maps.marker.AdvancedMarkerElement.prototype.anchorLeft;
/**
* A CSS
* length-percentage value which is used to offset the anchor point of the
* marker from the top left corner of the marker. This is useful when using a
* visual which has an anchor point that is different than the typical bottom
* center point of the default marker.
* @default "-100%"
* @type {string|null|undefined}
*/
google.maps.marker.AdvancedMarkerElement.prototype.anchorTop;
/**
* See {@link
* google.maps.marker.AdvancedMarkerElementOptions.collisionBehavior}.
* @type {!google.maps.CollisionBehavior|null|undefined}
*/
google.maps.marker.AdvancedMarkerElement.prototype.collisionBehavior;
/**
* See {@link google.maps.marker.AdvancedMarkerElementOptions.gmpClickable}.
* @type {boolean|null|undefined}
*/
google.maps.marker.AdvancedMarkerElement.prototype.gmpClickable;
/**
* See {@link google.maps.marker.AdvancedMarkerElementOptions.gmpDraggable}.
* @type {boolean|null|undefined}
*/
google.maps.marker.AdvancedMarkerElement.prototype.gmpDraggable;
/**
* See {@link google.maps.marker.AdvancedMarkerElementOptions.map}.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.marker.AdvancedMarkerElement.prototype.map;
/**
* See {@link google.maps.marker.AdvancedMarkerElementOptions.position}.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.marker.AdvancedMarkerElement.prototype.position;
/**
* See {@link google.maps.marker.AdvancedMarkerElementOptions.title}.
* @type {string}
*/
google.maps.marker.AdvancedMarkerElement.prototype.title;
/**
* See {@link google.maps.marker.AdvancedMarkerElementOptions.zIndex}.
* @type {number|null|undefined}
*/
google.maps.marker.AdvancedMarkerElement.prototype.zIndex;
/**
* This field is read-only. The DOM Element backing the view.
* @type {!HTMLElement}
* @deprecated Use the AdvancedMarkerElement directly.
*/
google.maps.marker.AdvancedMarkerElement.prototype.element;
/**
* See {@link google.maps.marker.AdvancedMarkerElementOptions.content}.
* @type {!Node|null|undefined}
* @deprecated Use .children
* instead.
*/
google.maps.marker.AdvancedMarkerElement.prototype.content;
/**
* Adds the given listener function to the given event name in the Maps Eventing
* system.
* @param {string} eventName Observed event.
* @param {!Function} handler Function to handle events.
* @return {!google.maps.MapsEventListener} Resulting event listener.
*/
google.maps.marker.AdvancedMarkerElement.prototype.addListener = function(
eventName, handler) {};
/**
* Options for constructing an {@link google.maps.marker.AdvancedMarkerElement}.
* @record
*/
google.maps.marker.AdvancedMarkerElementOptions = function() {};
/**
* A CSS
* length-percentage value which is used to offset the anchor point of the
* marker from the top left corner of the marker. This is useful when using a
* visual which has an anchor point that is different than the typical bottom
* center point of the default marker.
* @default "-50%"
* @type {string|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.anchorLeft;
/**
* A CSS
* length-percentage value which is used to offset the anchor point of the
* marker from the top left corner of the marker. This is useful when using a
* visual which has an anchor point that is different than the typical bottom
* center point of the default marker.
* @default "-100%"
* @type {string|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.anchorTop;
/**
* An enumeration specifying how an AdvancedMarkerElement should
* behave when it collides with another AdvancedMarkerElement or
* with the basemap labels on a vector map. AdvancedMarkerElement to AdvancedMarkerElement
* collision works on both raster and vector maps, however,
* AdvancedMarkerElement to base map's label collision only
* works on vector maps.
* @type {!google.maps.CollisionBehavior|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.collisionBehavior;
/**
* The DOM Element backing the visual of an AdvancedMarkerElement.
* AdvancedMarkerElement does not clone
* the passed-in DOM element. Once the DOM element is passed to an
* AdvancedMarkerElement, passing the same DOM element to another
* AdvancedMarkerElement will move the DOM element and cause the
* previous AdvancedMarkerElement to look empty.
* @default {@link google.maps.marker.PinElement.element}
* @type {!Node|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.content;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* If true, the AdvancedMarkerElement will be
* clickable and trigger the gmp-click event, and will be
* interactive for accessibility purposes (e.g. allowing keyboard navigation via
* arrow keys).
* @default false
* @type {boolean|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.gmpClickable;
/**
* If true, the AdvancedMarkerElement can be dragged.
* AdvancedMarkerElement with altitude is
* not draggable.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.gmpDraggable;
/**
* Map on which to display the AdvancedMarkerElement. The map is
* required to display the AdvancedMarkerElement and can be
* provided by setting {@link google.maps.marker.AdvancedMarkerElement.map} if
* not provided at the construction.
* @type {!google.maps.Map|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.map;
/**
* Sets the AdvancedMarkerElement's position. An
* AdvancedMarkerElement may be constructed without a position, but
* will not be displayed until its position is provided - for example, by a
* user's actions or choices. An AdvancedMarkerElement's
* position can be provided by setting {@link
* google.maps.marker.AdvancedMarkerElement.position} if not provided at the
* construction. AdvancedMarkerElement
* with altitude is only supported on vector maps.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.position;
/**
* Rollover text. If provided, an accessibility text (e.g. for use with screen
* readers) will be added to the AdvancedMarkerElement with the
* provided value.
* @type {string|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.title;
/**
* All AdvancedMarkerElements are displayed on the map in order of
* their zIndex, with higher values displaying in front of
* AdvancedMarkerElements with lower values. By default,
* AdvancedMarkerElements are displayed according to their vertical
* position on screen, with lower AdvancedMarkerElements appearing
* in front of AdvancedMarkerElements farther up the screen. Note
* that zIndex is also used to help determine relative priority
* between {@link
* google.maps.CollisionBehavior.OPTIONAL_AND_HIDES_LOWER_PRIORITY} Advanced
* Markers. A higher zIndex value indicates higher priority.
* @type {number|null|undefined}
*/
google.maps.marker.AdvancedMarkerElementOptions.prototype.zIndex;
/**
* A PinElement represents a DOM element that consists of a shape
* and a glyph. The shape has the same balloon style as seen in the
* default {@link google.maps.marker.AdvancedMarkerElement} or {@link
* google.maps.maps3d.Marker3DElement}. The glyph is an optional DOM element
* displayed in the balloon shape. A PinElement may have a
* different aspect ratio depending on its {@link
* google.maps.marker.PinElement.scale}.
*
* Access by calling `const {PinElement} = await
* google.maps.importLibrary("marker")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.marker.PinElementOptions=} options
* @implements {google.maps.marker.PinElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.marker.PinElement = function(options) {};
/**
* See {@link google.maps.marker.PinElementOptions.background}.
* @type {string|null|undefined}
*/
google.maps.marker.PinElement.prototype.background;
/**
* See {@link google.maps.marker.PinElementOptions.borderColor}.
* @type {string|null|undefined}
*/
google.maps.marker.PinElement.prototype.borderColor;
/**
* See {@link google.maps.marker.PinElementOptions.glyphColor}.
* @type {string|null|undefined}
*/
google.maps.marker.PinElement.prototype.glyphColor;
/**
* See {@link google.maps.marker.PinElementOptions.glyphSrc}.
* @type {!URL|string|null|undefined}
*/
google.maps.marker.PinElement.prototype.glyphSrc;
/**
* See {@link google.maps.marker.PinElementOptions.glyphText}.
* @type {string|null|undefined}
*/
google.maps.marker.PinElement.prototype.glyphText;
/**
* See {@link google.maps.marker.PinElementOptions.scale}.
* @type {number|null|undefined}
*/
google.maps.marker.PinElement.prototype.scale;
/**
* This field is read-only. The DOM Element backing the view.
* @type {!HTMLElement}
* @deprecated Use the PinElement directly.
*/
google.maps.marker.PinElement.prototype.element;
/**
* See {@link google.maps.marker.PinElementOptions.glyph}.
* @type {string|!Element|!URL|null|undefined}
* @deprecated Use {@link google.maps.marker.PinElementOptions.glyphText}
* or {@link google.maps.marker.PinElementOptions.glyphSrc} instead.
*/
google.maps.marker.PinElement.prototype.glyph;
/**
* Options for creating a {@link google.maps.marker.PinElement}.
* @record
*/
google.maps.marker.PinElementOptions = function() {};
/**
* The background color of the pin shape. Supports any CSS color
* value.
* @type {string|null|undefined}
*/
google.maps.marker.PinElementOptions.prototype.background;
/**
* The border color of the pin shape. Supports any CSS color
* value.
* @type {string|null|undefined}
*/
google.maps.marker.PinElementOptions.prototype.borderColor;
/**
* The color of the glyph. Supports any CSS color
* value.
* @type {string|null|undefined}
*/
google.maps.marker.PinElementOptions.prototype.glyphColor;
/**
* The source of the glyph image to be displayed in the pin.
* @type {!URL|string|null|undefined}
*/
google.maps.marker.PinElementOptions.prototype.glyphSrc;
/**
* The text displayed in the pin.
* @type {string|null|undefined}
*/
google.maps.marker.PinElementOptions.prototype.glyphText;
/**
* The scale of the pin.
* @default 1
* @type {number|null|undefined}
*/
google.maps.marker.PinElementOptions.prototype.scale;
/**
* The DOM element displayed in the pin.
* @type {string|!Element|!URL|null|undefined}
* @deprecated Use {@link google.maps.marker.PinElementOptions.glyphText}
* or {@link google.maps.marker.PinElementOptions.glyphSrc} instead.
*/
google.maps.marker.PinElementOptions.prototype.glyph;
/**
* @const
*/
google.maps.places = {};
/**
*
* Access by calling `const {AccessibilityOptions} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.AccessibilityOptions = function() {};
/**
* Whether a place has a wheelchair accessible entrance. Returns 'true'
* or 'false' if the value is known. Returns 'null' if the value
* is unknown.
* @type {boolean|null}
*/
google.maps.places.AccessibilityOptions.prototype
.hasWheelchairAccessibleEntrance;
/**
* Whether a place has wheelchair accessible parking. Returns 'true' or
* 'false' if the value is known. Returns 'null' if the value is
* unknown.
* @type {boolean|null}
*/
google.maps.places.AccessibilityOptions.prototype
.hasWheelchairAccessibleParking;
/**
* Whether a place has a wheelchair accessible restroom. Returns 'true'
* or 'false' if the value is known. Returns 'null' if the value
* is unknown.
* @type {boolean|null}
*/
google.maps.places.AccessibilityOptions.prototype
.hasWheelchairAccessibleRestroom;
/**
* Whether a place offers wheelchair accessible seating. Returns 'true'
* or 'false' if the value is known. Returns 'null' if the value
* is unknown.
* @type {boolean|null}
*/
google.maps.places.AccessibilityOptions.prototype
.hasWheelchairAccessibleSeating;
/**
* Address component for the Place's location.
*
* Access by calling `const {AddressComponent} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.AddressComponent = function() {};
/**
* The full text of the address component.
* @type {string|null}
*/
google.maps.places.AddressComponent.prototype.longText;
/**
* The abbreviated, short text of the given address component.
* @type {string|null}
*/
google.maps.places.AddressComponent.prototype.shortText;
/**
* An array of strings denoting the type of this address component. A list of
* valid types can be found here.
* @type {!Arraytext, and listens for text
* entry in that field. The list of predictions is presented as a drop-down
* list, and is updated as text is entered.
*
* Access by calling `const {Autocomplete} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!HTMLInputElement} inputField The <input> text
* field to which the Autocomplete should be attached.
* @param {?google.maps.places.AutocompleteOptions=} opts Options.
* @extends {google.maps.MVCObject}
* @constructor
* @deprecated As of March 1st, 2025, google.maps.places.Autocomplete is not
* available to new customers. Please use {@link
* google.maps.places.PlaceAutocompleteElement} instead. At this time,
* google.maps.places.Autocomplete is not scheduled to be discontinued,
* but {@link google.maps.places.PlaceAutocompleteElement} is recommended
* over google.maps.places.Autocomplete. While
* google.maps.places.Autocomplete will continue to receive bug fixes for
* any major regressions, existing bugs in google.maps.places.Autocomplete
* will not be addressed. At least 12 months notice will be given before
* support is discontinued. Please see https://developers.google.com/maps/legacy
* for additional details and https://developers.google.com/maps/documentation/javascript/places-migration-overview
* for the migration guide.
*/
google.maps.places.Autocomplete = function(inputField, opts) {};
/**
* Returns the bounds to which predictions are biased.
* @return {!google.maps.LatLngBounds|undefined} The biasing bounds.
*/
google.maps.places.Autocomplete.prototype.getBounds = function() {};
/**
* Returns the fields to be included for the Place in the details response when
* the details are successfully retrieved. For a list of fields see {@link
* google.maps.places.PlaceResult}.
* @return {!Arrayname property set to the current value of the input field.
* @return {!google.maps.places.PlaceResult} The Place selected by the user.
*/
google.maps.places.Autocomplete.prototype.getPlace = function() {};
/**
* Sets the preferred area within which to return Place results. Results are
* biased towards, but not restricted to, this area.
* @param {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|undefined}
* bounds The biasing bounds.
* @return {undefined}
*/
google.maps.places.Autocomplete.prototype.setBounds = function(bounds) {};
/**
* Sets the component restrictions. Component restrictions are used to restrict
* predictions to only those within the parent component. For example, the
* country.
* @param {?google.maps.places.ComponentRestrictions} restrictions The
* restrictions to use.
* @return {undefined}
*/
google.maps.places.Autocomplete.prototype.setComponentRestrictions = function(
restrictions) {};
/**
* Sets the fields to be included for the Place in the details response when the
* details are successfully retrieved. For a list of fields see {@link
* google.maps.places.PlaceResult}.
* @param {!ArrayAutocomplete object.
* @record
*/
google.maps.places.AutocompleteOptions = function() {};
/**
* The area in which to search for places.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|undefined}
*/
google.maps.places.AutocompleteOptions.prototype.bounds;
/**
* The component restrictions. Component restrictions are used to restrict
* predictions to only those within the parent component. For example, the
* country.
* @type {!google.maps.places.ComponentRestrictions|undefined}
*/
google.maps.places.AutocompleteOptions.prototype.componentRestrictions;
/**
* Fields to be included for the Place in the details response when the details
* are successfully retrieved, which
* will be billed for. If ['ALL'] is passed in, all
* available fields will be returned and billed for (this is not recommended for
* production deployments). For a list of fields see {@link
* google.maps.places.PlaceResult}. Nested fields can be specified with
* dot-paths (for example, "geometry.location"). The default is
* ['ALL'].
* @type {!Arrayfalse (which is
* the default) will make the results biased towards, but not restricted to,
* places contained within the bounds.
* @type {boolean|undefined}
*/
google.maps.places.AutocompleteOptions.prototype.strictBounds;
/**
* The types of predictions to be returned. For supported types, see the
* developer's guide. If no types are specified, all types will be
* returned.
* @type {!ArrayplaceIdOnly is deprecated as of January 15, 2019,
* and will be turned off on January 15, 2020. Use {@link
* google.maps.places.AutocompleteOptions.fields} instead: fields:
* ['place_id', 'name', 'types'].
*/
google.maps.places.AutocompleteOptions.prototype.placeIdOnly;
/**
* Represents a single autocomplete prediction.
* @record
*/
google.maps.places.AutocompletePrediction = function() {};
/**
* This is the unformatted version of the query suggested by the Places service.
* @type {string}
*/
google.maps.places.AutocompletePrediction.prototype.description;
/**
* The distance in meters of the place from the {@link
* google.maps.places.AutocompletionRequest.origin}.
* @type {number|undefined}
*/
google.maps.places.AutocompletePrediction.prototype.distance_meters;
/**
* A set of substrings in the place's description that match elements in the
* user's input, suitable for use in highlighting those substrings. Each
* substring is identified by an offset and a length, expressed in unicode
* characters.
* @type {!Array}
*/
google.maps.places.AutocompletePrediction.prototype.matched_substrings;
/**
* A place ID that can be used to retrieve details about this place using the
* place details service (see {@link
* google.maps.places.PlacesService.getDetails}).
* @type {string}
*/
google.maps.places.AutocompletePrediction.prototype.place_id;
/**
* Structured information about the place's description, divided into a main
* text and a secondary text, including an array of matched substrings from the
* autocomplete input, identified by an offset and a length, expressed in
* unicode characters.
* @type {!google.maps.places.StructuredFormatting}
*/
google.maps.places.AutocompletePrediction.prototype.structured_formatting;
/**
* Information about individual terms in the above description, from most to
* least specific. For example, "Taco Bell", "Willitis", and
* "CA".
* @type {!Array}
*/
google.maps.places.AutocompletePrediction.prototype.terms;
/**
* An array of types that the prediction belongs to, for example
* 'establishment' or 'geocode'.
* @type {!Array
A Place is only returned if its primary type is included in this
* list. Up to 5 values can be specified. If no types are specified, all Place
* types are returned.
* @type {!ArraylocationRestriction and includedRegionCodes
* are set, the results will be located in the area of intersection.
* @type {!Arrayinput indicating the
* cursor position in input. The cursor position may influence what
* predictions are returned. If not specified, defaults to the length of
* input.
* @type {number|undefined}
*/
google.maps.places.AutocompleteRequest.prototype.inputOffset;
/**
* The language in which to return results. Will default to the browser's
* language preference. The results may be in mixed languages if the language
* used in input is different from language, or if the
* returned Place does not have a translation from the local language to
* language.
* @type {string|undefined}
*/
google.maps.places.AutocompleteRequest.prototype.language;
/**
* Bias results to a specified location.
At most one of
* locationBias or locationRestriction should be set.
* If neither are set, the results will be biased by IP address, meaning the IP
* address will be mapped to an imprecise location and used as a biasing signal.
* @type {!google.maps.places.LocationBias|undefined}
*/
google.maps.places.AutocompleteRequest.prototype.locationBias;
/**
* Restrict results to a specified location.
At most one of
* locationBias or locationRestriction should be set.
* If neither are set, the results will be biased by IP address, meaning the IP
* address will be mapped to an imprecise location and used as a biasing signal.
* @type {!google.maps.places.LocationRestriction|undefined}
*/
google.maps.places.AutocompleteRequest.prototype.locationRestriction;
/**
* The origin point from which to calculate geodesic distance to the destination
* (returned as {@link google.maps.places.PlacePrediction.distanceMeters}). If
* this value is omitted, geodesic distance will not be returned.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|undefined}
*/
google.maps.places.AutocompleteRequest.prototype.origin;
/**
* The region code, specified as a CLDR two-character region code. This affects
* address formatting, result ranking, and may influence what results are
* returned. This does not restrict results to the specified region.
* @type {string|undefined}
*/
google.maps.places.AutocompleteRequest.prototype.region;
/**
* A token which identifies an Autocomplete session for billing purposes.
* Generate a new session token via {@link
* google.maps.places.AutocompleteSessionToken}.
The session begins
* when the user starts typing a query, and concludes when they select a place
* and call {@link google.maps.places.Place.fetchFields}. Each session can have
* multiple queries, followed by one fetchFields call. The
* credentials used for each request within a session must belong to the same
* Google Cloud Console project. Once a session has concluded, the token is no
* longer valid; your app must generate a fresh token for each session. If the
* sessionToken parameter is omitted, or if you reuse a session
* token, the session is charged as if no session token was provided (each
* request is billed separately).
When a session token is provided in
* the request to {@link
* google.maps.places.AutocompleteSuggestion.fetchAutocompleteSuggestions}, the
* same token will automatically be included in the first call to fetchFields on
* a {@link google.maps.places.Place} returned by calling {@link
* google.maps.places.PlacePrediction.toPlace} on one of the resulting {@link
* google.maps.places.AutocompleteSuggestion}s.
We recommend the
* following guidelines:
* @type {!google.maps.places.AutocompleteSessionToken|undefined}
*/
google.maps.places.AutocompleteRequest.prototype.sessionToken;
/**
* An Autocomplete response returned by the call to {@link
* google.maps.places.AutocompleteService.getPlacePredictions} containing a list
* of {@link google.maps.places.AutocompletePrediction}s.
* @record
*/
google.maps.places.AutocompleteResponse = function() {};
/**
* The list of {@link google.maps.places.AutocompletePrediction}s.
* @type {!Array}
*/
google.maps.places.AutocompleteResponse.prototype.predictions;
/**
* Contains methods related to retrieving Autocomplete predictions.
*
* Access by calling `const {AutocompleteService} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
* @deprecated As of March 1st, 2025, google.maps.places.AutocompleteService is
* not available to new customers. Please use {@link
* google.maps.places.AutocompleteSuggestion} instead. At this time,
* google.maps.places.AutocompleteService is not scheduled to be
* discontinued, but {@link google.maps.places.AutocompleteSuggestion} is
* recommended over google.maps.places.AutocompleteService. While
* google.maps.places.AutocompleteService will continue to receive bug fixes
* for any major regressions, existing bugs in
* google.maps.places.AutocompleteService will not be addressed. At least 12
* months notice will be given before support is discontinued. Please see https://developers.google.com/maps/legacy
* for additional details and https://developers.google.com/maps/documentation/javascript/places-migration-overview
* for the migration guide.
*/
google.maps.places.AutocompleteService = function() {};
/**
* Retrieves place autocomplete predictions based on the supplied autocomplete
* request.
* @param {!google.maps.places.AutocompletionRequest} request The autocompletion
* request.
* @param {(function(?Array,
* !google.maps.places.PlacesServiceStatus): void)=} callback A callback
* accepting an array of AutocompletePrediction objects and a
* PlacesServiceStatus value as argument.
* @return {!Promise}
*/
google.maps.places.AutocompleteService.prototype.getPlacePredictions = function(
request, callback) {};
/**
* Retrieves query autocomplete predictions based on the supplied query
* autocomplete request.
* @param {!google.maps.places.QueryAutocompletionRequest} request The query
* autocompletion request.
* @param {function(?Array,
* !google.maps.places.PlacesServiceStatus): void} callback A callback
* accepting an array of QueryAutocompletePrediction objects and a
* PlacesServiceStatus value as argument.
* @return {undefined}
*/
google.maps.places.AutocompleteService.prototype.getQueryPredictions = function(
request, callback) {};
/**
* Represents a session token used for tracking an autocomplete session.
*
* Access by calling `const {AutocompleteSessionToken} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.AutocompleteSessionToken = function() {};
/**
* An Autocomplete suggestion result.
*
* Access by calling `const {AutocompleteSuggestion} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.AutocompleteSuggestion = function() {};
/**
* Contains the human-readable name for the returned result. For establishment
* results, this is usually the business name and address.
If
* a {@link google.maps.places.AutocompleteRequest.sessionToken} was provided in
* the AutocompleteRequest used to fetch this AutocompleteSuggestion, the same
* token will automatically be included when calling {@link
* google.maps.places.Place.fetchFields} for the first time on the {@link
* google.maps.places.Place} returned by a call to {@link
* google.maps.places.PlacePrediction.toPlace}.
* @type {!google.maps.places.PlacePrediction|null}
*/
google.maps.places.AutocompleteSuggestion.prototype.placePrediction;
/**
* Fetches a list of AutocompleteSuggestions.
If a {@link
* google.maps.places.AutocompleteRequest.sessionToken} is provided in the
* request, then that session token will automatically be included when
* calling {@link google.maps.places.Place.fetchFields} for the first time, on
* each {@link google.maps.places.Place} returned by {@link
* google.maps.places.PlacePrediction.toPlace} on the resulting {@link
* google.maps.places.PlacePrediction}s.
* @param {!google.maps.places.AutocompleteRequest} autocompleteRequest
* @return {!Promise}>}
*/
google.maps.places.AutocompleteSuggestion.fetchAutocompleteSuggestions =
function(autocompleteRequest) {};
/**
* An Autocompletion request to be sent to {@link
* google.maps.places.AutocompleteService.getPlacePredictions}.
* @record
*/
google.maps.places.AutocompletionRequest = function() {};
/**
* The component restrictions. Component restrictions are used to restrict
* predictions to only those within the parent component. For example, the
* country.
* @type {!google.maps.places.ComponentRestrictions|undefined}
*/
google.maps.places.AutocompletionRequest.prototype.componentRestrictions;
/**
* The user entered input string.
* @type {string}
*/
google.maps.places.AutocompletionRequest.prototype.input;
/**
* A language identifier for the language in which the results should be
* returned, if possible. Results in the selected language may be given a higher
* ranking, but suggestions are not restricted to this language. See the list of
* supported languages.
* @type {string|null|undefined}
*/
google.maps.places.AutocompletionRequest.prototype.language;
/**
* A soft boundary or hint to use when searching for places.
* @type {!google.maps.places.LocationBias|null|undefined}
*/
google.maps.places.AutocompletionRequest.prototype.locationBias;
/**
* Bounds to constrain search results.
* @type {!google.maps.places.LocationRestriction|null|undefined}
*/
google.maps.places.AutocompletionRequest.prototype.locationRestriction;
/**
* The character position in the input term at which the service uses text for
* predictions (the position of the cursor in the input field).
* @type {number|undefined}
*/
google.maps.places.AutocompletionRequest.prototype.offset;
/**
* The location where {@link
* google.maps.places.AutocompletePrediction.distance_meters} is calculated
* from.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|undefined}
*/
google.maps.places.AutocompletionRequest.prototype.origin;
/**
* A region code which is used for result formatting and for result filtering.
* It does not restrict the suggestions to this country. The region code accepts
* a ccTLD
* ("top-level domain") two-character value. Most ccTLD codes are
* identical to ISO 3166-1 codes, with some notable exceptions. For example, the
* United Kingdom's ccTLD is "uk" (.co.uk) while its
* ISO 3166-1 code is "gb" (technically for the entity of "The
* United Kingdom of Great Britain and Northern Ireland").
* @type {string|null|undefined}
*/
google.maps.places.AutocompletionRequest.prototype.region;
/**
* Unique reference used to bundle individual requests into sessions.
* @type {!google.maps.places.AutocompleteSessionToken|undefined}
*/
google.maps.places.AutocompletionRequest.prototype.sessionToken;
/**
* The types of predictions to be returned. For supported types, see the
* developer's guide. If no types are specified, all types will be
* returned.
* @type {!Arraybounds. Both location and
* radius will be ignored if bounds is set.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|undefined}
* @deprecated bounds is deprecated as of May 2023. Use {@link
* google.maps.places.AutocompletionRequest.locationBias} and {@link
* google.maps.places.AutocompletionRequest.locationRestriction} instead.
*/
google.maps.places.AutocompletionRequest.prototype.bounds;
/**
* Location for prediction biasing. Predictions will be biased towards the given
* location and radius. Alternatively,
* bounds can be used.
* @type {!google.maps.LatLng|undefined}
* @deprecated location is deprecated as of May 2023. Use {@link
* google.maps.places.AutocompletionRequest.locationBias} and {@link
* google.maps.places.AutocompletionRequest.locationRestriction} instead.
*/
google.maps.places.AutocompletionRequest.prototype.location;
/**
* The radius of the area used for prediction biasing. The radius
* is specified in meters, and must always be accompanied by a
* location property. Alternatively, bounds can be
* used.
* @type {number|undefined}
* @deprecated radius is deprecated as of May 2023. Use {@link
* google.maps.places.AutocompletionRequest.locationBias} and {@link
* google.maps.places.AutocompletionRequest.locationRestriction} instead.
*/
google.maps.places.AutocompletionRequest.prototype.radius;
/**
* BasicPlaceAutocompleteElement is an HTMLElement subclass which
* provides a UI component for the Places Autocomplete API.
*
* Access by calling `const {BasicPlaceAutocompleteElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.BasicPlaceAutocompleteElementOptions} options
* @implements {google.maps.places.BasicPlaceAutocompleteElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.BasicPlaceAutocompleteElement = function(options) {};
/**
* Included primary Place
* type (for example, "restaurant" or "gas_station").
*
A Place is only returned if its primary type is included in this
* list. Up to 5 values can be specified. If no types are specified, all Place
* types are returned.
* @type {!ArraylocationRestriction and includedRegionCodes
* are set, the results will be located in the area of intersection.
* @type {!Array.co.uk) while its
* ISO 3166-1 code is "gb" (technically for the entity of "The
* United Kingdom of Great Britain and Northern Ireland").
* @type {string|null}
*/
google.maps.places.BasicPlaceAutocompleteElement.prototype.requestedRegion;
/**
* The unit system used to display distances. If not specified, the unit system
* is determined by requestedRegion.
* @type {!google.maps.UnitSystem|null|undefined}
*/
google.maps.places.BasicPlaceAutocompleteElement.prototype.unitSystem;
/**
* Options for constructing a BasicPlaceAutocompleteElement.
* @record
*/
google.maps.places.BasicPlaceAutocompleteElementOptions = function() {};
/**
* @type {!Array'OPERATIONAL' or
* google.maps.places.BusinessStatus.OPERATIONAL).
*
* Access by calling `const {BusinessStatus} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.BusinessStatus = {
/**
* The business is closed permanently.
*/
CLOSED_PERMANENTLY: 'CLOSED_PERMANENTLY',
/**
* The business is closed temporarily.
*/
CLOSED_TEMPORARILY: 'CLOSED_TEMPORARILY',
/**
* The business is operating normally.
*/
OPERATIONAL: 'OPERATIONAL',
};
/**
* Defines the component restrictions that can be used with the autocomplete
* service.
* @record
*/
google.maps.places.ComponentRestrictions = function() {};
/**
* Restricts predictions to the specified country (ISO 3166-1 Alpha-2 country
* code, case insensitive). For example, 'us', 'br',
* or 'au'. You can provide a single one, or an array of up to five
* country code strings.
* @type {string|!ArraylanguageCode field.
*
* Access by calling `const {ConsumerAlert} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.ConsumerAlert = function() {};
/**
* The details of the consumer alert message.
* @type {!google.maps.places.ConsumerAlertDetails|null}
*/
google.maps.places.ConsumerAlert.prototype.details;
/**
* The language code of the consumer alert message.
* @type {string|null}
*/
google.maps.places.ConsumerAlert.prototype.languageCode;
/**
* The overview of the consumer alert message.
* @type {string|null}
*/
google.maps.places.ConsumerAlert.prototype.overview;
/**
* Details of the consumer alert message.
*
* Access by calling `const {ConsumerAlertDetails} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.ConsumerAlertDetails = function() {};
/**
* The title to show for a link to provide more information.
* @type {string|null}
*/
google.maps.places.ConsumerAlertDetails.prototype.aboutLinkTitle;
/**
* The URI for a link to provide more information.
* @type {string|null}
*/
google.maps.places.ConsumerAlertDetails.prototype.aboutLinkURI;
/**
* The description of the consumer alert message.
* @type {string|null}
*/
google.maps.places.ConsumerAlertDetails.prototype.description;
/**
* The title to show together with the detailed description.
* @type {string|null}
*/
google.maps.places.ConsumerAlertDetails.prototype.title;
/**
* Information about the EV charging station hosted in the place.
*
* Access by calling `const {EVChargeOptions} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.EVChargeOptions = function() {};
/**
* A list of EV charging connector aggregations that contain connectors of the
* same type and same charge rate.
* @type {!Array}
*/
google.maps.places.EVChargeOptions.prototype.connectorAggregations;
/**
* Number of connectors at this station. Because some ports can have multiple
* connectors but only be able to charge one car at a time, the number of
* connectors may be greater than the total number of cars which can charge
* simultaneously.
* @type {number}
*/
google.maps.places.EVChargeOptions.prototype.connectorCount;
/**
* EV charging connector types.
*
* Access by calling `const {EVConnectorType} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.EVConnectorType = {
/**
* Combined Charging System (AC and DC). Based on SAE Type-1 J-1772 connector.
*/
CCS_COMBO_1: 'CCS_COMBO_1',
/**
* Combined Charging System (AC and DC). Based on Type-2 Mennekes connector.
*/
CCS_COMBO_2: 'CCS_COMBO_2',
/**
* CHAdeMO type connector.
*/
CHADEMO: 'CHADEMO',
/**
* J1772 type 1 connector.
*/
J1772: 'J1772',
/**
* The North American Charging System (NACS), standardized as SAE J3400.
*/
NACS: 'NACS',
/**
* Other connector types.
*/
OTHER: 'OTHER',
/**
* The generic TESLA connector. This is NACS in the North America but can be
* non-NACS in other parts of the world (e.g. CCS Combo 2 (CCS2) or GB/T).
* This value is less representative of an actual connector type, and more
* represents the ability to charge a Tesla brand vehicle at a Tesla owned
* charging station.
*/
TESLA: 'TESLA',
/**
* IEC 62196 type 2 connector. Often referred to as MENNEKES.
*/
TYPE_2: 'TYPE_2',
/**
* GB/T type corresponds to the GB/T standard in China. This type covers all
* GB_T types.
*/
UNSPECIFIED_GB_T: 'UNSPECIFIED_GB_T',
/**
* Unspecified wall outlet.
*/
UNSPECIFIED_WALL_OUTLET: 'UNSPECIFIED_WALL_OUTLET',
};
/**
* EV-related options that can be specified for a place search request.
* @record
*/
google.maps.places.EVSearchOptions = function() {};
/**
* The list of preferred EV connector types. A place that does not support any
* of the listed connector types is filtered out.
* @type {!Array|undefined}
*/
google.maps.places.EVSearchOptions.prototype.connectorTypes;
/**
* Minimum required charging rate in kilowatts. A place with a charging rate
* less than the specified rate is filtered out.
* @type {number|undefined}
*/
google.maps.places.EVSearchOptions.prototype.minimumChargingRateKw;
/**
* Options for fetching Place fields.
* @record
*/
google.maps.places.FetchFieldsRequest = function() {};
/**
* List of fields to be fetched.
* @type {!Array['ALL'] is passed in, all
* available fields will be returned and billed for (this is not recommended for
* production deployments). For a list of fields see {@link
* google.maps.places.PlaceResult}. Nested fields can be specified with
* dot-paths (for example, "geometry.location").
* @type {!Array['ALL'] is passed in, all
* available fields will be returned and billed for (this is not recommended for
* production deployments). For a list of fields see {@link
* google.maps.places.PlaceResult}. Nested fields can be specified with
* dot-paths (for example, "geometry.location").
* @type {!Arraytext. The substrings may not be exact matches
* of {@link google.maps.places.AutocompleteRequest.input} if the matching was
* determined by criteria other than string matching (for example, spell
* corrections or transliterations). These values are Unicode character offsets
* of {@link google.maps.places.FormattableText.text}. The ranges are guaranteed
* to be ordered in increasing offset values.
* @type {!Array}
*/
google.maps.places.FormattableText.prototype.matches;
/**
* Text that may be used as is or formatted with {@link
* google.maps.places.FormattableText.matches}.
* @type {string}
*/
google.maps.places.FormattableText.prototype.text;
/**
* The most recent information about fuel options in a gas station. This
* information is updated regularly.
*
* Access by calling `const {FuelOptions} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.FuelOptions = function() {};
/**
* A list of fuel prices for each type of fuel this station has, one entry per
* fuel type.
* @type {!Array}
*/
google.maps.places.FuelOptions.prototype.fuelPrices;
/**
* Fuel price information for a given type of fuel.
*
* Access by calling `const {FuelPrice} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.FuelPrice = function() {};
/**
* The price of the fuel.
* @type {!google.maps.places.Money|null}
*/
google.maps.places.FuelPrice.prototype.price;
/**
* The type of fuel.
* @type {!google.maps.places.FuelType|null}
*/
google.maps.places.FuelPrice.prototype.type;
/**
* The time the fuel price was last updated.
* @type {!Date|null}
*/
google.maps.places.FuelPrice.prototype.updateTime;
/**
* Types of fuel.
*
* Access by calling `const {FuelType} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.FuelType = {
/**
* Bio-diesel.
*/
BIO_DIESEL: 'BIO_DIESEL',
/**
* Diesel fuel.
*/
DIESEL: 'DIESEL',
/**
* Diesel plus fuel.
*/
DIESEL_PLUS: 'DIESEL_PLUS',
/**
* E 100.
*/
E100: 'E100',
/**
* E 80.
*/
E80: 'E80',
/**
* E 85.
*/
E85: 'E85',
/**
* LPG.
*/
LPG: 'LPG',
/**
* Methane.
*/
METHANE: 'METHANE',
/**
* Midgrade.
*/
MIDGRADE: 'MIDGRADE',
/**
* Premium.
*/
PREMIUM: 'PREMIUM',
/**
* Regular unleaded.
*/
REGULAR_UNLEADED: 'REGULAR_UNLEADED',
/**
* SP 100.
*/
SP100: 'SP100',
/**
* SP 91.
*/
SP91: 'SP91',
/**
* SP 91 E10.
*/
SP91_E10: 'SP91_E10',
/**
* SP 92.
*/
SP92: 'SP92',
/**
* SP 95.
*/
SP95: 'SP95',
/**
* SP95 E10.
*/
SP95_E10: 'SP95_E10',
/**
* SP 98.
*/
SP98: 'SP98',
/**
* SP 99.
*/
SP99: 'SP99',
/**
* Truck diesel.
*/
TRUCK_DIESEL: 'TRUCK_DIESEL',
};
/**
* Links to trigger different Google Maps actions.
*
* Access by calling `const {GoogleMapsLinks} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.GoogleMapsLinks = function() {};
/**
* A link to show the directions to the place on Google Maps. The link only
* populates the destination location and uses the default travel mode
* DRIVE.
* @type {string|null}
*/
google.maps.places.GoogleMapsLinks.prototype.directionsURI;
/**
* A link to show the photos for the place on Google Maps.
* @type {string|null}
*/
google.maps.places.GoogleMapsLinks.prototype.photosURI;
/**
* A link to show the place on Google Maps.
* @type {string|null}
*/
google.maps.places.GoogleMapsLinks.prototype.placeURI;
/**
* A link to show the reviews for the place on Google Maps.
* @type {string|null}
*/
google.maps.places.GoogleMapsLinks.prototype.reviewsURI;
/**
* A link to write a review for the place on Google Maps.
* @type {string|null}
*/
google.maps.places.GoogleMapsLinks.prototype.writeAReviewURI;
/**
* @typedef {!google.maps.LatLng|!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|!google.maps.Circle|!google.maps.CircleLiteral|string}
*/
google.maps.places.LocationBias;
/**
* @typedef {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral}
*/
google.maps.places.LocationRestriction;
/**
* The preferred media size in cases where multiple sizes are supported, such as
* the vertical {@link google.maps.places.PlaceSearchElement}.
*
* Access by calling `const {MediaSize} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.MediaSize = {
/**
* Large media size.
*/
LARGE: 'LARGE',
/**
* Medium media size.
*/
MEDIUM: 'MEDIUM',
/**
* Small media size.
*/
SMALL: 'SMALL',
};
/**
* A representation of an amount of money with its currency type.
*
* Access by calling `const {Money} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.Money = function() {};
/**
* The three-letter currency code, defined in ISO 4217.
* @type {string}
*/
google.maps.places.Money.prototype.currencyCode;
/**
* Number of nano (10^-9) units of the amount.
* @type {number}
*/
google.maps.places.Money.prototype.nanos;
/**
* The whole units of the amount. For example, if {@link
* google.maps.places.Money.currencyCode} is "USD", then 1 unit is 1
* US dollar.
* @type {number}
*/
google.maps.places.Money.prototype.units;
/**
* Returns a human-readable representation of the amount of money with its
* currency symbol.
* @return {string}
*/
google.maps.places.Money.prototype.toString = function() {};
/**
* Information about business hours of a Place.
*
* Access by calling `const {OpeningHours} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.OpeningHours = function() {};
/**
* Opening periods covering each day of the week, starting from Sunday, in
* chronological order. Does not include days where the Place is not open.
* @type {!Array}
*/
google.maps.places.OpeningHours.prototype.periods;
/**
* An array of seven strings representing the formatted opening hours for each
* day of the week. The Places Service will format and localize the opening
* hours appropriately for the current language. The ordering of the elements in
* this array depends on the language. Some languages start the week on Monday,
* while others start on Sunday.
* @type {!Arrayundefined if the
* accessibility options data have not been called for from the server.
* @type {!google.maps.places.AccessibilityOptions|null|undefined}
*/
google.maps.places.Place.prototype.accessibilityOptions;
/**
* The collection of address components for this Place’s location. Empty object
* if there is no known address data. undefined if the address data
* has not been called for from the server.
* @type {!Array|undefined}
*/
google.maps.places.Place.prototype.addressComponents;
/**
* The representation of the Place’s address in the adr microformat.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.adrFormatAddress;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.allowsDogs;
/**
* Data providers that must be shown for the Place.
* @type {!Array|undefined}
*/
google.maps.places.Place.prototype.attributions;
/**
* The location's operational status. null if there is no known
* status. undefined if the status data has not been loaded from
* the server.
* @type {!google.maps.places.BusinessStatus|null|undefined}
*/
google.maps.places.Place.prototype.businessStatus;
/**
* The consumer alert for this place.
* @type {!google.maps.places.ConsumerAlert|null|undefined}
*/
google.maps.places.Place.prototype.consumerAlert;
/**
* The location's display name. null if there is no name.
* undefined if the name data has not been loaded from the server.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.displayName;
/**
* The language of the location's display name. null if there
* is no name. undefined if the name data has not been loaded from
* the server.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.displayNameLanguageCode;
/**
* The editorial summary for this place. null if there is no
* editorial summary. undefined if this field has not yet been
* requested.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.editorialSummary;
/**
* The language of the editorial summary for this place. null if
* there is no editorial summary. undefined if this field has not
* yet been requested.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.editorialSummaryLanguageCode;
/**
* EV Charge options provided by the place. undefined if the EV
* charge options have not been called for from the server.
* @type {!google.maps.places.EVChargeOptions|null|undefined}
*/
google.maps.places.Place.prototype.evChargeOptions;
/**
* The locations’s full address.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.formattedAddress;
/**
* Fuel options provided by the place. undefined if the fuel
* options have not been called for from the server.
* @type {!google.maps.places.FuelOptions|null|undefined}
*/
google.maps.places.Place.prototype.fuelOptions;
/**
* Links to trigger different Google Maps actions.
* @type {!google.maps.places.GoogleMapsLinks|null|undefined}
*/
google.maps.places.Place.prototype.googleMapsLinks;
/**
* URL of the official Google page for this place. This is the Google-owned page
* that contains the best available information about the Place.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.googleMapsURI;
/**
* Whether a place has curbside pickup. Returns 'true' or
* 'false' if the value is known. Returns 'null' if the value is
* unknown. Returns 'undefined' if this field has not yet been
* requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.hasCurbsidePickup;
/**
* Whether a place has delivery. Returns 'true' or 'false' if
* the value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.hasDelivery;
/**
* Whether a place has dine in. Returns 'true' or 'false' if the
* value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.hasDineIn;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.hasLiveMusic;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.hasMenuForChildren;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.hasOutdoorSeating;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.hasRestroom;
/**
* Whether a place has takeout. Returns 'true' or 'false' if the
* value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.hasTakeout;
/**
* The default HEX color code for the place's category.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.iconBackgroundColor;
/**
* The unique place id.
* @type {string}
*/
google.maps.places.Place.prototype.id;
/**
* The Place’s phone number in international format. International format
* includes the country code, and is prefixed with the plus (+) sign.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.internationalPhoneNumber;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.isGoodForChildren;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.isGoodForGroups;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.isGoodForWatchingSports;
/**
* Whether a place is reservable. Returns 'true' or 'false' if
* the value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.isReservable;
/**
* The Place’s position.
* @type {!google.maps.LatLng|null|undefined}
*/
google.maps.places.Place.prototype.location;
/**
* The Place’s phone number, formatted according to the number's
* regional convention.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.nationalPhoneNumber;
/**
* Options of parking provided by the place. undefined if the
* parking options data have not been called for from the server.
* @type {!google.maps.places.ParkingOptions|null|undefined}
*/
google.maps.places.Place.prototype.parkingOptions;
/**
* Payment options provided by the place. undefined if the payment
* options data have not been called for from the server.
* @type {!google.maps.places.PaymentOptions|null|undefined}
*/
google.maps.places.Place.prototype.paymentOptions;
/**
* Photos of this Place. The collection will contain up to ten {@link
* google.maps.places.Photo} objects.
* @type {!Array|undefined}
*/
google.maps.places.Place.prototype.photos;
/**
* @type {!google.maps.places.PlusCode|null|undefined}
*/
google.maps.places.Place.prototype.plusCode;
/**
* @type {!google.maps.places.PostalAddress|null|undefined}
*/
google.maps.places.Place.prototype.postalAddress;
/**
* The price level of the Place. This property can return any of the following
* values
* @type {!google.maps.places.PriceLevel|null|undefined}
*/
google.maps.places.Place.prototype.priceLevel;
/**
* The price range for this Place. FreeInexpensiveModerateExpensiveVery ExpensiveendPrice could be unset, which
* indicates a range without upper bound (e.g. "More than $100").
* @type {!google.maps.places.PriceRange|null|undefined}
*/
google.maps.places.Place.prototype.priceRange;
/**
* The location's primary type. null if there is no type.
* undefined if the type data has not been loaded from the server.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.primaryType;
/**
* The location's primary type display name. null if there is
* no type. undefined if the type data has not been loaded from the
* server.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.primaryTypeDisplayName;
/**
* The language of the location's primary type display name.
* null if there is no type. undefined if the type
* data has not been loaded from the server.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.primaryTypeDisplayNameLanguageCode;
/**
* A rating, between 1.0 to 5.0, based on user reviews of this Place.
* @type {number|null|undefined}
*/
google.maps.places.Place.prototype.rating;
/**
* @type {!google.maps.places.OpeningHours|null|undefined}
*/
google.maps.places.Place.prototype.regularOpeningHours;
/**
* The requested language for this place.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.requestedLanguage;
/**
* The requested region for this place.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.requestedRegion;
/**
* A list of reviews for this Place.
* @type {!Array|undefined}
*/
google.maps.places.Place.prototype.reviews;
/**
* Whether a place serves beer. Returns 'true' or 'false' if the
* value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesBeer;
/**
* Whether a place serves breakfast. Returns 'true' or 'false'
* if the value is known. Returns 'null' if the value is unknown.
* Returns 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesBreakfast;
/**
* Whether a place serves brunch. Returns 'true' or 'false' if
* the value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesBrunch;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesCocktails;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesCoffee;
/**
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesDessert;
/**
* Whether a place serves dinner. Returns 'true' or 'false' if
* the value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesDinner;
/**
* Whether a place serves lunch. Returns 'true' or 'false' if
* the value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesLunch;
/**
* Whether a place serves vegetarian food. Returns 'true' or
* 'false' if the value is known. Returns 'null' if the value is
* unknown. Returns 'undefined' if this field has not yet been
* requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesVegetarianFood;
/**
* Whether a place serves wine. Returns 'true' or 'false' if the
* value is known. Returns 'null' if the value is unknown. Returns
* 'undefined' if this field has not yet been requested.
* @type {boolean|null|undefined}
*/
google.maps.places.Place.prototype.servesWine;
/**
* URI to the svg image mask resource that can be used to represent a place’s
* category.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.svgIconMaskURI;
/**
* An array of types
* for this Place (for example, ["political",
* "locality"] or ["restaurant",
* "establishment"]).
* @type {!Arrayutc_offset_minutes will be
* 660. For timezones behind UTC, the offset is negative. For
* example, the utc_offset_minutes is -60 for Cape
* Verde.
* @type {number|null|undefined}
*/
google.maps.places.Place.prototype.utcOffsetMinutes;
/**
* The preferred viewport when displaying this Place on a map.
* @type {!google.maps.LatLngBounds|null|undefined}
*/
google.maps.places.Place.prototype.viewport;
/**
* The authoritative website for this Place, such as a business' homepage.
* @type {string|null|undefined}
*/
google.maps.places.Place.prototype.websiteURI;
/**
* @type {!google.maps.places.OpeningHours|null|undefined}
* @deprecated Use {@link google.maps.places.Place.regularOpeningHours} instead.
*/
google.maps.places.Place.prototype.openingHours;
/**
* @type {boolean|null|undefined}
* @deprecated This field was accidentally documented, but has never actually
* been populated.
*/
google.maps.places.Place.prototype.hasWiFi;
/**
* Text query based place search.
* @param {!google.maps.places.SearchByTextRequest} request
* @return {!Promise}>}
*/
google.maps.places.Place.searchByText = function(request) {};
/**
* Search for nearby places.
* @param {!google.maps.places.SearchNearbyRequest} request
* @return {!Promise}>}
*/
google.maps.places.Place.searchNearby = function(request) {};
/**
* @param {!google.maps.places.FetchFieldsRequest} options
* @return {!Promise}
*/
google.maps.places.Place.prototype.fetchFields = function(options) {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* Calculates the Date representing the next OpeningHoursTime. Returns undefined
* if the data is insufficient to calculate the result, or this place is not
* operational.
* @param {!Date=} date
* @return {!Promise}
*/
google.maps.places.Place.prototype.getNextOpeningTime = function(date) {};
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* Check if the place is open at the given datetime. Resolves with
* undefined if the known data for the location is insufficient to
* calculate this, e.g. if the opening hours are unregistered.
* @param {!Date=} date Defaults to now.
* @return {!Promise
*
* Access by calling `const {PlaceAccessibleEntranceIconElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceAccessibleEntranceIconElementOptions=}
* options
* @implements {google.maps.places.PlaceAccessibleEntranceIconElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceAccessibleEntranceIconElement = function(options) {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-accessible-entrance-icon></gmp-place-accessible-entrance-icon>
* </gmp-place-content-config>
PlaceAccessibleEntranceIconElement.
* @record
*/
google.maps.places.PlaceAccessibleEntranceIconElementOptions = function() {};
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement}, or {@link
* google.maps.places.PlaceSearchElement} to show a place's address. Append
* this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceAddressElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceAddressElementOptions=} options
* @implements {google.maps.places.PlaceAddressElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceAddressElement = function(options) {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-address></gmp-place-address>
* </gmp-place-content-config>
PlaceAddressElement.
* @record
*/
google.maps.places.PlaceAddressElementOptions = function() {};
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement}, or {@link
* google.maps.places.PlaceSearchElement} to show all available content. Append
* this element as a child to use it. For example:
*
* Access by calling `const {PlaceAllContentElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceAllContentElementOptions=} options
* @implements {google.maps.places.PlaceAllContentElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceAllContentElement = function(options) {};
/**
* Options for
* <gmp-place-details>
* <gmp-place-all-content></gmp-place-all-content>
* </gmp-place-details>
PlaceAllContentElement.
* @record
*/
google.maps.places.PlaceAllContentElementOptions = function() {};
/**
* Defines information about an aspect of the place that users have reviewed.
* @record
* @deprecated This interface is no longer used.
*/
google.maps.places.PlaceAspectRating = function() {};
/**
* The rating of this aspect. For individual reviews this is an integer from 0
* to 3. For aggregated ratings of a place this is an integer from 0 to 30.
* @type {number}
*/
google.maps.places.PlaceAspectRating.prototype.rating;
/**
* The aspect type. For example, "food", "decor",
* "service", or "overall".
* @type {string}
*/
google.maps.places.PlaceAspectRating.prototype.type;
/**
* Allows customization of the Google Maps attribution text in a {@link
* google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement}, or {@link
* google.maps.places.PlaceSearchElement}. Append this element as a child of
* a {@link google.maps.places.PlaceContentConfigElement} to use it. If this
* element is omitted, attribution will still be shown with default colors. For
* example:
*
* Access by calling `const {PlaceAttributionElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceAttributionElementOptions=} options
* @implements {google.maps.places.PlaceAttributionElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceAttributionElement = function(options) {};
/**
* The color of the Google Maps attribution in dark mode.
* @default <gmp-place-content-config>
* <gmp-place-attribution
* light-scheme-color="black"
* dark-scheme-color="white"
* ></gmp-place-attribution>
* </gmp-place-content-config>
AttributionColor.WHITE
* @type {!google.maps.places.AttributionColor|null|undefined}
*/
google.maps.places.PlaceAttributionElement.prototype.darkSchemeColor;
/**
* The color of the Google Maps attribution in light mode.
* @default AttributionColor.GRAY
* @type {!google.maps.places.AttributionColor|null|undefined}
*/
google.maps.places.PlaceAttributionElement.prototype.lightSchemeColor;
/**
* Options for PlaceAttributionElement.
* @record
*/
google.maps.places.PlaceAttributionElementOptions = function() {};
/**
* See {@link google.maps.places.PlaceAttributionElement.darkSchemeColor}.
* @type {!google.maps.places.AttributionColor|null|undefined}
*/
google.maps.places.PlaceAttributionElementOptions.prototype.darkSchemeColor;
/**
* See {@link google.maps.places.PlaceAttributionElement.lightSchemeColor}.
* @type {!google.maps.places.AttributionColor|null|undefined}
*/
google.maps.places.PlaceAttributionElementOptions.prototype.lightSchemeColor;
/**
* PlaceAutocompleteElement is an HTMLElement subclass which
* provides a UI component for the Places Autocomplete API.
* PlaceAutocompleteElement automatically uses {@link
* google.maps.places.AutocompleteSessionToken}s internally to group the query
* and selection phases of a user's autocomplete search.
The
* first call to {@link google.maps.places.Place.fetchFields} on a {@link
* google.maps.places.Place} returned by {@link
* google.maps.places.PlacePrediction.toPlace} will automatically include the
* session token used to fetch the PlacePrediction.
See
* https://developers.google.com/maps/documentation/places/web-service/place-session-tokens
* for more details on how sessions work.
*
* Access by calling `const {PlaceAutocompleteElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceAutocompleteElementOptions} options
* @implements {google.maps.places.PlaceAutocompleteElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceAutocompleteElement = function(options) {};
/**
* Included primary Place
* type (for example, "restaurant" or "gas_station").
*
A Place is only returned if its primary type is included in this
* list. Up to 5 values can be specified. If no types are specified, all Place
* types are returned.
* @type {!ArraylocationRestriction and includedRegionCodes
* are set, the results will be located in the area of intersection.
* @type {!Array.co.uk) while its
* ISO 3166-1 code is "gb" (technically for the entity of "The
* United Kingdom of Great Britain and Northern Ireland").
* @type {string|null}
*/
google.maps.places.PlaceAutocompleteElement.prototype.requestedRegion;
/**
* The unit system used to display distances. If not specified, the unit system
* is determined by requestedRegion.
* @type {!google.maps.UnitSystem|null|undefined}
*/
google.maps.places.PlaceAutocompleteElement.prototype.unitSystem;
/**
* Options for constructing a PlaceAutocompleteElement. For the description of
* each property, refer to the property of the same name in the
* PlaceAutocompleteElement class.
* @record
*/
google.maps.places.PlaceAutocompleteElementOptions = function() {};
/**
* @type {!Array
For {@link
* google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement} or {@link
* google.maps.places.PlaceSearchElement}, append any of the following elements
* to the {@link google.maps.places.PlaceContentConfigElement} to show the
* corresponding content:
{@link
* google.maps.places.PlaceAddressElement}, {@link
* google.maps.places.PlaceAccessibleEntranceIconElement}, {@link
* google.maps.places.PlaceAttributionElement} {@link
* google.maps.places.PlaceMediaElement}, {@link
* google.maps.places.PlaceOpenNowStatusElement}, {@link
* google.maps.places.PlacePriceElement}, {@link
* google.maps.places.PlaceRatingElement}, {@link
* google.maps.places.PlaceTypeElement}.
Specific to {@link
* google.maps.places.PlaceDetailsElement}, you may also append any of the
* following elements:
{@link
* google.maps.places.PlaceFeatureListElement} {@link
* google.maps.places.PlaceOpeningHoursElement}, {@link
* google.maps.places.PlacePhoneNumberElement}, {@link
* google.maps.places.PlacePlusCodeElement}, {@link
* google.maps.places.PlaceReviewsElement}, {@link
* google.maps.places.PlaceSummaryElement}, {@link
* google.maps.places.PlaceTypeSpecificHighlightsElement}, {@link
* google.maps.places.PlaceWebsiteElement}.
The order of the children
* does not matter; the element renders content in a standard order which is not
* customizable. Example:
*
* Access by calling `const {PlaceContentConfigElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceContentConfigElementOptions=} options
* @implements {google.maps.places.PlaceContentConfigElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceContentConfigElement = function(options) {};
/**
* Options for <gmp-place-details>
* <gmp-place-content-config>
* <gmp-place-media
* lightbox-preferred></gmp-place-media>
* <gmp-place-address></gmp-place-address>
* </gmp-place-content-config>
</gmp-place-details>
* PlaceContentConfigElement.
* @record
*/
google.maps.places.PlaceContentConfigElementOptions = function() {};
/**
* Available only in the v=alpha channel: https://goo.gle/js-alpha-channel.
*
* A widget that uses the context token to display a contextual view of the
* Grounding with Google Maps response.
*
* Access by calling `const {PlaceContextualElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceContextualElementOptions=} options
* @implements {google.maps.places.PlaceContextualElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceContextualElement = function(options) {};
/**
* The context token.
* @type {string|null|undefined}
*/
google.maps.places.PlaceContextualElement.prototype.contextToken;
/**
* Available only in the v=alpha channel: https://goo.gle/js-alpha-channel.
*
* Options for PlaceContextualElement.
* @record
*/
google.maps.places.PlaceContextualElementOptions = function() {};
/**
* The context token provided by the Grounding with Google Maps response.
* @type {string|null|undefined}
*/
google.maps.places.PlaceContextualElementOptions.prototype.contextToken;
/**
* Available only in the v=alpha channel: https://goo.gle/js-alpha-channel.
*
* An HTML element that configures options for the Place Contextual
* Element's list view.
*
* Access by calling `const {PlaceContextualListConfigElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceContextualListConfigElementOptions=} options
* @implements {google.maps.places.PlaceContextualListConfigElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceContextualListConfigElement = function(options) {};
/**
* The layout.
* @type {!google.maps.places.PlaceContextualListLayout|null|undefined}
*/
google.maps.places.PlaceContextualListConfigElement.prototype.layout;
/**
* Whether the map is hidden.
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceContextualListConfigElement.prototype.mapHidden;
/**
* Available only in the v=alpha channel: https://goo.gle/js-alpha-channel.
*
* Options for PlaceContextualListConfigElement.
* @record
*/
google.maps.places.PlaceContextualListConfigElementOptions = function() {};
/**
* The layout.
* @default {@link google.maps.places.PlaceContextualListLayout.VERTICAL}
* @type {!google.maps.places.PlaceContextualListLayout|null|undefined}
*/
google.maps.places.PlaceContextualListConfigElementOptions.prototype.layout;
/**
* True if the map should be hidden.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceContextualListConfigElementOptions.prototype.mapHidden;
/**
* Available only in the v=alpha channel: https://goo.gle/js-alpha-channel.
*
* The list of layouts that the Place Contextual Element supports for the list
* view.
*
* Access by calling `const {PlaceContextualListLayout} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.PlaceContextualListLayout = {
/**
* Compact list layout: list items are rendered as links across a single line,
* with overflows in a dropdown list.
*/
COMPACT: 'COMPACT',
/**
* Vertical list layout: list items are rendered as cards in a vertical list.
*/
VERTICAL: 'VERTICAL',
};
/**
* Displays details for a place in a compact layout. Append a {@link
* google.maps.places.PlaceDetailsPlaceRequestElement} or {@link
* google.maps.places.PlaceDetailsLocationRequestElement} to specify the place
* to be rendered. Append a {@link
* google.maps.places.PlaceContentConfigElement}, {@link
* google.maps.places.PlaceStandardContentElement}, or {@link
* google.maps.places.PlaceAllContentElement} to specify which content to
* render.
Example: <gmp-place-details-compact>
* <gmp-place-details-place-request
* place="PLACE_ID"
* ></gmp-place-details-place-request>
* <gmp-place-content-config>
* <gmp-place-media
* lightbox-preferred></gmp-place-media>
* </gmp-place-content-config>
* </gmp-place-details-compact>
To use this element,
* enable the Places UI Kit API for your project in the Google Cloud console.
*
* Access by calling `const {PlaceDetailsCompactElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceDetailsCompactElementOptions=} options
* @implements {google.maps.places.PlaceDetailsCompactElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceDetailsCompactElement = function(options) {};
/**
* The orientation variant (vertical or horizontal) of the element.
* @default PlaceDetailsOrientation.VERTICAL
* @type {!google.maps.places.PlaceDetailsOrientation|null|undefined}
*/
google.maps.places.PlaceDetailsCompactElement.prototype.orientation;
/**
* Read only. Place object containing the ID, location, and viewport of the
* currently rendered place.
* @type {!google.maps.places.Place|undefined}
*/
google.maps.places.PlaceDetailsCompactElement.prototype.place;
/**
* If true, truncates the place name and address to fit on one line instead of
* wrapping.
* @default false
* @type {boolean}
*/
google.maps.places.PlaceDetailsCompactElement.prototype.truncationPreferred;
/**
* Options for PlaceDetailsCompactElement.
* @record
*/
google.maps.places.PlaceDetailsCompactElementOptions = function() {};
/**
* See {@link google.maps.places.PlaceDetailsCompactElement.orientation}.
* @type {!google.maps.places.PlaceDetailsOrientation|null|undefined}
*/
google.maps.places.PlaceDetailsCompactElementOptions.prototype.orientation;
/**
* See {@link
* google.maps.places.PlaceDetailsCompactElement.truncationPreferred}.
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceDetailsCompactElementOptions.prototype
.truncationPreferred;
/**
* Displays details for a place in a full layout. Append either a {@link
* google.maps.places.PlaceDetailsPlaceRequestElement} or {@link
* google.maps.places.PlaceDetailsLocationRequestElement} to specify the place
* to be rendered. Append a {@link
* google.maps.places.PlaceContentConfigElement}, {@link
* google.maps.places.PlaceStandardContentElement}, or {@link
* google.maps.places.PlaceAllContentElement} to specify which content to
* render.
Example: <gmp-place-details>
* <gmp-place-details-place-request
* place="PLACE_ID"
* ></gmp-place-details-place-request>
* <gmp-place-content-config>
* <gmp-place-media
* lightbox-preferred></gmp-place-media>
* </gmp-place-content-config>
</gmp-place-details>
*
To use this element, enable the Places UI Kit API for your project in the Google Cloud console.
*
* Access by calling `const {PlaceDetailsElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceDetailsElementOptions=} options
* @implements {google.maps.places.PlaceDetailsElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceDetailsElement = function(options) {};
/**
* Read only. Place object containing the ID, location, and viewport of the
* currently rendered place.
* @type {!google.maps.places.Place|undefined}
*/
google.maps.places.PlaceDetailsElement.prototype.place;
/**
* Options for PlaceDetailsElement.
* @record
*/
google.maps.places.PlaceDetailsElementOptions = function() {};
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement} or {@link
* google.maps.places.PlaceDetailsElement} to load data based on a location.
* Append this element as a child of a {@link
* google.maps.places.PlaceDetailsCompactElement} or {@link
* google.maps.places.PlaceDetailsElement} to load data for the specified
* location. For example:
*
* Access by calling `const {PlaceDetailsLocationRequestElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceDetailsLocationRequestElementOptions=}
* options
* @implements {google.maps.places.PlaceDetailsLocationRequestElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceDetailsLocationRequestElement = function(options) {};
/**
* The location to render details for in the Place Details element. Normalizes
* to a <gmp-place-details>
* <gmp-place-details-location-request
* location="37.6207665,-122.4284806"
* ></gmp-place-details-location-request>
* </gmp-place-details> LatLngAltitude.
* @default null
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.places.PlaceDetailsLocationRequestElement.prototype.location;
/**
* Options for PlaceDetailsLocationRequestElement.
* @record
*/
google.maps.places.PlaceDetailsLocationRequestElementOptions = function() {};
/**
* The location to render the place for.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|!google.maps.LatLngAltitude|!google.maps.LatLngAltitudeLiteral|null|undefined}
*/
google.maps.places.PlaceDetailsLocationRequestElementOptions.prototype.location;
/**
* Orientation variants for {@link
* google.maps.places.PlaceDetailsCompactElement}.
*
* Access by calling `const {PlaceDetailsOrientation} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.PlaceDetailsOrientation = {
/**
* Horizontal orientation.
*/
HORIZONTAL: 'HORIZONTAL',
/**
* Vertical orientation.
*/
VERTICAL: 'VERTICAL',
};
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement} or {@link
* google.maps.places.PlaceDetailsElement} to load data based on a place object,
* ID, or resource name. Append this element as a child of a {@link
* google.maps.places.PlaceDetailsCompactElement} or {@link
* google.maps.places.PlaceDetailsElement} to load data for the specified place.
* For example:
*
* Access by calling `const {PlaceDetailsPlaceRequestElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceDetailsPlaceRequestElementOptions=} options
* @implements {google.maps.places.PlaceDetailsPlaceRequestElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceDetailsPlaceRequestElement = function(options) {};
/**
* The place object, ID, or resource name to render details for in the Place
* Details Compact element. This property reflects to the attribute as a
* resource name.
* @default <gmp-place-details>
* <gmp-place-details-place-request
* place="PLACE_ID"
* ></gmp-place-details-place-request>
* </gmp-place-details> null
* @type {!google.maps.places.Place|null}
*/
google.maps.places.PlaceDetailsPlaceRequestElement.prototype.place;
/**
* Options for PlaceDetailsPlaceRequestElement.
* @record
*/
google.maps.places.PlaceDetailsPlaceRequestElementOptions = function() {};
/**
* See {@link google.maps.places.PlaceDetailsPlaceRequestElement.place}
* @type {!google.maps.places.Place|string|null|undefined}
*/
google.maps.places.PlaceDetailsPlaceRequestElementOptions.prototype.place;
/**
* A Place details query to be sent to the PlacesService.
* @record
*/
google.maps.places.PlaceDetailsRequest = function() {};
/**
* Fields to be included in the details response, which
* will be billed for. If no fields are specified or
* ['ALL'] is passed in, all available fields will be
* returned and billed for (this is not recommended for production deployments).
* For a list of fields see {@link google.maps.places.PlaceResult}. Nested
* fields can be specified with dot-paths (for example,
* "geometry.location").
* @type {!Array.co.uk) while its
* ISO 3166-1 code is "gb" (technically for the entity of "The
* United Kingdom of Great Britain and Northern Ireland").
* @type {string|null|undefined}
*/
google.maps.places.PlaceDetailsRequest.prototype.region;
/**
* Unique reference used to bundle the details request with an autocomplete
* session.
* @type {!google.maps.places.AutocompleteSessionToken|undefined}
*/
google.maps.places.PlaceDetailsRequest.prototype.sessionToken;
/**
* Configures a {@link google.maps.places.PlaceDetailsElement} to show a
* place's feature list in the "About" tab. Feature list can
* include accessibility options, amenities, accepted payment methods, and more.
* Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceFeatureListElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PlaceFeatureListElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceFeatureListElement = function() {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-feature-list></gmp-place-feature-list>
* </gmp-place-content-config>
PlaceFeatureListElement.
* @record
*/
google.maps.places.PlaceFeatureListElementOptions = function() {};
/**
* Defines information about the geometry of a Place.
* @record
*/
google.maps.places.PlaceGeometry = function() {};
/**
* The Place’s position.
* @type {!google.maps.LatLng|undefined}
*/
google.maps.places.PlaceGeometry.prototype.location;
/**
* The preferred viewport when displaying this Place on a map. This property
* will be null if the preferred viewport for the Place is not
* known. Only available with {@link
* google.maps.places.PlacesService.getDetails}.
* @type {!google.maps.LatLngBounds|undefined}
*/
google.maps.places.PlaceGeometry.prototype.viewport;
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement}, or {@link
* google.maps.places.PlaceSearchElement} to show a place's media, such as
* photos. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceMediaElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceMediaElementOptions=} options
* @implements {google.maps.places.PlaceMediaElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceMediaElement = function(options) {};
/**
* Whether to enable or disable the media lightbox, in cases where both options
* are supported.
* @default <gmp-place-content-config>
* <gmp-place-media
* lightbox-preferred></gmp-place-media>
* </gmp-place-content-config>
false
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceMediaElement.prototype.lightboxPreferred;
/**
* The preferred media size in cases where multiple sizes are supported, such as
* the vertical {@link google.maps.places.PlaceSearchElement}. The vertical
* PlaceSearchElement will use MediaSize.SMALL by
* default if this is not specified.
* @default null
* @type {!google.maps.places.MediaSize|null|undefined}
*/
google.maps.places.PlaceMediaElement.prototype.preferredSize;
/**
* Options for PlaceMediaElement.
* @record
*/
google.maps.places.PlaceMediaElementOptions = function() {};
/**
* See {@link google.maps.places.PlaceMediaElement.lightboxPreferred}.
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceMediaElementOptions.prototype.lightboxPreferred;
/**
* See {@link google.maps.places.PlaceMediaElement.preferredSize}.
* @type {!google.maps.places.MediaSize|null|undefined}
*/
google.maps.places.PlaceMediaElementOptions.prototype.preferredSize;
/**
* Configures a {@link google.maps.places.PlaceSearchElement} to load results
* based on a nearby search request. The locationRestriction
* property is required for the search element to load. Any other configured
* properties will be ignored if locationRestriction is not set.
* Append this element as a child of a {@link
* google.maps.places.PlaceSearchElement} to load results. For example:
*
*
* Access by calling `const {PlaceNearbySearchRequestElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceNearbySearchRequestElementOptions=} options
* @implements {google.maps.places.PlaceNearbySearchRequestElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceNearbySearchRequestElement = function(options) {};
/**
* Excluded primary place types.
* @default <gmp-place-search>
* <gmp-place-nearby-search-request
* location-restriction="RADIUS@LAT,LNG"
* ></gmp-place-nearby-search-request>
* <gmp-place-content-config>
* <gmp-place-media
* lightbox-preferred></gmp-place-media>
* </gmp-place-content-config>
</gmp-place-search>
* null
* @type {!Arraynull
* @type {!Arraynull
* @type {!Arraynull
* @type {!ArrayCircle.
* @default null
* @type {!google.maps.Circle|!google.maps.CircleLiteral|null|undefined}
*/
google.maps.places.PlaceNearbySearchRequestElement.prototype
.locationRestriction;
/**
* Maximum number of results to return.
* @default null
* @type {number|null|undefined}
*/
google.maps.places.PlaceNearbySearchRequestElement.prototype.maxResultCount;
/**
* How results will be ranked in the response.
* @default null
* @type {!google.maps.places.SearchNearbyRankPreference|null|undefined}
*/
google.maps.places.PlaceNearbySearchRequestElement.prototype.rankPreference;
/**
* Options for PlaceNearbySearchRequestElement.
* @record
*/
google.maps.places.PlaceNearbySearchRequestElementOptions = function() {};
/**
* Excluded primary place types. See {@link
* google.maps.places.PlaceNearbySearchRequestElement.excludedPrimaryTypes}
* and {@link google.maps.places.SearchNearbyRequest.excludedPrimaryTypes} for
* more details.
* @type {!Array
*
* Access by calling `const {PlaceOpenNowStatusElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceOpenNowStatusElementOptions=} options
* @implements {google.maps.places.PlaceOpenNowStatusElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceOpenNowStatusElement = function(options) {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-open-now-status></gmp-place-open-now-status>
* </gmp-place-content-config>
PlaceOpenNowStatusElement.
* @record
*/
google.maps.places.PlaceOpenNowStatusElementOptions = function() {};
/**
* Defines information about the opening hours of a Place.
* @record
*/
google.maps.places.PlaceOpeningHours = function() {};
/**
* Opening periods covering for each day of the week, starting from Sunday, in
* chronological order. Days in which the Place is not open are not included.
* Only available with {@link google.maps.places.PlacesService.getDetails}.
* @type {!Array|undefined}
*/
google.maps.places.PlaceOpeningHours.prototype.periods;
/**
* An array of seven strings representing the formatted opening hours for each
* day of the week. The Places Service will format and localize the opening
* hours appropriately for the current language. The ordering of the elements in
* this array depends on the language. Some languages start the week on Monday
* while others start on Sunday. Only available with {@link
* google.maps.places.PlacesService.getDetails}. Other calls may return an empty
* array.
* @type {!Arrayopen_now is deprecated as of November 2019. Use
* the {@link google.maps.places.PlaceOpeningHours.isOpen} method from
* a {@link google.maps.places.PlacesService.getDetails} result instead. See
* https://goo.gle/js-open-now
*/
google.maps.places.PlaceOpeningHours.prototype.open_now;
/**
* Check whether the place is open now (when no date is passed), or at the given
* date. If this place does not have {@link
* google.maps.places.PlaceResult.utc_offset_minutes} or {@link
* google.maps.places.PlaceOpeningHours.periods} then undefined is
* returned ({@link google.maps.places.PlaceOpeningHours.periods} is only
* available via {@link google.maps.places.PlacesService.getDetails}). This
* method does not take exceptional hours, such as holiday hours, into
* consideration.
* @param {!Date=} date
* @return {boolean|undefined}
*/
google.maps.places.PlaceOpeningHours.prototype.isOpen = function(date) {};
/**
* Configures a {@link google.maps.places.PlaceDetailsElement} to show a
* place's opening hours. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceOpeningHoursElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PlaceOpeningHoursElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceOpeningHoursElement = function() {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-opening-hours></gmp-place-opening-hours>
* </gmp-place-content-config>
PlaceOpeningHoursElement.
* @record
*/
google.maps.places.PlaceOpeningHoursElementOptions = function() {};
/**
* Defines structured information about the opening hours of a Place.
* Note: If a Place is always open, the
* close section will be missing from the response. Clients can
* rely on always-open being represented as an open period
* containing day with value 0 and time
* with value "0000", and no close.
* @record
*/
google.maps.places.PlaceOpeningHoursPeriod = function() {};
/**
* The closing time for the Place.
* @type {!google.maps.places.PlaceOpeningHoursTime|undefined}
*/
google.maps.places.PlaceOpeningHoursPeriod.prototype.close;
/**
* The opening time for the Place.
* @type {!google.maps.places.PlaceOpeningHoursTime}
*/
google.maps.places.PlaceOpeningHoursPeriod.prototype.open;
/**
* Defines when a Place opens or closes.
* @record
*/
google.maps.places.PlaceOpeningHoursTime = function() {};
/**
* The days of the week, as a number in the range [0,
* 6], starting on Sunday. For example, 2 means
* Tuesday.
* @type {number}
*/
google.maps.places.PlaceOpeningHoursTime.prototype.day;
/**
* The hours of the {@link google.maps.places.PlaceOpeningHoursTime.time} as a
* number, in the range [0, 23]. This will be reported
* in the Place’s time zone.
* @type {number}
*/
google.maps.places.PlaceOpeningHoursTime.prototype.hours;
/**
* The minutes of the {@link google.maps.places.PlaceOpeningHoursTime.time} as a
* number, in the range [0, 59]. This will be reported
* in the Place’s time zone.
* @type {number}
*/
google.maps.places.PlaceOpeningHoursTime.prototype.minutes;
/**
* The timestamp (as milliseconds since the epoch, suitable for use with
* new Date()) representing the next occurrence of this
* PlaceOpeningHoursTime. It is calculated from the {@link
* google.maps.places.PlaceOpeningHoursTime.day} of week, the {@link
* google.maps.places.PlaceOpeningHoursTime.time}, and the {@link
* google.maps.places.PlaceResult.utc_offset_minutes}. If the {@link
* google.maps.places.PlaceResult.utc_offset_minutes} is undefined,
* then nextDate will be undefined.
* @type {number|undefined}
*/
google.maps.places.PlaceOpeningHoursTime.prototype.nextDate;
/**
* The time of day in 24-hour "hhmm" format. Values are in the range
* ["0000", "2359"]. The time will be reported in the
* Place’s time zone.
* @type {string}
*/
google.maps.places.PlaceOpeningHoursTime.prototype.time;
/**
* Options for constructing a Place.
* @record
*/
google.maps.places.PlaceOptions = function() {};
/**
* The unique place id.
* @type {string}
*/
google.maps.places.PlaceOptions.prototype.id;
/**
* A language identifier for the language in which details should be returned.
* See the list
* of supported languages.
* @type {string|null|undefined}
*/
google.maps.places.PlaceOptions.prototype.requestedLanguage;
/**
* A region code of the user's region. This can affect which photos may be
* returned, and possibly other things. The region code accepts a ccTLD
* ("top-level domain") two-character value. Most ccTLD codes are
* identical to ISO 3166-1 codes, with some notable exceptions. For example, the
* United Kingdom's ccTLD is "uk" (.co.uk) while its
* ISO 3166-1 code is "gb" (technically for the entity of "The
* United Kingdom of Great Britain and Northern Ireland").
* @type {string|null|undefined}
*/
google.maps.places.PlaceOptions.prototype.requestedRegion;
/**
* Configures a {@link google.maps.places.PlaceDetailsElement} to show a
* place's phone number. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlacePhoneNumberElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PlacePhoneNumberElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlacePhoneNumberElement = function() {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-phone-number></gmp-place-phone-number>
* </gmp-place-content-config>
PlacePhoneNumberElement.
* @record
*/
google.maps.places.PlacePhoneNumberElementOptions = function() {};
/**
* Represents a photo element of a Place.
* @record
*/
google.maps.places.PlacePhoto = function() {};
/**
* The height of the photo in pixels.
* @type {number}
*/
google.maps.places.PlacePhoto.prototype.height;
/**
* Attribution text to be displayed for this photo.
* @type {!Array"9G8F+5W
* Zurich, Switzerland". If no suitable locality that can be found to
* shorten the code then this field is omitted.
* @type {string|undefined}
*/
google.maps.places.PlacePlusCode.prototype.compound_code;
/**
* A plus code with a 1/8000th of a degree by
* 1/8000th of a degree area. For example, "8FVC9G8F+5W".
* @type {string}
*/
google.maps.places.PlacePlusCode.prototype.global_code;
/**
* Configures a {@link google.maps.places.PlaceDetailsElement} to show a
* place's plus code. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlacePlusCodeElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PlacePlusCodeElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlacePlusCodeElement = function() {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-plus-code></gmp-place-plus-code>
* </gmp-place-content-config>
PlacePlusCodeElement.
* @record
*/
google.maps.places.PlacePlusCodeElementOptions = function() {};
/**
* Prediction results for a Place Autocomplete prediction.
*
* Access by calling `const {PlacePrediction} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.PlacePrediction = function() {};
/**
* The length of the geodesic in meters from origin if
* origin is specified.
* @type {number|null}
*/
google.maps.places.PlacePrediction.prototype.distanceMeters;
/**
* Represents the name of the Place.
* @type {!google.maps.places.FormattableText|null}
*/
google.maps.places.PlacePrediction.prototype.mainText;
/**
* The unique identifier of the suggested Place. This identifier can be used in
* other APIs that accept Place IDs.
* @type {string}
*/
google.maps.places.PlacePrediction.prototype.placeId;
/**
* Represents additional disambiguating features (such as a city or region) to
* further identify the Place.
* @type {!google.maps.places.FormattableText|null}
*/
google.maps.places.PlacePrediction.prototype.secondaryText;
/**
* Contains the human-readable name for the returned result. For establishment
* results, this is usually the business name and address.
* text is recommended for developers who wish to show a single UI
* element. Developers who wish to show two separate, but related, UI elements
* may want to use {@link google.maps.places.PlacePrediction.mainText}
* and {@link google.maps.places.PlacePrediction.secondaryText} instead.
* @type {!google.maps.places.FormattableText}
*/
google.maps.places.PlacePrediction.prototype.text;
/**
* List of types that apply to this Place from Table A or Table B in https://developers.google.com/maps/documentation/places/web-service/place-types.
* @type {!Array
If a {@link google.maps.places.AutocompleteRequest.sessionToken}
* was provided in the {@link google.maps.places.AutocompleteRequest} used to
* fetch this PlacePrediction, the same token will automatically be included
* when calling fetchFields.
Alternatively, when using {@link
* google.maps.places.PlaceAutocompleteElement} the first call to {@link
* google.maps.places.Place.fetchFields} on a {@link google.maps.places.Place}
* returned by {@link google.maps.places.PlacePrediction.toPlace} will
* automatically include the session token.
* @return {!google.maps.places.Place}
*/
google.maps.places.PlacePrediction.prototype.toPlace = function() {};
/**
* This event is created after the user selects a prediction item with the
* PlaceAutocompleteElement. Access the selection with
* event.placePrediction.
Convert placePrediction to
* a {@link google.maps.places.Place} by calling {@link
* google.maps.places.PlacePrediction.toPlace}.
*
* Access by calling `const {PlacePredictionSelectEvent} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {Event}
* @constructor
*/
google.maps.places.PlacePredictionSelectEvent = function() {};
/**
* Convert this to a {@link google.maps.places.Place} by calling {@link
* google.maps.places.PlacePrediction.toPlace}.
* @type {!google.maps.places.PlacePrediction}
*/
google.maps.places.PlacePredictionSelectEvent.prototype.placePrediction;
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement}, or {@link
* google.maps.places.PlaceSearchElement} to show a place's price level or
* price range. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlacePriceElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlacePriceElementOptions=} options
* @implements {google.maps.places.PlacePriceElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlacePriceElement = function(options) {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-price></gmp-place-price>
* </gmp-place-content-config>
PlacePriceElement.
* @record
*/
google.maps.places.PlacePriceElementOptions = function() {};
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement}, or {@link
* google.maps.places.PlaceSearchElement} to show a place's rating. Append
* this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceRatingElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceRatingElementOptions=} options
* @implements {google.maps.places.PlaceRatingElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceRatingElement = function(options) {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-rating></gmp-place-rating>
* </gmp-place-content-config>
PlaceRatingElement.
* @record
*/
google.maps.places.PlaceRatingElementOptions = function() {};
/**
* Defines information about a Place.
* @record
*/
google.maps.places.PlaceResult = function() {};
/**
* The collection of address components for this Place’s location. Only
* available with {@link google.maps.places.PlacesService.getDetails}.
* @type {!Array|undefined}
*/
google.maps.places.PlaceResult.prototype.address_components;
/**
* The representation of the Place’s address in the adr microformat. Only available
* with {@link google.maps.places.PlacesService.getDetails}.
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.adr_address;
/**
* The rated aspects of this Place, based on Google and Zagat user reviews. The
* ratings are on a scale of 0 to 30.
* @type {!Array|undefined}
*/
google.maps.places.PlaceResult.prototype.aspects;
/**
* A flag indicating the operational status of the Place, if it is a business
* (indicates whether the place is operational, or closed either temporarily or
* permanently). If no data is available, the flag is not present in search or
* details responses.
* @type {!google.maps.places.BusinessStatus|undefined}
*/
google.maps.places.PlaceResult.prototype.business_status;
/**
* The Place’s full address.
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.formatted_address;
/**
* The Place’s phone number, formatted according to the
* number's regional convention. Only available with {@link
* google.maps.places.PlacesService.getDetails}.
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.formatted_phone_number;
/**
* The Place’s geometry-related information.
* @type {!google.maps.places.PlaceGeometry|undefined}
*/
google.maps.places.PlaceResult.prototype.geometry;
/**
* Attribution text to be displayed for this Place result. Available
* html_attributions are always returned regardless of what
* fields have been requested, and must be displayed.
* @type {!Array.svg or .png).
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.icon_mask_base_uri;
/**
* The Place’s phone number in international format. International format
* includes the country code, and is prefixed with the plus (+) sign. Only
* available with {@link google.maps.places.PlacesService.getDetails}.
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.international_phone_number;
/**
* The Place’s name. Note: In the case of user entered Places, this is the raw
* text, as typed by the user. Please exercise caution when using this data, as
* malicious users may try to use it as a vector for code injection attacks (See
*
* http://en.wikipedia.org/wiki/Code_injection).
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.name;
/**
* Defines when the Place opens or closes.
* @type {!google.maps.places.PlaceOpeningHours|undefined}
*/
google.maps.places.PlaceResult.prototype.opening_hours;
/**
* Photos of this Place. The collection will contain up to ten {@link
* google.maps.places.PlacePhoto} objects.
* @type {!Array|undefined}
*/
google.maps.places.PlaceResult.prototype.photos;
/**
* A unique identifier for the Place.
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.place_id;
/**
* Defines Open Location Codes or "plus
* codes" for the Place.
* @type {!google.maps.places.PlacePlusCode|undefined}
*/
google.maps.places.PlaceResult.prototype.plus_code;
/**
* The price level of the Place, on a scale of 0 to 4. Price levels are
* interpreted as follows:
*
* @type {number|undefined}
*/
google.maps.places.PlaceResult.prototype.price_level;
/**
* A rating, between 1.0 to 5.0, based on user reviews of this Place.
* @type {number|undefined}
*/
google.maps.places.PlaceResult.prototype.rating;
/**
* A list of reviews of this Place. Only available with {@link
* google.maps.places.PlacesService.getDetails}.
* @type {!Array|undefined}
*/
google.maps.places.PlaceResult.prototype.reviews;
/**
* An array of
* types for this Place (for example, 0: Free 1: Inexpensive 2:
* Moderate 3: Expensive 4: Very Expensive
* ["political", "locality"]
* or ["restaurant", "establishment"]).
* @type {!Arrayutc_offset_minutes will be 660. For timezones
* behind UTC, the offset is negative. For example, the
* utc_offset_minutes is -60 for Cape Verde. Only
* available with {@link google.maps.places.PlacesService.getDetails}.
* @type {number|undefined}
*/
google.maps.places.PlaceResult.prototype.utc_offset_minutes;
/**
* The simplified address for the Place, including the street name, street
* number, and locality, but not the province/state, postal code, or country.
* For example, Google's Sydney, Australia office has a vicinity value of
* "48 Pirrama Road, Pyrmont". Only available with {@link
* google.maps.places.PlacesService.getDetails}.
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.vicinity;
/**
* The authoritative website for this Place, such as a business' homepage.
* Only available with {@link google.maps.places.PlacesService.getDetails}.
* @type {string|undefined}
*/
google.maps.places.PlaceResult.prototype.website;
/**
* The offset from UTC of the Place’s current timezone, in minutes. For example,
* Sydney, Australia in daylight savings is 11 hours ahead of UTC, so the
* utc_offset will be 660. For timezones behind UTC,
* the offset is negative. For example, the utc_offset is
* -60 for Cape Verde. Only available with {@link
* google.maps.places.PlacesService.getDetails}.
* @type {number|undefined}
* @deprecated utc_offset is deprecated as of November 2019.
* Use {@link google.maps.places.PlaceResult.utc_offset_minutes} instead.
* See https://goo.gle/js-open-now
*/
google.maps.places.PlaceResult.prototype.utc_offset;
/**
* A flag indicating whether the Place is closed, either permanently or
* temporarily. If the place is operational, or if no data is available, the
* flag is absent from the response.
* @type {boolean|undefined}
* @deprecated permanently_closed is deprecated as of May 2020 and
* will be turned off in May 2021. Use {@link
* google.maps.places.PlaceResult.business_status} instead as
* permanently_closed does not distinguish between temporary
* and permanent closures.
*/
google.maps.places.PlaceResult.prototype.permanently_closed;
/**
* Represents a single review of a place.
* @record
*/
google.maps.places.PlaceReview = function() {};
/**
* The name of the reviewer.
* @type {string}
*/
google.maps.places.PlaceReview.prototype.author_name;
/**
* A URL to the reviewer's profile. This will be undefined when
* the reviewer's profile is unavailable.
* @type {string|undefined}
*/
google.maps.places.PlaceReview.prototype.author_url;
/**
* An IETF language code indicating the language in which this review is
* written. Note that this code includes only the main language tag without any
* secondary tag indicating country or region. For example, all the English
* reviews are tagged as 'en' rather than 'en-AU' or
* 'en-UK'.
* @type {string}
*/
google.maps.places.PlaceReview.prototype.language;
/**
* A URL to the reviwer's profile image.
* @type {string}
*/
google.maps.places.PlaceReview.prototype.profile_photo_url;
/**
* The rating of this review, a number between 1.0 and 5.0 (inclusive).
* @type {number|undefined}
*/
google.maps.places.PlaceReview.prototype.rating;
/**
* A string of formatted recent time, expressing the review time relative to the
* current time in a form appropriate for the language and country. For example
* "a month ago".
* @type {string}
*/
google.maps.places.PlaceReview.prototype.relative_time_description;
/**
* The text of a review.
* @type {string}
*/
google.maps.places.PlaceReview.prototype.text;
/**
* Timestamp for the review, expressed in seconds since epoch.
* @type {number}
*/
google.maps.places.PlaceReview.prototype.time;
/**
* The aspects rated by the review. The ratings on a scale of 0 to 3.
* @type {!Array|undefined}
* @deprecated This field is no longer available.
*/
google.maps.places.PlaceReview.prototype.aspects;
/**
* Configures a {@link google.maps.places.PlaceDetailsElement} to show a
* place's reviews. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceReviewsElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PlaceReviewsElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceReviewsElement = function() {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-reviews></gmp-place-reviews>
* </gmp-place-content-config>
PlaceReviewsElement.
* @record
*/
google.maps.places.PlaceReviewsElementOptions = function() {};
/**
* Attribution positions for {@link google.maps.places.PlaceSearchElement}.
*
* Access by calling `const {PlaceSearchAttributionPosition} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.PlaceSearchAttributionPosition = {
/**
* Attribution at the bottom of the PlaceSearchElement
*/
BOTTOM: 'BOTTOM',
/**
* Attribution at the top of the PlaceSearchElement
*/
TOP: 'TOP',
};
/**
* Displays the results of a place search in a list. Append a {@link
* google.maps.places.PlaceTextSearchRequestElement} or {@link
* google.maps.places.PlaceNearbySearchRequestElement} to specify the request to
* render results for. Append a {@link
* google.maps.places.PlaceContentConfigElement}, {@link
* google.maps.places.PlaceStandardContentElement}, or {@link
* google.maps.places.PlaceAllContentElement} to specify which content to
* render.
Example: <gmp-place-search>
* <gmp-place-text-search-request
* text-query="QUERY"
* ></gmp-place-text-search-request>
* <gmp-place-content-config>
* <gmp-place-media
* lightbox-preferred></gmp-place-media>
* </gmp-place-content-config>
</gmp-place-search>
*
To use the Place Search Element, enable the Places UI Kit API for your project in the Google Cloud console.
*
* Access by calling `const {PlaceSearchElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceSearchElementOptions=} options
* @implements {google.maps.places.PlaceSearchElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceSearchElement = function(options) {};
/**
* The position of the attribution logo and legal disclosure button.
* @default PlaceSearchAttributionPosition.TOP
* @type {!google.maps.places.PlaceSearchAttributionPosition|null|undefined}
*/
google.maps.places.PlaceSearchElement.prototype.attributionPosition;
/**
* The orientation variant (vertical or horizontal) of the element.
* @default PlaceSearchOrientation.VERTICAL
* @type {!google.maps.places.PlaceSearchOrientation|null|undefined}
*/
google.maps.places.PlaceSearchElement.prototype.orientation;
/**
* Read only. Array of Place objects containing the IDs, locations,
* and viewports of the currently rendered places.
* @type {!Array}
*/
google.maps.places.PlaceSearchElement.prototype.places;
/**
* Whether or not the list items are selectable. If true, the list items will be
* buttons that dispatch the gmp-select event when clicked.
* Accessible keyboard navigation and selection is also supported.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceSearchElement.prototype.selectable;
/**
* If true, truncates certain lines of content to fit on one line instead of
* wrapping.
* @default false
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceSearchElement.prototype.truncationPreferred;
/**
* Options for PlaceSearchElement.
* @record
*/
google.maps.places.PlaceSearchElementOptions = function() {};
/**
* See {@link google.maps.places.PlaceSearchElement.attributionPosition}.
* @type {!google.maps.places.PlaceSearchAttributionPosition|null|undefined}
*/
google.maps.places.PlaceSearchElementOptions.prototype.attributionPosition;
/**
* See {@link google.maps.places.PlaceSearchElement.orientation}.
* @type {!google.maps.places.PlaceSearchOrientation|null|undefined}
*/
google.maps.places.PlaceSearchElementOptions.prototype.orientation;
/**
* See {@link google.maps.places.PlaceSearchElement.selectable}
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceSearchElementOptions.prototype.selectable;
/**
* See {@link google.maps.places.PlaceSearchElement.truncationPreferred}.
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceSearchElementOptions.prototype.truncationPreferred;
/**
* Orientation variants for {@link google.maps.places.PlaceSearchElement}.
*
* Access by calling `const {PlaceSearchOrientation} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.PlaceSearchOrientation = {
/**
* Horizontal orientation.
*/
HORIZONTAL: 'HORIZONTAL',
/**
* Vertical orientation.
*/
VERTICAL: 'VERTICAL',
};
/**
* An object used to fetch additional pages of Places results.
* @record
*/
google.maps.places.PlaceSearchPagination = function() {};
/**
* Indicates if further results are available. true when there is
* an additional results page.
* @type {boolean}
*/
google.maps.places.PlaceSearchPagination.prototype.hasNextPage;
/**
* Fetches the next page of results. Uses the same callback function that was
* provided to the first search request.
* @return {void}
*/
google.maps.places.PlaceSearchPagination.prototype.nextPage = function() {};
/**
* A Place search query to be sent to the PlacesService.
* @record
*/
google.maps.places.PlaceSearchRequest = function() {};
/**
* The bounds within which to search for Places. Both location and
* radius will be ignored if bounds is set.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.bounds;
/**
* A term to be matched against all available fields, including but not limited
* to name, type, and address, as well as customer reviews and other third-party
* content.
* @type {string|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.keyword;
/**
* A language identifier for the language in which names and addresses should be
* returned, when possible. See the list of
* supported languages.
* @type {string|null|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.language;
/**
* The location around which to search for Places.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.location;
/**
* Restricts results to only those places at the specified price level or lower.
* Valid values are in the range from 0 (most affordable) to 4 (most expensive),
* inclusive. Must be greater than or equal to minPrice , if
* specified.
* @type {number|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.maxPriceLevel;
/**
* Restricts results to only those places at the specified price level or
* higher. Valid values are in the range from 0 (most affordable) to 4 (most
* expensive), inclusive. Must be less than or equal to maxPrice,
* if specified.
* @type {number|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.minPriceLevel;
/**
* Restricts results to only those places that are open right now.
* @type {boolean|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.openNow;
/**
* The distance from the given location within which to search for Places, in
* meters. The maximum allowed value is 50 000.
* @type {number|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.radius;
/**
* Specifies the ranking method to use when returning results. Note that when
* rankBy is set to DISTANCE, you must specify a
* location but you cannot specify a radius or
* bounds.
* @default {@link google.maps.places.RankBy.PROMINENCE}
* @type {!google.maps.places.RankBy|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.rankBy;
/**
* Searches for places of the given type. The type is translated to the local
* language of the request's target location and used as a query string. If
* a query is also provided, it is concatenated to the localized type string.
* Results of a different type are dropped from the response. Use this field to
* perform language and region independent categorical searches. Valid types are
* given here.
* @type {string|undefined}
*/
google.maps.places.PlaceSearchRequest.prototype.type;
/**
* Equivalent to keyword. Values in this field are combined with
* values in the keyword field and passed as part of the same
* search string.
* @type {string|undefined}
* @deprecated Use keyword instead.
*/
google.maps.places.PlaceSearchRequest.prototype.name;
/**
* This event fires when a place is selected from a list of places. Access the
* selection with event.place.
*
* Access by calling `const {PlaceSelectEvent} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {Event}
* @constructor
*/
google.maps.places.PlaceSelectEvent = function() {};
/**
* The selected place.
* @type {!google.maps.places.Place}
*/
google.maps.places.PlaceSelectEvent.prototype.place;
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement}, or {@link
* google.maps.places.PlaceSearchElement} to show a standard set of content.
* Append this element as a child to use it.
For {@link
* google.maps.places.PlaceDetailsElement}, standard content consists of:
*
For {@link
* google.maps.places.PlaceDetailsCompactElement}, standard content consists of:
*
* For {@link google.maps.places.PlaceSearchElement}, standard content consists
* of:
For example:
*
* Access by calling `const {PlaceStandardContentElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceStandardContentElementOptions=} options
* @implements {google.maps.places.PlaceStandardContentElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceStandardContentElement = function(options) {};
/**
* Options for
* <gmp-place-details>
* <gmp-place-standard-content></gmp-place-standard-content>
* </gmp-place-details>
PlaceStandardContentElement.
* @record
*/
google.maps.places.PlaceStandardContentElementOptions = function() {};
/**
* Configures a {@link google.maps.places.PlaceDetailsElement} to show a
* place's summary. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceSummaryElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PlaceSummaryElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceSummaryElement = function() {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-summary></gmp-place-summary>
* </gmp-place-content-config>
PlaceSummaryElement.
* @record
*/
google.maps.places.PlaceSummaryElementOptions = function() {};
/**
* Configures a {@link google.maps.places.PlaceSearchElement} to load results
* based on a text search request. The textQuery property is
* required for the search element to load. Any other configured properties will
* be ignored if textQuery is not set. Append this element as a
* child of a {@link google.maps.places.PlaceSearchElement} to load results. For
* example:
*
* Access by calling `const {PlaceTextSearchRequestElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceTextSearchRequestElementOptions=} options
* @implements {google.maps.places.PlaceTextSearchRequestElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceTextSearchRequestElement = function(options) {};
/**
* The list of preferred EV connector types.
* @default <gmp-place-search>
* <gmp-place-text-search-request
* text-query="QUERY"
* ></gmp-place-text-search-request>
* <gmp-place-content-config>
* <gmp-place-media
* lightbox-preferred></gmp-place-media>
* </gmp-place-content-config>
</gmp-place-search>
* null
* @type {!Array|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.evConnectorTypes;
/**
* Minimum required charging rate in kilowatts.
* @default null
* @type {number|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype
.evMinimumChargingRateKw;
/**
* The requested place type.
* @default null
* @type {string|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.includedType;
/**
* Used to restrict the search to places that are currently open.
* @default null
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.isOpenNow;
/**
* Location bias for the search. Normalizes to a LatLngAltitude |
* LatLngBounds | Circle | string.
* @default null
* @type {!google.maps.places.LocationBias|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.locationBias;
/**
* Location restriction for the search. Normalizes to a
* LatLngBounds.
* @default null
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.locationRestriction;
/**
* Maximum number of results to return.
* @default null
* @type {number|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.maxResultCount;
/**
* Filter out results whose average user rating is strictly less than this
* limit.
* @default null
* @type {number|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.minRating;
/**
* Used to restrict the search to places that are marked as certain price
* levels.
* @default null
* @type {!Array|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.priceLevels;
/**
* How results will be ranked in the response.
* @default null
* @type {!google.maps.places.SearchByTextRankPreference|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.rankPreference;
/**
* The text query for textual search.
* @default null
* @type {string|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype.textQuery;
/**
* Used to set strict type filtering for 'includedType'.
* @default null
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElement.prototype
.useStrictTypeFiltering;
/**
* Options for PlaceTextSearchRequestElement.
* @record
*/
google.maps.places.PlaceTextSearchRequestElementOptions = function() {};
/**
* The list of preferred EV connector types. See {@link
* google.maps.places.SearchByTextRequest.evSearchOptions} and {@link
* google.maps.places.PlaceTextSearchRequestElement.evConnectorTypes} for more
* details.
* @type {!Array|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype
.evConnectorTypes;
/**
* Minimum required charging rate in kilowatts. See {@link
* google.maps.places.SearchByTextRequest.evSearchOptions} and {@link
* google.maps.places.PlaceTextSearchRequestElement.evMinimumChargingRateKw} for
* more details.
* @type {number|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype
.evMinimumChargingRateKw;
/**
* The requested place type. See {@link
* google.maps.places.SearchByTextRequest.includedType} and {@link
* google.maps.places.PlaceTextSearchRequestElement.includedType} for more
* details.
* @type {string|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype.includedType;
/**
* Used to restrict the search to places that are currently open. See {@link
* google.maps.places.SearchByTextRequest.isOpenNow} and {@link
* google.maps.places.PlaceTextSearchRequestElement.isOpenNow} for more details.
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype.isOpenNow;
/**
* Location bias for the search. See {@link
* google.maps.places.SearchByTextRequest.locationBias} and {@link
* google.maps.places.PlaceTextSearchRequestElement.locationBias} for more
* details.
* @type {!google.maps.places.LocationBias|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype.locationBias;
/**
* Location restriction for the search. See {@link
* google.maps.places.SearchByTextRequest.locationRestriction} and {@link
* google.maps.places.PlaceTextSearchRequestElement.locationRestriction} for
* more details.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype
.locationRestriction;
/**
* Maximum number of results to return. See {@link
* google.maps.places.SearchByTextRequest.maxResultCount} and {@link
* google.maps.places.PlaceTextSearchRequestElement.maxResultCount} for more
* details.
* @type {number|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype
.maxResultCount;
/**
* Filter out results whose average user rating is strictly less than this
* limit. See {@link google.maps.places.SearchByTextRequest.minRating}
* and {@link google.maps.places.PlaceTextSearchRequestElement.minRating} for
* more details.
* @type {number|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype.minRating;
/**
* Used to restrict the search to places that are marked as certain price
* levels. See {@link google.maps.places.SearchByTextRequest.priceLevels}
* and {@link google.maps.places.PlaceTextSearchRequestElement.priceLevels} for
* more details.
* @type {!Array|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype.priceLevels;
/**
* How results will be ranked in the response. See {@link
* google.maps.places.SearchByTextRequest.rankPreference} and {@link
* google.maps.places.PlaceTextSearchRequestElement.rankPreference} for more
* details.
* @type {!google.maps.places.SearchByTextRankPreference|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype
.rankPreference;
/**
* The text query for textual search. See {@link
* google.maps.places.SearchByTextRequest.textQuery} and {@link
* google.maps.places.PlaceTextSearchRequestElement.textQuery} for more details.
* @type {string|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype.textQuery;
/**
* Used to set strict type filtering for {@link
* google.maps.places.SearchByTextRequest.includedType}. See {@link
* google.maps.places.SearchByTextRequest.useStrictTypeFiltering} and {@link
* google.maps.places.PlaceTextSearchRequestElement.useStrictTypeFiltering} for
* more details.
* @type {boolean|null|undefined}
*/
google.maps.places.PlaceTextSearchRequestElementOptions.prototype
.useStrictTypeFiltering;
/**
* Configures a {@link google.maps.places.PlaceDetailsCompactElement}, {@link
* google.maps.places.PlaceDetailsElement}, or {@link
* google.maps.places.PlaceSearchElement} to show a place's type. Append
* this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceTypeElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!google.maps.places.PlaceTypeElementOptions=} options
* @implements {google.maps.places.PlaceTypeElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceTypeElement = function(options) {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-type></gmp-place-type>
* </gmp-place-content-config>
PlaceTypeElement.
* @record
*/
google.maps.places.PlaceTypeElementOptions = function() {};
/**
* Configures a {@link google.maps.places.PlaceDetailsElement} to show a
* place's type-specific highlights, such as gas prices and EV charger
* availability. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceTypeSpecificHighlightsElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PlaceTypeSpecificHighlightsElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceTypeSpecificHighlightsElement = function() {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-type-specific-highlights></gmp-place-type-specific-highlights>
* </gmp-place-content-config>
PlaceTypeSpecificHighlightsElement.
* @record
*/
google.maps.places.PlaceTypeSpecificHighlightsElementOptions = function() {};
/**
* Configures a {@link google.maps.places.PlaceDetailsElement} to show a
* place's website. Append this element as a child of a {@link
* google.maps.places.PlaceContentConfigElement} to use it. For example:
*
*
* Access by calling `const {PlaceWebsiteElement} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PlaceWebsiteElementOptions}
* @extends {HTMLElement}
* @constructor
*/
google.maps.places.PlaceWebsiteElement = function() {};
/**
* Options for <gmp-place-content-config>
* <gmp-place-website></gmp-place-website>
* </gmp-place-content-config>
PlaceWebsiteElement.
* @record
*/
google.maps.places.PlaceWebsiteElementOptions = function() {};
/**
* Contains methods related to searching for places and retrieving details about
* a place.
*
* Access by calling `const {PlacesService} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!HTMLDivElement|!google.maps.Map} attrContainer
* @constructor
* @deprecated As of March 1st, 2025, google.maps.places.PlacesService is not
* available to new customers. Please use {@link google.maps.places.Place}
* instead. At this time, google.maps.places.PlacesService is not scheduled
* to be discontinued, but {@link google.maps.places.Place} is recommended
* over google.maps.places.PlacesService. While
* google.maps.places.PlacesService will continue to receive bug fixes for
* any major regressions, existing bugs in google.maps.places.PlacesService
* will not be addressed. At least 12 months notice will be given before
* support is discontinued. Please see https://developers.google.com/maps/legacy
* for additional details and https://developers.google.com/maps/documentation/javascript/places-migration-overview
* for the migration guide.
*/
google.maps.places.PlacesService = function(attrContainer) {};
/**
* Retrieves a list of places based on a phone number. In most cases there
* should be just one item in the result list, however if the request is
* ambiguous more than one result may be returned. The {@link
* google.maps.places.PlaceResult}s passed to the callback are subsets of a
* full {@link google.maps.places.PlaceResult}. Your app can get a more
* detailed {@link google.maps.places.PlaceResult} for each place by
* calling {@link google.maps.places.PlacesService.getDetails} and passing
* the {@link google.maps.places.PlaceResult.place_id} for the desired place.
* @param {!google.maps.places.FindPlaceFromPhoneNumberRequest} request
* @param {function((!Array|null),
* !google.maps.places.PlacesServiceStatus): void} callback
* @return {undefined}
*/
google.maps.places.PlacesService.prototype.findPlaceFromPhoneNumber = function(
request, callback) {};
/**
* Retrieves a list of places based on a query string. In most cases there
* should be just one item in the result list, however if the request is
* ambiguous more than one result may be returned. The {@link
* google.maps.places.PlaceResult}s passed to the callback are subsets of a
* full {@link google.maps.places.PlaceResult}. Your app can get a more
* detailed {@link google.maps.places.PlaceResult} for each place by
* calling {@link google.maps.places.PlacesService.getDetails} and passing
* the {@link google.maps.places.PlaceResult.place_id} for the desired place.
* @param {!google.maps.places.FindPlaceFromQueryRequest} request
* @param {function((!Array|null),
* !google.maps.places.PlacesServiceStatus): void} callback
* @return {undefined}
*/
google.maps.places.PlacesService.prototype.findPlaceFromQuery = function(
request, callback) {};
/**
* Retrieves details about the place identified by the given
* placeId.
* @param {!google.maps.places.PlaceDetailsRequest} request
* @param {function((!google.maps.places.PlaceResult|null),
* !google.maps.places.PlacesServiceStatus): void} callback
* @return {undefined}
*/
google.maps.places.PlacesService.prototype.getDetails = function(
request, callback) {};
/**
* Retrieves a list of places near a particular location, based on keyword or
* type. Location must always be specified, either by passing a
* LatLngBounds, or location and radius
* parameters. The {@link google.maps.places.PlaceResult}s passed to the
* callback are subsets of the full {@link google.maps.places.PlaceResult}. Your
* app can get a more detailed {@link google.maps.places.PlaceResult} for each
* place by sending a Place
* Details request passing the {@link
* google.maps.places.PlaceResult.place_id} for the desired place. The {@link
* google.maps.places.PlaceSearchPagination} object can be used to fetch
* additional pages of results (null if this is the last page of results or if
* there is only one page of results).
* @param {!google.maps.places.PlaceSearchRequest} request
* @param {function((!Array|null),
* !google.maps.places.PlacesServiceStatus,
* (!google.maps.places.PlaceSearchPagination|null)): void} callback
* @return {undefined}
*/
google.maps.places.PlacesService.prototype.nearbySearch = function(
request, callback) {};
/**
* Retrieves a list of places based on a query string (for example, "pizza
* in New York", or "shoe stores near Ottawa"). Location
* parameters are optional; when the location is specified, results are only
* biased toward nearby results rather than restricted to places inside the
* area. Use textSearch when you want to search for places using an
* arbitrary string, and in cases where you may not want to restrict search
* results to a particular location. The PlaceSearchPagination
* object can be used to fetch additional pages of results (null if this is the
* last page of results or if there is only one page of results).
* @param {!google.maps.places.TextSearchRequest} request
* @param {function((!Array|null),
* !google.maps.places.PlacesServiceStatus,
* (!google.maps.places.PlaceSearchPagination|null)): void} callback
* @return {undefined}
*/
google.maps.places.PlacesService.prototype.textSearch = function(
request, callback) {};
/**
* The status returned by the PlacesService on the completion of
* its searches. Specify these by value, or by using the constant's name.
* For example, 'OK' or
* google.maps.places.PlacesServiceStatus.OK.
*
* Access by calling `const {PlacesServiceStatus} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.PlacesServiceStatus = {
/**
* This request was invalid.
*/
INVALID_REQUEST: 'INVALID_REQUEST',
/**
* The place referenced was not found.
*/
NOT_FOUND: 'NOT_FOUND',
/**
* The response contains a valid result.
*/
OK: 'OK',
/**
* The application has gone over its request quota.
*/
OVER_QUERY_LIMIT: 'OVER_QUERY_LIMIT',
/**
* The application is not allowed to use the PlacesService.
*/
REQUEST_DENIED: 'REQUEST_DENIED',
/**
* The PlacesService request could not be processed due to a
* server error. The request may succeed if you try again.
*/
UNKNOWN_ERROR: 'UNKNOWN_ERROR',
/**
* No result was found for this request.
*/
ZERO_RESULTS: 'ZERO_RESULTS',
};
/**
* Plus code for the Place. See https://plus.codes/ for more information.
*
* Access by calling `const {PlusCode} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.PlusCode = function() {};
/**
* A plus code with a 1/8000th of a degree by 1/8000th of a degree area where
* the first four characters (the area code) are dropped and replaced with a
* locality description. For example, "9G8F+5W Zurich, Switzerland".
* @type {string|null}
*/
google.maps.places.PlusCode.prototype.compoundCode;
/**
* A plus code with a 1/8000th of a degree by 1/8000th of a degree area. For
* example, "8FVC9G8F+5W".
* @type {string|null}
*/
google.maps.places.PlusCode.prototype.globalCode;
/**
* Represents a postal address (e.g. for a postal service to deliver items to).
* Note: PostalAddress is used by the JavaScript API to instantiate objects that
* represent data returned by the Web Service.
*
* Access by calling `const {PostalAddress} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.places.PostalAddressLiteral}
* @constructor
*/
google.maps.places.PostalAddress = function() {};
/**
* Unstructured address lines describing the lower levels of an address.
* @type {!ArrayendPrice could be
* unset, which indicates a range without upper bound (e.g. "More than
* $100").
*
* Access by calling `const {PriceRange} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.PriceRange = function() {};
/**
* The upper end of the price range (inclusive). Price should be lower than this
* amount.
* @type {!google.maps.places.Money|null}
*/
google.maps.places.PriceRange.prototype.endPrice;
/**
* The low end of the price range (inclusive). Price should be at or above this
* amount.
* @type {!google.maps.places.Money}
*/
google.maps.places.PriceRange.prototype.startPrice;
/**
* Represents a single Query Autocomplete prediction.
* @record
*/
google.maps.places.QueryAutocompletePrediction = function() {};
/**
* This is the unformatted version of the query suggested by the Places service.
* @type {string}
*/
google.maps.places.QueryAutocompletePrediction.prototype.description;
/**
* A set of substrings in the place's description that match elements in the
* user's input, suitable for use in highlighting those substrings. Each
* substring is identified by an offset and a length, expressed in unicode
* characters.
* @type {!Array}
*/
google.maps.places.QueryAutocompletePrediction.prototype.matched_substrings;
/**
* Only available if prediction is a place. A place ID that can be used to
* retrieve details about this place using the place details service (see {@link
* google.maps.places.PlacesService.getDetails}).
* @type {string|undefined}
*/
google.maps.places.QueryAutocompletePrediction.prototype.place_id;
/**
* Information about individual terms in the above description. Categorical
* terms come first (for example, "restaurant"). Address terms appear
* from most to least specific. For example, "San Francisco", and
* "CA".
* @type {!Array}
*/
google.maps.places.QueryAutocompletePrediction.prototype.terms;
/**
* A QueryAutocompletion request to be sent to the
* QueryAutocompleteService.
* @record
*/
google.maps.places.QueryAutocompletionRequest = function() {};
/**
* Bounds for prediction biasing. Predictions will be biased towards, but not
* restricted to, the given bounds. Both location and
* radius will be ignored if bounds is set.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|undefined}
*/
google.maps.places.QueryAutocompletionRequest.prototype.bounds;
/**
* The user entered input string.
* @type {string}
*/
google.maps.places.QueryAutocompletionRequest.prototype.input;
/**
* Location for prediction biasing. Predictions will be biased towards the given
* location and radius. Alternatively,
* bounds can be used.
* @type {!google.maps.LatLng|undefined}
*/
google.maps.places.QueryAutocompletionRequest.prototype.location;
/**
* The character position in the input term at which the service uses text for
* predictions (the position of the cursor in the input field).
* @type {number|undefined}
*/
google.maps.places.QueryAutocompletionRequest.prototype.offset;
/**
* The radius of the area used for prediction biasing. The radius
* is specified in meters, and must always be accompanied by a
* location property. Alternatively, bounds can be
* used.
* @type {number|undefined}
*/
google.maps.places.QueryAutocompletionRequest.prototype.radius;
/**
* Ranking options for a PlaceSearchRequest.
*
* Access by calling `const {RankBy} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {number}
*/
google.maps.places.RankBy = {
/**
* Ranks place results by distance from the location.
*/
DISTANCE: 0,
/**
* Ranks place results by their prominence.
*/
PROMINENCE: 1,
};
/**
* Information about a review of a Place.
*
* Access by calling `const {Review} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.Review = function() {};
/**
* The reviewer.
* @type {!google.maps.places.AuthorAttribution|null}
*/
google.maps.places.Review.prototype.authorAttribution;
/**
* A link where user can flag a problem with the review.
* @type {string|null}
*/
google.maps.places.Review.prototype.flagContentURI;
/**
* A link to show the review on Google Maps.
* @type {string|null}
*/
google.maps.places.Review.prototype.googleMapsURI;
/**
* The review text in its original language.
* @type {string|null}
*/
google.maps.places.Review.prototype.originalText;
/**
* An IETF language code indicating the original language of the review.
* @type {string|null}
*/
google.maps.places.Review.prototype.originalTextLanguageCode;
/**
* @type {!Date|null}
*/
google.maps.places.Review.prototype.publishTime;
/**
* The rating of this review, a number between 1.0 and 5.0 (inclusive).
* @type {number|null}
*/
google.maps.places.Review.prototype.rating;
/**
* A string of formatted recent time, expressing the review time relative to the
* current time in a form appropriate for the language and country. For example
* `"a month ago"'.
* @type {string|null}
*/
google.maps.places.Review.prototype.relativePublishTimeDescription;
/**
* The localized text of the review.
* @type {string|null}
*/
google.maps.places.Review.prototype.text;
/**
* An IETF language code indicating the localized language of the review.
* @type {string|null}
*/
google.maps.places.Review.prototype.textLanguageCode;
/**
* The month of the date when the review author visited the place. This field is
* 0-based; 0 is January, and 11 is December.
* @type {number|null}
*/
google.maps.places.Review.prototype.visitDateMonth;
/**
* The year of the date when the review author visited the place.
* @type {number|null}
*/
google.maps.places.Review.prototype.visitDateYear;
/**
* A widget that provides query predictions based on a user's text input. It
* attaches to an input element of type text, and listens for text
* entry in that field. The list of predictions is presented as a drop-down
* list, and is updated as text is entered.
*
* Access by calling `const {SearchBox} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {!HTMLInputElement} inputField
* @param {(!google.maps.places.SearchBoxOptions|null)=} opts
* @extends {google.maps.MVCObject}
* @constructor
* @deprecated As of March 1st, 2025, google.maps.places.SearchBox is not
* available to new customers. At this time, google.maps.places.SearchBox is
* not scheduled to be discontinued and will continue to receive bug fixes
* for any major regressions. At least 12 months notice will be given before
* support is discontinued. Please see https://developers.google.com/maps/legacy
* for additional details.
*/
google.maps.places.SearchBox = function(inputField, opts) {};
/**
* Returns the bounds to which query predictions are biased.
* @return {!google.maps.LatLngBounds|undefined}
*/
google.maps.places.SearchBox.prototype.getBounds = function() {};
/**
* Returns the query selected by the user to be used with
* places_changed event.
* @return {!Array|undefined}
*/
google.maps.places.SearchBox.prototype.getPlaces = function() {};
/**
* Sets the region to use for biasing query predictions. Results will only be
* biased towards this area and not be completely restricted to it.
* @param {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null}
* bounds
* @return {undefined}
*/
google.maps.places.SearchBox.prototype.setBounds = function(bounds) {};
/**
* The options that can be set on a SearchBox object.
* @record
*/
google.maps.places.SearchBoxOptions = function() {};
/**
* The area towards which to bias query predictions. Predictions are biased
* towards, but not restricted to, queries targeting these bounds.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|null|undefined}
*/
google.maps.places.SearchBoxOptions.prototype.bounds;
/**
* RankPreference enum for SearchByTextRequest.
*
* Access by calling `const {SearchByTextRankPreference} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.SearchByTextRankPreference = {
/**
* Ranks results by distance.
*/
DISTANCE: 'DISTANCE',
/**
* Ranks results by relevance.
*/
RELEVANCE: 'RELEVANCE',
};
/**
* Request interface for {@link google.maps.places.Place.searchByText}.
* @record
*/
google.maps.places.SearchByTextRequest = function() {};
/**
* EV-related options that can be specified for a place search request.
* @type {!google.maps.places.EVSearchOptions|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.evSearchOptions;
/**
* Fields to be included in the response, which
* will be billed for. If ['*'] is passed in, all
* available fields will be returned and billed for (this is not recommended for
* production deployments). You can request any property in the {@link
* google.maps.places.Place} class as a field.
* @type {!Arrayfalse
* @type {boolean|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.isOpenNow;
/**
* Place details will be displayed with the preferred language if available.
* Will default to the browser's language preference. Current list of
* supported languages: https://developers.google.com/maps/faq#languagesupport.
* @type {string|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.language;
/**
* The region to search. This location serves as a bias which means results
* around given location might be returned. Cannot be set along with
* locationRestriction.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|!google.maps.CircleLiteral|!google.maps.Circle|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.locationBias;
/**
* The region to search. This location serves as a restriction which means
* results outside given location will not be returned. Cannot be set along with
* locationBias.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.locationRestriction;
/**
* Maximum number of results to return. It must be between 1 and 20,
* inclusively.
* @type {number|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.maxResultCount;
/**
* Filter out results whose average user rating is strictly less than this
* limit. A valid value must be an float between 0 and 5 (inclusively) at a 0.5
* cadence i.e. [0, 0.5, 1.0, ... , 5.0] inclusively. The input rating will be
* rounded up to the nearest 0.5(ceiling). For instance, a rating of 0.6 will
* eliminate all results with a less than 1.0 rating.
* @type {number|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.minRating;
/**
* Used to restrict the search to places that are marked as certain price
* levels. Any combinations of price levels can be chosen. Defaults to all price
* levels.
* @type {!Array|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.priceLevels;
/**
* How results will be ranked in the response.
* @default SearchByTextRankPreference.RELEVANCE
* @type {!google.maps.places.SearchByTextRankPreference|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.rankPreference;
/**
* The Unicode country/region code (CLDR) of the location where the request is
* coming from. This parameter is used to display the place details, like
* region-specific place name, if available. The parameter can affect results
* based on applicable law. For more information, see https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html.
* Note that 3-digit region codes are not currently supported.
* @type {string|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.region;
/**
* Required when you do not use {@link
* google.maps.places.SearchByTextRequest.query}. The text query for textual
* search.
* @type {string|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.textQuery;
/**
* Used to set strict type filtering for {@link
* google.maps.places.SearchByTextRequest.includedType}. If set to true, only
* results of the same type will be returned.
* @default false
* @type {boolean|undefined}
*/
google.maps.places.SearchByTextRequest.prototype.useStrictTypeFiltering;
/**
* @type {string|undefined}
* @deprecated Please use textQuery instead
*/
google.maps.places.SearchByTextRequest.prototype.query;
/**
* Available only in the v=beta channel: https://goo.gle/3oAthT3.
* @type {!google.maps.places.SearchByTextRankPreference|undefined}
* @deprecated Please use rankPreference instead.
*/
google.maps.places.SearchByTextRequest.prototype.rankBy;
/**
* RankPreference enum for SearchNearbyRequest.
*
* Access by calling `const {SearchNearbyRankPreference} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.places.SearchNearbyRankPreference = {
/**
* Ranks results by distance.
*/
DISTANCE: 'DISTANCE',
/**
* Ranks results by popularity.
*/
POPULARITY: 'POPULARITY',
};
/**
* Request interface for {@link google.maps.places.Place.searchNearby}. For more
* information on the request, see Places
* API reference.
* @record
*/
google.maps.places.SearchNearbyRequest = function() {};
/**
* Excluded primary place types. See the full
* list of types supported. A place can only have a single primary type. Up
* to 50 types may be specified. If you specify the same type in both
* included and excluded lists, an INVALID_ARGUMENT
* error is returned.
* @type {!Arrayincluded and excluded lists, an INVALID_ARGUMENT
* error is returned.
* @type {!Array['*'] is passed in, all
* available fields will be returned and billed for (this is not recommended for
* production deployments). You can request any property in the {@link
* google.maps.places.Place} class as a field.
* @type {!Arrayincluded and excluded lists, an INVALID_ARGUMENT
* error is returned.
* @type {!Arrayincluded and excluded lists, an INVALID_ARGUMENT
* error is returned.
* @type {!ArraySearchNearbyRankPreference.POPULARITY
* @type {!google.maps.places.SearchNearbyRankPreference|undefined}
*/
google.maps.places.SearchNearbyRequest.prototype.rankPreference;
/**
* The Unicode country/region code (CLDR) of the location where the request is
* coming from. This parameter is used to display the place details, like
* region-specific place name, if available. The parameter can affect results
* based on applicable law. For more information, see https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html.
* Note that 3-digit region codes are not currently supported.
* @type {string|undefined}
*/
google.maps.places.SearchNearbyRequest.prototype.region;
/**
* Identifies a substring within a given text.
*
* Access by calling `const {StringRange} = await
* google.maps.importLibrary("places")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.places.StringRange = function() {};
/**
* Zero-based offset of the last Unicode character of the substring (exclusive).
* @type {number}
*/
google.maps.places.StringRange.prototype.endOffset;
/**
* Zero-based offset of the first Unicode character of the substring
* (inclusive).
* @type {number}
*/
google.maps.places.StringRange.prototype.startOffset;
/**
* Contains structured information about the place's description, divided
* into a main text and a secondary text, including an array of matched
* substrings from the autocomplete input, identified by an offset and a length,
* expressed in unicode characters.
* @record
*/
google.maps.places.StructuredFormatting = function() {};
/**
* This is the main text part of the unformatted description of the place
* suggested by the Places service. Usually the name of the place.
* @type {string}
*/
google.maps.places.StructuredFormatting.prototype.main_text;
/**
* A set of substrings in the main text that match elements in the user's
* input, suitable for use in highlighting those substrings. Each substring is
* identified by an offset and a length, expressed in unicode characters.
* @type {!Array}
*/
google.maps.places.StructuredFormatting.prototype.main_text_matched_substrings;
/**
* This is the secondary text part of the unformatted description of the place
* suggested by the Places service. Usually the location of the place.
* @type {string}
*/
google.maps.places.StructuredFormatting.prototype.secondary_text;
/**
* A text search request to be sent to the PlacesService.
* @record
*/
google.maps.places.TextSearchRequest = function() {};
/**
* Bounds used to bias results when searching for Places (optional). Both
* location and radius will be ignored if
* bounds is set. Results will not be restricted to those inside
* these bounds; but, results inside it will rank higher.
* @type {!google.maps.LatLngBounds|!google.maps.LatLngBoundsLiteral|undefined}
*/
google.maps.places.TextSearchRequest.prototype.bounds;
/**
* A language identifier for the language in which names and addresses should be
* returned, when possible. See the list of
* supported languages.
* @type {string|null|undefined}
*/
google.maps.places.TextSearchRequest.prototype.language;
/**
* The center of the area used to bias results when searching for Places.
* @type {!google.maps.LatLng|!google.maps.LatLngLiteral|undefined}
*/
google.maps.places.TextSearchRequest.prototype.location;
/**
* The request's query term. For example, the name of a place ('Eiffel
* Tower'), a category followed by the name of a location ('pizza in New
* York'), or the name of a place followed by a location disambiguator
* ('Starbucks in Sydney').
* @type {string|undefined}
*/
google.maps.places.TextSearchRequest.prototype.query;
/**
* The radius of the area used to bias results when searching for Places, in
* meters.
* @type {number|undefined}
*/
google.maps.places.TextSearchRequest.prototype.radius;
/**
* A region code to bias results towards. The region code accepts a ccTLD
* ("top-level domain") two-character value. Most ccTLD codes are
* identical to ISO 3166-1 codes, with some notable exceptions. For example, the
* United Kingdom's ccTLD is "uk" (.co.uk) while its
* ISO 3166-1 code is "gb" (technically for the entity of "The
* United Kingdom of Great Britain and Northern Ireland").
* @type {string|null|undefined}
*/
google.maps.places.TextSearchRequest.prototype.region;
/**
* Searches for places of the given type. The type is translated to the local
* language of the request's target location and used as a query string. If
* a query is also provided, it is concatenated to the localized type string.
* Results of a different type are dropped from the response. Use this field to
* perform language and region independent categorical searches. Valid types are
* given here.
* @type {string|undefined}
*/
google.maps.places.TextSearchRequest.prototype.type;
/**
* @const
*/
google.maps.routes = {};
/**
* Extra computations to perform for a {@link
* google.maps.routes.RouteMatrix.computeRouteMatrix} request.
*
* Access by calling `const {ComputeRouteMatrixExtraComputation} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.ComputeRouteMatrixExtraComputation = {
/**
* Toll information for the matrix item(s).
*/
TOLLS: 'TOLLS',
};
/**
* Request for a route matrix.
* @record
*/
google.maps.routes.ComputeRouteMatrixRequest = function() {};
/**
* The arrival time.
Note: Can only be set when {@link
* google.maps.routes.ComputeRouteMatrixRequest.travelMode} is set to
* TRANSIT. You can specify either {@link
* google.maps.routes.ComputeRouteMatrixRequest.departureTime} or {@link
* google.maps.routes.ComputeRouteMatrixRequest.arrivalTime}, but not both.
* Transit trips are available for up to 7 days in the past or 100 days in the
* future.
* @type {!Date|undefined}
*/
google.maps.routes.ComputeRouteMatrixRequest.prototype.arrivalTime;
/**
* The departure time. If you don't set this value, then this value defaults
* to the time that you made the request.
Note: You can only specify a
* time in the past when {@link
* google.maps.routes.ComputeRouteMatrixRequest.travelMode} is set to
* TRANSIT. Transit trips are available for up to 7 days in the
* past or 100 days in the future.
* @type {!Date|undefined}
*/
google.maps.routes.ComputeRouteMatrixRequest.prototype.departureTime;
/**
* Array of destinations, which determines the columns of the response matrix. A
* value passed as a string may be an address, a plus code, or a Place resource name. Altitude
* values are not taken into consideration.
* @type {!Iterable
Note: These extra computations may return extra fields on the
* response. These extra fields must also be specified in {@link
* google.maps.routes.ComputeRouteMatrixRequest.fields} to be returned in the
* response.
* @type {!Iterable|undefined}
*/
google.maps.routes.ComputeRouteMatrixRequest.prototype.extraComputations;
/**
* Collection of fields to be fetched. Specify ["*"] for
* all fields.
* @type {!Iterable
Several size restrictions apply to the cardinality of
* origins and destinations:
* @type {!Iterablestrings or {@link
* google.maps.places.Place}s must be no greater than 50. TRAFFIC_AWARE_OPTIMAL. TRANSIT. DRIVING or TWO_WHEELER, otherwise the request
* fails.
* @type {!google.maps.routes.RoutingPreference|undefined}
*/
google.maps.routes.ComputeRouteMatrixRequest.prototype.routingPreference;
/**
* Specifies the assumptions to use when calculating time in traffic. This
* setting affects the value returned in {@link
* google.maps.routes.RouteMatrixItem.durationMillis} which contains the
* predicted time in traffic based on historical averages. {@link
* google.maps.routes.ComputeRouteMatrixRequest.trafficModel} is only available
* for requests that have set {@link
* google.maps.routes.ComputeRouteMatrixRequest.routingPreference} to
* TRAFFIC_AWARE_OPTIMAL and {@link
* google.maps.routes.ComputeRouteMatrixRequest.travelMode} to
* DRIVING. Defaults to BEST_GUESS.
* @type {!google.maps.TrafficModel|undefined}
*/
google.maps.routes.ComputeRouteMatrixRequest.prototype.trafficModel;
/**
* Specifies preferences that influence the route returned for
* TRANSIT routes.
Note: Can only be specified when {@link
* google.maps.routes.ComputeRouteMatrixRequest.travelMode} is set to
* TRANSIT.
* @type {!google.maps.routes.TransitPreference|undefined}
*/
google.maps.routes.ComputeRouteMatrixRequest.prototype.transitPreference;
/**
* Specifies the mode of transportation.
* @type {!google.maps.TravelMode|undefined}
*/
google.maps.routes.ComputeRouteMatrixRequest.prototype.travelMode;
/**
* Specifies the units of measure for the display fields. If you don't
* provide this value, then the display units are inferred from the location of
* the first origin.
* @type {!google.maps.UnitSystem|undefined}
*/
google.maps.routes.ComputeRouteMatrixRequest.prototype.units;
/**
* Extra computations to perform for a {@link
* google.maps.routes.Route.computeRoutes} request.
*
* Access by calling `const {ComputeRoutesExtraComputation} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.ComputeRoutesExtraComputation = {
/**
* Flyover information for the route(s). The
* "polylineDetails" field must be specified in {@link
* google.maps.routes.ComputeRoutesRequest.fields} to return this information.
* This data will only currently be populated for certain metros in India.
* This feature is experimental, and the SKU/charge is subject to change.
*/
FLYOVER_INFO_ON_POLYLINE: 'FLYOVER_INFO_ON_POLYLINE',
/**
* Estimated fuel consumption for the route(s).
*/
FUEL_CONSUMPTION: 'FUEL_CONSUMPTION',
/**
* Navigation instructions presented as a formatted HTML text string. This
* content is meant to be read as-is and is for display only. Do not
* programmatically parse it.
*/
HTML_FORMATTED_NAVIGATION_INSTRUCTIONS:
'HTML_FORMATTED_NAVIGATION_INSTRUCTIONS',
/**
* Narrow road information for the route(s). The
* "polylineDetails" field must be specified in {@link
* google.maps.routes.ComputeRoutesRequest.fields} to return this information.
* This data will only currently be populated for certain metros in India.
* This feature is experimental, and the SKU/charge is subject to change.
*/
NARROW_ROAD_INFO_ON_POLYLINE: 'NARROW_ROAD_INFO_ON_POLYLINE',
/**
* Toll information for the route(s).
*/
TOLLS: 'TOLLS',
/**
* Traffic aware polylines for the route(s).
*/
TRAFFIC_ON_POLYLINE: 'TRAFFIC_ON_POLYLINE',
};
/**
* Request for routes.
* @record
*/
google.maps.routes.ComputeRoutesRequest = function() {};
/**
* The arrival time.
Note: Can only be set when {@link
* google.maps.routes.ComputeRoutesRequest.travelMode} is set to
* TRANSIT. You can specify either {@link
* google.maps.routes.ComputeRoutesRequest.departureTime} or {@link
* google.maps.routes.ComputeRoutesRequest.arrivalTime}, but not both. Transit
* trips are available for up to 7 days in the past or 100 days in the future.
* @type {!Date|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.arrivalTime;
/**
* Specifies whether to calculate alternate routes in addition to the route. No
* alternative routes are returned for requests that have intermediate
* waypoints.
* @type {boolean|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.computeAlternativeRoutes;
/**
* The departure time. If you don't set this value, then this value defaults
* to the time that you made the request.
Note: You can only specify a
* time in the past when {@link
* google.maps.routes.ComputeRoutesRequest.travelMode} is set to
* TRANSIT. Transit trips are available for up to 7 days in the
* past or 100 days in the future.
* @type {!Date|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.departureTime;
/**
* The destination of the route. A value passed as a string may be an address,
* plus code, or a Place resource name.
* Altitude values are not taken into consideration for computing routes.
* @type {string|google.maps.LatLng|google.maps.LatLngLiteral|google.maps.LatLngAltitudeLiteral|google.maps.routes.DirectionalLocationLiteral|google.maps.places.Place|google.maps.routes.Waypoint}
*/
google.maps.routes.ComputeRoutesRequest.prototype.destination;
/**
* A list of extra computations which may be used to complete the request.
*
Note: These extra computations may return extra fields on the
* response. These extra fields must also be specified in {@link
* google.maps.routes.ComputeRoutesRequest.fields} to be returned in the
* response.
* @type {!Iterable|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.extraComputations;
/**
* Collection of fields to be fetched. Specify ["*"] for
* all fields.
* @type {!Iterable"optimizedIntermediateWaypointIndices" is not
* requested in {@link google.maps.routes.ComputeRoutesRequest.fields}, the
* request fails. If set to false, {@link
* google.maps.routes.Route.optimizedIntermediateWaypointIndices} in the
* response will be empty.
* @type {boolean|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.optimizeWaypointOrder;
/**
* The origin of the route. A value passed as a string may be an address, plus code, or a Place resource name. Altitude
* values are not taken into consideration for computing routes.
* @type {string|google.maps.LatLng|google.maps.LatLngLiteral|google.maps.LatLngAltitudeLiteral|google.maps.routes.DirectionalLocationLiteral|google.maps.places.Place|google.maps.routes.Waypoint}
*/
google.maps.routes.ComputeRoutesRequest.prototype.origin;
/**
* Specifies the preference for the quality of the polyline.
* @type {!google.maps.routes.PolylineQuality|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.polylineQuality;
/**
* The region code, specified as a ccTLD ("top-level domain")
* two-character value. For more information see Country
* code top-level domains. When you don't provide this value, the region
* is inferred from your Google Maps JavaScript API localization
* settings. Otherwise, the region is inferred from the location of the
* origin.
* @type {string|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.region;
/**
* Specifies what reference routes to calculate as part of the request in
* addition to the default route. A reference route is a route with a different
* route calculation objective than the default route. For example a
* FUEL_EFFICIENT reference route calculation takes into account
* various parameters that would generate an optimal fuel efficient route. When
* using this feature, look for {@link google.maps.routes.Route.routeLabels} on
* the resulting routes.
* @type {!Iterable|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.requestedReferenceRoutes;
/**
* A set of conditions to satisfy that affect the way routes are calculated. For
* example you can specify features to avoid such as toll roads or highways.
* @type {!google.maps.routes.RouteModifiers|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.routeModifiers;
/**
* Specifies how to compute the route. The server attempts to use the selected
* routing preference to compute the route. If the routing preference results in
* an error or an extra long latency, an error is returned. You can specify this
* option only when {@link google.maps.routes.ComputeRoutesRequest.travelMode}
* is DRIVING or TWO_WHEELER, otherwise the request
* fails.
* @type {!google.maps.routes.RoutingPreference|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.routingPreference;
/**
* Specifies the assumptions to use when calculating time in traffic. This
* setting affects the value of {@link google.maps.routes.Route.durationMillis}
* and {@link google.maps.routes.RouteLeg.durationMillis} which contain the
* predicted time in traffic based on historical averages. {@link
* google.maps.routes.ComputeRoutesRequest.trafficModel} is only available for
* requests that have set {@link
* google.maps.routes.ComputeRoutesRequest.routingPreference} to
* TRAFFIC_AWARE_OPTIMAL and {@link
* google.maps.routes.ComputeRoutesRequest.travelMode} to DRIVING.
* Defaults to BEST_GUESS.
* @type {!google.maps.TrafficModel|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.trafficModel;
/**
* Specifies preferences that influence the route returned for
* TRANSIT routes.
Note: Can only be specified when {@link
* google.maps.routes.ComputeRoutesRequest.travelMode} is set to
* TRANSIT.
* @type {!google.maps.routes.TransitPreference|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.transitPreference;
/**
* Specifies the mode of transportation.
* @type {!google.maps.TravelMode|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.travelMode;
/**
* Specifies the units of measure for the display fields, such as navigation
* instructions. The units of measure used for the route, leg, step distance,
* and duration are not affected by this value. If you don't provide this
* value, then the display units are inferred from the location of the origin.
* @type {!google.maps.UnitSystem|undefined}
*/
google.maps.routes.ComputeRoutesRequest.prototype.units;
/**
* Encapsulates a geographic point and an optional heading.
*
* Access by calling `const {DirectionalLocation} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @implements {google.maps.routes.DirectionalLocationLiteral}
* @extends {google.maps.LatLngAltitude}
* @constructor
*/
google.maps.routes.DirectionalLocation = function() {};
/**
* The compass heading associated with the direction of the flow of traffic.
* Heading values can be numbers from 0 to 360, where 0 specifies a heading of
* due North, 90 specifies a heading of due East, and so on. You can use this
* field only for DRIVING and TWO_WHEELER {@link
* google.maps.routes.ComputeRoutesRequest.travelMode}.
* @type {number|null|undefined}
*/
google.maps.routes.DirectionalLocation.prototype.heading;
/**
* Converts to an object.
* @return {!google.maps.routes.DirectionalLocationLiteral}
*/
google.maps.routes.DirectionalLocation.prototype.toJSON = function() {};
/**
* Object literals are accepted in place of {@link
* google.maps.routes.DirectionalLocation} instances as a convenience. These are
* converted to {@link google.maps.routes.DirectionalLocation} when the Maps JS
* API encounters them.
* @extends {google.maps.LatLngAltitudeLiteral}
* @record
*/
google.maps.routes.DirectionalLocationLiteral = function() {};
/**
* The compass heading associated with the direction of the flow of traffic.
* Heading values can be numbers from 0 to 360, where 0 specifies a heading of
* due North, 90 specifies a heading of due East, and so on. You can use this
* field only for DRIVING and TWO_WHEELER {@link
* google.maps.routes.ComputeRoutesRequest.travelMode}.
* @type {number|null|undefined}
*/
google.maps.routes.DirectionalLocationLiteral.prototype.heading;
/**
* Information related to how and why a fallback result was used in a {@link
* google.maps.routes.Route.computeRoutes} response. If this field is set, then
* it means the server used a different routing mode from your preferred mode as
* fallback.
*
* Access by calling `const {FallbackInfo} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.FallbackInfo = function() {};
/**
* The reason why fallback response was used instead of the original response.
* This field is only populated when the fallback mode is triggered and the
* fallback response is returned.
* @type {!google.maps.routes.FallbackReason|null|undefined}
*/
google.maps.routes.FallbackInfo.prototype.reason;
/**
* Routing mode used for the response. If fallback was triggered, the mode may
* be different from routing preference set in the original client request.
* @type {!google.maps.routes.FallbackRoutingMode|null|undefined}
*/
google.maps.routes.FallbackInfo.prototype.routingMode;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.FallbackInfo.prototype.toJSON = function() {};
/**
* The reason that a fallback response was returned in a {@link
* google.maps.routes.Route.computeRoutes} response.
*
* Access by calling `const {FallbackReason} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.FallbackReason = {
/**
* We were not able to finish the calculation with your preferred routing mode
* on time, but we were able to return a result calculated by an alternative
* mode.
*/
LATENCY_EXCEEDED: 'LATENCY_EXCEEDED',
/**
* A server error happened while calculating routes with your preferred
* routing mode, but we were able to return a result calculated by an
* alternative mode.
*/
SERVER_ERROR: 'SERVER_ERROR',
};
/**
* The actual routing mode used when a fallback response is returned in a {@link
* google.maps.routes.Route.computeRoutes} response.
*
* Access by calling `const {FallbackRoutingMode} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.FallbackRoutingMode = {
/**
* Indicates the TRAFFIC_AWARE {@link
* google.maps.routes.RoutingPreference} was used to compute the response.
*/
TRAFFIC_AWARE: 'TRAFFIC_AWARE',
/**
* Indicates the TRAFFIC_UNAWARE {@link
* google.maps.routes.RoutingPreference} was used to compute the response.
*/
TRAFFIC_UNAWARE: 'TRAFFIC_UNAWARE',
};
/**
* Geocoding about the locations used as waypoints. Only populated for address
* waypoints. Includes details about the geocoding results for the purposes of
* determining what the address was geocoded to.
*
* Access by calling `const {GeocodedWaypoint} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.GeocodedWaypoint = function() {};
/**
* Indicates the status code resulting from the geocoding operation.
* @type {!google.maps.RPCStatus|null}
*/
google.maps.routes.GeocodedWaypoint.prototype.geocoderStatus;
/**
* The index of the corresponding intermediate waypoint in the request. Only
* populated if the corresponding waypoint is an intermediate waypoint.
* @type {number|null}
*/
google.maps.routes.GeocodedWaypoint.prototype.intermediateWaypointRequestIndex;
/**
* Indicates that the geocoder did not return an exact match for the original
* request, though it was able to match part of the requested address. You may
* wish to examine the original request for misspellings and/or an incomplete
* address.
* @type {boolean}
*/
google.maps.routes.GeocodedWaypoint.prototype.partialMatch;
/**
* The place ID for this result.
* @type {string}
*/
google.maps.routes.GeocodedWaypoint.prototype.placeId;
/**
* The type(s) of the result, in the form of zero or more type tags. See https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types
* for supported types.
* @type {!ArrayPolylineDetails describes a road feature for a given interval.
*
* Access by calling `const {PolylineDetails} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.PolylineDetails = function() {};
/**
* Flyover details along the polyline.
* @type {!Array}
*/
google.maps.routes.PolylineDetails.prototype.flyoverInfo;
/**
* Narrow road details along the polyline.
* @type {!Array}
*/
google.maps.routes.PolylineDetails.prototype.narrowRoadInfo;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.PolylineDetails.prototype.toJSON = function() {};
/**
* Specifies the quality of the polyline.
*
* Access by calling `const {PolylineQuality} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.PolylineQuality = {
/**
* Specifies a high-quality polyline that is composed using more points than
* OVERVIEW at the cost of increased response size. Use this
* value when you need more precision.
*/
HIGH_QUALITY: 'HIGH_QUALITY',
/**
* Specifies an overview polyline that is composed using a small number of
* points. Using this option has a lower request latency compared to
* HIGH_QUALITY. Use this value when displaying an overview of
* the route.
*/
OVERVIEW: 'OVERVIEW',
};
/**
* A supported reference route on a {@link
* google.maps.routes.ComputeRoutesRequest}.
*
* Access by calling `const {ReferenceRoute} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.ReferenceRoute = {
/**
* Fuel efficient route.
*/
FUEL_EFFICIENT: 'FUEL_EFFICIENT',
/**
* Route with shorter travel distance.
*/
SHORTER_DISTANCE: 'SHORTER_DISTANCE',
};
/**
* Encapsulates the states of road features along a stretch of polyline.
*
* Access by calling `const {RoadFeatureState} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.RoadFeatureState = {
/**
* The road feature does not exist.
*/
DOES_NOT_EXIST: 'DOES_NOT_EXIST',
/**
* The road feature exists.
*/
EXISTS: 'EXISTS',
};
/**
* Contains a route, which consists of a series of connected road segments that
* join beginning, ending, and intermediate waypoints.
*
* Access by calling `const {Route} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.Route = function() {};
/**
* A description of the route.
* @type {string|null|undefined}
*/
google.maps.routes.Route.prototype.description;
/**
* The travel distance of the route, in meters.
* @type {number|undefined}
*/
google.maps.routes.Route.prototype.distanceMeters;
/**
* The length of time needed to navigate the route in milliseconds. If you
* set {@link google.maps.routes.ComputeRoutesRequest.routingPreference} to
* TRAFFIC_UNAWARE, then this value is the same as {@link
* google.maps.routes.Route.staticDurationMillis}. If you set {@link
* google.maps.routes.ComputeRoutesRequest.routingPreference} to either
* TRAFFIC_AWARE or TRAFFIC_AWARE_OPTIMAL, then this
* value is calculated taking traffic conditions into account.
Note: If
* the duration exceeds 2^53 milliseconds, then this value is
* Number.POSITIVE_INFINITY.
* @type {number|null|undefined}
*/
google.maps.routes.Route.prototype.durationMillis;
/**
* A collection of legs (path segments between waypoints) that make up the
* route. Each leg corresponds to the trip between two non-via
* waypoints.
For example:
The order of the legs matches the order of waypoints from
* via intermediate waypoint has two legs. via intermediate waypoint has one leg. origin to intermediates to
* destination.
* @type {!Array|undefined}
*/
google.maps.routes.Route.prototype.legs;
/**
* Text representations of properties of the {@link google.maps.routes.Route}.
* @type {!google.maps.routes.RouteLocalizedValues|null|undefined}
*/
google.maps.routes.Route.prototype.localizedValues;
/**
* If you set {@link
* google.maps.routes.ComputeRoutesRequest.optimizeWaypointOrder} to
* true, this field contains the optimized ordering of intermediate
* waypoints. Otherwise, this field is empty. The index starts with 0 for the
* first intermediate waypoint provided in the input.
For example, if
* you give an input of:
and the
* optimized intermediate waypoint order is Phoenix, Dallas, Bangor, then this
* field will be [2, 0, 1].
* @type {!Array
Note:
* routeToken is only available for requests that have set {@link
* google.maps.routes.ComputeRoutesRequest.routingPreference} to
* TRAFFIC_AWARE or TRAFFIC_AWARE_OPTIMAL. It is not
* supported for requests that have via waypoints.
* @type {string|null|undefined}
*/
google.maps.routes.Route.prototype.routeToken;
/**
* Groupings of sections of the route path with their corresponding speed
* reading. For this field to be populated, {@link
* google.maps.routes.ComputeRoutesRequest.routingPreference} must be set to
* TRAFFIC_AWARE or TRAFFIC_AWARE_OPTIMAL and {@link
* google.maps.routes.ComputeRoutesRequest.extraComputations} must include
* TRAFFIC_ON_POLYLINE.
* @type {!Array|undefined}
*/
google.maps.routes.Route.prototype.speedPaths;
/**
* The duration of traveling through the route without taking traffic conditions
* into consideration.
Note: If the duration exceeds 2^53 milliseconds,
* then this value is Number.POSITIVE_INFINITY.
* @type {number|null|undefined}
*/
google.maps.routes.Route.prototype.staticDurationMillis;
/**
* Additional information about the route.
* @type {!google.maps.routes.RouteTravelAdvisory|null|undefined}
*/
google.maps.routes.Route.prototype.travelAdvisory;
/**
* The viewport bounding box of the route.
* @type {!google.maps.LatLngBounds|null|undefined}
*/
google.maps.routes.Route.prototype.viewport;
/**
* An array of warnings to show when displaying the route.
* @type {!Array
Note: This method requires
* that you specify a response field mask in the request by setting the {@link
* google.maps.routes.ComputeRoutesRequest.fields} property. The value is a list
* of field paths.
For example:
fields: ['*']fields:
* ['durationMillis', 'distanceMeters',
* 'path']
Use of the wildcard response field
* mask fields: ['*'] is discouraged because:
*
* @param {!google.maps.routes.ComputeRoutesRequest} request
* @return {!Promise|undefined),
* fallbackInfo:(!google.maps.routes.FallbackInfo|null),
* geocodingResults:(!google.maps.routes.GeocodingResults|null)}>}
*/
google.maps.routes.Route.computeRoutes = function(request) {};
/**
* Creates polylines for the route based on the data available.
* Multi-modal polylines:
*
"path" and "legs" fields must
* be requested in {@link google.maps.routes.ComputeRoutesRequest.fields} TRANSIT.
Traffic polylines:
"path" and "travelAdvisory"
* fields (or just "speedPaths" as a shorthand) must be
* requested in {@link google.maps.routes.ComputeRoutesRequest.fields}. TRAFFIC_AWARE or TRAFFIC_AWARE_OPTIMAL.
* TRAFFIC_ON_POLYLINE.
Overall polyline:
* @param {!google.maps.routes.RoutePolylineOptions=} options
* @return {!Array}
*/
google.maps.routes.Route.prototype.createPolylines = function(options) {};
/**
* Creates markers for the route labeled 'A', 'B', 'C',
* etc. for each waypoint. Markers have default styling applied. Options can be
* passed in to alter the marker style based on the marker index or properties
* of the corresponding {@link google.maps.routes.RouteLeg}. The {@link
* google.maps.routes.WaypointMarkerDetails.leg} parameter will be undefined if
* the route has no legs.
"path" or "legs" field must be
* requested in {@link google.maps.routes.ComputeRoutesRequest.fields}.
The "legs" field must
* be requested in {@link google.maps.routes.ComputeRoutesRequest.fields} in
* order for intermediate waypoints to be included.
* @param {(!google.maps.marker.AdvancedMarkerElementOptions|(function(!google.maps.marker.AdvancedMarkerElementOptions,
* !google.maps.routes.WaypointMarkerDetails):
* !google.maps.marker.AdvancedMarkerElementOptions))=} options
* @return {!Promise>}
*/
google.maps.routes.Route.prototype.createWaypointAdvancedMarkers = function(
options) {};
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.Route.prototype.toJSON = function() {};
/**
* Labels for the route that are useful to identify specific properties to
* compare against others.
*
* Access by calling `const {RouteLabel} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.RouteLabel = {
/**
* The default "best" route returned for the route computation.
*/
DEFAULT_ROUTE: 'DEFAULT_ROUTE',
/**
* An alternative to the default "best" route. Routes like this will
* be returned when {@link
* google.maps.routes.ComputeRoutesRequest.computeAlternativeRoutes} is
* specified.
*/
DEFAULT_ROUTE_ALTERNATE: 'DEFAULT_ROUTE_ALTERNATE',
/**
* Fuel efficient route. Routes labeled with this value are determined to be
* optimized for eco parameters such as fuel consumption.
*/
FUEL_EFFICIENT: 'FUEL_EFFICIENT',
/**
* Shorter travel distance route. This is an experimental feature.
*/
SHORTER_DISTANCE: 'SHORTER_DISTANCE',
};
/**
* Contains a segment between non-via waypoints.
*
* Access by calling `const {RouteLeg} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteLeg = function() {};
/**
* The travel distance of the route leg, in meters.
* @type {number}
*/
google.maps.routes.RouteLeg.prototype.distanceMeters;
/**
* The length of time needed to navigate the route leg in milliseconds. If you
* set {@link google.maps.routes.ComputeRoutesRequest.routingPreference} to
* TRAFFIC_UNAWARE, then this value is the same as
* staticDurationMillis. If you set {@link
* google.maps.routes.ComputeRoutesRequest.routingPreference} to either
* TRAFFIC_AWARE or TRAFFIC_AWARE_OPTIMAL, then this
* value is calculated taking traffic conditions into account.
Note: If
* the duration exceeds 2^53 milliseconds, then this value is
* Number.POSITIVE_INFINITY.
* @type {number|null}
*/
google.maps.routes.RouteLeg.prototype.durationMillis;
/**
* The end location of this leg. This location might be different from {@link
* google.maps.routes.ComputeRoutesRequest.destination}. For example,
* when {@link google.maps.routes.ComputeRoutesRequest.destination} is not near
* a road, this is a point on the road.
* @type {!google.maps.routes.DirectionalLocation|null}
*/
google.maps.routes.RouteLeg.prototype.endLocation;
/**
* Text representations of properties of the RouteLeg.
* @type {!google.maps.routes.RouteLegLocalizedValues|null}
*/
google.maps.routes.RouteLeg.prototype.localizedValues;
/**
* The list of {@link google.maps.LatLngAltitude}s of the route leg, which can
* be used to draw a route leg polyline. Granularity of the path can be
* controlled by setting {@link
* google.maps.routes.ComputeRoutesRequest.polylineQuality}.
* @type {!Array}
*/
google.maps.routes.RouteLeg.prototype.path;
/**
* Groupings of sections of the route leg path with their corresponding speed
* reading. For this field to be populated, {@link
* google.maps.routes.ComputeRoutesRequest.routingPreference} must be set to
* TRAFFIC_AWARE or TRAFFIC_AWARE_OPTIMAL and {@link
* google.maps.routes.ComputeRoutesRequest.extraComputations} must include
* TRAFFIC_ON_POLYLINE.
* @type {!Array}
*/
google.maps.routes.RouteLeg.prototype.speedPaths;
/**
* The start location of this leg. This location might be different from {@link
* google.maps.routes.ComputeRoutesRequest.origin}. For example, when {@link
* google.maps.routes.ComputeRoutesRequest.origin} is not near a road, this is a
* point on the road.
* @type {!google.maps.routes.DirectionalLocation|null}
*/
google.maps.routes.RouteLeg.prototype.startLocation;
/**
* The duration of traveling through the leg without taking traffic conditions
* into consideration.
Note: If the duration exceeds 2^53 milliseconds,
* then this value is Number.POSITIVE_INFINITY.
* @type {number|null}
*/
google.maps.routes.RouteLeg.prototype.staticDurationMillis;
/**
* An array of steps denoting segments within this leg. Each step represents one
* navigation instruction.
* @type {!Array}
*/
google.maps.routes.RouteLeg.prototype.steps;
/**
* Overview information about the steps in this RouteLeg. This
* field is only populated for TRANSIT routes.
* @type {!google.maps.routes.StepsOverview|null}
*/
google.maps.routes.RouteLeg.prototype.stepsOverview;
/**
* Contains the additional information that the user should be informed about,
* such as possible traffic zone restrictions, on a route leg.
* @type {!google.maps.routes.RouteLegTravelAdvisory|null}
*/
google.maps.routes.RouteLeg.prototype.travelAdvisory;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteLeg.prototype.toJSON = function() {};
/**
* Text representations of the {@link google.maps.routes.RouteLeg}.
*
* Access by calling `const {RouteLegLocalizedValues} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteLegLocalizedValues = function() {};
/**
* Travel distance of the route leg in text form.
* @type {string|null}
*/
google.maps.routes.RouteLegLocalizedValues.prototype.distance;
/**
* The distance text's BCP-47 language code, such as "en-US" or
* "sr-Latn".
For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null}
*/
google.maps.routes.RouteLegLocalizedValues.prototype.distanceLanguage;
/**
* Duration, represented in text form and localized to the region of the query.
* Takes traffic conditions into consideration.
* @type {string|null}
*/
google.maps.routes.RouteLegLocalizedValues.prototype.duration;
/**
* The duration text's BCP-47 language code, such as "en-US" or
* "sr-Latn".
For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null}
*/
google.maps.routes.RouteLegLocalizedValues.prototype.durationLanguage;
/**
* Duration without taking traffic conditions into consideration, represented in
* text form.
* @type {string|null}
*/
google.maps.routes.RouteLegLocalizedValues.prototype.staticDuration;
/**
* The static duration text's BCP-47 language code, such as
* "en-US" or "sr-Latn".
* @type {string|null}
*/
google.maps.routes.RouteLegLocalizedValues.prototype.staticDurationLanguage;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteLegLocalizedValues.prototype.toJSON = function() {};
/**
* Contains a segment of a RouteLeg. A step corresponds to a single
* navigation instruction. Route legs are made up of steps.
*
* Access by calling `const {RouteLegStep} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteLegStep = function() {};
/**
* The travel distance of this step, in meters.
* @type {number}
*/
google.maps.routes.RouteLegStep.prototype.distanceMeters;
/**
* The end location of this step.
* @type {!google.maps.routes.DirectionalLocation|null}
*/
google.maps.routes.RouteLegStep.prototype.endLocation;
/**
* Instructions for navigating this step.
* @type {string|null}
*/
google.maps.routes.RouteLegStep.prototype.instructions;
/**
* Text representations of properties of the RouteLegStep.
* @type {!google.maps.routes.RouteLegStepLocalizedValues|null}
*/
google.maps.routes.RouteLegStep.prototype.localizedValues;
/**
* The navigation maneuver to perform at this step. See Maneuver
* for a list of possible values.
* @type {string|null}
*/
google.maps.routes.RouteLegStep.prototype.maneuver;
/**
* The list of {@link google.maps.LatLngAltitude}s of the route leg step, which
* can be used to draw a route leg step polyline. Granularity of the path can be
* controlled by setting {@link
* google.maps.routes.ComputeRoutesRequest.polylineQuality}. The
* "path" field must be requested in {@link
* google.maps.routes.ComputeRoutesRequest.fields} in order for this field to be
* populated.
* @type {!Array}
*/
google.maps.routes.RouteLegStep.prototype.path;
/**
* The start location of this step.
* @type {!google.maps.routes.DirectionalLocation|null}
*/
google.maps.routes.RouteLegStep.prototype.startLocation;
/**
* The duration of traveling through this step without taking traffic conditions
* into consideration.
Note: If the duration exceeds 2^53 milliseconds,
* then this value is Number.POSITIVE_INFINITY.
* @type {number|null}
*/
google.maps.routes.RouteLegStep.prototype.staticDurationMillis;
/**
* Details pertaining to this step if the travel mode is TRANSIT.
* @type {!google.maps.routes.TransitDetails|null}
*/
google.maps.routes.RouteLegStep.prototype.transitDetails;
/**
* The travel mode used for this step.
* @type {!google.maps.TravelMode|null}
*/
google.maps.routes.RouteLegStep.prototype.travelMode;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteLegStep.prototype.toJSON = function() {};
/**
* Text representations of properties of the RouteLegStep.
*
* Access by calling `const {RouteLegStepLocalizedValues} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteLegStepLocalizedValues = function() {};
/**
* Travel distance of the route leg step in text form.
* @type {string|null}
*/
google.maps.routes.RouteLegStepLocalizedValues.prototype.distance;
/**
* The distance text's BCP-47 language code, such as "en-US" or
* "sr-Latn".
For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null}
*/
google.maps.routes.RouteLegStepLocalizedValues.prototype.distanceLanguage;
/**
* Duration without taking traffic conditions into consideration, represented in
* text form.
* @type {string|null}
*/
google.maps.routes.RouteLegStepLocalizedValues.prototype.staticDuration;
/**
* The static duration text's BCP-47 language code, such as
* "en-US" or "sr-Latn".
For more information, see
* http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null}
*/
google.maps.routes.RouteLegStepLocalizedValues.prototype.staticDurationLanguage;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteLegStepLocalizedValues.prototype.toJSON = function() {};
/**
* Contains additional information that the user should be informed about on
* a {@link google.maps.routes.RouteLeg}.
*
* Access by calling `const {RouteLegTravelAdvisory} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteLegTravelAdvisory = function() {};
/**
* Speed reading intervals detailing traffic density. Applicable in case of
* TRAFFIC_AWARE and TRAFFIC_AWARE_OPTIMAL {@link
* google.maps.routes.ComputeRoutesRequest.routingPreference}. The intervals
* cover the entire polyline of the {@link google.maps.routes.RouteLeg} without
* overlap. The start point of a specified interval is the same as the end point
* of the preceding interval.
Example:
* @type {!Array|undefined}
*/
google.maps.routes.RouteLegTravelAdvisory.prototype.speedReadingIntervals;
/**
* Contains information about tolls on the specific {@link
* google.maps.routes.RouteLeg}. This field is only populated if tolls are
* expected on the {@link google.maps.routes.RouteLeg}. If this field is set
* but {@link google.maps.routes.TollInfo.estimatedPrices} is not populated,then
* the route leg contains tolls but the estimated price is unknown. If this
* field is empty, then there are no tolls on the {@link
* google.maps.routes.RouteLeg}.
* @type {google.maps.routes.TollInfo|null}
*/
google.maps.routes.RouteLegTravelAdvisory.prototype.tollInfo;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteLegTravelAdvisory.prototype.toJSON = function() {};
/**
* Text representations of properties of the polyline: A
* ---- B ---- C ---- D ---- E ---- F ---- G
speedReadingIntervals: [A,C),
* [C,D), [D,G) Route.
*
* Access by calling `const {RouteLocalizedValues} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteLocalizedValues = function() {};
/**
* Travel distance of the route represented in text form.
* @type {string|null}
*/
google.maps.routes.RouteLocalizedValues.prototype.distance;
/**
* The distance text's BCP-47 language code, such as "en-US" or
* "sr-Latn".
For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null}
*/
google.maps.routes.RouteLocalizedValues.prototype.distanceLanguage;
/**
* Duration, represented in text form and localized to the region of the query.
* Takes traffic conditions into consideration. Note: If you did not request
* traffic information, this value is the same value as
* staticDuration.
* @type {string|null}
*/
google.maps.routes.RouteLocalizedValues.prototype.duration;
/**
* The duration text's BCP-47 language code, such as "en-US" or
* "sr-Latn".
For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null}
*/
google.maps.routes.RouteLocalizedValues.prototype.durationLanguage;
/**
* Duration without taking traffic conditions into consideration, represented in
* text form.
* @type {string|null}
*/
google.maps.routes.RouteLocalizedValues.prototype.staticDuration;
/**
* The static duration text's BCP-47 language code, such as
* "en-US" or "sr-Latn".
* @type {string|null}
*/
google.maps.routes.RouteLocalizedValues.prototype.staticDurationLanguage;
/**
* Transit fare represented in text form.
* @type {string|null}
*/
google.maps.routes.RouteLocalizedValues.prototype.transitFare;
/**
* The transit fare text's BCP-47 language code, such as "en-US"
* or "sr-Latn".
* @type {string|null}
*/
google.maps.routes.RouteLocalizedValues.prototype.transitFareLanguage;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteLocalizedValues.prototype.toJSON = function() {};
/**
* A matrix of routes computed for a set of origin/destination pairs by {@link
* google.maps.routes.RouteMatrix.computeRouteMatrix}
*
* Access by calling `const {RouteMatrix} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteMatrix = function() {};
/**
* The rows of the matrix. Each row corresponds to an origin and contains an
* array of {@link google.maps.routes.RouteMatrixItem}s, each representing a
* route to a destination.
* @type {!Array}
*/
google.maps.routes.RouteMatrix.prototype.rows;
/**
* Takes in a list of origins and destinations and returns a matrix containing
* route information for each combination of origin and destination.
* Note: This method requires that you specify a response field mask in the
* request by setting the {@link
* google.maps.routes.ComputeRouteMatrixRequest.fields} property. The value is a
* list of field paths.
For example:
fields: ['*']fields: ['durationMillis',
* 'distanceMeters']
Use of the wildcard response
* field mask fields: ['*'] is discouraged because:
*
* @param {!google.maps.routes.ComputeRouteMatrixRequest} request
* @return {!Promise}
*/
google.maps.routes.RouteMatrix.computeRouteMatrix = function(request) {};
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteMatrix.prototype.toJSON = function() {};
/**
* Contains route information computed for an origin/destination pair passed
* to {@link google.maps.routes.RouteMatrix.computeRouteMatrix}.
*
* Access by calling `const {RouteMatrixItem} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteMatrixItem = function() {};
/**
* Indicates whether the route was found or not.
* @type {!google.maps.routes.RouteMatrixItemCondition|null|undefined}
*/
google.maps.routes.RouteMatrixItem.prototype.condition;
/**
* The travel distance of the route in meters.
* @type {number|undefined}
*/
google.maps.routes.RouteMatrixItem.prototype.distanceMeters;
/**
* The length of time needed to navigate the route in milliseconds. If you
* set {@link google.maps.routes.ComputeRouteMatrixRequest.routingPreference} to
* TRAFFIC_UNAWARE, then this value is the same as {@link
* google.maps.routes.RouteMatrixItem.staticDurationMillis}. If you set {@link
* google.maps.routes.ComputeRouteMatrixRequest.routingPreference} to either
* TRAFFIC_AWARE or TRAFFIC_AWARE_OPTIMAL, then this
* value is calculated taking traffic conditions into account.
Note: If
* the duration exceeds 2^53 milliseconds, then this value is
* Number.POSITIVE_INFINITY.
* @type {number|null|undefined}
*/
google.maps.routes.RouteMatrixItem.prototype.durationMillis;
/**
* Error that occurred during the computation of the route.
* @type {!google.maps.routes.RouteMatrixItemError|null|undefined}
*/
google.maps.routes.RouteMatrixItem.prototype.error;
/**
* In some cases when the server is not able to compute the route with the given
* preferences for this particular origin/destination pair, it may fall back to
* using a different mode of computation. When a fallback is used, this field
* contains detailed information about the fallback response. Otherwise this
* field is unset.
* @type {!google.maps.routes.FallbackInfo|null|undefined}
*/
google.maps.routes.RouteMatrixItem.prototype.fallbackInfo;
/**
* Text representations of properties of the {@link
* google.maps.routes.RouteMatrixItem}.
* @type {!google.maps.routes.RouteMatrixItemLocalizedValues|null|undefined}
*/
google.maps.routes.RouteMatrixItem.prototype.localizedValues;
/**
* The duration of traveling through the route without taking traffic conditions
* into consideration.
Note: If the duration exceeds 2^53 milliseconds,
* then this value is Number.POSITIVE_INFINITY.
* @type {number|null|undefined}
*/
google.maps.routes.RouteMatrixItem.prototype.staticDurationMillis;
/**
* Additional information about the route.
* @type {!google.maps.routes.RouteTravelAdvisory|null|undefined}
*/
google.maps.routes.RouteMatrixItem.prototype.travelAdvisory;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteMatrixItem.prototype.toJSON = function() {};
/**
* The condition of a route for a given origin/destination pair.
*
* Access by calling `const {RouteMatrixItemCondition} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.RouteMatrixItemCondition = {
/**
* A route was found.
*/
ROUTE_EXISTS: 'ROUTE_EXISTS',
/**
* No route could be found.
*/
ROUTE_NOT_FOUND: 'ROUTE_NOT_FOUND',
};
/**
* An error that occurred during {@link
* google.maps.routes.RouteMatrix.computeRouteMatrix} for a specific
* origin/destination pair.
*
* Access by calling `const {RouteMatrixItemError} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @extends {Error}
* @constructor
*/
google.maps.routes.RouteMatrixItemError = function() {};
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteMatrixItemError.prototype.toJSON = function() {};
/**
* Text representations of the {@link google.maps.routes.RouteMatrixItem}.
*
* Access by calling `const {RouteMatrixItemLocalizedValues} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteMatrixItemLocalizedValues = function() {};
/**
* Travel distance of the route matrix item in text form.
* @type {string|null|undefined}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype.distance;
/**
* The distance text's BCP-47 language code, such as "en-US" or
* "sr-Latn".
For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null|undefined}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype.distanceLanguage;
/**
* Duration, represented in text form and localized to the region of the query.
* Takes traffic conditions into consideration.
Note: If you did not
* request traffic information, this value is the same value as {@link
* google.maps.routes.RouteMatrixItemLocalizedValues.staticDuration}.
* @type {string|null|undefined}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype.duration;
/**
* The duration text's BCP-47 language code, such as "en-US" or
* "sr-Latn".
For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null|undefined}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype.durationLanguage;
/**
* Duration without taking traffic conditions into consideration, represented in
* text form.
* @type {string|null|undefined}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype.staticDuration;
/**
* The static duration text's BCP-47 language code, such as
* "en-US" or "sr-Latn".
* @type {string|null|undefined}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype
.staticDurationLanguage;
/**
* Transit fare, represented in text form.
* @type {string|null|undefined}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype.transitFare;
/**
* The transit fare text's BCP-47 language code, such as "en-US"
* or "sr-Latn".
For more information, see http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null|undefined}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype.transitFareLanguage;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteMatrixItemLocalizedValues.prototype.toJSON =
function() {};
/**
* A single origin for a {@link google.maps.routes.ComputeRouteMatrixRequest}.
* @record
*/
google.maps.routes.RouteMatrixOrigin = function() {};
/**
* Modifiers for every route that takes this as the origin.
* @type {!google.maps.routes.RouteModifiers|null|undefined}
*/
google.maps.routes.RouteMatrixOrigin.prototype.routeModifiers;
/**
* The location of the origin. A value passed as a string may be an address or
* plus code. Altitude values for are not taken
* into consideration.
* @type {string|google.maps.LatLng|google.maps.LatLngLiteral|google.maps.LatLngAltitudeLiteral|google.maps.routes.DirectionalLocationLiteral|google.maps.places.Place|google.maps.routes.Waypoint}
*/
google.maps.routes.RouteMatrixOrigin.prototype.waypoint;
/**
* Corresponds to an origin passed to {@link
* google.maps.routes.RouteMatrix.computeRouteMatrix}. Contains a list of {@link
* google.maps.routes.RouteMatrixItem}s, each item representing a route to a
* destination.
*
* Access by calling `const {RouteMatrixRow} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteMatrixRow = function() {};
/**
* The route information for each destination.
* @type {!Array}
*/
google.maps.routes.RouteMatrixRow.prototype.items;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteMatrixRow.prototype.toJSON = function() {};
/**
* Encapsulates a set of optional conditions to satisfy when calculating routes.
* @record
*/
google.maps.routes.RouteModifiers = function() {};
/**
* When set to true, avoids ferries where reasonable, giving
* preference to routes not containing ferries. Applies only to
* DRIVING or TWO_WHEELER {@link
* google.maps.TravelMode}.
* @type {boolean|null|undefined}
*/
google.maps.routes.RouteModifiers.prototype.avoidFerries;
/**
* When set to true, avoids highways where reasonable, giving
* preference to routes not containing highways. Applies only to
* DRIVING or TWO_WHEELER {@link
* google.maps.TravelMode}.
* @type {boolean|null|undefined}
*/
google.maps.routes.RouteModifiers.prototype.avoidHighways;
/**
* When set to true, avoids navigating indoors where reasonable,
* giving preference to routes not containing indoor navigation. Applies only to
* WALKING {@link google.maps.TravelMode}.
* @type {boolean|null|undefined}
*/
google.maps.routes.RouteModifiers.prototype.avoidIndoor;
/**
* When set to true, avoids toll roads where reasonable, giving
* preference to routes not containing toll roads. Applies only to
* DRIVING or TWO_WHEELER {@link
* google.maps.TravelMode}.
* @type {boolean|null|undefined}
*/
google.maps.routes.RouteModifiers.prototype.avoidTolls;
/**
* Encapsulates information about toll passes. If toll passes are provided, the
* API tries to return the pass price. If toll passes are not provided, the API
* treats the toll pass as unknown and tries to return the cash price. Applies
* only to DRIVING or TWO_WHEELER {@link
* google.maps.TravelMode}. See TollPass
* for a list of valid values.
* @type {!IterableFOLLOW_SYSTEM while the map colorScheme is also
* FOLLOW_SYSTEM, the polylines will be drawn in the same
* dark/light mode as the map. When not specified, {@link
* google.maps.routes.Route.createPolylines} attempts to use the
* colorScheme of the map or falls back to the system default.
* @type {!google.maps.ColorScheme|undefined}
*/
google.maps.routes.RoutePolylineOptions.prototype.colorScheme;
/**
* Options for customizing the style of a polyline. Can either be a {@link
* google.maps.PolylineOptions} object that is applied to all polylines for the
* route or a function that takes default {@link google.maps.PolylineOptions}
* and {@link google.maps.routes.RoutePolylineDetails} and returns the {@link
* google.maps.PolylineOptions} to be applied to that polyline.
* @type {!google.maps.PolylineOptions|(function(!google.maps.PolylineOptions,
* !google.maps.routes.RoutePolylineDetails):
* !google.maps.PolylineOptions)|undefined}
*/
google.maps.routes.RoutePolylineOptions.prototype.polylineOptions;
/**
* Contains additional information that the user should be informed about on
* a {@link google.maps.routes.Route}.
*
* Access by calling `const {RouteTravelAdvisory} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.RouteTravelAdvisory = function() {};
/**
* The predicted fuel consumption in microliters.
Note: If the fuel
* consumption exceeds 2^53 microliters, then this value is
* Number.POSITIVE_INFINITY.
* @type {number|undefined}
*/
google.maps.routes.RouteTravelAdvisory.prototype.fuelConsumptionMicroliters;
/**
* The {@link google.maps.routes.Route} may have restrictions that are not
* suitable for the requested travel mode or route modifiers.
* @type {boolean|null|undefined}
*/
google.maps.routes.RouteTravelAdvisory.prototype
.routeRestrictionsPartiallyIgnored;
/**
* Speed reading intervals detailing traffic density. Applicable in case of
* TRAFFIC_AWARE and TRAFFIC_AWARE_OPTIMAL {@link
* google.maps.routes.ComputeRoutesRequest.routingPreference}. The intervals
* cover the entire polyline of the {@link google.maps.routes.Route} without
* overlap. The start point of a specified interval is the same as the end point
* of the preceding interval.
Example:
* @type {!Array|undefined}
*/
google.maps.routes.RouteTravelAdvisory.prototype.speedReadingIntervals;
/**
* Contains information about tolls on the {@link google.maps.routes.Route}.
* This field is only populated if tolls are expected on the {@link
* google.maps.routes.Route}. If this field is set but {@link
* google.maps.routes.TollInfo.estimatedPrices} is not populated,then the route
* contains tolls but the estimated price is unknown. If this field is empty,
* then there are no tolls on the {@link google.maps.routes.Route}.
* @type {!google.maps.routes.TollInfo|null|undefined}
*/
google.maps.routes.RouteTravelAdvisory.prototype.tollInfo;
/**
* If present, contains the total fare or ticket costs of this {@link
* google.maps.routes.Route}. This property is only returned for
* polyline: A
* ---- B ---- C ---- D ---- E ---- F ---- G
speedReadingIntervals: [A,C),
* [C,D), [D,G) TRANSIT {@link
* google.maps.routes.ComputeRoutesRequest.travelMode} and only for routes where
* fare information is available for all transit steps.
* @type {!google.maps.places.Money|null|undefined}
*/
google.maps.routes.RouteTravelAdvisory.prototype.transitFare;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.RouteTravelAdvisory.prototype.toJSON = function() {};
/**
* Factors to take into consideration when calculating a route.
*
* Access by calling `const {RoutingPreference} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.RoutingPreference = {
/**
* Calculates routes taking live traffic conditions into consideration. In
* contrast to TRAFFIC_AWARE_OPTIMAL, some optimizations are
* applied to significantly reduce latency.
*/
TRAFFIC_AWARE: 'TRAFFIC_AWARE',
/**
* Calculates the routes taking live traffic conditions into consideration,
* without applying most performance optimizations. Using this value produces
* the highest latency.
*/
TRAFFIC_AWARE_OPTIMAL: 'TRAFFIC_AWARE_OPTIMAL',
/**
* Computes routes without taking live traffic conditions into consideration.
* Suitable when traffic conditions don't matter or are not applicable.
* Using this value produces the lowest latency.
*/
TRAFFIC_UNAWARE: 'TRAFFIC_UNAWARE',
};
/**
* The classification of polyline speed based on traffic data.
*
* Access by calling `const {Speed} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.Speed = {
/**
* Normal speed, no traffic delays.
*/
NORMAL: 'NORMAL',
/**
* Slowdown detected, medium amount of traffic.
*/
SLOW: 'SLOW',
/**
* Traffic delays.
*/
TRAFFIC_JAM: 'TRAFFIC_JAM',
};
/**
* Groups together the {@link google.maps.LatLngAltitude}s of a route interval
* with the speed reading for the interval.
* @record
*/
google.maps.routes.SpeedPath = function() {};
/**
* The path covered by this speed path.
* @type {!Array}
*/
google.maps.routes.SpeedPath.prototype.path;
/**
* The speed reading of the path.
* @type {!google.maps.routes.Speed|null|undefined}
*/
google.maps.routes.SpeedPath.prototype.speed;
/**
* Traffic density indicator on a contiguous segment of a polyline or path.
* Given a path with points P_0, P_1, ... , P_N (zero-based index), the
* SpeedReadingInterval describes the traffic density of an
* interval.
*
* Access by calling `const {SpeedReadingInterval} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.SpeedReadingInterval = function() {};
/**
* The ending index of this interval in the polyline.
* @type {number|null|undefined}
*/
google.maps.routes.SpeedReadingInterval.prototype.endPolylinePointIndex;
/**
* Traffic speed in this interval.
* @type {!google.maps.routes.Speed|null|undefined}
*/
google.maps.routes.SpeedReadingInterval.prototype.speed;
/**
* The starting index of this interval in the polyline.
* @type {number|null|undefined}
*/
google.maps.routes.SpeedReadingInterval.prototype.startPolylinePointIndex;
/**
* Converts to an object.
* @return {undefined}
*/
google.maps.routes.SpeedReadingInterval.prototype.toJSON = function() {};
/**
* Provides overview information about a list of {@link
* google.maps.routes.RouteLeg.steps}.
*
* Access by calling `const {StepsOverview} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.StepsOverview = function() {};
/**
* Summarized information about different multi-modal segments of the {@link
* google.maps.routes.RouteLeg.steps}.
* @type {!Array}
*/
google.maps.routes.StepsOverview.prototype.multiModalSegments;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.StepsOverview.prototype.toJSON = function() {};
/**
* Encapsulates toll information on a {@link google.maps.routes.Route} or {@link
* google.maps.routes.RouteLeg}.
*
* Access by calling `const {TollInfo} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.TollInfo = function() {};
/**
* The monetary amount of tolls for the corresponding {@link
* google.maps.routes.Route} or {@link google.maps.routes.RouteLeg}. This list
* contains an amount for each currency that is expected to be charged by toll
* stations. Typically this list will contain only one item for routes with
* tolls in one currency. For international trips, this list may contain
* multiple items to reflect tolls in different currencies.
* @type {!Array|null|undefined}
*/
google.maps.routes.TollInfo.prototype.estimatedPrices;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.TollInfo.prototype.toJSON = function() {};
/**
* Information about a transit agency.
*
* Access by calling `const {TransitAgency} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.TransitAgency = function() {};
/**
* The name of this transit agency.
* @type {string|null}
*/
google.maps.routes.TransitAgency.prototype.name;
/**
* The transit agency's locale-specific formatted phone number.
* @type {string|null}
*/
google.maps.routes.TransitAgency.prototype.phoneNumber;
/**
* The transit agency's URL.
* @type {!URL|null}
*/
google.maps.routes.TransitAgency.prototype.url;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.TransitAgency.prototype.toJSON = function() {};
/**
* Additional information about a transit step in a route.
*
* Access by calling `const {TransitDetails} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.TransitDetails = function() {};
/**
* Information about the arrival stop for the step.
* @type {!google.maps.routes.TransitStop|null}
*/
google.maps.routes.TransitDetails.prototype.arrivalStop;
/**
* The estimated time of arrival for the step.
* @type {!Date|null}
*/
google.maps.routes.TransitDetails.prototype.arrivalTime;
/**
* Information about the departure stop for the step.
* @type {!google.maps.routes.TransitStop|null}
*/
google.maps.routes.TransitDetails.prototype.departureStop;
/**
* The estimated time of departure for the step.
* @type {!Date|null}
*/
google.maps.routes.TransitDetails.prototype.departureTime;
/**
* Specifies the direction in which to travel on this line as marked on the
* vehicle or at the departure stop. The direction is often the terminus
* station.
* @type {string|null}
*/
google.maps.routes.TransitDetails.prototype.headsign;
/**
* Specifies the expected time in milliseconds between departures from the same
* stop at this time. For example, with a headway value of 600,000, you would
* expect a ten minute wait if you should miss your bus.
Note: If the
* headway exceeds 2^53 milliseconds, then this value is
* Number.POSITIVE_INFINITY.
* @type {number|null}
*/
google.maps.routes.TransitDetails.prototype.headwayMillis;
/**
* The number of stops from the departure to the arrival stop. This count
* includes the arrival stop, but excludes the departure stop. For example, if
* your route leaves from Stop A, passes through stops B and C, and arrives at
* stop D, stopCount will be 3.
* @type {number}
*/
google.maps.routes.TransitDetails.prototype.stopCount;
/**
* Information about the transit line used in the step.
* @type {!google.maps.routes.TransitLine|null}
*/
google.maps.routes.TransitDetails.prototype.transitLine;
/**
* The text that appears in schedules and sign boards to identify a transit trip
* to passengers. The text uniquely identifies a trip within a service day. For
* example, "538" is the tripShortText of the Amtrak
* train that leaves San Jose, CA at 15:10 on weekdays to Sacramento, CA.
* @type {string|null}
*/
google.maps.routes.TransitDetails.prototype.tripShortText;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.TransitDetails.prototype.toJSON = function() {};
/**
* Information about a transit line.
*
* Access by calling `const {TransitLine} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.TransitLine = function() {};
/**
* The transit agency (or agencies) that operates this transit line.
* @type {!Array}
*/
google.maps.routes.TransitLine.prototype.agencies;
/**
* The color commonly used in signage for this line. Represented in hexadecimal.
* @type {string|null}
*/
google.maps.routes.TransitLine.prototype.color;
/**
* The URL for the icon associated with this line.
* @type {!URL|null}
*/
google.maps.routes.TransitLine.prototype.iconURL;
/**
* The full name of this transit line, For example, "8 Avenue Local".
* @type {string|null}
*/
google.maps.routes.TransitLine.prototype.name;
/**
* The short name of this transit line. This name will normally be a line
* number, such as "M7" or "355".
* @type {string|null}
*/
google.maps.routes.TransitLine.prototype.shortName;
/**
* The color commonly used in text on signage for this line. Represented in
* hexadecimal.
* @type {string|null}
*/
google.maps.routes.TransitLine.prototype.textColor;
/**
* The URL for this transit line as provided by the transit agency.
* @type {!URL|null}
*/
google.maps.routes.TransitLine.prototype.url;
/**
* The type of vehicle that operates on this transit line.
* @type {!google.maps.routes.TransitVehicle|null}
*/
google.maps.routes.TransitLine.prototype.vehicle;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.TransitLine.prototype.toJSON = function() {};
/**
* Preferences for TRANSIT based routes that influence the route
* that is returned.
* @record
*/
google.maps.routes.TransitPreference = function() {};
/**
* A set of travel modes to use when getting a TRANSIT route.
* Defaults to all supported modes of travel.
* @type {!Iterable|undefined}
*/
google.maps.routes.TransitPreference.prototype.allowedTransitModes;
/**
* A routing preference that, when specified, influences the
* TRANSIT route returned.
* @type {!google.maps.TransitRoutePreference|undefined}
*/
google.maps.routes.TransitPreference.prototype.routingPreference;
/**
* Information about a transit stop.
*
* Access by calling `const {TransitStop} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.TransitStop = function() {};
/**
* The location of the stop expressed in latitude/longitude coordinates and an
* optional heading.
* @type {!google.maps.routes.DirectionalLocation|null}
*/
google.maps.routes.TransitStop.prototype.location;
/**
* The name of the transit stop.
* @type {string|null}
*/
google.maps.routes.TransitStop.prototype.name;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.TransitStop.prototype.toJSON = function() {};
/**
* Information about a vehicle used in transit routes.
*
* Access by calling `const {TransitVehicle} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @constructor
*/
google.maps.routes.TransitVehicle = function() {};
/**
* The URL for an icon associated with this vehicle type.
* @type {!URL|null}
*/
google.maps.routes.TransitVehicle.prototype.iconURL;
/**
* The URL for the icon associated with this vehicle type, based on the local
* transport signage.
* @type {!URL|null}
*/
google.maps.routes.TransitVehicle.prototype.localIconURL;
/**
* The name of this vehicle, capitalized.
* @type {string|null}
*/
google.maps.routes.TransitVehicle.prototype.name;
/**
* The vehicle name text's BCP-47 language code, such as "en-US"
* or "sr-Latn".
For more information see: https://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
* @type {string|null}
*/
google.maps.routes.TransitVehicle.prototype.nameLanguage;
/**
* The type of vehicle used.
See https://developers.google.com/maps/documentation/routes/reference/rpc/google.maps.routing.v2#transitvehicletype
* for a list of possible values.
* @type {string|null}
*/
google.maps.routes.TransitVehicle.prototype.vehicleType;
/**
* Converts to an object.
* @return {!Object}
*/
google.maps.routes.TransitVehicle.prototype.toJSON = function() {};
/**
* A set of values describing the vehicle's emission type. Applies only to
* the DRIVING travel mode.
*
* Access by calling `const {VehicleEmissionType} = await
* google.maps.importLibrary("routes")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @enum {string}
*/
google.maps.routes.VehicleEmissionType = {
/**
* Diesel fueled vehicle.
*/
DIESEL: 'DIESEL',
/**
* Electricity powered vehicle.
*/
ELECTRIC: 'ELECTRIC',
/**
* Gasoline/petrol fueled vehicle.
*/
GASOLINE: 'GASOLINE',
/**
* Hybrid fuel (such as gasoline + electric) vehicle.
*/
HYBRID: 'HYBRID',
};
/**
* Contains the vehicle information, such as the vehicle emission type.
* @record
*/
google.maps.routes.VehicleInfo = function() {};
/**
* Describes the vehicle's emission type. Applies only to the
* DRIVING travel mode.
* @type {!google.maps.routes.VehicleEmissionType|null|undefined}
*/
google.maps.routes.VehicleInfo.prototype.emissionType;
/**
* Represents a waypoint in a route.
* @record
*/
google.maps.routes.Waypoint = function() {};
/**
* The location of the waypoint. A string may be an address, a plus code, or a Place resource name.
* @type {string|google.maps.LatLng|google.maps.LatLngLiteral|google.maps.LatLngAltitudeLiteral|google.maps.routes.DirectionalLocationLiteral|google.maps.places.Place}
*/
google.maps.routes.Waypoint.prototype.location;
/**
* Indicates that the location of this waypoint is meant to have a preference
* for the vehicle to stop at a particular side of road. When you set this
* value, the route will pass through the location so that the vehicle can stop
* at the side of road that the location is biased towards from the center of
* the road. This option works only for DRIVING and
* TWO_WHEELER {@link
* google.maps.routes.ComputeRoutesRequest.travelMode}
* @type {boolean|null|undefined}
*/
google.maps.routes.Waypoint.prototype.sideOfRoad;
/**
* Indicates that the waypoint is meant for vehicles to stop at, where the
* intention is to either pickup or drop-off. When you set this value, the
* calculated route won't include non-via waypoints on roads
* that are unsuitable for pickup and drop-off. This option works only for
* DRIVING and TWO_WHEELER {@link
* google.maps.routes.ComputeRoutesRequest.travelMode} and when the {@link
* google.maps.routes.Waypoint.location} is not a string or
* a {@link google.maps.places.Place}.
* @type {boolean|null|undefined}
*/
google.maps.routes.Waypoint.prototype.vehicleStopover;
/**
* Marks this waypoint as a milestone rather a stopping point. For each
* non-via waypoint in the {@link
* google.maps.routes.ComputeRoutesRequest}, {@link
* google.maps.routes.Route.computeRoutes} appends an entry to the {@link
* google.maps.routes.Route.legs} array to provide the details for stopovers on
* that leg of the trip.
Set this value to true when you
* want the route to pass through this waypoint without stopping over. Via
* waypoints don't cause an entry to be added to the {@link
* google.maps.routes.Route.legs} array, but they do route the journey through
* the waypoint.
Notes:
* @type {boolean|null|undefined}
*/
google.maps.routes.Waypoint.prototype.via;
/**
* Details about a waypoint that can be used to customize marker style.
* @record
*/
google.maps.routes.WaypointMarkerDetails = function() {};
/**
* The index of the marker.
* @type {number}
*/
google.maps.routes.WaypointMarkerDetails.prototype.index;
/**
* The leg that the marker belongs to. Empty if the route has no legs.
* @type {!google.maps.routes.RouteLeg|undefined}
*/
google.maps.routes.WaypointMarkerDetails.prototype.leg;
/**
* The total number of markers in the route.
* @type {number}
*/
google.maps.routes.WaypointMarkerDetails.prototype.totalMarkers;
/**
* @const
*/
google.maps.visualization = {};
/**
* A layer that provides a client-side rendered heatmap, depicting the intensity
* of data at geographical points.
*
* Access by calling `const {HeatmapLayer} = await
* google.maps.importLibrary("visualization")`. See
* https://developers.google.com/maps/documentation/javascript/libraries.
* @param {google.maps.visualization.HeatmapLayerOptions=} opts
* @extends {google.maps.MVCObject}
* @constructor
* @deprecated The Heatmap Layer functionality in the Maps JavaScript API is no
* longer supported. This API was deprecated in May 2025 and will be made
* unavailable in a later version of the Maps JavaScript API, releasing in
* May 2026. For more info, see https://developers.google.com/maps/deprecations).
*/
google.maps.visualization.HeatmapLayer = function(opts) {};
/**
* Returns the data points currently displayed by this heatmap.
* @return {!google.maps.MVCArray}
*/
google.maps.visualization.HeatmapLayer.prototype.getData = function() {};
/**
* @return {!google.maps.Map|undefined}
*/
google.maps.visualization.HeatmapLayer.prototype.getMap = function() {};
/**
* Sets the data points to be displayed by this heatmap.
* @param {!google.maps.MVCArray|!Array}
* data
* @return {undefined}
*/
google.maps.visualization.HeatmapLayer.prototype.setData = function(data) {};
/**
* Renders the heatmap on the specified map. If map is set to true, this field cannot be set to true; otherwise, the request
* fails. null,
* the heatmap will be removed.
* @param {?google.maps.Map} map
* @return {undefined}
*/
google.maps.visualization.HeatmapLayer.prototype.setMap = function(map) {};
/**
* @param {?google.maps.visualization.HeatmapLayerOptions} options
* @return {undefined}
*/
google.maps.visualization.HeatmapLayer.prototype.setOptions = function(
options) {};
/**
* This object defines the properties that can be set on a
* HeatmapLayer object.
* @record
*/
google.maps.visualization.HeatmapLayerOptions = function() {};
/**
* The data points to display. Required.
* @type {!google.maps.MVCArray|!Array|null|undefined}
*/
google.maps.visualization.HeatmapLayerOptions.prototype.data;
/**
* Specifies whether heatmaps dissipate on zoom. By default, the radius of
* influence of a data point is specified by the radius option only. When
* dissipating is disabled, the radius option is interpreted as a radius at zoom
* level 0.
* @type {boolean|null|undefined}
*/
google.maps.visualization.HeatmapLayerOptions.prototype.dissipating;
/**
* The color gradient of the heatmap, specified as an array of CSS color
* strings. All CSS3 colors are supported except for extended named colors.
* @type {!Array0.6
* @type {number|null|undefined}
*/
google.maps.visualization.HeatmapLayerOptions.prototype.opacity;
/**
* The radius of influence for each data point, in pixels.
* @type {number|null|undefined}
*/
google.maps.visualization.HeatmapLayerOptions.prototype.radius;
/**
* A data point entry for a heatmap. This is a geographical data point with a
* weight attribute.
* @record
*/
google.maps.visualization.WeightedLocation = function() {};
/**
* The location of the data point.
* @type {!google.maps.LatLng}
*/
google.maps.visualization.WeightedLocation.prototype.location;
/**
* The weighting value of the data point.
* @type {number}
*/
google.maps.visualization.WeightedLocation.prototype.weight;
