Deployed the page to Github Pages.

node_modules/@agm/core/lib/services/fit-bounds.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="googlemaps" />
+import { BehaviorSubject, Observable } from 'rxjs';
+import { MapsAPILoader } from './maps-api-loader/maps-api-loader';
+export interface FitBoundsDetails {
+    latLng: google.maps.LatLng | google.maps.LatLngLiteral;
+}
+/**
+ * @internal
+ */
+export declare type BoundsMap = Map<string, google.maps.LatLng | google.maps.LatLngLiteral>;
+/**
+ * Class to implement when you what to be able to make it work with the auto fit bounds feature
+ * of AGM.
+ */
+export declare abstract class FitBoundsAccessor {
+    abstract getFitBoundsDetails$(): Observable<FitBoundsDetails>;
+}
+/**
+ * The FitBoundsService is responsible for computing the bounds of the a single map.
+ */
+export declare class FitBoundsService {
+    protected readonly bounds$: Observable<google.maps.LatLngBounds>;
+    protected readonly _boundsChangeSampleTime$: BehaviorSubject<number>;
+    protected readonly _includeInBounds$: BehaviorSubject<BoundsMap>;
+    constructor(loader: MapsAPILoader);
+    private _generateBounds;
+    addToBounds(latLng: google.maps.LatLng | google.maps.LatLngLiteral): void;
+    removeFromBounds(latLng: google.maps.LatLng | google.maps.LatLngLiteral): void;
+    changeFitBoundsChangeSampleTime(timeMs: number): void;
+    getBounds$(): Observable<google.maps.LatLngBounds>;
+    protected _createIdentifier(latLng: google.maps.LatLng | google.maps.LatLngLiteral): string;
+}

node_modules/@agm/core/lib/services/geocoder-service.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="googlemaps" />
+import { Observable } from 'rxjs';
+import { MapsAPILoader } from './maps-api-loader/maps-api-loader';
+export declare class AgmGeocoder {
+    protected readonly geocoder$: Observable<google.maps.Geocoder>;
+    constructor(loader: MapsAPILoader);
+    geocode(request: google.maps.GeocoderRequest): Observable<google.maps.GeocoderResult[]>;
+    private _getGoogleResults;
+    private _createGeocoder;
+}

node_modules/@agm/core/lib/services/google-maps-api-wrapper.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { MapsAPILoader } from './maps-api-loader/maps-api-loader';
+/**
+ * Wrapper class that handles the communication with the Google Maps Javascript
+ * API v3
+ */
+export declare class GoogleMapsAPIWrapper {
+    private _loader;
+    private _zone;
+    private _map;
+    private _mapResolver;
+    constructor(_loader: MapsAPILoader, _zone: NgZone);
+    createMap(el: HTMLElement, mapOptions: google.maps.MapOptions): Promise<void>;
+    setMapOptions(options: google.maps.MapOptions): void;
+    /**
+     * Creates a google map marker with the map context
+     */
+    createMarker(options?: google.maps.MarkerOptions, addToMap?: boolean): Promise<google.maps.Marker>;
+    createInfoWindow(options?: google.maps.InfoWindowOptions): Promise<google.maps.InfoWindow>;
+    /**
+     * Creates a google.map.Circle for the current map.
+     */
+    createCircle(options: google.maps.CircleOptions): Promise<google.maps.Circle>;
+    /**
+     * Creates a google.map.Rectangle for the current map.
+     */
+    createRectangle(options: google.maps.RectangleOptions): Promise<google.maps.Rectangle>;
+    createPolyline(options: google.maps.PolylineOptions): Promise<google.maps.Polyline>;
+    createPolygon(options: google.maps.PolygonOptions): Promise<google.maps.Polygon>;
+    /**
+     * Creates a new google.map.Data layer for the current map
+     */
+    createDataLayer(options?: google.maps.Data.DataOptions): Promise<google.maps.Data>;
+    /**
+     * Creates a TransitLayer instance for a map
+     * @returns a new transit layer object
+     */
+    createTransitLayer(): Promise<google.maps.TransitLayer>;
+    /**
+     * Creates a BicyclingLayer instance for a map
+     * @returns a new bicycling layer object
+     */
+    createBicyclingLayer(): Promise<google.maps.BicyclingLayer>;
+    /**
+     * Determines if given coordinates are insite a Polygon path.
+     */
+    containsLocation(latLng: google.maps.LatLng, polygon: google.maps.Polygon): Promise<boolean>;
+    subscribeToMapEvent<N extends keyof google.maps.MapHandlerMap>(eventName: N): Observable<google.maps.MapHandlerMap[N]>;
+    clearInstanceListeners(): void;
+    setCenter(latLng: google.maps.LatLngLiteral): Promise<void>;
+    getZoom(): Promise<number>;
+    getBounds(): Promise<google.maps.LatLngBounds>;
+    getMapTypeId(): Promise<google.maps.MapTypeId>;
+    setZoom(zoom: number): Promise<void>;
+    getCenter(): Promise<google.maps.LatLng>;
+    panTo(latLng: google.maps.LatLng | google.maps.LatLngLiteral): Promise<void>;
+    panBy(x: number, y: number): Promise<void>;
+    fitBounds(latLng: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding): Promise<void>;
+    panToBounds(latLng: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding): Promise<void>;
+    /**
+     * Returns the native Google Maps Map instance. Be careful when using this instance directly.
+     */
+    getNativeMap(): Promise<google.maps.Map>;
+    /**
+     * Triggers the given event name on the map instance.
+     */
+    triggerMapEvent(eventName: string): Promise<void>;
+}

node_modules/@agm/core/lib/services/managers/circle-manager.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmCircle } from '../../directives/circle';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+export declare class CircleManager {
+    private _apiWrapper;
+    private _zone;
+    private _circles;
+    constructor(_apiWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    addCircle(circle: AgmCircle): void;
+    /**
+     * Removes the given circle from the map.
+     */
+    removeCircle(circle: AgmCircle): Promise<void>;
+    setOptions(circle: AgmCircle, options: google.maps.CircleOptions): Promise<void>;
+    getBounds(circle: AgmCircle): Promise<google.maps.LatLngBounds>;
+    getCenter(circle: AgmCircle): Promise<google.maps.LatLng>;
+    getRadius(circle: AgmCircle): Promise<number>;
+    setCenter(circle: AgmCircle): Promise<void>;
+    setEditable(circle: AgmCircle): Promise<void>;
+    setDraggable(circle: AgmCircle): Promise<void>;
+    setVisible(circle: AgmCircle): Promise<void>;
+    setRadius(circle: AgmCircle): Promise<void>;
+    getNativeCircle(circle: AgmCircle): Promise<google.maps.Circle>;
+    createEventObservable<T>(eventName: string, circle: AgmCircle): Observable<T>;
+}

node_modules/@agm/core/lib/services/managers/data-layer-manager.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmDataLayer } from './../../directives/data-layer';
+import { GoogleMapsAPIWrapper } from './../google-maps-api-wrapper';
+/**
+ * Manages all Data Layers for a Google Map instance.
+ */
+export declare class DataLayerManager {
+    private _wrapper;
+    private _zone;
+    private _layers;
+    constructor(_wrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    /**
+     * Adds a new Data Layer to the map.
+     */
+    addDataLayer(layer: AgmDataLayer): void;
+    deleteDataLayer(layer: AgmDataLayer): void;
+    updateGeoJson(layer: AgmDataLayer, geoJson: object | string): void;
+    setDataOptions(layer: AgmDataLayer, options: google.maps.Data.DataOptions): void;
+    /**
+     * Creates a Google Maps event listener for the given DataLayer as an Observable
+     */
+    createEventObservable<T>(eventName: string, layer: AgmDataLayer): Observable<T>;
+    /**
+     * Extract features from a geoJson using google.maps Data Class
+     * @param d : google.maps.Data class instance
+     * @param geoJson : url or geojson object
+     */
+    getDataFeatures(d: google.maps.Data, geoJson: object | string): Promise<google.maps.Data.Feature[]>;
+}

node_modules/@agm/core/lib/services/managers/info-window-manager.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmInfoWindow } from '../../directives/info-window';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+import { MarkerManager } from './marker-manager';
+export declare class InfoWindowManager {
+    private _mapsWrapper;
+    private _zone;
+    private _markerManager;
+    private _infoWindows;
+    constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: NgZone, _markerManager: MarkerManager);
+    deleteInfoWindow(infoWindow: AgmInfoWindow): Promise<void>;
+    setPosition(infoWindow: AgmInfoWindow): Promise<void>;
+    setZIndex(infoWindow: AgmInfoWindow): Promise<void>;
+    open(infoWindow: AgmInfoWindow): Promise<void>;
+    close(infoWindow: AgmInfoWindow): Promise<void>;
+    setOptions(infoWindow: AgmInfoWindow, options: google.maps.InfoWindowOptions): Promise<void>;
+    addInfoWindow(infoWindow: AgmInfoWindow): void;
+    /**
+     * Creates a Google Maps event listener for the given InfoWindow as an Observable
+     */
+    createEventObservable<T>(eventName: string, infoWindow: AgmInfoWindow): Observable<T>;
+}

node_modules/@agm/core/lib/services/managers/kml-layer-manager.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmKmlLayer } from './../../directives/kml-layer';
+import { GoogleMapsAPIWrapper } from './../google-maps-api-wrapper';
+/**
+ * Manages all KML Layers for a Google Map instance.
+ */
+export declare class KmlLayerManager {
+    private _wrapper;
+    private _zone;
+    private _layers;
+    constructor(_wrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    /**
+     * Adds a new KML Layer to the map.
+     */
+    addKmlLayer(layer: AgmKmlLayer): void;
+    setOptions(layer: AgmKmlLayer, options: google.maps.KmlLayerOptions): void;
+    deleteKmlLayer(layer: AgmKmlLayer): void;
+    /**
+     * Creates a Google Maps event listener for the given KmlLayer as an Observable
+     */
+    createEventObservable<T>(eventName: string, layer: AgmKmlLayer): Observable<T>;
+}

node_modules/@agm/core/lib/services/managers/layer-manager.d.ts

@@ -0,0 +1,30 @@
+import { AgmBicyclingLayer } from '../../directives/bicycling-layer';
+import { AgmTransitLayer } from '../../directives/transit-layer';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+/**
+ * This class manages Transit and Bicycling Layers for a Google Map instance.
+ */
+export declare class LayerManager {
+    private _wrapper;
+    private _layers;
+    constructor(_wrapper: GoogleMapsAPIWrapper);
+    /**
+     * Adds a transit layer to a map instance.
+     * @param layer - a TransitLayer object
+     * @param _options - TransitLayerOptions options
+     * @returns void
+     */
+    addTransitLayer(layer: AgmTransitLayer): void;
+    /**
+     * Adds a bicycling layer to a map instance.
+     * @param layer - a bicycling layer object
+     * @param _options - BicyclingLayer options
+     * @returns void
+     */
+    addBicyclingLayer(layer: AgmBicyclingLayer): void;
+    /**
+     * Deletes a map layer
+     * @param layer - the layer to delete
+     */
+    deleteLayer(layer: AgmTransitLayer | AgmBicyclingLayer): Promise<void>;
+}

node_modules/@agm/core/lib/services/managers/marker-manager.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmMarker } from './../../directives/marker';
+import { GoogleMapsAPIWrapper } from './../google-maps-api-wrapper';
+export declare class MarkerManager {
+    protected _mapsWrapper: GoogleMapsAPIWrapper;
+    protected _zone: NgZone;
+    protected _markers: Map<AgmMarker, Promise<google.maps.Marker>>;
+    constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    convertAnimation(uiAnim: keyof typeof google.maps.Animation | null): Promise<google.maps.Animation>;
+    deleteMarker(markerDirective: AgmMarker): Promise<void>;
+    updateMarkerPosition(marker: AgmMarker): Promise<void>;
+    updateTitle(marker: AgmMarker): Promise<void>;
+    updateLabel(marker: AgmMarker): Promise<void>;
+    updateDraggable(marker: AgmMarker): Promise<void>;
+    updateIcon(marker: AgmMarker): Promise<void>;
+    updateOpacity(marker: AgmMarker): Promise<void>;
+    updateVisible(marker: AgmMarker): Promise<void>;
+    updateZIndex(marker: AgmMarker): Promise<void>;
+    updateClickable(marker: AgmMarker): Promise<void>;
+    updateAnimation(marker: AgmMarker): Promise<void>;
+    addMarker(marker: AgmMarker): void;
+    getNativeMarker(marker: AgmMarker): Promise<google.maps.Marker>;
+    createEventObservable<T extends (google.maps.MouseEvent | void)>(eventName: google.maps.MarkerMouseEventNames | google.maps.MarkerChangeOptionEventNames, marker: AgmMarker): Observable<T>;
+}

node_modules/@agm/core/lib/services/managers/polygon-manager.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmPolygon } from '../../directives/polygon';
+import { MVCEvent } from '../../utils/mvcarray-utils';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+export declare class PolygonManager {
+    private _mapsWrapper;
+    private _zone;
+    private _polygons;
+    constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    addPolygon(path: AgmPolygon): void;
+    updatePolygon(polygon: AgmPolygon): Promise<void>;
+    setPolygonOptions(path: AgmPolygon, options: {
+        [propName: string]: any;
+    }): Promise<void>;
+    deletePolygon(paths: AgmPolygon): Promise<void>;
+    getPath(polygonDirective: AgmPolygon): Promise<google.maps.LatLng[]>;
+    getPaths(polygonDirective: AgmPolygon): Promise<google.maps.LatLng[][]>;
+    createEventObservable<T>(eventName: string, path: AgmPolygon): Observable<T>;
+    createPathEventObservable(agmPolygon: AgmPolygon): Promise<Observable<MVCEvent<google.maps.LatLng[] | google.maps.LatLngLiteral[]>>>;
+}

node_modules/@agm/core/lib/services/managers/polyline-manager.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmPolyline } from '../../directives/polyline';
+import { MVCEvent } from '../../utils/mvcarray-utils';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+export declare class PolylineManager {
+    private _mapsWrapper;
+    private _zone;
+    private _polylines;
+    constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    private static _convertPoints;
+    private static _convertPath;
+    private static _convertIcons;
+    addPolyline(line: AgmPolyline): void;
+    updatePolylinePoints(line: AgmPolyline): Promise<void>;
+    updateIconSequences(line: AgmPolyline): Promise<void>;
+    setPolylineOptions(line: AgmPolyline, options: {
+        [propName: string]: any;
+    }): Promise<void>;
+    deletePolyline(line: AgmPolyline): Promise<void>;
+    private getMVCPath;
+    getPath(agmPolyline: AgmPolyline): Promise<google.maps.LatLng[]>;
+    createEventObservable<T>(eventName: string, line: AgmPolyline): Observable<T>;
+    createPathEventObservable(line: AgmPolyline): Promise<Observable<MVCEvent<google.maps.LatLng>>>;
+}

node_modules/@agm/core/lib/services/managers/rectangle-manager.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmRectangle } from '../../directives/rectangle';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+export declare class RectangleManager {
+    private _apiWrapper;
+    private _zone;
+    private _rectangles;
+    constructor(_apiWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    addRectangle(rectangle: AgmRectangle): void;
+    /**
+     * Removes the given rectangle from the map.
+     */
+    removeRectangle(rectangle: AgmRectangle): Promise<void>;
+    setOptions(rectangle: AgmRectangle, options: google.maps.RectangleOptions): Promise<void>;
+    getBounds(rectangle: AgmRectangle): Promise<google.maps.LatLngBounds>;
+    setBounds(rectangle: AgmRectangle): Promise<void>;
+    setEditable(rectangle: AgmRectangle): Promise<void>;
+    setDraggable(rectangle: AgmRectangle): Promise<void>;
+    setVisible(rectangle: AgmRectangle): Promise<void>;
+    createEventObservable<T>(eventName: string, rectangle: AgmRectangle): Observable<T>;
+}

node_modules/@agm/core/lib/services/maps-api-loader/lazy-maps-api-loader.d.ts

@@ -0,0 +1,79 @@
+import { InjectionToken } from '@angular/core';
+import { DocumentRef, WindowRef } from '../../utils/browser-globals';
+import { MapsAPILoader } from './maps-api-loader';
+export declare enum GoogleMapsScriptProtocol {
+    HTTP = 1,
+    HTTPS = 2,
+    AUTO = 3
+}
+/**
+ * Token for the config of the LazyMapsAPILoader. Please provide an object of type {@link
+ * LazyMapsAPILoaderConfig}.
+ */
+export declare const LAZY_MAPS_API_CONFIG: InjectionToken<LazyMapsAPILoaderConfigLiteral>;
+/**
+ * Configuration for the {@link LazyMapsAPILoader}.
+ */
+export interface LazyMapsAPILoaderConfigLiteral {
+    /**
+     * The Google Maps API Key (see:
+     * https://developers.google.com/maps/documentation/javascript/get-api-key)
+     */
+    apiKey?: 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.
+     */
+    clientId?: 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.
+     */
+    channel?: string;
+    /**
+     * Google Maps API version.
+     */
+    apiVersion?: string;
+    /**
+     * Host and Path used for the `<script>` tag.
+     */
+    hostAndPath?: string;
+    /**
+     * Protocol used for the `<script>` tag.
+     */
+    protocol?: GoogleMapsScriptProtocol;
+    /**
+     * Defines which Google Maps libraries should get loaded.
+     */
+    libraries?: 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
+     */
+    region?: 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
+     */
+    language?: string;
+}
+export declare class LazyMapsAPILoader extends MapsAPILoader {
+    private localeId;
+    protected _scriptLoadingPromise: Promise<void>;
+    protected _config: LazyMapsAPILoaderConfigLiteral;
+    protected _windowRef: WindowRef;
+    protected _documentRef: DocumentRef;
+    protected readonly _SCRIPT_ID: string;
+    protected readonly callbackName: string;
+    constructor(config: any, w: WindowRef, d: DocumentRef, localeId: string);
+    load(): Promise<void>;
+    private _assignScriptLoadingPromise;
+    protected _getScriptSrc(callbackName: string): string;
+}

node_modules/@agm/core/lib/services/maps-api-loader/maps-api-loader.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class MapsAPILoader {
+    abstract load(): Promise<void>;
+}

node_modules/@agm/core/lib/services/maps-api-loader/noop-maps-api-loader.d.ts

@@ -0,0 +1,9 @@
+import { MapsAPILoader } from './maps-api-loader';
+/**
+ * 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.
+ */
+export declare class NoOpMapsAPILoader implements MapsAPILoader {
+    load(): Promise<void>;
+}