@inlog/inlog-maps 6.1.0 → 6.2.0

package/lib/index.d.ts

@@ -0,0 +1,46 @@
+import Map from './map';
+import IMapFunctions from './models/apis/mapFunctions';
+import CircleAlterOptions from './models/features/circle/circle-alter-options';
+import CircleOptions from './models/features/circle/circle-options';
+import EventReturn from './models/features/events/event-return';
+import GeoJsonOptions from './models/features/geojson/geojson-options';
+import CircleMarkerOptions from './models/features/marker/circle-marker-options';
+import CircleMarkerStyle from './models/features/marker/circle-marker-style';
+import MarkerAlterOptions from './models/features/marker/marker-alter-options';
+import MarkerIcon from './models/features/marker/marker-icon';
+import MarkerOptions from './models/features/marker/marker-options';
+import OverlayOptions from './models/features/overlay/overlay-options';
+import PolygonAlterOptions from './models/features/polygons/polygon-alter-options';
+import PolygonOptions from './models/features/polygons/polygon-options';
+import NavigationOptions from './models/features/polyline/navigations-options';
+import PolylineOptions from './models/features/polyline/polyline-options';
+import PopupOptions from './models/features/popup/popup-options';
+import MarkerClustererConfig from './models/features/marker-clusterer/marker-clusterer-config';
+import { MarkerEventType, CircleEventType, PolygonEventType, PolylineEventType, MapEventType } from './models/dto/event-type';
+import { MapType } from './models/dto/map-type';
+import { PolylineType } from './models/dto/polyline-type';
+export { Map };
+export { MarkerOptions };
+export { MarkerIcon };
+export { EventReturn };
+export { CircleMarkerOptions };
+export { CircleMarkerStyle };
+export { GeoJsonOptions };
+export { MarkerAlterOptions };
+export { PopupOptions };
+export { PolygonOptions };
+export { PolygonAlterOptions };
+export { CircleOptions };
+export { CircleAlterOptions };
+export { PolylineOptions };
+export { NavigationOptions };
+export { IMapFunctions };
+export { OverlayOptions };
+export { MapType };
+export { PolylineType };
+export { MapEventType };
+export { MarkerEventType };
+export { CircleEventType };
+export { PolygonEventType };
+export { PolylineEventType };
+export { MarkerClustererConfig };

package/lib/map.d.ts

@@ -0,0 +1,519 @@
+import { MarkerEventType, CircleEventType, PolygonEventType, PolylineEventType, MapEventType } from "./models/dto/event-type";
+import { MapType } from "./models/dto/map-type";
+import CircleAlterOptions from "./models/features/circle/circle-alter-options";
+import CircleOptions from "./models/features/circle/circle-options";
+import GeoJsonOptions from "./models/features/geojson/geojson-options";
+import MarkerClustererConfig from "./models/features/marker-clusterer/marker-clusterer-config";
+import CircleMarkerOptions from "./models/features/marker/circle-marker-options";
+import MarkerAlterOptions from "./models/features/marker/marker-alter-options";
+import MarkerOptions from "./models/features/marker/marker-options";
+import OverlayOptions from "./models/features/overlay/overlay-options";
+import PolygonAlterOptions from "./models/features/polygons/polygon-alter-options";
+import PolygonOptions from "./models/features/polygons/polygon-options";
+import PolylineOptions from "./models/features/polyline/polyline-options";
+import PopupOptions from "./models/features/popup/popup-options";
+export default class Map {
+    private markersList;
+    private polygonsList;
+    private circlesList;
+    private polylinesList;
+    private infoWindowList;
+    private overlayList;
+    private map;
+    private markerClusterer;
+    constructor();
+    /**
+     * Use this to initialize map
+     * @param {InlogMaps.MapType} mapType
+     * @param {any} options
+     * @param {string} elementId default: 'inlog-map' [nullable]
+     * @returns {Promisse<any>}
+     */
+    initialize(mapType: MapType, options: any, elementId?: string): Promise<any>;
+    /**
+     * Use this function to add GEOJSON to the currentMap
+     * @param {object} data Geojson
+     * @param {InlogMaps.GeoJsonOptions} options
+     * @param {any} eventClick is a function callback on click [nullable]
+     */
+    loadGEOJson(data: object, options: GeoJsonOptions, eventClick?: any): void;
+    /**
+     * Use this function to draw markers in the currentMap
+     * @param {string} type
+     * @param {InlogMaps.MarkerOptions} options
+     * @param {any} eventClick is a function callback on click [nullable]
+     */
+    drawMarker(type: string, options: MarkerOptions, eventClick?: any): void;
+    /**
+     * Use this function to draw circle markers in the currentMap
+     * @param {string} type
+     * @param {InlogMaps.CircleMarkerOptions} options
+     * @param {any} eventClick is a function callback on click [nullable]
+     */
+    drawCircleMarker(type: string, options: CircleMarkerOptions, eventClick?: any): void;
+    /**
+     * Use this function to show/hide markers from a specific type
+     * @param {boolean} show
+     * @param {string} type
+     * @param {any} condition toogle markers with the condition [nullable]
+     */
+    toggleMarkers(show: boolean, type: string, condition?: any): void;
+    /**
+     * Remove markers from the map and from internal list
+     * @param {string} type
+     * @param {any} condition remove markers with the condition [nullable]
+     */
+    removeMarkers(type: string, condition?: any): void;
+    /**
+     * Remove all markers from the map and from the internal list
+     */
+    removeAllMarkers(): void;
+    /**
+     * Use this function to alter marker style
+     * @param {string} type
+     * @param {InlogMaps.MarkerAlterOptions} options
+     * @param {any} condition alter markers with the condition [nullable]
+     */
+    alterMarkerOptions(type: string, options: MarkerAlterOptions, condition?: any): void;
+    /**
+     * Use this functions to alterar marker position
+     * @param {string } type
+     * @param {number[]} position
+     * @param {boolean} addTransition [nullable]
+     * @param {any} condition [nullable]
+     */
+    alterMarkerPosition(type: string, position: number[], addTransition?: boolean, condition?: any): void;
+    /**
+     * Use this function to fit bounds in the markers with the especified type
+     * @param {string} type
+     * @param {any} condition [nullable]
+     * @param {boolean} onlyMarkersOnMap default true
+     */
+    fitBoundsMarkers(type: string, condition?: any, onlyMarkersOnMap?: boolean): void;
+    /**
+     * Use this functions to set the center of the map on marker
+     * @param {string} type
+     * @param {any} condition center on marker with the condition [nullable]
+     */
+    setCenterMarker(type: string, condition?: any): void;
+    /**
+     * This functions returns if marker exists
+     * @param type
+     * @param condition [nullable]
+     * @returns {boolean}
+     */
+    markerExists(type: string, condition?: any): boolean;
+    /**
+     * Use this function to count markers by type
+     * @param {string} type
+     * @param {boolean} onlyOnMap exclude hidden markers, default true
+     * @param {any} condition
+     * @returns {number}
+     */
+    countMarkers(type: string, onlyOnMap?: boolean, condition?: any): number;
+    /**
+     * This function add new events on marker
+     * @param {string} type
+     * @param {InlogMaps.MarkerEventType} event
+     * @param {any} eventFunction
+     * @param {any} condition [nullable]
+     */
+    addMarkerEvent(type: string, event: MarkerEventType, eventFunction: any, condition?: any): void;
+    /**
+     * This function remove events of marker
+     * @param {string} type
+     * @param {InlogMaps.MarkerEventType} event
+     * @param {any} condition [nullable]
+     */
+    removeMarkerEvent(type: string, event: MarkerEventType, condition?: any): void;
+    /**
+     * Use this function to add MarkerClusterer on the map
+     * @param {string} type same type of markers
+     * @param {InlogMaps.MarkerClusterConfig} config
+     */
+    addMarkerClusterer(type: string, config: MarkerClustererConfig): void;
+    /**
+     * Use this function to alter clusterer options
+     * @param type same type of markers
+     * @param {InlogMaps.MarkerClusterConfig} config
+     */
+    alterMarkerClustererConfig(type: string, config: MarkerClustererConfig): void;
+    /**
+     * Use this function to redraw marker clusterer
+     * @param type same type of markers
+     */
+    refreshClusterer(type: string): void;
+    /**
+     * Use this to clear markers on clusterer
+     * @param type same type of markers
+     */
+    clearMarkersClusterer(type: string): void;
+    /**
+     * Use this function to draw polygons
+     * @param {string} type
+     * @param {InlogMaps.PolygonOptions} options
+     * @param {any} eventClick [nullable]
+     */
+    drawPolygon(type: string, options: PolygonOptions, eventClick?: any): void;
+    /**
+     * Use this function to show/hide polygon from a especific type
+     * @param {boolean} show
+     * @param {string} type
+     * @param {any} condition toggle polygon with the condition [nullable]
+     */
+    togglePolygons(show: boolean, type: string, condition?: any): void;
+    /**
+     * Remove polygons from the map and from internal list
+     * @param {string} type
+     * @param {any} condition remove polygons with the condition [nullable]
+     */
+    removePolygons(type: string, condition?: any): void;
+    /**
+     * Remove all polygons from the map and from the internal list
+     */
+    removeAllPolygons(): void;
+    /**
+     * Use this function to alter polygons options/style
+     * @param {string} type
+     * @param {InlogMaps.PolygonAlterOptions} options
+     * @param {any} condition alter polygon with the condition [nullable]
+     */
+    alterPolygonOptions(type: string, options: PolygonAlterOptions, condition?: any): void;
+    /**
+     * Use this function to fit bounds of a polygon
+     * @param {string} type
+     * @param {any} condition fit polygon bounds with the condition [nullable]
+     */
+    fitBoundsPolygons(type: string, condition?: any): void;
+    /**
+     * Set center on polygon bounds
+     * @param {string} type
+     * @param {any} condition fit polygon bounds with the condition [nullable]
+     */
+    setCenterPolygons(type: string, condition?: any): void;
+    /**
+     * This functions returns if polygon exists
+     * @param type
+     * @param condition [nullable]
+     * @returns {boolean}
+     */
+    polygonExists(type: string, condition?: any): boolean;
+    /**
+     * Use this function to get the path of some polygon
+     * @param {string} type
+     * @param {any} condition
+     * @returns {number[]}
+     */
+    getPolygonPath(type: string, condition?: any): number[][] | undefined;
+    /**
+     * This function add new events on polygon
+     * @param {string} type
+     * @param {InlogMaps.PolygonEventType} event
+     * @param {any} eventFunction
+     * @param {any} condition [nullable]
+     */
+    addPolygonEvent(type: string, event: PolygonEventType, eventFunction: any, condition?: any): void;
+    /**
+     * This function remove events of polygon
+     * @param {string} type
+     * @param {InlogMaps.PolygonEventType} event
+     * @param {any} condition [nullable]
+     */
+    removePolygonEvent(type: string, event: PolygonEventType, condition?: any): void;
+    /**
+     * Use this function to draw circles on the currentMap
+     * @param {string} type
+     * @param {InlogMaps.CircleOptions} options
+     * @param {any} eventClick [nullable]
+     */
+    drawCircle(type: string, options: CircleOptions, eventClick?: any): void;
+    /**
+     * Use this function to show/hide circles from a especific type
+     * @param {boolean} show
+     * @param {string} type
+     * @param {any} condition toggle circles with the condition [nullable]
+     */
+    toggleCircles(show: boolean, type: string, condition?: any): void;
+    /**
+     * Remove circles from the map and from internal list
+     * @param {string} type
+     * @param {any} condition remove circles with the condition [nullable]
+     */
+    removeCircles(type: string, condition?: any): void;
+    /**
+     * Remove all circles from the map and from the internal list
+     */
+    removeAllCircles(): void;
+    /**
+     * Use this function to alter circle options
+     * @param {string} type
+     * @param {InlogMaps.CircleAlterOptions} options
+     * @param {any} condition alter circle with the condition [nullable]
+     */
+    alterCircleOptions(type: string, options: CircleAlterOptions, condition?: any): void;
+    /**
+     * Use this function to fit bounds of a polygon
+     * @param {string} type
+     * @param {any} condition fit polygon bounds with the condition [nullable]
+     */
+    fitBoundsCircles(type: string, condition?: any): void;
+    /**
+     * This functions returns if circle exists
+     * @param {string} type
+     * @param {any} condition [nullable]
+     * @returns {boolean}
+     */
+    circleExists(type: string, condition?: any): boolean;
+    /**
+     * This function return circle center
+     * @param {string} type
+     * @param {any} condition [nullable]
+     * @returns {number[]}
+     */
+    getCircleCenter(type: string, condition?: any): number[] | null;
+    /**
+     * This function return circle center
+     * @param {string} type
+     * @param {any} condition [nullable]
+     * @returns {number}
+     */
+    getCircleRadius(type: string, condition?: any): number | null;
+    /**
+     * This function add new events on circle
+     * @param {string} type
+     * @param {InlogMaps.CircleEventType} event
+     * @param {any} eventFunction
+     * @param {any} condition [nullable]
+     */
+    addCircleEvent(type: string, event: CircleEventType, eventFunction: any, condition?: any): void;
+    /**
+     * This function remove events of circle
+     * @param {string} type
+     * @param {InlogMaps.CircleEventType} event
+     * @param {any} condition [nullable]
+     */
+    removeCircleEvent(type: string, event: CircleEventType, condition?: any): void;
+    /**
+     * Use this function to draw polylines on the currentMap
+     * @param {string} type
+     * @param {InlogMaps.PolylineOptions} options
+     * @param {any} eventClick [nullable]
+     */
+    drawPolyline(type: string, options: PolylineOptions, eventClick?: any): void;
+    /**
+     * Use this function to draw polylines with navigation on the currentMap
+     * @param {string} type
+     * @param {InlogMaps.PolylineOptions} options
+     */
+    drawPolylineWithNavigation(type: string, options: PolylineOptions, eventClick?: any): void;
+    /**
+     * Use this function to toggle polylines
+     * @param {boolean} show
+     * @param {string} type
+     * @param {any} condition toggle polyline with the condition [nullable]
+     */
+    togglePolylines(show: boolean, type: string, condition?: any): void;
+    /**
+     * Use this function to remove polylines
+     * @param {string} type
+     * @param {any} condition remove polyline with the condition [nullable]
+     */
+    removePolylines(type: string, condition?: any): void;
+    /**
+     * Remove all polylines from the map and from the internal list
+     */
+    removeAllPolylines(): void;
+    /**
+     * Use this function to alter polyline options
+     * @param {string} type
+     * @param {InlogMaps.PolylineOptions} options
+     * @param {any} condition alter polyline with the condition [nullable]
+     */
+    alterPolylineOptions(type: string, options: PolylineOptions, condition?: any): void;
+    /**
+     * Use this functions to fit polylines bounds
+     * @param {string} type
+     * @param {any} condition [nullable]
+     */
+    fitBoundsPolylines(type: string, condition?: any): void;
+    /**
+     * This functions returns if polyline exists
+     * @param {string} type
+     * @param {any} condition [nullable]
+     * @returns {boolean}
+     */
+    polylineExists(type: string, condition?: any): boolean;
+    /**
+     * Use this function to add more paths to a polyline
+     * @param {string} type
+     * @param {number[]} position
+     * @param {any} condition [nullable]
+     */
+    addPolylinePath(type: string, position: number[], condition?: any): void;
+    /**
+     * Use this function to get the path of some polyline
+     * @param {string} type
+     * @param {any} condition
+     * @returns {number[]}
+     */
+    getPolylinePath(type: string, condition?: any): number[][] | undefined;
+    /**
+     * Use this function to clear polyline selected from the currentMap
+     */
+    removePolylineHighlight(): void;
+    /**
+     * Use this function to add listeners on polyline
+     * @param {string} type
+     * @param {InlogMaps.PolylineEventType} event
+     * @param {any} eventFunction
+     * @param {any} condition [nullable]
+     */
+    addPolylineEvent(type: string, event: PolylineEventType, eventFunction: any, condition?: any): void;
+    /**
+     * Use this function to remove listeners of polyline
+     * @param {string} type
+     * @param {InlogMaps.PolylineEventType} event
+     * @param {any} condition [nullable]
+     */
+    removePolylineEvent(type: string, event: PolylineEventType, condition?: any): void;
+    /**
+     * Use this function to set position of polyline highlight
+     * @param {string} type
+     * @param {number} initialIndex
+     * @param {any} condition [nullable]
+     */
+    setIndexPolylineHighlight(type: string, initialIndex: number, condition?: any): void;
+    /**
+     * Use this function to get the object of a polyline
+     * @param {string} type
+     * @param {any} condition
+     * @returns {object}
+     */
+    getObjectPolyline(type: string, condition?: any): object | null;
+    /**
+     * Use this function to get the object of the polyline highligth
+     * @returns {object}
+     */
+    getObjectPolylineHighlight(): any;
+    /**
+     * Use this function to add events on polyline highligtht / selected polyline
+     * @param {InlogMaps.PolylineEventType} event
+     * @param {any} eventFunction
+     */
+    addPolylineHighlightEvent(event: PolylineEventType, eventFunction: any): void;
+    /**
+     * Use this function to get initial and final index of the polyline highlight
+     * @returns {number[]} returns an array with initial index and final index
+     */
+    getPolylineHighlightIndex(): number[];
+    /**
+     * Use this function to draw popups on the currentMap
+     * @param {string} type
+     * @param {InlogMaps.PopupOptions} options
+     */
+    drawPopup(type: string, options: PopupOptions): void;
+    /**
+     * Use this function to alter popups
+     * @param {string} type
+     * @param {InlogMaps.PopupOptions} options
+     */
+    alterPopup(type: string, options: PopupOptions): void;
+    /**
+     *
+     * @param {string} type
+     * @returns {object}
+     */
+    getObjectOpenPopup(type: string): object;
+    /**
+     * Use this function to close popup by type
+     * @param {string} type
+     */
+    closePopup(type: string): void;
+    /**
+     * Use this function to close all popups
+     * @param {string} type
+     */
+    closeAllPopups(): void;
+    /**
+     * Resize de map based on html size
+     */
+    resizeMap(): void;
+    /**
+     * Use this function to add event clicks on the currentMap
+     * @param {InlogMaps.MapEventType} eventType
+     * @param eventFunction function callback
+     */
+    addEventMap(eventType: MapEventType, eventFunction: any): void;
+    /**
+     * Use this function to remove event clicks from the currentMap
+     * @param {InlogMaps.MapEventType} eventType
+     */
+    removeEventMap(eventType: MapEventType): void;
+    /**
+     * Returns the current zoom level of the map view
+     * @returns {number}
+     */
+    getZoom(): number;
+    /**
+     * Set the current zoom level of the map view
+     * @param {number} zoom
+     */
+    setZoom(zoom: number): void;
+    /**
+     * Takes a screenshot with all the context included in it (visible area)
+     * Returns the image as a base64 string or null
+     * @returns {Promise<string | null>}
+     */
+    takeMapScreenshot(): Promise<string>;
+    /**
+     * Returns the center position of the map
+     * @returns {number[]}
+     */
+    getCenter(): number[];
+    /**
+     * Set the position center of the map
+     * @param {number[]} position
+     */
+    setCenter(position: number[]): void;
+    /**
+     * Returns the coordinates from pixels
+     * @param {number} offsetx
+     * @param {number} offsety
+     * @returns {number[]}
+     */
+    pixelsToLatLng(offsetx: number, offsety: number): number[];
+    /**
+     * Use this functions to fit bounds on elements with same type and condition
+     * @param {string} type
+     * @param {any} condition [nullable]
+     */
+    fitBoundsElements(type: string, condition?: any): void;
+    /**
+     * Use this function to dray overlays on the current map
+     * @param {string} type
+     * @param {InlogMaps.OverlayOptions} options
+     */
+    drawOverlay(type: string, options: OverlayOptions): void;
+    /**
+     * Use this function to show or hide overlay
+     * @param {boolean} show
+     * @param {string} type
+     * @param {any} condition [nullable]
+     */
+    toggleOverlay(show: boolean, type: string, condition?: any): void;
+    /**
+     * Remove overlays from the map and from internal list
+     * @param {string} type
+     * @param {any} condition remove overlays with the condition [nullable]
+     */
+    removeOverlays(type: string, condition?: any): void;
+    /**
+     * Remove all overlays from the map and from the internal list
+     */
+    removeAllOverlays(): void;
+    private getMarkers;
+    private getPolygons;
+    private getCircles;
+    private getPolylines;
+    private getOverlays;
+}

package/lib/models/apis/google/google-circles.d.ts

@@ -0,0 +1,18 @@
+import { CircleEventType } from '../../dto/event-type';
+import CircleAlterOptions from '../../features/circle/circle-alter-options';
+import CircleOptions from '../../features/circle/circle-options';
+export default class GoogleCircles {
+    private map;
+    private google;
+    constructor(map: any, google: any);
+    drawCircle(options: CircleOptions, eventClick: any): any;
+    toggleCircles(circles: any[], show: boolean): void;
+    alterCircleOptions(circles: any[], options: CircleAlterOptions): void;
+    fitBoundsCircles(circles: any): void;
+    isCircleOnMap(circle: any): boolean;
+    getCircleCenter(circle: any): number[];
+    getCircleRadius(circle: any): number;
+    addCircleEvent(circles: any, eventType: CircleEventType, eventFunction: any): void;
+    removeCircleEvent(circles: any, event: CircleEventType): void;
+    private getCirclesBounds;
+}

package/lib/models/apis/google/google-geojson.d.ts

@@ -0,0 +1,9 @@
+import GeoJsonOptions from "../../features/geojson/geojson-options";
+export default class GoogleGeoJson {
+    private map;
+    private google;
+    constructor(map: any, google: any);
+    loadGEOJson(data: object, options: GeoJsonOptions, eventClick: any): void;
+    private parseGeoJson;
+    private parseGeoJsonToObject;
+}

package/lib/models/apis/google/google-map.d.ts

@@ -0,0 +1,16 @@
+import { MapEventType } from "../../dto/event-type";
+export default class GoogleMap {
+    private map;
+    private google;
+    constructor(map: any, google: any);
+    resizeMap(): void;
+    addEventMap(eventType: MapEventType, eventFunction: any): void;
+    removeEventMap(eventType: MapEventType): void;
+    getZoom(): number;
+    setZoom(zoom: number): any;
+    takeScreenShot(elementId: string): Promise<string>;
+    getCenter(): number[];
+    setCenter(position: number[]): void;
+    pixelsToLatLng(offsetx: number, offsety: number): any[];
+    fitBoundsElements(markers: any, circles: any, polygons: any, polylines: any): void;
+}

package/lib/models/apis/google/google-markers.d.ts

@@ -0,0 +1,29 @@
+import { MarkerEventType } from "../../dto/event-type";
+import MarkerClustererConfig from "../../features/marker-clusterer/marker-clusterer-config";
+import CircleMarkerOptions from "../../features/marker/circle-marker-options";
+import MarkerAlterOptions from "../../features/marker/marker-alter-options";
+import MarkerOptions from "../../features/marker/marker-options";
+export default class GoogleMarkers {
+    private map;
+    private google;
+    constructor(map: any, google: any);
+    drawMarker(options: MarkerOptions, eventClick: any): any;
+    drawCircleMarker(options: CircleMarkerOptions, eventClick: any): any;
+    toggleMarkers(markers: any[], show: boolean, markerClusterer?: any): void;
+    alterMarkerOptions(markers: any[], options: MarkerAlterOptions): void;
+    alterMarkerPosition(markers: any[], position: number[], addTransition: boolean): void;
+    fitBoundsPositions(markers: any[]): void;
+    isMarkerOnMap(marker: any): boolean | undefined;
+    setCenterMarker(marker: any): void;
+    addMarkerEvent(markers: any, eventType: MarkerEventType, eventFunction: any): void;
+    removeMarkerEvent(markers: any, event: MarkerEventType): void;
+    addMarkerClusterer(config: MarkerClustererConfig): any;
+    alterMarkerClustererConfig(markerClusterer: any, config: MarkerClustererConfig): void;
+    refreshClusterer(markerClusterer: any): void;
+    addMarkerOnClusterer(marker: any, markerClusterer: any): void;
+    removeMarkerFromClusterer(marker: any, markerClusterer: any): void;
+    clearMarkersClusterer(markerClusterer: any): void;
+    countMarkersOnCluster(markerClusterer: any): number;
+    private moveTransitionMarker;
+    private moveMarker;
+}

package/lib/models/apis/google/google-overlay.d.ts

@@ -0,0 +1,11 @@
+import OverlayOptions from "../../features/overlay/overlay-options";
+import GooglePolygons from "./google-polygons";
+export default class GoogleOverlays {
+    private map;
+    private google;
+    private googlePolygons;
+    private OverlayGoogle;
+    constructor(map: any, google: any, googlePolygons: GooglePolygons);
+    drawOverlay(options: OverlayOptions, polygons: any): any;
+    toggleOverlay(overlays: any[], show: boolean): void;
+}

package/lib/models/apis/google/google-polygons.d.ts

@@ -0,0 +1,29 @@
+import { PolygonEventType } from "../../dto/event-type";
+import PolygonAlterOptions from "../../features/polygons/polygon-alter-options";
+import PolygonOptions from "../../features/polygons/polygon-options";
+export default class GooglePolygons {
+    private map;
+    private google;
+    constructor(map: any, google: any);
+    drawPolygon(options: PolygonOptions, eventClick: any): any;
+    togglePolygons(polygons: any[], show: boolean): void;
+    alterPolygonOptions(polygons: any[], options: PolygonAlterOptions): void;
+    fitBoundsPolygons(polygons: any): void;
+    setCenterPolygons(polygons: any): void;
+    isPolygonOnMap(polygon: any): boolean;
+    getPolygonPath(polygon: any): number[][];
+    addPolygonEvent(polygons: any, eventType: PolygonEventType, eventFunction: any): void;
+    removePolygonEvent(polygons: any, event: PolygonEventType): void;
+    getPolygonsBounds(polygons: any): any;
+    private getPolygonBounds;
+    private addPolygonEventMove;
+    private addPolygonEventMoveAllPaths;
+    private addPolygonEventInsertAt;
+    private addPolygonEventInsertAtAllPaths;
+    private addPolygonEventRemoveAt;
+    private addPolygonEventRemoveAtAllPaths;
+    private addPolygonEventDragPolygon;
+    private addPolygonEventClick;
+    private getPathRecursiveArray;
+    private getPathPolylineArray;
+}