@agm/core

  • Version 3.0.0-beta.0
  • Published
  • 1.82 MB
  • 1 dependency
  • MIT license

Install

npm i @agm/core
yarn add @agm/core
pnpm add @agm/core

Overview

Angular components for Google Maps

Index

Variables

Classes

Interfaces

Enums

Variables

variable LAZY_MAPS_API_CONFIG

const LAZY_MAPS_API_CONFIG: any;

variable ɵe

const ɵe: any[];

    Classes

    class AgmBicyclingLayer

    class AgmBicyclingLayer implements OnInit, OnDestroy {}

      constructor

      constructor(_manager: LayerManager);

        property visible

        visible: boolean;
        • Hide/show bicycling layer

        method ngOnInit

        ngOnInit: () => void;

          class AgmCircle

          class AgmCircle implements OnInit, OnChanges, OnDestroy {}

            constructor

            constructor(_manager: CircleManager);

              property centerChange

              centerChange: any;
              • This event is fired when the circle's center is changed.

              property circleClick

              circleClick: any;
              • This event emitter gets emitted when the user clicks on the circle.

              property circleDblClick

              circleDblClick: any;
              • This event emitter gets emitted when the user clicks on the circle.

              property clickable

              clickable: boolean;
              • Indicates whether this Circle handles mouse events. Defaults to true.

              property drag

              drag: any;
              • This event is repeatedly fired while the user drags the circle.

              property dragEnd

              dragEnd: any;
              • This event is fired when the user stops dragging the circle.

              property draggable

              draggable: boolean;
              • If set to true, the user can drag this circle over the map. Defaults to false.

              property dragStart

              dragStart: any;
              • This event is fired when the user starts dragging the circle.

              property editable

              editable: boolean;
              • 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. Defaults to false.

              property fillColor

              fillColor: string;
              • The fill color. All CSS3 colors are supported except for extended named colors.

              property fillOpacity

              fillOpacity: number;
              • The fill opacity between 0.0 and 1.0.

              property latitude

              latitude: number;
              • The latitude position of the circle (required).

              property longitude

              longitude: number;
              • The clickable position of the circle (required).

              property mouseDown

              mouseDown: any;
              • This event is fired when the DOM mousedown event is fired on the circle.

              property mouseMove

              mouseMove: any;
              • This event is fired when the DOM mousemove event is fired on the circle.

              property mouseOut

              mouseOut: any;
              • This event is fired on circle mouseout.

              property mouseOver

              mouseOver: any;
              • This event is fired on circle mouseover.

              property mouseUp

              mouseUp: any;
              • This event is fired when the DOM mouseup event is fired on the circle.

              property radius

              radius: number;
              • The radius in meters on the Earth's surface.

              property radiusChange

              radiusChange: any;
              • This event is fired when the circle's radius is changed.

              property rightClick

              rightClick: any;
              • This event is fired when the circle is right-clicked on.

              property strokeColor

              strokeColor: string;
              • The stroke color. All CSS3 colors are supported except for extended named colors.

              property strokeOpacity

              strokeOpacity: number;
              • The stroke opacity between 0.0 and 1.0

              property strokePosition

              strokePosition: string | number | symbol;
              • The stroke position. Defaults to CENTER. This property is not supported on Internet Explorer 8 and earlier.

              property strokeWeight

              strokeWeight: number;
              • The stroke width in pixels.

              property visible

              visible: boolean;
              • Whether this circle is visible on the map. Defaults to true.

              property zIndex

              zIndex: number;
              • The zIndex compared to other polys.

              method getBounds

              getBounds: () => Promise<google.maps.LatLngBounds>;
              • Gets the LatLngBounds of this Circle.

              method getCenter

              getCenter: () => Promise<google.maps.LatLng>;

                class AgmCoreModule

                class AgmCoreModule {}
                • The angular-google-maps core module. Contains all Directives/Services/Pipes of the core module. Please use AgmCoreModule.forRoot() in your app module.

                method forRoot

                static forRoot: (
                lazyMapsAPILoaderConfig?: LazyMapsAPILoaderConfigLiteral
                ) => any;
                • Please use this method when you register the module at the root level.

                class AgmDataLayer

                class AgmDataLayer implements OnInit, OnDestroy, OnChanges {}
                • AgmDataLayer enables the user to add data layers to the map.

                  ### Example

                  import { Component } from 'angular2/core';
                  import { AgmMap, AgmDataLayer } from
                  'angular-google-maps/core';
                  @Component({
                  selector: 'my-map-cmp',
                  directives: [AgmMap, AgmDataLayer],
                  styles: [`
                  .agm-container {
                  height: 300px;
                  }
                  `],
                  template: `
                  <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
                  <agm-data-layer [geoJson]="geoJsonObject" (layerClick)="clicked($event)" [style]="styleFunc">
                  </agm-data-layer>
                  </agm-map>
                  `
                  })
                  export class MyMapCmp {
                  lat: number = -25.274449;
                  lng: number = 133.775060;
                  zoom: number = 5;
                  clicked(clickEvent) {
                  console.log(clickEvent);
                  }
                  styleFunc(feature) {
                  return ({
                  clickable: false,
                  fillColor: feature.getProperty('color'),
                  strokeWeight: 1
                  });
                  }
                  geoJsonObject: Object = {
                  "type": "FeatureCollection",
                  "features": [
                  {
                  "type": "Feature",
                  "properties": {
                  "letter": "G",
                  "color": "blue",
                  "rank": "7",
                  "ascii": "71"
                  },
                  "geometry": {
                  "type": "Polygon",
                  "coordinates": [
                  [
                  [123.61, -22.14], [122.38, -21.73], [121.06, -21.69], [119.66, -22.22], [119.00, -23.40],
                  [118.65, -24.76], [118.43, -26.07], [118.78, -27.56], [119.22, -28.57], [120.23, -29.49],
                  [121.77, -29.87], [123.57, -29.64], [124.45, -29.03], [124.71, -27.95], [124.80, -26.70],
                  [124.80, -25.60], [123.61, -25.64], [122.56, -25.64], [121.72, -25.72], [121.81, -26.62],
                  [121.86, -26.98], [122.60, -26.90], [123.57, -27.05], [123.57, -27.68], [123.35, -28.18],
                  [122.51, -28.38], [121.77, -28.26], [121.02, -27.91], [120.49, -27.21], [120.14, -26.50],
                  [120.10, -25.64], [120.27, -24.52], [120.67, -23.68], [121.72, -23.32], [122.43, -23.48],
                  [123.04, -24.04], [124.54, -24.28], [124.58, -23.20], [123.61, -22.14]
                  ]
                  ]
                  }
                  },
                  {
                  "type": "Feature",
                  "properties": {
                  "letter": "o",
                  "color": "red",
                  "rank": "15",
                  "ascii": "111"
                  },
                  "geometry": {
                  "type": "Polygon",
                  "coordinates": [
                  [
                  [128.84, -25.76], [128.18, -25.60], [127.96, -25.52], [127.88, -25.52], [127.70, -25.60],
                  [127.26, -25.79], [126.60, -26.11], [126.16, -26.78], [126.12, -27.68], [126.21, -28.42],
                  [126.69, -29.49], [127.74, -29.80], [128.80, -29.72], [129.41, -29.03], [129.72, -27.95],
                  [129.68, -27.21], [129.33, -26.23], [128.84, -25.76]
                  ],
                  [
                  [128.45, -27.44], [128.32, -26.94], [127.70, -26.82], [127.35, -27.05], [127.17, -27.80],
                  [127.57, -28.22], [128.10, -28.42], [128.49, -27.80], [128.45, -27.44]
                  ]
                  ]
                  }
                  },
                  {
                  "type": "Feature",
                  "properties": {
                  "letter": "o",
                  "color": "yellow",
                  "rank": "15",
                  "ascii": "111"
                  },
                  "geometry": {
                  "type": "Polygon",
                  "coordinates": [
                  [
                  [131.87, -25.76], [131.35, -26.07], [130.95, -26.78], [130.82, -27.64], [130.86, -28.53],
                  [131.26, -29.22], [131.92, -29.76], [132.45, -29.87], [133.06, -29.76], [133.72, -29.34],
                  [134.07, -28.80], [134.20, -27.91], [134.07, -27.21], [133.81, -26.31], [133.37, -25.83],
                  [132.71, -25.64], [131.87, -25.76]
                  ],
                  [
                  [133.15, -27.17], [132.71, -26.86], [132.09, -26.90], [131.74, -27.56], [131.79, -28.26],
                  [132.36, -28.45], [132.93, -28.34], [133.15, -27.76], [133.15, -27.17]
                  ]
                  ]
                  }
                  },
                  {
                  "type": "Feature",
                  "properties": {
                  "letter": "g",
                  "color": "blue",
                  "rank": "7",
                  "ascii": "103"
                  },
                  "geometry": {
                  "type": "Polygon",
                  "coordinates": [
                  [
                  [138.12, -25.04], [136.84, -25.16], [135.96, -25.36], [135.26, -25.99], [135, -26.90],
                  [135.04, -27.91], [135.26, -28.88], [136.05, -29.45], [137.02, -29.49], [137.81, -29.49],
                  [137.94, -29.99], [137.90, -31.20], [137.85, -32.24], [136.88, -32.69], [136.45, -32.36],
                  [136.27, -31.80], [134.95, -31.84], [135.17, -32.99], [135.52, -33.43], [136.14, -33.76],
                  [137.06, -33.83], [138.12, -33.65], [138.86, -33.21], [139.30, -32.28], [139.30, -31.24],
                  [139.30, -30.14], [139.21, -28.96], [139.17, -28.22], [139.08, -27.41], [139.08, -26.47],
                  [138.99, -25.40], [138.73, -25.00], [138.12, -25.04]
                  ],
                  [
                  [137.50, -26.54], [136.97, -26.47], [136.49, -26.58], [136.31, -27.13], [136.31, -27.72],
                  [136.58, -27.99], [137.50, -28.03], [137.68, -27.68], [137.59, -26.78], [137.50, -26.54]
                  ]
                  ]
                  }
                  },
                  {
                  "type": "Feature",
                  "properties": {
                  "letter": "l",
                  "color": "green",
                  "rank": "12",
                  "ascii": "108"
                  },
                  "geometry": {
                  "type": "Polygon",
                  "coordinates": [
                  [
                  [140.14, -21.04], [140.31, -29.42], [141.67, -29.49], [141.59, -20.92], [140.14, -21.04]
                  ]
                  ]
                  }
                  },
                  {
                  "type": "Feature",
                  "properties": {
                  "letter": "e",
                  "color": "red",
                  "rank": "5",
                  "ascii": "101"
                  },
                  "geometry": {
                  "type": "Polygon",
                  "coordinates": [
                  [
                  [144.14, -27.41], [145.67, -27.52], [146.86, -27.09], [146.82, -25.64], [146.25, -25.04],
                  [145.45, -24.68], [144.66, -24.60], [144.09, -24.76], [143.43, -25.08], [142.99, -25.40],
                  [142.64, -26.03], [142.64, -27.05], [142.64, -28.26], [143.30, -29.11], [144.18, -29.57],
                  [145.41, -29.64], [146.46, -29.19], [146.64, -28.72], [146.82, -28.14], [144.84, -28.42],
                  [144.31, -28.26], [144.14, -27.41]
                  ],
                  [
                  [144.18, -26.39], [144.53, -26.58], [145.19, -26.62], [145.72, -26.35], [145.81, -25.91],
                  [145.41, -25.68], [144.97, -25.68], [144.49, -25.64], [144, -25.99], [144.18, -26.39]
                  ]
                  ]
                  }
                  }
                  ]
                  };
                  }

                constructor

                constructor(_manager: DataLayerManager);

                  property geoJson

                  geoJson: string | object;
                  • The geoJson to be displayed

                  property layerClick

                  layerClick: any;
                  • This event is fired when a feature in the layer is clicked.

                  property style

                  style: (param: any) => any;
                  • The layer's style function.

                  method ngOnInit

                  ngOnInit: () => void;

                    class AgmFitBounds

                    class AgmFitBounds implements OnInit, OnDestroy, OnChanges {}
                    • Adds the given directive to the auto fit bounds feature when the value is true. To make it work with you custom AGM component, you also have to implement the FitBoundsAccessor abstract class.

                      Example 1

                      <agm-marker [agmFitBounds]="true">

                    constructor

                    constructor(
                    _fitBoundsAccessor: FitBoundsAccessor,
                    _fitBoundsService: FitBoundsService
                    );

                      property agmFitBounds

                      agmFitBounds: boolean;
                      • If the value is true, the element gets added to the bounds of the map. Default: true.

                      class AgmFullscreenControl

                      class AgmFullscreenControl extends AgmMapControl {}

                        method getOptions

                        getOptions: () => any;

                          class AgmGeocoder

                          class AgmGeocoder {}

                            constructor

                            constructor(loader: MapsAPILoader);

                              property geocoder$

                              protected readonly geocoder$: any;

                                method geocode

                                geocode: (request: any) => any;

                                  class AgmInfoWindow

                                  class AgmInfoWindow implements OnDestroy, OnChanges, OnInit {}
                                  • AgmInfoWindow renders a info window inside a AgmMarker or standalone.

                                    ### Example

                                    import { Component } from '@angular/core';
                                    @Component({
                                    selector: 'my-map-cmp',
                                    styles: [`
                                    .agm-map-container {
                                    height: 300px;
                                    }
                                    `],
                                    template: `
                                    <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
                                    <agm-marker [latitude]="lat" [longitude]="lng" [label]="'M'">
                                    <agm-info-window [disableAutoPan]="true">
                                    Hi, this is the content of the <strong>info window</strong>
                                    </agm-info-window>
                                    </agm-marker>
                                    </agm-map>
                                    `
                                    })

                                  constructor

                                  constructor(_infoWindowManager: InfoWindowManager, _el: any);

                                    property content

                                    content: Node;
                                    • Holds the native element that is used for the info window content.

                                    property disableAutoPan

                                    disableAutoPan: boolean;
                                    • Disable auto-pan on open. By default, the info window will pan the map so that it is fully visible when it opens.

                                    property hostMarker

                                    hostMarker: AgmMarker;
                                    • Holds the marker that is the host of the info window (if available)

                                    property infoWindowClose

                                    infoWindowClose: any;
                                    • Emits an event when the info window is closed.

                                    property isOpen

                                    isOpen: boolean;
                                    • Sets the open state for the InfoWindow. You can also call the open() and close() methods.

                                    property latitude

                                    latitude: number;
                                    • The latitude position of the info window (only usefull if you use it ouside of a AgmMarker).

                                    property longitude

                                    longitude: number;
                                    • The longitude position of the info window (only usefull if you use it ouside of a AgmMarker).

                                    property maxWidth

                                    maxWidth: number;
                                    • 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, update maxWidth, and then open.

                                    property zIndex

                                    zIndex: number;
                                    • 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.

                                    method close

                                    close: () => Promise<void>;
                                    • Closes the info window.

                                    method ngOnInit

                                    ngOnInit: () => void;

                                      method open

                                      open: () => Promise<void>;
                                      • Opens the info window.

                                      class AgmKmlLayer

                                      class AgmKmlLayer implements OnInit, OnDestroy, OnChanges {}

                                        constructor

                                        constructor(_manager: KmlLayerManager);

                                          property clickable

                                          clickable: boolean;
                                          • If true, the layer receives mouse events. Default value is true.

                                          property defaultViewportChange

                                          defaultViewportChange: any;
                                          • This event is fired when the KML layers default viewport has changed.

                                          property layerClick

                                          layerClick: any;
                                          • This event is fired when a feature in the layer is clicked.

                                          property preserveViewport

                                          preserveViewport: boolean;
                                          • By default, the input map is centered and zoomed to the bounding box of the contents of the layer. If this option is set to true, the viewport is left unchanged, unless the map's center and zoom were never set.

                                          property screenOverlays

                                          screenOverlays: boolean;
                                          • Whether to render the screen overlays. Default true.

                                          property statusChange

                                          statusChange: any;
                                          • This event is fired when the KML layer has finished loading. At this point it is safe to read the status property to determine if the layer loaded successfully.

                                          property suppressInfoWindows

                                          suppressInfoWindows: boolean;
                                          • Suppress the rendering of info windows when layer features are clicked.

                                          property url

                                          url: string;
                                          • The URL of the KML document to display.

                                          property zIndex

                                          zIndex: number;
                                          • The z-index of the layer.

                                          method ngOnChanges

                                          ngOnChanges: (changes: any) => void;

                                            method ngOnInit

                                            ngOnInit: () => void;

                                              class AgmMap

                                              class AgmMap implements OnChanges, AfterContentInit, OnDestroy {}
                                              • AgmMap renders a Google Map. **Important note**: To be able see a map in the browser, you have to define a height for the element agm-map.

                                                ### Example

                                                import { Component } from '@angular/core';
                                                @Component({
                                                selector: 'my-map-cmp',
                                                styles: [`
                                                agm-map {
                                                height: 300px;
                                                }
                                                `],
                                                template: `
                                                <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
                                                </agm-map>
                                                `
                                                })

                                              constructor

                                              constructor(
                                              _elem: any,
                                              _mapsWrapper: GoogleMapsAPIWrapper,
                                              _platformId: Object,
                                              _fitBoundsService: FitBoundsService,
                                              _zone: any
                                              );

                                                property backgroundColor

                                                backgroundColor: string;
                                                • 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.

                                                property boundsChange

                                                boundsChange: any;
                                                • This event is fired when the viewport bounds have changed.

                                                property centerChange

                                                centerChange: any;
                                                • This event emitter is fired when the map center changes.

                                                property clickableIcons

                                                clickableIcons: boolean;
                                                • When false, map icons are not clickable. A map icon represents a point of interest, also known as a POI. By default map icons are clickable.

                                                property controlSize

                                                controlSize: number;
                                                • The control size for the default map controls. Only governs the controls made by the Maps API itself

                                                property disableDefaultUI

                                                disableDefaultUI: boolean;
                                                • Enables/disables all default UI of the Google map. Please note: When the map is created, this value cannot get updated.

                                                property disableDoubleClickZoom

                                                disableDoubleClickZoom: boolean;
                                                • Enables/disables zoom and center on double click. Enabled by default.

                                                property draggable

                                                draggable: boolean;
                                                • Enables/disables if map is draggable.

                                                property draggableCursor

                                                draggableCursor: string;
                                                • 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;'"

                                                property draggingCursor

                                                draggingCursor: string;
                                                • 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;'"

                                                property fitBounds

                                                fitBounds: any;
                                                • Sets the viewport to contain the given bounds. If this option to true, the bounds get automatically computed from all elements that use the AgmFitBounds directive.

                                                property fitBoundsPadding

                                                fitBoundsPadding: any;
                                                • Padding amount for the bounds.

                                                property gestureHandling

                                                gestureHandling: any;
                                                • This setting controls how gestures on the map are handled. Allowed values: - 'cooperative' (Two-finger touch gestures pan and zoom the map. One-finger touch gestures are not handled by the map.) - 'greedy' (All touch gestures 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 not.

                                                property idle

                                                idle: any;
                                                • This event is fired when the map becomes idle after panning or zooming.

                                                property keyboardShortcuts

                                                keyboardShortcuts: boolean;
                                                • If false, prevents the map from being controlled by the keyboard. Keyboard shortcuts are enabled by default.

                                                property latitude

                                                latitude: number;
                                                • The latitude that defines the center of the map.

                                                property longitude

                                                longitude: number;
                                                • The longitude that defines the center of the map.

                                                property mapClick

                                                mapClick: any;
                                                • This event emitter gets emitted when the user clicks on the map (but not when they click on a marker or infoWindow).

                                                property mapControls

                                                mapControls: any;

                                                  property mapDblClick

                                                  mapDblClick: any;
                                                  • This event emitter gets emitted when the user double-clicks on the map (but not when they click on a marker or infoWindow).

                                                  property mapReady

                                                  mapReady: any;
                                                  • This event is fired when the google map is fully initialized. You get the google.maps.Map instance as a result of this EventEmitter.

                                                  property mapRightClick

                                                  mapRightClick: any;
                                                  • This event emitter gets emitted when the user right-clicks on the map (but not when they click on a marker or infoWindow).

                                                  property mapTypeId

                                                  mapTypeId: string | number | symbol;
                                                  • The map mapTypeId. Defaults to 'roadmap'.

                                                  property mapTypeIdChange

                                                  mapTypeIdChange: any;
                                                  • This event is fired when the mapTypeId property changes.

                                                  property maxZoom

                                                  maxZoom: number;
                                                  • The maximal zoom level of the map allowed. When not provided, no restrictions to the zoom level are enforced.

                                                  property minZoom

                                                  minZoom: number;
                                                  • The minimal zoom level of the map allowed. When not provided, no restrictions to the zoom level are enforced.

                                                  property restriction

                                                  restriction: any;
                                                  • Options for restricting the bounds of the map. User cannot pan or zoom away from restricted area.

                                                  property scrollwheel

                                                  scrollwheel: boolean;
                                                  • If false, disables scrollwheel zooming on the map. The scrollwheel is enabled by default.

                                                  property showDefaultInfoWindow

                                                  showDefaultInfoWindow: boolean;
                                                  • A map icon represents a point of interest, also known as a POI. When map icons are clickable by default, an info window is displayed. When this property is set to false, the info window will not be shown but the click event will still fire

                                                  property styles

                                                  styles: any[];
                                                  • 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.

                                                  property tilesLoaded

                                                  tilesLoaded: any;
                                                  • This event is fired when the visible tiles have finished loading.

                                                  property tilt

                                                  tilt: number;
                                                  • 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. (Default of AGM is 0 (disabled). Enable it with value 45.)

                                                  property usePanning

                                                  usePanning: boolean;
                                                  • When true and the latitude and/or longitude values changes, the Google Maps panTo method is used to center the map. See: https://developers.google.com/maps/documentation/javascript/reference#Map

                                                  property zoom

                                                  zoom: number;
                                                  • The zoom level of the map. The default zoom level is 8.

                                                  property zoomChange

                                                  zoomChange: any;
                                                  • This event is fired when the zoom level has changed.

                                                  method ngOnChanges

                                                  ngOnChanges: (changes: any) => void;

                                                    method triggerResize

                                                    triggerResize: (recenter?: boolean) => Promise<void>;
                                                    • Triggers a resize event on the google map instance. When recenter is true, the of the google map gets called with the current lat/lng values or fitBounds value to recenter the map. Returns a promise that gets resolved after the event was triggered.

                                                    class AgmMapTypeControl

                                                    class AgmMapTypeControl extends AgmMapControl {}

                                                      property mapTypeIds

                                                      mapTypeIds: (string | number | symbol)[];

                                                        property style

                                                        style: string | number | symbol;

                                                          method getOptions

                                                          getOptions: () => any;

                                                            class AgmMarker

                                                            class AgmMarker
                                                            implements OnDestroy, OnChanges, AfterContentInit, FitBoundsAccessor {}
                                                            • AgmMarker renders a map marker inside a AgmMap.

                                                              ### Example

                                                              import { Component } from '@angular/core';
                                                              @Component({
                                                              selector: 'my-map-cmp',
                                                              styles: [`
                                                              .agm-map-container {
                                                              height: 300px;
                                                              }
                                                              `],
                                                              template: `
                                                              <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
                                                              <agm-marker [latitude]="lat" [longitude]="lng" [label]="'M'">
                                                              </agm-marker>
                                                              </agm-map>
                                                              `
                                                              })

                                                            constructor

                                                            constructor(_markerManager: MarkerManager);

                                                              property animation

                                                              animation: string | number | symbol;
                                                              • Which animation to play when marker is added to a map. This can be 'BOUNCE' or 'DROP'

                                                              property animationChange

                                                              animationChange: any;
                                                              • This event is fired when the marker's animation property changes.

                                                              property clickable

                                                              clickable: boolean;
                                                              • If true, the marker can be clicked. Default value is true.

                                                              property drag

                                                              drag: any;
                                                              • This event is repeatedly fired while the user drags the marker.

                                                              property dragEnd

                                                              dragEnd: any;
                                                              • This event is fired when the user stops dragging the marker.

                                                              property draggable

                                                              draggable: boolean;
                                                              • If true, the marker can be dragged. Default value is false.

                                                              property dragStart

                                                              dragStart: any;
                                                              • This event is fired when the user starts dragging the marker.

                                                              property iconUrl

                                                              iconUrl: any;
                                                              • Icon (the URL of the image) for the foreground.

                                                              property label

                                                              label: any;
                                                              • The label (a single uppercase character) for the marker.

                                                              property latitude

                                                              latitude: number;
                                                              • The latitude position of the marker.

                                                              property longitude

                                                              longitude: number;
                                                              • The longitude position of the marker.

                                                              property markerClick

                                                              markerClick: any;
                                                              • This event emitter gets emitted when the user clicks on the marker.

                                                              property markerDblClick

                                                              markerDblClick: any;
                                                              • This event emitter gets emitted when the user clicks twice on the marker.

                                                              property markerRightClick

                                                              markerRightClick: any;
                                                              • This event is fired when the user rightclicks on the marker.

                                                              property mouseOut

                                                              mouseOut: any;
                                                              • This event is fired when the user mouses outside the marker.

                                                              property mouseOver

                                                              mouseOver: any;
                                                              • This event is fired when the user mouses over the marker.

                                                              property opacity

                                                              opacity: number;
                                                              • The marker's opacity between 0.0 and 1.0.

                                                              property openInfoWindow

                                                              openInfoWindow: boolean;
                                                              • Whether to automatically open the child info window when the marker is clicked.

                                                              property title

                                                              title: string;
                                                              • The title of the marker.

                                                              property visible

                                                              visible: boolean;
                                                              • If true, the marker is visible

                                                              property zIndex

                                                              zIndex: number;
                                                              • 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.

                                                              method ngAfterContentInit

                                                              ngAfterContentInit: () => void;

                                                                class AgmPanControl

                                                                class AgmPanControl extends AgmMapControl {}

                                                                  method getOptions

                                                                  getOptions: () => any;

                                                                    class AgmPolygon

                                                                    class AgmPolygon implements OnDestroy, OnChanges, AfterContentInit {}
                                                                    • AgmPolygon renders a polygon on a AgmMap

                                                                      ### Example

                                                                      import { Component } from '@angular/core';
                                                                      @Component({
                                                                      selector: 'my-map-cmp',
                                                                      styles: [`
                                                                      agm-map {
                                                                      height: 300px;
                                                                      }
                                                                      `],
                                                                      template: `
                                                                      <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
                                                                      <agm-polygon [paths]="paths">
                                                                      </agm-polygon>
                                                                      </agm-map>
                                                                      `
                                                                      })
                                                                      export class MyMapCmp {
                                                                      lat: number = 0;
                                                                      lng: number = 0;
                                                                      zoom: number = 10;
                                                                      paths: LatLngLiteral[] = [
                                                                      { lat: 0, lng: 10 },
                                                                      { lat: 0, lng: 20 },
                                                                      { lat: 10, lng: 20 },
                                                                      { lat: 10, lng: 10 },
                                                                      { lat: 0, lng: 10 }
                                                                      ]
                                                                      // Nesting paths will create a hole where they overlap;
                                                                      nestedPaths: LatLngLiteral[][] = [[
                                                                      { lat: 0, lng: 10 },
                                                                      { lat: 0, lng: 20 },
                                                                      { lat: 10, lng: 20 },
                                                                      { lat: 10, lng: 10 },
                                                                      { lat: 0, lng: 10 }
                                                                      ], [
                                                                      { lat: 0, lng: 15 },
                                                                      { lat: 0, lng: 20 },
                                                                      { lat: 5, lng: 20 },
                                                                      { lat: 5, lng: 15 },
                                                                      { lat: 0, lng: 15 }
                                                                      ]]
                                                                      }

                                                                    constructor

                                                                    constructor(_polygonManager: PolygonManager);

                                                                      property clickable

                                                                      clickable: boolean;
                                                                      • Indicates whether this Polygon handles mouse events. Defaults to true.

                                                                      property draggable

                                                                      draggable: boolean;
                                                                      • If set to true, the user can drag this shape over the map. The geodesic property defines the mode of dragging. Defaults to false.

                                                                      property editable

                                                                      editable: boolean;
                                                                      • If set to true, the user can edit this shape by dragging the control points shown at the vertices and on each segment. Defaults to false.

                                                                      property fillColor

                                                                      fillColor: string;
                                                                      • The fill color. All CSS3 colors are supported except for extended named colors.

                                                                      property fillOpacity

                                                                      fillOpacity: number;
                                                                      • The fill opacity between 0.0 and 1.0

                                                                      property geodesic

                                                                      geodesic: boolean;
                                                                      • 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. Defaults to false.

                                                                      property paths

                                                                      paths: any;
                                                                      • 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 Arrays. Inserting or removing LatLngs from the Array will automatically update the polygon on the map.

                                                                      property polyClick

                                                                      polyClick: any;
                                                                      • This event is fired when the DOM click event is fired on the Polygon.

                                                                      property polyDblClick

                                                                      polyDblClick: any;
                                                                      • This event is fired when the DOM dblclick event is fired on the Polygon.

                                                                      property polyDrag

                                                                      polyDrag: any;
                                                                      • This event is repeatedly fired while the user drags the polygon.

                                                                      property polyDragEnd

                                                                      polyDragEnd: any;
                                                                      • This event is fired when the user stops dragging the polygon.

                                                                      property polyDragStart

                                                                      polyDragStart: any;
                                                                      • This event is fired when the user starts dragging the polygon.

                                                                      property polyMouseDown

                                                                      polyMouseDown: any;
                                                                      • This event is fired when the DOM mousedown event is fired on the Polygon.

                                                                      property polyMouseMove

                                                                      polyMouseMove: any;
                                                                      • This event is fired when the DOM mousemove event is fired on the Polygon.

                                                                      property polyMouseOut

                                                                      polyMouseOut: any;
                                                                      • This event is fired on Polygon mouseout.

                                                                      property polyMouseOver

                                                                      polyMouseOver: any;
                                                                      • This event is fired on Polygon mouseover.

                                                                      property polyMouseUp

                                                                      polyMouseUp: any;
                                                                      • This event is fired whe the DOM mouseup event is fired on the Polygon

                                                                      property polyPathsChange

                                                                      polyPathsChange: any;
                                                                      • This event is fired after Polygon first path changes.

                                                                      property polyRightClick

                                                                      polyRightClick: any;
                                                                      • This event is fired when the Polygon is right-clicked on.

                                                                      property strokeColor

                                                                      strokeColor: string;
                                                                      • The stroke color. All CSS3 colors are supported except for extended named colors.

                                                                      property strokeOpacity

                                                                      strokeOpacity: number;
                                                                      • The stroke opacity between 0.0 and 1.0

                                                                      property strokeWeight

                                                                      strokeWeight: number;
                                                                      • The stroke width in pixels.

                                                                      property visible

                                                                      visible: boolean;
                                                                      • Whether this polygon is visible on the map. Defaults to true.

                                                                      property zIndex

                                                                      zIndex: number;
                                                                      • The zIndex compared to other polys.

                                                                      method getPath

                                                                      getPath: () => Promise<google.maps.LatLng[]>;

                                                                        method getPaths

                                                                        getPaths: () => Promise<google.maps.LatLng[][]>;

                                                                          method ngOnChanges

                                                                          ngOnChanges: (changes: any) => any;

                                                                            class AgmPolyline

                                                                            class AgmPolyline implements OnDestroy, OnChanges, AfterContentInit {}
                                                                            • AgmPolyline renders a polyline on a AgmMap

                                                                              ### Example

                                                                              import { Component } from '@angular/core';
                                                                              @Component({
                                                                              selector: 'my-map-cmp',
                                                                              styles: [`
                                                                              .agm-map-container {
                                                                              height: 300px;
                                                                              }
                                                                              `],
                                                                              template: `
                                                                              <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
                                                                              <agm-polyline>
                                                                              <agm-polyline-point [latitude]="latA" [longitude]="lngA">
                                                                              </agm-polyline-point>
                                                                              <agm-polyline-point [latitude]="latB" [longitude]="lngB">
                                                                              </agm-polyline-point>
                                                                              </agm-polyline>
                                                                              </agm-map>
                                                                              `
                                                                              })

                                                                            constructor

                                                                            constructor(_polylineManager: PolylineManager);

                                                                              property clickable

                                                                              clickable: boolean;
                                                                              • Indicates whether this Polyline handles mouse events. Defaults to true.

                                                                              property draggable

                                                                              draggable: boolean;
                                                                              • If set to true, the user can drag this shape over the map. The geodesic property defines the mode of dragging. Defaults to false.

                                                                              property editable

                                                                              editable: boolean;
                                                                              • If set to true, the user can edit this shape by dragging the control points shown at the vertices and on each segment. Defaults to false.

                                                                              property geodesic

                                                                              geodesic: boolean;
                                                                              • 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. Defaults to false.

                                                                              property iconSequences

                                                                              iconSequences: any;

                                                                                property lineClick

                                                                                lineClick: any;
                                                                                • This event is fired when the DOM click event is fired on the Polyline.

                                                                                property lineDblClick

                                                                                lineDblClick: any;
                                                                                • This event is fired when the DOM dblclick event is fired on the Polyline.

                                                                                property lineDrag

                                                                                lineDrag: any;
                                                                                • This event is repeatedly fired while the user drags the polyline.

                                                                                property lineDragEnd

                                                                                lineDragEnd: any;
                                                                                • This event is fired when the user stops dragging the polyline.

                                                                                property lineDragStart

                                                                                lineDragStart: any;
                                                                                • This event is fired when the user starts dragging the polyline.

                                                                                property lineMouseDown

                                                                                lineMouseDown: any;
                                                                                • This event is fired when the DOM mousedown event is fired on the Polyline.

                                                                                property lineMouseMove

                                                                                lineMouseMove: any;
                                                                                • This event is fired when the DOM mousemove event is fired on the Polyline.

                                                                                property lineMouseOut

                                                                                lineMouseOut: any;
                                                                                • This event is fired on Polyline mouseout.

                                                                                property lineMouseOver

                                                                                lineMouseOver: any;
                                                                                • This event is fired on Polyline mouseover.

                                                                                property lineMouseUp

                                                                                lineMouseUp: any;
                                                                                • This event is fired whe the DOM mouseup event is fired on the Polyline

                                                                                property lineRightClick

                                                                                lineRightClick: any;
                                                                                • This event is fired when the Polyline is right-clicked on.

                                                                                property polyPathChange

                                                                                polyPathChange: any;
                                                                                • This event is fired after Polyline's path changes.

                                                                                property strokeColor

                                                                                strokeColor: string;
                                                                                • The stroke color. All CSS3 colors are supported except for extended named colors.

                                                                                property strokeOpacity

                                                                                strokeOpacity: number;
                                                                                • The stroke opacity between 0.0 and 1.0.

                                                                                property strokeWeight

                                                                                strokeWeight: number;
                                                                                • The stroke width in pixels.

                                                                                property visible

                                                                                visible: boolean;
                                                                                • Whether this polyline is visible on the map. Defaults to true.

                                                                                property zIndex

                                                                                zIndex: number;
                                                                                • The zIndex compared to other polys.

                                                                                method getPath

                                                                                getPath: () => Promise<google.maps.LatLng[]>;

                                                                                  method ngOnChanges

                                                                                  ngOnChanges: (changes: any) => any;

                                                                                    class AgmPolylineIcon

                                                                                    class AgmPolylineIcon implements OnInit {}
                                                                                    • AgmPolylineIcon enables to add polyline sequences to add arrows, circle, or custom icons either along the entire line, or in a specific part of it. See https://developers.google.com/maps/documentation/javascript/shapes#polyline_customize

                                                                                      ### Example

                                                                                      <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
                                                                                      <agm-polyline>
                                                                                      <agm-icon-sequence [fixedRotation]="true" [path]="'FORWARD_OPEN_ARROW'">
                                                                                      </agm-icon-sequence>
                                                                                      </agm-polyline>
                                                                                      </agm-map>

                                                                                    property anchorX

                                                                                    anchorX: number;
                                                                                    • The x coordinate of the position of the symbol relative to the polyline. The coordinate of the symbol's path is translated _left_ by the anchor's x coordinate. By default, a symbol is anchored at (0, 0). The position is expressed in the same coordinate system as the symbol's path.

                                                                                    property anchorY

                                                                                    anchorY: number;
                                                                                    • The y coordinate of the position of the symbol relative to the polyline. The coordinate of the symbol's path is translated _up_ by the anchor's y coordinate. By default, a symbol is anchored at (0, 0). The position is expressed in the same coordinate system as the symbol's path.

                                                                                    property fillColor

                                                                                    fillColor: string;
                                                                                    • The symbol's fill color. All CSS3 colors are supported except for extended named colors. Defaults to the stroke color of the corresponding polyline.

                                                                                    property fillOpacity

                                                                                    fillOpacity: number;
                                                                                    • The symbol's fill opacity. Defaults to 0.

                                                                                    property fixedRotation

                                                                                    fixedRotation: boolean;
                                                                                    • If true, each icon in the sequence has the same fixed rotation regardless of the angle of the edge on which it lies. Defaults to false, in which case each icon in the sequence is rotated to align with its edge.

                                                                                    property offset

                                                                                    offset: string;
                                                                                    • 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'). Defaults to '100%'.

                                                                                    property path

                                                                                    path: string | number | symbol;
                                                                                    • The symbol's path, which is a built-in symbol path, or a custom path expressed using SVG path notation. Required.

                                                                                    property repeat

                                                                                    repeat: string;
                                                                                    • 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'. Defaults to '0'.

                                                                                    property rotation

                                                                                    rotation: number;
                                                                                    • The angle by which to rotate the symbol, expressed clockwise in degrees. Defaults to 0. A symbol where fixedRotation is false is rotated relative to the angle of the edge on which it lies.

                                                                                    property scale

                                                                                    scale: number;
                                                                                    • The amount by which the symbol is scaled in size. 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.

                                                                                    property strokeColor

                                                                                    strokeColor: string;
                                                                                    • The symbol's stroke color. All CSS3 colors are supported except for extended named colors. Defaults to the stroke color of the polyline.

                                                                                    property strokeOpacity

                                                                                    strokeOpacity: number;
                                                                                    • The symbol's stroke opacity. Defaults to the stroke opacity of the polyline.

                                                                                    property strokeWeight

                                                                                    strokeWeight: number;
                                                                                    • The symbol's stroke weight. Defaults to the scale of the symbol.

                                                                                    method ngOnInit

                                                                                    ngOnInit: () => void;

                                                                                      class AgmPolylinePoint

                                                                                      class AgmPolylinePoint implements OnChanges, FitBoundsAccessor {}
                                                                                      • AgmPolylinePoint represents one element of a polyline within a AgmPolyline

                                                                                      constructor

                                                                                      constructor();

                                                                                        property latitude

                                                                                        latitude: number;
                                                                                        • The latitude position of the point.

                                                                                        property longitude

                                                                                        longitude: number;
                                                                                        • The longitude position of the point;

                                                                                        property positionChanged

                                                                                        positionChanged: any;
                                                                                        • This event emitter gets emitted when the position of the point changed.

                                                                                        method ngOnChanges

                                                                                        ngOnChanges: (changes: any) => any;

                                                                                          class AgmRectangle

                                                                                          class AgmRectangle implements OnInit, OnChanges, OnDestroy {}

                                                                                            constructor

                                                                                            constructor(_manager: RectangleManager);

                                                                                              property boundsChange

                                                                                              boundsChange: any;
                                                                                              • This event is fired when the rectangle's is changed.

                                                                                              property clickable

                                                                                              clickable: boolean;
                                                                                              • Indicates whether this Rectangle handles mouse events. Defaults to true.

                                                                                              property drag

                                                                                              drag: any;
                                                                                              • This event is repeatedly fired while the user drags the rectangle.

                                                                                              property dragEnd

                                                                                              dragEnd: any;
                                                                                              • This event is fired when the user stops dragging the rectangle.

                                                                                              property draggable

                                                                                              draggable: boolean;
                                                                                              • If set to true, the user can drag this rectangle over the map. Defaults to false.

                                                                                              property dragStart

                                                                                              dragStart: any;
                                                                                              • This event is fired when the user starts dragging the rectangle.

                                                                                              property east

                                                                                              east: number;
                                                                                              • The east position of the rectangle (required).

                                                                                              property editable

                                                                                              editable: boolean;
                                                                                              • If set to true, the user can edit this rectangle by dragging the control points shown at the center and around the circumference of the rectangle. Defaults to false.

                                                                                              property fillColor

                                                                                              fillColor: string;
                                                                                              • The fill color. All CSS3 colors are supported except for extended named colors.

                                                                                              property fillOpacity

                                                                                              fillOpacity: number;
                                                                                              • The fill opacity between 0.0 and 1.0.

                                                                                              property mouseDown

                                                                                              mouseDown: any;
                                                                                              • This event is fired when the DOM mousedown event is fired on the rectangle.

                                                                                              property mouseMove

                                                                                              mouseMove: any;
                                                                                              • This event is fired when the DOM mousemove event is fired on the rectangle.

                                                                                              property mouseOut

                                                                                              mouseOut: any;
                                                                                              • This event is fired on rectangle mouseout.

                                                                                              property mouseOver

                                                                                              mouseOver: any;
                                                                                              • This event is fired on rectangle mouseover.

                                                                                              property mouseUp

                                                                                              mouseUp: any;
                                                                                              • This event is fired when the DOM mouseup event is fired on the rectangle.

                                                                                              property north

                                                                                              north: number;
                                                                                              • The north position of the rectangle (required).

                                                                                              property rectangleClick

                                                                                              rectangleClick: any;
                                                                                              • This event emitter gets emitted when the user clicks on the rectangle.

                                                                                              property rectangleDblClick

                                                                                              rectangleDblClick: any;
                                                                                              • This event emitter gets emitted when the user clicks on the rectangle.

                                                                                              property rightClick

                                                                                              rightClick: any;
                                                                                              • This event is fired when the rectangle is right-clicked on.

                                                                                              property south

                                                                                              south: number;
                                                                                              • The south position of the rectangle (required).

                                                                                              property strokeColor

                                                                                              strokeColor: string;
                                                                                              • The stroke color. All CSS3 colors are supported except for extended named colors.

                                                                                              property strokeOpacity

                                                                                              strokeOpacity: number;
                                                                                              • The stroke opacity between 0.0 and 1.0

                                                                                              property strokePosition

                                                                                              strokePosition: string | number | symbol;
                                                                                              • The stroke position. Defaults to CENTER. This property is not supported on Internet Explorer 8 and earlier.

                                                                                              property strokeWeight

                                                                                              strokeWeight: number;
                                                                                              • The stroke width in pixels.

                                                                                              property visible

                                                                                              visible: boolean;
                                                                                              • Whether this rectangle is visible on the map. Defaults to true.

                                                                                              property west

                                                                                              west: number;
                                                                                              • The west position of the rectangle (required).

                                                                                              property zIndex

                                                                                              zIndex: number;
                                                                                              • The zIndex compared to other polys.

                                                                                              method getBounds

                                                                                              getBounds: () => Promise<google.maps.LatLngBounds>;
                                                                                              • Gets the LatLngBounds of this Rectangle.

                                                                                              class AgmRotateControl

                                                                                              class AgmRotateControl extends AgmMapControl {}

                                                                                                method getOptions

                                                                                                getOptions: () => any;

                                                                                                  class AgmScaleControl

                                                                                                  class AgmScaleControl extends AgmMapControl {}

                                                                                                    method getOptions

                                                                                                    getOptions: () => any;

                                                                                                      class AgmStreetViewControl

                                                                                                      class AgmStreetViewControl extends AgmMapControl {}

                                                                                                        method getOptions

                                                                                                        getOptions: () => any;

                                                                                                          class AgmTransitLayer

                                                                                                          class AgmTransitLayer implements OnInit, OnDestroy {}

                                                                                                            constructor

                                                                                                            constructor(_manager: LayerManager);

                                                                                                              property visible

                                                                                                              visible: boolean;
                                                                                                              • Hide/show transit layer

                                                                                                              method ngOnInit

                                                                                                              ngOnInit: () => void;

                                                                                                                class AgmZoomControl

                                                                                                                class AgmZoomControl extends AgmMapControl {}

                                                                                                                  property style

                                                                                                                  style: string | number | symbol;

                                                                                                                    method getOptions

                                                                                                                    getOptions: () => any;

                                                                                                                      class CircleManager

                                                                                                                      class CircleManager {}

                                                                                                                        constructor

                                                                                                                        constructor(_apiWrapper: GoogleMapsAPIWrapper, _zone: any);

                                                                                                                          method addCircle

                                                                                                                          addCircle: (circle: AgmCircle) => void;

                                                                                                                            method createEventObservable

                                                                                                                            createEventObservable: <T>(eventName: string, circle: AgmCircle) => any;

                                                                                                                              method getBounds

                                                                                                                              getBounds: (circle: AgmCircle) => Promise<google.maps.LatLngBounds>;

                                                                                                                                method getCenter

                                                                                                                                getCenter: (circle: AgmCircle) => Promise<google.maps.LatLng>;

                                                                                                                                  method getNativeCircle

                                                                                                                                  getNativeCircle: (circle: AgmCircle) => Promise<google.maps.Circle>;

                                                                                                                                    method getRadius

                                                                                                                                    getRadius: (circle: AgmCircle) => Promise<number>;

                                                                                                                                      method removeCircle

                                                                                                                                      removeCircle: (circle: AgmCircle) => Promise<void>;
                                                                                                                                      • Removes the given circle from the map.

                                                                                                                                      method setCenter

                                                                                                                                      setCenter: (circle: AgmCircle) => Promise<void>;

                                                                                                                                        method setDraggable

                                                                                                                                        setDraggable: (circle: AgmCircle) => Promise<void>;

                                                                                                                                          method setEditable

                                                                                                                                          setEditable: (circle: AgmCircle) => Promise<void>;

                                                                                                                                            method setOptions

                                                                                                                                            setOptions: (circle: AgmCircle, options: any) => Promise<void>;

                                                                                                                                              method setRadius

                                                                                                                                              setRadius: (circle: AgmCircle) => Promise<void>;

                                                                                                                                                method setVisible

                                                                                                                                                setVisible: (circle: AgmCircle) => Promise<void>;

                                                                                                                                                  class DataLayerManager

                                                                                                                                                  class DataLayerManager {}
                                                                                                                                                  • Manages all Data Layers for a Google Map instance.

                                                                                                                                                  constructor

                                                                                                                                                  constructor(_wrapper: GoogleMapsAPIWrapper, _zone: any);

                                                                                                                                                    method addDataLayer

                                                                                                                                                    addDataLayer: (layer: AgmDataLayer) => void;
                                                                                                                                                    • Adds a new Data Layer to the map.

                                                                                                                                                    method createEventObservable

                                                                                                                                                    createEventObservable: <T>(eventName: string, layer: AgmDataLayer) => any;
                                                                                                                                                    • Creates a Google Maps event listener for the given DataLayer as an Observable

                                                                                                                                                    method deleteDataLayer

                                                                                                                                                    deleteDataLayer: (layer: AgmDataLayer) => void;

                                                                                                                                                      method getDataFeatures

                                                                                                                                                      getDataFeatures: (
                                                                                                                                                      d: any,
                                                                                                                                                      geoJson: object | string
                                                                                                                                                      ) => Promise<google.maps.Data.Feature[]>;
                                                                                                                                                      • Extract features from a geoJson using google.maps Data Class

                                                                                                                                                        Parameter d

                                                                                                                                                        : google.maps.Data class instance

                                                                                                                                                        Parameter geoJson

                                                                                                                                                        : url or geojson object

                                                                                                                                                      method setDataOptions

                                                                                                                                                      setDataOptions: (layer: AgmDataLayer, options: any) => void;

                                                                                                                                                        method updateGeoJson

                                                                                                                                                        updateGeoJson: (layer: AgmDataLayer, geoJson: object | string) => void;

                                                                                                                                                          class FitBoundsAccessor

                                                                                                                                                          abstract class FitBoundsAccessor {}
                                                                                                                                                          • Class to implement when you what to be able to make it work with the auto fit bounds feature of AGM.

                                                                                                                                                          method getFitBoundsDetails$

                                                                                                                                                          abstract getFitBoundsDetails$: () => any;

                                                                                                                                                            class GoogleMapsAPIWrapper

                                                                                                                                                            class GoogleMapsAPIWrapper {}
                                                                                                                                                            • Wrapper class that handles the communication with the Google Maps Javascript API v3

                                                                                                                                                            constructor

                                                                                                                                                            constructor(_loader: MapsAPILoader, _zone: any);

                                                                                                                                                              method clearInstanceListeners

                                                                                                                                                              clearInstanceListeners: () => void;

                                                                                                                                                                method containsLocation

                                                                                                                                                                containsLocation: (latLng: any, polygon: any) => Promise<boolean>;
                                                                                                                                                                • Determines if given coordinates are insite a Polygon path.

                                                                                                                                                                method createBicyclingLayer

                                                                                                                                                                createBicyclingLayer: () => Promise<google.maps.BicyclingLayer>;
                                                                                                                                                                • Creates a BicyclingLayer instance for a map

                                                                                                                                                                  Returns

                                                                                                                                                                  a new bicycling layer object

                                                                                                                                                                method createCircle

                                                                                                                                                                createCircle: (options: any) => Promise<google.maps.Circle>;
                                                                                                                                                                • Creates a google.map.Circle for the current map.

                                                                                                                                                                method createDataLayer

                                                                                                                                                                createDataLayer: (options?: any) => Promise<google.maps.Data>;
                                                                                                                                                                • Creates a new google.map.Data layer for the current map

                                                                                                                                                                method createInfoWindow

                                                                                                                                                                createInfoWindow: (options?: any) => Promise<google.maps.InfoWindow>;

                                                                                                                                                                  method createMap

                                                                                                                                                                  createMap: (el: HTMLElement, mapOptions: any) => Promise<void>;

                                                                                                                                                                    method createMarker

                                                                                                                                                                    createMarker: (options?: any, addToMap?: boolean) => Promise<google.maps.Marker>;
                                                                                                                                                                    • Creates a google map marker with the map context

                                                                                                                                                                    method createPolygon

                                                                                                                                                                    createPolygon: (options: any) => Promise<google.maps.Polygon>;

                                                                                                                                                                      method createPolyline

                                                                                                                                                                      createPolyline: (options: any) => Promise<google.maps.Polyline>;

                                                                                                                                                                        method createRectangle

                                                                                                                                                                        createRectangle: (options: any) => Promise<google.maps.Rectangle>;
                                                                                                                                                                        • Creates a google.map.Rectangle for the current map.

                                                                                                                                                                        method createTransitLayer

                                                                                                                                                                        createTransitLayer: () => Promise<google.maps.TransitLayer>;
                                                                                                                                                                        • Creates a TransitLayer instance for a map

                                                                                                                                                                          Returns

                                                                                                                                                                          a new transit layer object

                                                                                                                                                                        method fitBounds

                                                                                                                                                                        fitBounds: (
                                                                                                                                                                        latLng: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral,
                                                                                                                                                                        padding?: number | google.maps.Padding
                                                                                                                                                                        ) => Promise<void>;

                                                                                                                                                                          method getBounds

                                                                                                                                                                          getBounds: () => Promise<google.maps.LatLngBounds>;

                                                                                                                                                                            method getCenter

                                                                                                                                                                            getCenter: () => Promise<google.maps.LatLng>;

                                                                                                                                                                              method getMapTypeId

                                                                                                                                                                              getMapTypeId: () => Promise<google.maps.MapTypeId>;

                                                                                                                                                                                method getNativeMap

                                                                                                                                                                                getNativeMap: () => Promise<google.maps.Map>;
                                                                                                                                                                                • Returns the native Google Maps Map instance. Be careful when using this instance directly.

                                                                                                                                                                                method getZoom

                                                                                                                                                                                getZoom: () => Promise<number>;

                                                                                                                                                                                  method panBy

                                                                                                                                                                                  panBy: (x: number, y: number) => Promise<void>;

                                                                                                                                                                                    method panTo

                                                                                                                                                                                    panTo: (latLng: google.maps.LatLng | google.maps.LatLngLiteral) => Promise<void>;

                                                                                                                                                                                      method panToBounds

                                                                                                                                                                                      panToBounds: (
                                                                                                                                                                                      latLng: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral,
                                                                                                                                                                                      padding?: number | google.maps.Padding
                                                                                                                                                                                      ) => Promise<void>;

                                                                                                                                                                                        method setCenter

                                                                                                                                                                                        setCenter: (latLng: any) => Promise<void>;

                                                                                                                                                                                          method setMapOptions

                                                                                                                                                                                          setMapOptions: (options: any) => void;

                                                                                                                                                                                            method setZoom

                                                                                                                                                                                            setZoom: (zoom: number) => Promise<void>;

                                                                                                                                                                                              method subscribeToMapEvent

                                                                                                                                                                                              subscribeToMapEvent: <N extends string | number | symbol>(eventName: N) => any;

                                                                                                                                                                                                method triggerMapEvent

                                                                                                                                                                                                triggerMapEvent: (eventName: string) => Promise<void>;
                                                                                                                                                                                                • Triggers the given event name on the map instance.

                                                                                                                                                                                                class InfoWindowManager

                                                                                                                                                                                                class InfoWindowManager {}

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                  _mapsWrapper: GoogleMapsAPIWrapper,
                                                                                                                                                                                                  _zone: any,
                                                                                                                                                                                                  _markerManager: MarkerManager
                                                                                                                                                                                                  );

                                                                                                                                                                                                    method addInfoWindow

                                                                                                                                                                                                    addInfoWindow: (infoWindow: AgmInfoWindow) => void;

                                                                                                                                                                                                      method close

                                                                                                                                                                                                      close: (infoWindow: AgmInfoWindow) => Promise<void>;

                                                                                                                                                                                                        method createEventObservable

                                                                                                                                                                                                        createEventObservable: <T>(eventName: string, infoWindow: AgmInfoWindow) => any;
                                                                                                                                                                                                        • Creates a Google Maps event listener for the given InfoWindow as an Observable

                                                                                                                                                                                                        method deleteInfoWindow

                                                                                                                                                                                                        deleteInfoWindow: (infoWindow: AgmInfoWindow) => Promise<void>;

                                                                                                                                                                                                          method open

                                                                                                                                                                                                          open: (infoWindow: AgmInfoWindow) => Promise<void>;

                                                                                                                                                                                                            method setOptions

                                                                                                                                                                                                            setOptions: (infoWindow: AgmInfoWindow, options: any) => Promise<void>;

                                                                                                                                                                                                              method setPosition

                                                                                                                                                                                                              setPosition: (infoWindow: AgmInfoWindow) => Promise<void>;

                                                                                                                                                                                                                method setZIndex

                                                                                                                                                                                                                setZIndex: (infoWindow: AgmInfoWindow) => Promise<void>;

                                                                                                                                                                                                                  class KmlLayerManager

                                                                                                                                                                                                                  class KmlLayerManager {}
                                                                                                                                                                                                                  • Manages all KML Layers for a Google Map instance.

                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                  constructor(_wrapper: GoogleMapsAPIWrapper, _zone: any);

                                                                                                                                                                                                                    method addKmlLayer

                                                                                                                                                                                                                    addKmlLayer: (layer: AgmKmlLayer) => void;
                                                                                                                                                                                                                    • Adds a new KML Layer to the map.

                                                                                                                                                                                                                    method createEventObservable

                                                                                                                                                                                                                    createEventObservable: <T>(eventName: string, layer: AgmKmlLayer) => any;
                                                                                                                                                                                                                    • Creates a Google Maps event listener for the given KmlLayer as an Observable

                                                                                                                                                                                                                    method deleteKmlLayer

                                                                                                                                                                                                                    deleteKmlLayer: (layer: AgmKmlLayer) => void;

                                                                                                                                                                                                                      method setOptions

                                                                                                                                                                                                                      setOptions: (layer: AgmKmlLayer, options: any) => void;

                                                                                                                                                                                                                        class LayerManager

                                                                                                                                                                                                                        class LayerManager {}
                                                                                                                                                                                                                        • This class manages Transit and Bicycling Layers for a Google Map instance.

                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                        constructor(_wrapper: GoogleMapsAPIWrapper);

                                                                                                                                                                                                                          method addBicyclingLayer

                                                                                                                                                                                                                          addBicyclingLayer: (layer: AgmBicyclingLayer) => void;
                                                                                                                                                                                                                          • Adds a bicycling layer to a map instance.

                                                                                                                                                                                                                            Parameter layer

                                                                                                                                                                                                                            a bicycling layer object

                                                                                                                                                                                                                            Parameter _options

                                                                                                                                                                                                                            BicyclingLayer options

                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                            void

                                                                                                                                                                                                                          method addTransitLayer

                                                                                                                                                                                                                          addTransitLayer: (layer: AgmTransitLayer) => void;
                                                                                                                                                                                                                          • Adds a transit layer to a map instance.

                                                                                                                                                                                                                            Parameter layer

                                                                                                                                                                                                                            a TransitLayer object

                                                                                                                                                                                                                            Parameter _options

                                                                                                                                                                                                                            TransitLayerOptions options

                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                            void

                                                                                                                                                                                                                          method deleteLayer

                                                                                                                                                                                                                          deleteLayer: (layer: AgmTransitLayer | AgmBicyclingLayer) => Promise<void>;
                                                                                                                                                                                                                          • Deletes a map layer

                                                                                                                                                                                                                            Parameter layer

                                                                                                                                                                                                                            the layer to delete

                                                                                                                                                                                                                          class LazyMapsAPILoader

                                                                                                                                                                                                                          class LazyMapsAPILoader extends MapsAPILoader {}

                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                            constructor(config: any, w: WindowRef, d: DocumentRef, localeId: string);

                                                                                                                                                                                                                              property callbackName

                                                                                                                                                                                                                              protected readonly callbackName: string;

                                                                                                                                                                                                                                method load

                                                                                                                                                                                                                                load: () => Promise<void>;

                                                                                                                                                                                                                                  class MapsAPILoader

                                                                                                                                                                                                                                  abstract class MapsAPILoader {}

                                                                                                                                                                                                                                    method load

                                                                                                                                                                                                                                    abstract load: () => Promise<void>;

                                                                                                                                                                                                                                      class MarkerManager

                                                                                                                                                                                                                                      class MarkerManager {}

                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                        constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: any);

                                                                                                                                                                                                                                          method addMarker

                                                                                                                                                                                                                                          addMarker: (marker: AgmMarker) => void;

                                                                                                                                                                                                                                            method convertAnimation

                                                                                                                                                                                                                                            convertAnimation: (
                                                                                                                                                                                                                                            uiAnim: keyof typeof google.maps.Animation | null
                                                                                                                                                                                                                                            ) => Promise<google.maps.Animation>;

                                                                                                                                                                                                                                              method createEventObservable

                                                                                                                                                                                                                                              createEventObservable: <T extends unknown>(
                                                                                                                                                                                                                                              eventName:
                                                                                                                                                                                                                                              | google.maps.MarkerMouseEventNames
                                                                                                                                                                                                                                              | google.maps.MarkerChangeOptionEventNames,
                                                                                                                                                                                                                                              marker: AgmMarker
                                                                                                                                                                                                                                              ) => any;

                                                                                                                                                                                                                                                method deleteMarker

                                                                                                                                                                                                                                                deleteMarker: (markerDirective: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                  method getNativeMarker

                                                                                                                                                                                                                                                  getNativeMarker: (marker: AgmMarker) => Promise<google.maps.Marker>;

                                                                                                                                                                                                                                                    method updateAnimation

                                                                                                                                                                                                                                                    updateAnimation: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                      method updateClickable

                                                                                                                                                                                                                                                      updateClickable: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                        method updateDraggable

                                                                                                                                                                                                                                                        updateDraggable: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                          method updateIcon

                                                                                                                                                                                                                                                          updateIcon: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                            method updateLabel

                                                                                                                                                                                                                                                            updateLabel: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                              method updateMarkerPosition

                                                                                                                                                                                                                                                              updateMarkerPosition: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                                method updateOpacity

                                                                                                                                                                                                                                                                updateOpacity: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                                  method updateTitle

                                                                                                                                                                                                                                                                  updateTitle: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                                    method updateVisible

                                                                                                                                                                                                                                                                    updateVisible: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                                      method updateZIndex

                                                                                                                                                                                                                                                                      updateZIndex: (marker: AgmMarker) => Promise<void>;

                                                                                                                                                                                                                                                                        class NoOpMapsAPILoader

                                                                                                                                                                                                                                                                        class NoOpMapsAPILoader implements MapsAPILoader {}
                                                                                                                                                                                                                                                                        • When using the NoOpMapsAPILoader, the Google Maps API must be added to the page via a <script> Tag. It's important that the Google Maps API script gets loaded first on the page.

                                                                                                                                                                                                                                                                        method load

                                                                                                                                                                                                                                                                        load: () => Promise<void>;

                                                                                                                                                                                                                                                                          class ɵa

                                                                                                                                                                                                                                                                          class FitBoundsService {}
                                                                                                                                                                                                                                                                          • The FitBoundsService is responsible for computing the bounds of the a single map.

                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                          constructor(loader: MapsAPILoader);

                                                                                                                                                                                                                                                                            property bounds$

                                                                                                                                                                                                                                                                            protected readonly bounds$: any;

                                                                                                                                                                                                                                                                              method addToBounds

                                                                                                                                                                                                                                                                              addToBounds: (latLng: google.maps.LatLng | google.maps.LatLngLiteral) => void;

                                                                                                                                                                                                                                                                                method changeFitBoundsChangeSampleTime

                                                                                                                                                                                                                                                                                changeFitBoundsChangeSampleTime: (timeMs: number) => void;

                                                                                                                                                                                                                                                                                  method getBounds$

                                                                                                                                                                                                                                                                                  getBounds$: () => any;

                                                                                                                                                                                                                                                                                    method removeFromBounds

                                                                                                                                                                                                                                                                                    removeFromBounds: (
                                                                                                                                                                                                                                                                                    latLng: google.maps.LatLng | google.maps.LatLngLiteral
                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                      class ɵb

                                                                                                                                                                                                                                                                                      abstract class AgmMapControl {}

                                                                                                                                                                                                                                                                                        property position

                                                                                                                                                                                                                                                                                        position: string | number | symbol;

                                                                                                                                                                                                                                                                                          method getOptions

                                                                                                                                                                                                                                                                                          abstract getOptions: () => any;

                                                                                                                                                                                                                                                                                            class ɵc

                                                                                                                                                                                                                                                                                            class WindowRef {}

                                                                                                                                                                                                                                                                                              method getNativeWindow

                                                                                                                                                                                                                                                                                              getNativeWindow: () => any;

                                                                                                                                                                                                                                                                                                class ɵd

                                                                                                                                                                                                                                                                                                class DocumentRef {}

                                                                                                                                                                                                                                                                                                  method getNativeDocument

                                                                                                                                                                                                                                                                                                  getNativeDocument: () => any;

                                                                                                                                                                                                                                                                                                    class PolygonManager

                                                                                                                                                                                                                                                                                                    class PolygonManager {}

                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                      constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: any);

                                                                                                                                                                                                                                                                                                        method addPolygon

                                                                                                                                                                                                                                                                                                        addPolygon: (path: AgmPolygon) => void;

                                                                                                                                                                                                                                                                                                          method createEventObservable

                                                                                                                                                                                                                                                                                                          createEventObservable: <T>(eventName: string, path: AgmPolygon) => any;

                                                                                                                                                                                                                                                                                                            method createPathEventObservable

                                                                                                                                                                                                                                                                                                            createPathEventObservable: (
                                                                                                                                                                                                                                                                                                            agmPolygon: AgmPolygon
                                                                                                                                                                                                                                                                                                            ) => Promise<
                                                                                                                                                                                                                                                                                                            Observable<MVCEvent<google.maps.LatLng[] | google.maps.LatLngLiteral[]>>
                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                              method deletePolygon

                                                                                                                                                                                                                                                                                                              deletePolygon: (paths: AgmPolygon) => Promise<void>;

                                                                                                                                                                                                                                                                                                                method getPath

                                                                                                                                                                                                                                                                                                                getPath: (polygonDirective: AgmPolygon) => Promise<google.maps.LatLng[]>;

                                                                                                                                                                                                                                                                                                                  method getPaths

                                                                                                                                                                                                                                                                                                                  getPaths: (polygonDirective: AgmPolygon) => Promise<google.maps.LatLng[][]>;

                                                                                                                                                                                                                                                                                                                    method setPolygonOptions

                                                                                                                                                                                                                                                                                                                    setPolygonOptions: (
                                                                                                                                                                                                                                                                                                                    path: AgmPolygon,
                                                                                                                                                                                                                                                                                                                    options: { [propName: string]: any }
                                                                                                                                                                                                                                                                                                                    ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                      method updatePolygon

                                                                                                                                                                                                                                                                                                                      updatePolygon: (polygon: AgmPolygon) => Promise<void>;

                                                                                                                                                                                                                                                                                                                        class PolylineManager

                                                                                                                                                                                                                                                                                                                        class PolylineManager {}

                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                          constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: any);

                                                                                                                                                                                                                                                                                                                            method addPolyline

                                                                                                                                                                                                                                                                                                                            addPolyline: (line: AgmPolyline) => void;

                                                                                                                                                                                                                                                                                                                              method createEventObservable

                                                                                                                                                                                                                                                                                                                              createEventObservable: <T>(eventName: string, line: AgmPolyline) => any;

                                                                                                                                                                                                                                                                                                                                method createPathEventObservable

                                                                                                                                                                                                                                                                                                                                createPathEventObservable: (
                                                                                                                                                                                                                                                                                                                                line: AgmPolyline
                                                                                                                                                                                                                                                                                                                                ) => Promise<Observable<MVCEvent<google.maps.LatLng>>>;

                                                                                                                                                                                                                                                                                                                                  method deletePolyline

                                                                                                                                                                                                                                                                                                                                  deletePolyline: (line: AgmPolyline) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                    method getPath

                                                                                                                                                                                                                                                                                                                                    getPath: (agmPolyline: AgmPolyline) => Promise<google.maps.LatLng[]>;

                                                                                                                                                                                                                                                                                                                                      method setPolylineOptions

                                                                                                                                                                                                                                                                                                                                      setPolylineOptions: (
                                                                                                                                                                                                                                                                                                                                      line: AgmPolyline,
                                                                                                                                                                                                                                                                                                                                      options: { [propName: string]: any }
                                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                        method updateIconSequences

                                                                                                                                                                                                                                                                                                                                        updateIconSequences: (line: AgmPolyline) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                          method updatePolylinePoints

                                                                                                                                                                                                                                                                                                                                          updatePolylinePoints: (line: AgmPolyline) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                            class RectangleManager

                                                                                                                                                                                                                                                                                                                                            class RectangleManager {}

                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                              constructor(_apiWrapper: GoogleMapsAPIWrapper, _zone: any);

                                                                                                                                                                                                                                                                                                                                                method addRectangle

                                                                                                                                                                                                                                                                                                                                                addRectangle: (rectangle: AgmRectangle) => void;

                                                                                                                                                                                                                                                                                                                                                  method createEventObservable

                                                                                                                                                                                                                                                                                                                                                  createEventObservable: <T>(eventName: string, rectangle: AgmRectangle) => any;

                                                                                                                                                                                                                                                                                                                                                    method getBounds

                                                                                                                                                                                                                                                                                                                                                    getBounds: (rectangle: AgmRectangle) => Promise<google.maps.LatLngBounds>;

                                                                                                                                                                                                                                                                                                                                                      method removeRectangle

                                                                                                                                                                                                                                                                                                                                                      removeRectangle: (rectangle: AgmRectangle) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                      • Removes the given rectangle from the map.

                                                                                                                                                                                                                                                                                                                                                      method setBounds

                                                                                                                                                                                                                                                                                                                                                      setBounds: (rectangle: AgmRectangle) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                        method setDraggable

                                                                                                                                                                                                                                                                                                                                                        setDraggable: (rectangle: AgmRectangle) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                          method setEditable

                                                                                                                                                                                                                                                                                                                                                          setEditable: (rectangle: AgmRectangle) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                            method setOptions

                                                                                                                                                                                                                                                                                                                                                            setOptions: (rectangle: AgmRectangle, options: any) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                              method setVisible

                                                                                                                                                                                                                                                                                                                                                              setVisible: (rectangle: AgmRectangle) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                Interfaces

                                                                                                                                                                                                                                                                                                                                                                interface FitBoundsDetails

                                                                                                                                                                                                                                                                                                                                                                interface FitBoundsDetails {}

                                                                                                                                                                                                                                                                                                                                                                  property latLng

                                                                                                                                                                                                                                                                                                                                                                  latLng: google.maps.LatLng | google.maps.LatLngLiteral;

                                                                                                                                                                                                                                                                                                                                                                    interface LazyMapsAPILoaderConfigLiteral

                                                                                                                                                                                                                                                                                                                                                                    interface LazyMapsAPILoaderConfigLiteral {}

                                                                                                                                                                                                                                                                                                                                                                    property apiKey

                                                                                                                                                                                                                                                                                                                                                                    apiKey?: string;
                                                                                                                                                                                                                                                                                                                                                                    • The Google Maps API Key (see: https://developers.google.com/maps/documentation/javascript/get-api-key)

                                                                                                                                                                                                                                                                                                                                                                    property apiVersion

                                                                                                                                                                                                                                                                                                                                                                    apiVersion?: string;
                                                                                                                                                                                                                                                                                                                                                                    • Google Maps API version.

                                                                                                                                                                                                                                                                                                                                                                    property channel

                                                                                                                                                                                                                                                                                                                                                                    channel?: string;
                                                                                                                                                                                                                                                                                                                                                                    • The Google Maps channel name (for premium plans). A channel parameter is an optional parameter that allows you to track usage under your client ID by assigning a distinct channel to each of your applications.

                                                                                                                                                                                                                                                                                                                                                                    property clientId

                                                                                                                                                                                                                                                                                                                                                                    clientId?: string;
                                                                                                                                                                                                                                                                                                                                                                    • The Google Maps client ID (for premium plans). When you have a Google Maps APIs Premium Plan license, you must authenticate your application with either an API key or a client ID. The Google Maps API will fail to load if both a client ID and an API key are included.

                                                                                                                                                                                                                                                                                                                                                                    property hostAndPath

                                                                                                                                                                                                                                                                                                                                                                    hostAndPath?: string;
                                                                                                                                                                                                                                                                                                                                                                    • Host and Path used for the <script> tag.

                                                                                                                                                                                                                                                                                                                                                                    property language

                                                                                                                                                                                                                                                                                                                                                                    language?: string;
                                                                                                                                                                                                                                                                                                                                                                    • The Google Maps API uses the browser's preferred language when displaying textual information. If you wish to overwrite this behavior and force the API to use a given language, you can use this setting. See https://developers.google.com/maps/documentation/javascript/basics#Language

                                                                                                                                                                                                                                                                                                                                                                    property libraries

                                                                                                                                                                                                                                                                                                                                                                    libraries?: string[];
                                                                                                                                                                                                                                                                                                                                                                    • Defines which Google Maps libraries should get loaded.

                                                                                                                                                                                                                                                                                                                                                                    property protocol

                                                                                                                                                                                                                                                                                                                                                                    protocol?: GoogleMapsScriptProtocol;
                                                                                                                                                                                                                                                                                                                                                                    • Protocol used for the <script> tag.

                                                                                                                                                                                                                                                                                                                                                                    property region

                                                                                                                                                                                                                                                                                                                                                                    region?: string;
                                                                                                                                                                                                                                                                                                                                                                    • The default bias for the map behavior is US. If you wish to alter your application to serve different map tiles or bias the application, you can overwrite the default behavior (US) by defining a region. See https://developers.google.com/maps/documentation/javascript/basics#Region

                                                                                                                                                                                                                                                                                                                                                                    Enums

                                                                                                                                                                                                                                                                                                                                                                    enum GoogleMapsScriptProtocol

                                                                                                                                                                                                                                                                                                                                                                    enum GoogleMapsScriptProtocol {
                                                                                                                                                                                                                                                                                                                                                                    HTTP = 1,
                                                                                                                                                                                                                                                                                                                                                                    HTTPS = 2,
                                                                                                                                                                                                                                                                                                                                                                    AUTO = 3,
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      member AUTO

                                                                                                                                                                                                                                                                                                                                                                      AUTO = 3

                                                                                                                                                                                                                                                                                                                                                                        member HTTP

                                                                                                                                                                                                                                                                                                                                                                        HTTP = 1

                                                                                                                                                                                                                                                                                                                                                                          member HTTPS

                                                                                                                                                                                                                                                                                                                                                                          HTTPS = 2

                                                                                                                                                                                                                                                                                                                                                                            Package Files (32)

                                                                                                                                                                                                                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@agm/core.

                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@agm/core)
                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@agm/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>