@ionic-native/google-maps/index.d.ts

Ionic Native - Native plugins for ionic apps

import { IonicNativePlugin } from '@ionic-native/core';
import { Observable } from 'rxjs';
export declare type MapType = 'MAP_TYPE_NORMAL' | 'MAP_TYPE_ROADMAP' | 'MAP_TYPE_SATELLITE' | 'MAP_TYPE_HYBRID' | 'MAP_TYPE_TERRAIN' | 'MAP_TYPE_NONE';
export interface ILatLng {
    lat: number;
    lng: number;
}
/**
 * @hidden
 */
export declare class LatLng implements ILatLng {
    lat: number;
    lng: number;
    constructor(lat: number, lng: number);
    equals(other: ILatLng): boolean;
    toString(): string;
    toUrlValue(precision?: number): string;
}
export interface ILatLngBounds {
    northeast: ILatLng;
    southwest: ILatLng;
}
/**
 * @hidden
 */
export declare class LatLngBounds implements ILatLngBounds {
    northeast: ILatLng;
    southwest: ILatLng;
    type: string;
    private _objectInstance;
    constructor(points?: ILatLng[]);
    /**
     * Converts to string
     * @return {string}
     */
    toString(): string;
    /**
     * Returns a string of the form "lat_sw,lng_sw,lat_ne,lng_ne" for this bounds, where "sw" corresponds to the southwest corner of the bounding box, while "ne" corresponds to the northeast corner of that box.
     * @param precision {number}
     * @return {string}
     */
    toUrlValue(precision?: number): string;
    /**
     * Extends this bounds to contain the given point.
     * @param LatLng {ILatLng}
     */
    extend(LatLng: ILatLng): void;
    /**
     * Returns true if the given lat/lng is in this bounds.
     * @param LatLng {ILatLng}
     */
    contains(LatLng: ILatLng): boolean;
    /**
     * Computes the center of this LatLngBounds
     * @return {LatLng}
     */
    getCenter(): LatLng;
}
export interface GoogleMapControlOptions {
    /**
     * Turns the compass on or off.
     */
    compass?: boolean;
    /**
     * Turns the myLocation button on or off. If turns on this button, the application displays a permission dialog to obtain the geolocation data.
     */
    myLocationButton?: boolean;
    /**
     * Turns the myLocation control(blue dot) on or off. If turns on this control, the application displays a permission dialog to obtain the geolocation data.
     */
    myLocation?: boolean;
    /**
     * Turns the indoor picker on or off.
     */
    indoorPicker?: boolean;
    /**
     * **Android**
     * Turns the map toolbar on or off.
     */
    mapToolbar?: boolean;
    /**
     * **Android**
     * Turns the zoom controller on or off.
     */
    zoom?: boolean;
    /**
     * Accept extra properties for future updates
     */
    [key: string]: any;
}
export interface GoogleMapGestureOptions {
    /**
     * Set false to disable the scroll gesture (default: true)
     */
    scroll?: boolean;
    /**
     * Set false to disable the tilt gesture (default: true)
     */
    tilt?: boolean;
    /**
     * Set false to disable the zoom gesture (default: true)
     */
    zoom?: boolean;
    /**
     * Set false to disable the rotate gesture (default: true)
     */
    rotate?: boolean;
    /**
     * Accept extra properties for future updates
     */
    [key: string]: any;
}
export interface GoogleMapZoomOptions {
    minZoom?: number;
    maxZoom?: number;
}
export interface GoogleMapPaddingOptions {
    left?: number;
    top?: number;
    bottom?: number;
    right?: number;
}
export interface GoogleMapPreferenceOptions {
    /**
     * Minimum and maximum zoom levels for zooming gestures.
     */
    zoom?: GoogleMapZoomOptions;
    /**
     * Paddings of controls.
     */
    padding?: GoogleMapPaddingOptions;
    /**
     * Turns the 3D buildings layer on or off.
     */
    building?: boolean;
    /**
     * Sets the bounds limit for user panning gesture.
     */
    gestureBounds?: ILatLng[];
    /**
     * Accept extra properties for future updates
     */
    [key: string]: any;
}
export interface GoogleMapOptions {
    /**
     * mapType [options]
     */
    mapType?: MapType | string;
    /**
     * controls [options]
     */
    controls?: GoogleMapControlOptions;
    /**
     * gestures [options]
     */
    gestures?: GoogleMapGestureOptions;
    /**
     * Map styles [options]
     * @ref https://developers.google.com/maps/documentation/javascript/style-reference
     */
    styles?: any[];
    /**
     * Initial camera position [options]
     */
    camera?: CameraPosition<any>;
    /**
     * preferences [options]
     */
    preferences?: GoogleMapPreferenceOptions;
    /**
     * Accept extra properties for future updates
     */
    [key: string]: any;
}
export interface CameraPosition<T> {
    /**
     * The center location of the camera view.
     *
     * [usage 1]
     *
     * let cameraPos: CameraPosition<ILatLng> = {
     *   target: {lat: ..., lng: ...},
     *   zoom: 10
     * }
     *
     * [usage 2] The zoom property is ignored when you specify multiple position
     *
     * let cameraPos: CameraPosition<ILatLng[]> = {
     *   target: [
     *      {lat: ..., lng: ...},
     *      {lat: ..., lng: ...},
     *      {lat: ..., lng: ...}
     *   ]
     * }
     */
    target?: T;
    /**
     * View angle
     */
    tilt?: number;
    /**
     * Zoom level
     */
    zoom?: number;
    /**
     * Map orientation
     */
    bearing?: number;
    /**
     * The duration of animation in milliseconds
     */
    duration?: number;
    /**
     * Camera padding in pixel
     */
    padding?: number;
}
export interface CircleOptions {
    /**
     * Center position of circle
     */
    center: ILatLng;
    /**
     * Radius of circle in meter
     */
    radius: number;
    /**
     * Set the stroke color
     * (rgb, rgba, #RRGGBB, "colorname", ...etc)
     */
    strokeColor?: string;
    /**
     * Set the stroke width in pixel
     */
    strokeWidth?: number;
    /**
     * Set the inside color of circle
     * (rgb, rgba, #RRGGBB, "colorname", ...etc)
     */
    fillColor?: string;
    /**
     * Set to true to receive the CIRCLE_CLICK event
     * (default: false)
     */
    clickable?: boolean;
    /**
     * Set to false to hide
     */
    visible?: boolean;
    /**
     * Z-index
     */
    zIndex?: number;
    /**
     * Accept own properties
     * You can get the property later using `get()` method.
     */
    [key: string]: any;
}
export interface GeocoderRequest {
    /**
     * The address property or position property is required.
     * You can not specify both property at the same time.
     *
     * [geocoding usage1]
     * let request: GeocoderRequest = {
     *   address: "Los Angeles, California, USA"
     * }
     *
     * [geocoding usage2]
     * let request: GeocoderRequest = {
     *   address: [
     *    "Los Angeles, California, USA",
     *    "San Francisco, California, USA",
     *   ]
     * }
     */
    address?: string | string[];
    /**
     *
     * [reverse-geocoding usage1]
     * let request: GeocoderRequest = {
     *   position: {"lat": 37.421655, "lng": -122.085637}
     * }
     *
     * [reverse-geocoding usage2]
     * let request: GeocoderRequest = {
     *   position: [
     *    {"lat": 37.421655, "lng": -122.085637},
     *    {"lat": 37.332, "lng": -122.030781}
     *   ]
     * }
     */
    position?: ILatLng | ILatLng[];
}
export interface GeocoderResult {
    adminArea?: string;
    country?: string;
    countryCode?: string;
    extra?: {
        featureName?: string;
        lines?: string[];
        permises?: string;
        phone?: string;
        url?: string;
    };
    locale?: string;
    locality?: string;
    position?: ILatLng;
    postalCode?: string;
    subAdminArea?: string;
    subLocality?: string;
    subThoroughfare?: string;
    thoroughfare?: string;
}
export interface GroundOverlayOptions {
    /**
     * URL of overlay
     */
    url: string;
    /**
     * Bounds, array of ILatLng
     */
    bounds: ILatLng[];
    /**
     * Set to true to receive the GROUND_OVERLAY_CLICK event
     * (default: false)
     */
    clickable?: boolean;
    /**
     * Set to false to hide
     */
    visible?: boolean;
    /**
     * Opacity. From 0.0 to 1.0 .
     */
    opacity?: number;
    /**
     * Bearing
     */
    bearing?: number;
    /**
     * Z-index
     */
    zIndex?: number;
    /**
     * Accept own properties
     * You can get the property later using `get()` method.
     */
    [key: string]: any;
}
export interface MarkerIcon {
    url?: string;
    size?: {
        width?: number;
        height?: number;
    };
}
export interface MarkerOptions {
    /**
     * The icon image url or properties. Also you can specify HTML Color values. Alternatively you can specify the image as Base64
     */
    icon?: any;
    /**
     * The content of the infoWindow.
     */
    title?: string;
    /**
     * The snippet of the infoWindow.
     */
    snippet?: string;
    /**
     * The position of the marker.
     */
    position: ILatLng;
    /**
     *  Specify the anchor of the InfoWindow
     */
    infoWindowAnchor?: number[];
    /**
     * 	Specify the anchor of icon image
     */
    anchor?: number[];
    /**
     * Set true if you want to enable to drag the marker. (Default: false) Important! Drag starts after long pressed on the marker.
     */
    draggable?: boolean;
    /**
     *  Set true if you want to use a flat marker. (Default: false)
     */
    flat?: boolean;
    /**
     *  Set rotation angle. (Default: 0)
     */
    rotation?: number;
    /**
     * Set false if you want to hide. (Default: true)
     */
    visible?: boolean;
    /**
     * Specify the options for title. This property work for normal InfoWindow.
     */
    styles?: any;
    /**
     * Which animation to play when marker is added to a map.
     */
    animation?: string;
    /**
     * Higher zIndex value overlays will be drawn on top of lower zIndex value tile layers and overlays.
     */
    zIndex?: number;
    /**
     * Set to true to disable auto panning when the marker is clicked.
     */
    disableAutoPan?: boolean;
    /**
     * Accept own properties
     * You can get the property later using `get()` method.
     */
    [key: string]: any;
}
export interface MarkerLabel {
    /**
     * Set true if use bold font
     */
    bold?: boolean;
    /**
     * Set font size in pixel
     */
    fontSize?: number;
    /**
     * color strings
     */
    color?: string;
    /**
     * Set true if use italic font
     */
    italic?: boolean;
}
export interface MarkerClusterIcon {
    /**
     * Minimum number of clustering
     */
    min?: number;
    /**
     * Maximum number of clustering
     */
    max?: number;
    /**
     * anchor position of the marker
     */
    anchor?: any;
    /**
     * label option for clustered marker
     */
    label?: MarkerLabel;
    /**
     * icon url
     */
    url: string;
    /**
     * icon size
     */
    size?: {
        width?: number;
        height?: number;
    };
}
export interface MarkerClusterOptions {
    /**
     * Maximum zoom level of clustering
     * (default: 15, max: 18)
     */
    maxZoomLevel?: number;
    /**
     * Draw a rectangle that contains all locations of clustered when you tap on a cluster marker.
     * (default: true)
     */
    boundsDraw?: boolean;
    /**
     * Position list
     * [
     *   {title: "store A", position: {lat: ..., lng: ...}},
     *   {title: "store B", position: {lat: ..., lng: ...}},
     *   {title: "store C", position: {lat: ..., lng: ...}}
     * ]
     */
    markers: MarkerOptions[];
    /**
     * Conditions of clustering
     * [
     *   {icon: "assets/small.png", min: 2, max: 10},
     *   {icon: "assets/middle.png", min: 11, max: 30},
     *   {icon: "assets/large.png", min: 31}
     * ]
     */
    icons: MarkerClusterIcon[];
    /**
     * Accept own properties
     * You can get the property later using `get()` method.
     */
    [key: string]: any;
}
export interface MyLocation {
    latLng?: LatLng;
    elapsedRealtimeNanos?: any;
    time?: string;
    accuracy?: any;
    bearing?: number;
    altitude?: any;
    speed?: number;
    provider?: any;
    hashCode?: any;
}
export interface MyLocationOptions {
    /**
     * Set true if you want to try to use GPS mandatory.
     * In false, the plugin try to use GPS and network.
     * (default: false)
     */
    enableHighAccuracy?: boolean;
}
export interface PolygonOptions {
    /**
     * Pass ILatLng[] to specify the vertixes.
     * You need to contain two points at least.
     */
    points: ILatLng[];
    /**
     * Set true if you want to draw the curve polygon based on the earth
     * (default: false)
     */
    geodesic?: boolean;
    /**
     * Set the stroke color
     * (rgb, rgba, #RRGGBB, "colorname", ...etc)
     */
    strokeColor?: string;
    /**
     * Set the stroke width in pixel
     */
    strokeWidth?: number;
    /**
     * Set the inside color of polygon
     * (rgb, rgba, #RRGGBB, "colorname", ...etc)
     */
    fillColor?: string;
    /**
     * Set false if you want to create invisible polygon
     * (Invisible polygon is not clickable, default true)
     */
    visible?: boolean;
    /**
     * Hierarchy z-index
     */
    zIndex?: number;
    /**
     * Pass ILatLng[][] to create holes in polygon
     */
    holes?: ILatLng[][];
    /**
     * Set true if you want to receive the POLYGON_CLICK event
     * (default: false)
     */
    clickable?: boolean;
    /**
     * Accept own properties
     * You can get the property later using `get()` method.
     */
    [key: string]: any;
}
export interface PolylineOptions {
    /**
     * Pass ILatLng[] to specify the vertixes.
     * You need to contain two points at least.
     */
    points: ILatLng[];
    /**
     * Set false if you want to create invisible polyline
     * (Invisible polyline is not clickable, default true)
     */
    visible?: boolean;
    /**
     * Set true if you want to draw the curve polyline based on the earth
     * (default: false)
     */
    geodesic?: boolean;
    /**
     * Set the stroke color
     * (rgb, rgba, #RRGGBB, "colorname", ...etc)
     */
    color?: string;
    /**
     * Set the stroke width in pixel
     */
    width?: number;
    /**
     * Hierarchy z-index
     */
    zIndex?: number;
    /**
     * Set true if you want to receive the POLYLINE_CLICK event
     * (default: false)
     */
    clickable?: boolean;
    /**
     * Accept own properties
     * You can get the property later using `get()` method.
     */
    [key: string]: any;
}
export interface TileOverlayOptions {
    /**
     * This callback must Returns string of image URL, or Promise.
     * If no tile, you need to Returns null.
     */
    getTile: (x: number, y: number, zoom: number) => string;
    /**
     * Set false if you want to create invisible tilelayer
     * (default true)
     */
    visible?: boolean;
    /**
     * Hierarchy z-index of tilelayer
     */
    zIndex?: number;
    /**
     * Default: 512px
     */
    tileSize?: number;
    /**
     * Default: 1.0
     */
    opacity?: number;
    /**
     * Set true if you want to display the tile information over the tile images.
     */
    debug?: boolean;
    /**
     * Accept own properties
     * You can get the property later using `get()` method.
     */
    [key: string]: any;
}
export interface ToDataUrlOptions {
    /**
     * True if you want get high quality map snapshot
     */
    uncompress?: boolean;
}
/**
 * Options for map.addKmlOverlay() method
 */
export interface KmlOverlayOptions {
    url: string;
    clickable?: boolean;
    suppressInfoWindows?: boolean;
    icon?: string | MarkerIcon;
    /**
     * Accept own properties for future update
     */
    [key: string]: any;
}
/**
 * Options for Environment.setEnv()
 */
export interface EnvOptions {
    API_KEY_FOR_BROWSER_RELEASE?: string;
    API_KEY_FOR_BROWSER_DEBUG?: string;
    /**
     * Accept own properties for future update
     */
    [key: string]: any;
}
/**
 * @hidden
 */
export declare class VisibleRegion implements ILatLngBounds {
    private _objectInstance;
    /**
     * The northeast of the bounds that contains the farLeft, farRight, nearLeft and nearRight.
     * Since the map view is able to rotate, the farRight is not the same as the northeast.
     */
    northeast: ILatLng;
    /**
     * The southwest of the bounds that contains the farLeft, farRight, nearLeft and nearRight.
     * Since the map view is able to rotate, the nearLeft is not the same as the southwest.
     */
    southwest: ILatLng;
    /**
     * The farLeft indicates the lat/lng of the top-left of the map view.
     */
    farLeft: ILatLng;
    /**
     * The farRight indicates the lat/lng of the top-right of the map view.
     */
    farRight: ILatLng;
    /**
     * The nearLeft indicates the lat/lng of the bottom-left of the map view.
     */
    nearLeft: ILatLng;
    /**
     * The nearRight indicates the lat/lng of the bottom-right of the map view.
     */
    nearRight: ILatLng;
    /**
     * constant value : `VisibleRegion`
     */
    type: string;
    constructor(southwest: LatLngBounds, northeast: LatLngBounds, farLeft: ILatLng, farRight: ILatLng, nearLeft: ILatLng, nearRight: ILatLng);
    /**
     * Converts to string
     * @return {string}
     */
    toString(): string;
    /**
     * Returns a string of the form "lat_sw,lng_sw,lat_ne,lng_ne" for this bounds, where "sw" corresponds to the southwest corner of the bounding box, while "ne" corresponds to the northeast corner of that box.
     * @param precision {number}
     * @return {string}
     */
    toUrlValue(precision?: number): string;
    /**
     * Returns true if the given lat/lng is in this bounds.
     * @param LatLng {ILatLng}
     */
    contains(LatLng: ILatLng): boolean;
}
/**
 * @hidden
 */
export declare const StreetViewSource: {
    DEFAULT: string;
    OUTDOOR: string;
};
export interface SetPovOption {
    bearing: number;
    radius?: number;
    zoom?: number;
    duration: number;
}
export interface StreetViewSetPositionOption {
    target: ILatLng;
    source?: string;
    radius?: number;
}
export interface StreetViewCameraPano {
    target: string;
    bearing?: number;
    tilt?: number;
    zoom?: number;
}
export interface StreetViewCameraPosition {
    target: ILatLng;
    source?: string;
    radius?: number;
    bearing?: number;
    tilt?: number;
    zoom?: number;
}
export interface StreetViewControlOptions {
    streetNames?: boolean;
    navigation?: boolean;
}
export interface StreetViewGestureOptions {
    panning?: boolean;
    zooming?: boolean;
}
export interface StreetViewOptions {
    camera?: StreetViewCameraPano | StreetViewCameraPosition;
    /**
     * controls [options]
     */
    controls?: StreetViewControlOptions;
    /**
     * gestures [options]
     */
    gestures?: StreetViewGestureOptions;
    /**
     * Accept extra properties for future updates
     */
    [key: string]: any;
}
export interface StreetViewNavigationLink {
    /**
     * panorama Id
     */
    panoId: string;
    /**
     * bearing (heading)
     */
    bearing: number;
}
export interface StreetViewLocation {
    latLng: ILatLng;
    links: StreetViewNavigationLink[];
}
/**
 * @hidden
 * You can listen to these events where appropriate
 */
export declare const GoogleMapsEvent: {
    MAP_READY: string;
    MAP_CLICK: string;
    MAP_LONG_CLICK: string;
    POI_CLICK: string;
    MY_LOCATION_CLICK: string;
    MY_LOCATION_BUTTON_CLICK: string;
    INDOOR_BUILDING_FOCUSED: string;
    INDOOR_LEVEL_ACTIVATED: string;
    CAMERA_MOVE_START: string;
    CAMERA_MOVE: string;
    CAMERA_MOVE_END: string;
    OVERLAY_CLICK: string;
    POLYGON_CLICK: string;
    POLYLINE_CLICK: string;
    CIRCLE_CLICK: string;
    GROUND_OVERLAY_CLICK: string;
    INFO_CLICK: string;
    INFO_LONG_CLICK: string;
    INFO_CLOSE: string;
    INFO_OPEN: string;
    MARKER_CLICK: string;
    MARKER_DRAG: string;
    MARKER_DRAG_START: string;
    MARKER_DRAG_END: string;
    MAP_DRAG: string;
    MAP_DRAG_START: string;
    MAP_DRAG_END: string;
    KML_CLICK: string;
    PANORAMA_READY: string;
    PANORAMA_CAMERA_CHANGE: string;
    PANORAMA_LOCATION_CHANGE: string;
    PANORAMA_CLICK: string;
};
/**
 * @hidden
 */
export declare const GoogleMapsAnimation: {
    BOUNCE: string;
    DROP: string;
};
/**
 * @hidden
 */
export declare const GoogleMapsMapTypeId: {
    NORMAL: string;
    ROADMAP: string;
    SATELLITE: string;
    HYBRID: string;
    TERRAIN: string;
    NONE: string;
};
/**
 * @name Google Maps
 * @description
 * This plugin uses the native Google Maps SDK
 * Note: As of Ionic native 4.0, this using the 2.0 version of the google maps plugin. Please make sure your plugin is updated
 * @usage
 * ```typescript
 * import {
 *  GoogleMaps,
 *  GoogleMap,
 *  GoogleMapsEvent,
 *  GoogleMapOptions,
 *  CameraPosition,
 *  MarkerOptions,
 *  Marker
 * } from '@ionic-native/google-maps';
 * import { Component } from "@angular/core/";
 *
 * @Component({
 *   selector: 'page-home',
 *   templateUrl: 'home.html'
 * })
 * export class HomePage {
 *   map: GoogleMap;
 *   constructor() { }
 *
 *   ionViewDidLoad() {
 *    this.loadMap();
 *   }
 *
 *  loadMap() {
 *
 *     let mapOptions: GoogleMapOptions = {
 *       camera: {
 *         target: {
 *           lat: 43.0741904,
 *           lng: -89.3809802
 *         },
 *         zoom: 18,
 *         tilt: 30
 *       }
 *     }
 *
 *     this.map = GoogleMaps.create('map_canvas', mapOptions);
 *
 *     let marker: Marker = this.map.addMarkerSync({
 *       title: 'Ionic',
 *       icon: 'blue',
 *       animation: 'DROP',
 *       position: {
 *         lat: 43.0741904,
 *         lng: -89.3809802
 *       }
 *     });
 *
 *     marker.on(GoogleMapsEvent.MARKER_CLICK)
 *       .subscribe(() => {
 *         alert('clicked');
 *       });
 *     });
 *   }
 * }
 *
 * ```
 * @classes
 * GoogleMaps
 * GoogleMap
 * StreetView
 * Circle
 * Encoding
 * Environment
 * Geocoder
 * GroundOverlay
 * HtmlInfoWindow
 * Geocoder
 * LatLng
 * LatLngBounds
 * Marker
 * MarkerCluster
 * Polygon
 * Polyline
 * Spherical
 * KmlOverlay
 * Poly
 * TileOverlay
 * BaseClass
 * BaseArrayClass
 * @interfaces
 * GoogleMapOptions
 * CameraPosition
 * CircleOptions
 * GeocoderRequest
 * GeocoderResult
 * GroundOverlayOptions
 * ILatLng
 * MarkerIcon
 * MarkerOptions
 * MarkerClusterIcon
 * MarkerClusterOptions
 * MyLocation
 * MyLocationOptions
 * PolygonOptions
 * PolylineOptions
 * TileOverlayOptions
 * KmlOverlayOptions
 * VisibleRegion
 */
export declare class GoogleMaps extends IonicNativePlugin {
    /**
     * Creates a new GoogleMap instance
     * @param element {string | HTMLElement} Element ID or reference to attach the map to
     * @param options {GoogleMapOptions} [options] Options
     * @return {GoogleMap}
     */
    static create(element: string | HTMLElement | GoogleMapOptions, options?: GoogleMapOptions): GoogleMap;
    /**
     * @deprecation keep this for backward compatibility.
     * @hidden
     */
    create(element: string | HTMLElement | GoogleMapOptions, options?: GoogleMapOptions): GoogleMap;
    /**
     * Creates a new StreetView instance
     * @param element {string | HTMLElement} Element ID or reference to attach the map to
     * @param options {StreetViewOptions} [options] Options
     * @return {StreetViewPanorama}
     */
    static createPanorama(element: string | HTMLElement, options?: StreetViewOptions): StreetViewPanorama;
}
/**
 * @hidden
 * https://github.com/mapsplugin/cordova-plugin-googlemaps-doc/blob/master/v2.0.0/class/BaseClass/README.md
 */
export declare class BaseClass {
    protected _objectInstance: any;
    constructor(objInstance?: any);
    /**
     * Adds an event listener.
     * @param eventName {string} event name you want to observe.
     * @return {Observable<any>}
     */
    addEventListener(eventName: string): Observable<any>;
    /**
     * Attaches the handler for the event that is thrown by the target, where the minimum interval between events (in milliseconds) is specified as a parameter.
     * @param eventName {string} event name you want to observe.
     * @param throttleInterval {number} throttle interval in milliseconds
     * @return {Observable<any>}
     */
    /**
     * Adds an event listener that works once.
     * @param eventName {string} event name you want to observe.
     * @return {Promise<any>}
     */
    addEventListenerOnce(eventName: string): Promise<any>;
    /**
     * @deprecated
     * Adds an event listener that works once.
     * @param eventName {string} event name you want to observe.
     * @return {Promise<any>}
     */
    addListenerOnce(eventName: string): Promise<any>;
    /**
     * Gets a value
     * @param key {any}
     */
    get(key: string): any;
    /**
     * Sets a value
     * @param key {string} The key name for the value. `(key)_changed` will be fired when you set value through this method.
     * @param value {any}
     * @param noNotify {boolean} [options] True if you want to prevent firing the `(key)_changed` event.
     */
    set(key: string, value: any, noNotify?: boolean): void;
    /**
     * Bind a key to another object
     * @param key {string} The property name you want to observe.
     * @param target {any} The target object you want to observe.
     * @param targetKey? {string} [options]  The property name you want to observe. If you omit this, the `key` argument is used.
     * @param noNotify? {boolean} [options] True if you want to prevent `(key)_changed` event when you bind first time, because the internal status is changed from `undefined` to something.
     */
    bindTo(key: string, target: any, targetKey?: string, noNotify?: boolean): void;
    /**
     * Alias of `addEventListener`
     * @param key {string} The property name you want to observe.
     * @return {Observable<any>}
     */
    on(eventName: string): Observable<any>;
    /**
     * Alias of `addThrottledEventListener`
     * @param key {string} The property name you want to observe.
     * @return {Observable<any>}
     */
    /**
     * Alias of `addEventListenerOnce`
     * @param key {string} The property name you want to observe.
     * @return {Promise<any>}
     */
    one(eventName: string): Promise<any>;
    /**
     * Return true if this object has event listener for event name
     * @param eventName {string} Event name
     * @return {boolean}
     */
    hasEventListener(): boolean;
    /**
     * Clears all stored values
     */
    empty(): void;
    /**
     * Dispatch event.
     * @param eventName {string} Event name
     * @param parameters {any} [options] The data you want to pass to event listerners.
     */
    trigger(eventName: string, ...parameters: any[]): void;
    /**
     * Executes off() and empty()
     */
    destroy(): void;
    /**
     * Remove event listener(s)
     * The `removeEventListener()` has three usages:
     *  - removeEventListener("eventName", listenerFunction);
     *     This removes one particular event listener
     *  - removeEventListener("eventName");
     *     This removes the event listeners that added for the event name.
     *  - removeEventListener();
     *     This removes all listeners.
     *
     * @param eventName {string} [options] Event name
     * @param listener {Function} [options] Event listener
     */
    removeEventListener(eventName?: string, listener?: (...parameters: any[]) => void): void;
    /**
     * Alias of `removeEventListener`
     *
     * @param eventName {string} [options] Event name
     * @param listener {Function} [options] Event listener
     */
    off(eventName?: string, listener?: (...parameters: any[]) => void): void;
}
/**
 * @hidden
 * https://github.com/mapsplugin/cordova-plugin-googlemaps-doc/blob/master/v2.0.0/class/BaseArrayClass/README.md
 */
export declare class BaseArrayClass<T> extends BaseClass {
    constructor(initialData?: T[] | any);
    /**
     * Removes all elements from the array.
     * @param noNotify? {boolean} [options] Set true to prevent remove_at events.
     */
    empty(noNotify?: boolean): void;
    /**
     * Iterate over each element, calling the provided callback.
     * @param fn {Function}
     */
    forEach(fn: (element: T, index?: number) => void): void;
    /**
     * Iterate over each element, calling the provided callback.
     * @param fn {Function}
     * @return {Promise<void>}
     */
    forEachAsync(fn: ((element: T, callback: () => void) => void)): Promise<void>;
    /**
     * Iterate over each element, then Returns a new value.
     * Then you can get the results of each callback.
     * @param fn {Function}
     * @return {Object[]} returns a new array with the results
     */
    map(fn: (element: T, index: number) => any): any[];
    /**
     * Iterate over each element, calling the provided callback.
     * Then you can get the results of each callback.
     * @param fn {Function}
     * @param callback {Function}
     * @return {Promise<any>} returns a new array with the results
     */
    mapAsync(fn: ((element: T, callback: (newElement: any) => void) => void)): Promise<any[]>;
    /**
     * Same as `mapAsync`, but keep the execution order
     * @param fn {Function}
     * @param callback {Function}
     * @return {Promise<any>} returns a new array with the results
     */
    mapSeries(fn: ((element: T, callback: (newElement: any) => void) => void)): Promise<any[]>;
    /**
     * The filter() method creates a new array with all elements that pass the test implemented by the provided function.
     * @param fn {Function}
     * @return {T[]} returns a new filtered array
     */
    filter(fn: (element: T, index: number) => boolean): T[];
    /**
     * The filterAsync() method creates a new array with all elements that pass the test implemented by the provided function.
     * @param fn {Function}
     * @param callback {Function}
     * @return {Promise<T[]>} returns a new filtered array
     */
    filterAsync(fn: (element: T, callback: (result: boolean) => void) => void): Promise<T[]>;
    /**
     * Returns a reference to the underlying Array.
     * @return {Object[]}
     */
    getArray(): T[];
    /**
     * Returns the element at the specified index.
     * @param index {number}
     * @return {Object}
     */
    getAt(index: number): any;
    /**
     * Returns the number of the elements.
     * @return {number}
     */
    getLength(): number;
    /**
     * The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.
     * @param element {Object}
     * @return {number}
     */
    indexOf(element: T): number;
    /**
     * The reverse() method reverses an array in place.
     */
    reverse(): void;
    /**
     * The sort() method sorts the elements of an array in place and returns the array.
     */
    sort(): void;
    /**
     * Inserts an element at the specified index.
     * @param index {number}
     * @param element {Object}
     * @param noNotify? {boolean} [options] Set true to prevent insert_at event.
     * @return {Object}
     */
    insertAt(index: number, element: T, noNotify?: boolean): void;
    /**
     * Removes the last element of the array and returns that element.
     * @param noNotify? {boolean} [options] Set true to prevent remove_at event.
     * @return {Object}
     */
    pop(noNotify?: boolean): T;
    /**
     * Adds one element to the end of the array and returns the new length of the array.
     * @param element {object}
     * @param noNotify? {boolean} Set true to prevent insert_at events.
     */
    push(element: T, noNotify?: boolean): void;
    /**
     * Removes an element from the specified index.
     * @param index {number}
     * @param noNotify? {boolean} [options] Set true to prevent remove_at event.
     */
    removeAt(index: number, noNotify?: boolean): T;
    /**
     * Sets an element at the specified index.
     * @param index {number}
     * @param element {object}
     * @param noNotify? {boolean} [options] Set true to prevent set_at event.
     */
    setAt(index: number, element: T, noNotify?: boolean): void;
}
/**
 * @hidden
 * https://github.com/mapsplugin/cordova-plugin-googlemaps-doc/blob/master/v2.0.0/class/Circle/README.md
 */
export declare class Circle extends BaseClass {
    private _map;
    constructor(_map: GoogleMap, _objectInstance: any);
    /**
     * Returns the ID of instance.
     * @return {string}
     */
    getId(): string;
    /**
     * Returns the map instance.
     * @return {GoogleMap}
     */
    getMap(): any;
    /**
     * Changes the center position.
     * @param latLng {ILatLng}
     */
    setCenter(latLng: ILatLng): void;
    /**
     * Returns the current center position
     * @return {ILatLng}
     */
    getCenter(): ILatLng;
    /**
     * Returns the current circle radius.
     * @return {number}
     */
    getRadius(): number;
    /**
     * Changes the circle radius.
     * @param radius {number}
     */
    setRadius(radius: number): void;
    /**
     * Changes the filling color (inner color).
     * @param color {string}
     */
    setFillColor(color: string): void;
    /**
     * Returns the current circle filling color (inner color).
     * @return {string}
     */
    getFillColor(): string;
    /**
     * Changes the stroke width.
     * @param strokeWidth {number}
     */
    setStrokeWidth(strokeWidth: number): void;
    /**
     * Returns the current circle stroke width (unit: pixel).
     * @return {number}
     */
    getStrokeWidth(): number;
    /**
     * Changes the stroke color (outter color).
     * @param strokeColor {string}
     */
    setStrokeColor(strokeColor: string): void;
    /**
     * Returns the current circle stroke color (outer color).
     * @return {string}
     */
    getStrokeColor(): string;
    /**
     * Changes click-ability of the circle.
     * @param clickable {boolean}
     */
    setClickable(clickable: boolean): void;
    /**
     * Returns true if the circle is clickable.
     * @return {boolean}
     */
    getClickable(): boolean;
    /**
     * Changes the circle zIndex order.
     * @param zIndex {number}
     */
    setZIndex(zIndex: number): void;
    /**
     * Returns the current circle zIndex.
     * @return {number}
     */
    getZIndex(): number;
    /**
     * Remove the circle.
     */
    remove(): void;
    /**
     * Returns the latLngBounds (rectangle) that contains the circle.
     * @return {LatLngBounds}
     */
    getBounds(): LatLngBounds;
    /**
     * Set circle visibility
     * @param visible {boolean}
     */
    setVisible(visible: boolean): void;
    /**
     * Returns true if the circle is visible.
     * @return {boolean}
     */
    getVisible(): boolean;
}
/**
 * @hidden
 */
export declare class Environment {
    /**
     * Set environment variables.
     */
    static setEnv(envOptions: EnvOptions): void;
    /**
     * Get the open source software license information for Google Maps SDK for iOS.
     * @return {Promise<any>}
     */
    static getLicenseInfo(): Promise<any>;
    /**
     * Specifies the background color of the app.
     * @param color
     */
    static setBackgroundColor(color: string): void;
    /**
     * @deprecation This method is static. Please use Environment.getLicenseInfo()
     * @hidden
     */
    getLicenseInfo(): Promise<any>;
    /**
     * @deprecation This method is static. Please use Environment.setBackgroundColor()
     * @hidden
     */
    setBackgroundColor(color: string): void;
}
/**
 * @hidden
 */
export declare class Geocoder {
    /**
     * @deprecation This method is static. Please use Geocoder.geocode()
     * @hidden
     */
    geocode(request: GeocoderRequest): Promise<GeocoderResult[] | BaseArrayClass<GeocoderResult[]>>;
    /**
     * Converts position to address and vice versa
     * @param {GeocoderRequest} request Request object with either an address or a position
     * @return {Promise<GeocoderResult[] | BaseArrayClass<GeocoderResult>>}
     */
    static geocode(request: GeocoderRequest): Promise<GeocoderResult[] | BaseArrayClass<GeocoderResult[]>>;
}
/**
 * @hidden
 */
export declare class LocationService {
    /**
     * Get the current device location without map
     * @return {Promise<MyLocation>}
     */
    static getMyLocation(options?: MyLocationOptions): Promise<MyLocation>;
    /**
     * Return true if the application has geolocation permission
     * @return {Promise<boolean>}
     */
    static hasPermission(): Promise<boolean>;
}
/**
 * @hidden
 */
export declare class Encoding {
    /**
     * Decodes an encoded path string into a sequence of LatLngs.
     * @param encoded {string} an encoded path string
     * @param precision? {number} default: 5
     * @return {LatLng}
     */
    static decodePath(encoded: string, precision?: number): ILatLng[];
    /**
     * Encodes a sequence of LatLngs into an encoded path string.
     * @param path {ILatLng[] | BaseArrayClass<ILatLng>} a sequence of LatLngs
     * @return {string}
     */
    static encodePath(path: ILatLng[] | BaseArrayClass<ILatLng>): string;
    /**
     * @deprecation This method is static. Please use Encoding.decodePath()
     * @hidden
     */
    decodePath(encoded: string, precision?: number): ILatLng[];
    /**
     * @deprecation This method is static. Please use Encoding.encodePath()
     * @hidden
     */
    encodePath(path: ILatLng[] | BaseArrayClass<ILatLng>): string;
}
/**
 * @hidden
 */
export declare class Poly {
    /**
     * Returns true if the specified location is in the polygon path
     * @param location {ILatLng}
     * @param path {ILatLng[]}
     * @return {boolean}
     */
    static containsLocation(location: ILatLng, path: ILatLng[]): boolean;
    /**
     * Returns true if the specified location is on the polyline path
     * @param location {ILatLng}
     * @param path {ILatLng[]}
     * @return {boolean}
     */
    static isLocationOnEdge(location: ILatLng, path: ILatLng[]): boolean;
}
/**
 * @hidden
 */
export declare class Spherical {
    /**
     * Returns the distance, in meters, between two LatLngs.
     * @param locationA {ILatLng}
     * @param locationB {ILatLng}
     * @return {number}
     */
    static computeDistanceBetween(from: ILatLng, to: ILatLng): number;
    /**
     * Returns the LatLng resulting from moving a distance from an origin in the specified heading (expressed in degrees clockwise from north)
     * @param from {ILatLng}
     * @param distance {number}
     * @param heading {number}
     * @return {LatLng}
     */
    static computeOffset(from: ILatLng, distance: number, heading: number): LatLng;
    /**
     * Returns the location of origin when provided with a LatLng destination, meters travelled and original heading. Headings are expressed in degrees clockwise from North. This function returns null when no solution is available.
     * @param to {ILatLng} The destination LatLng.
     * @param distance {number} The distance travelled, in meters.
     * @param heading {number} The heading in degrees clockwise from north.
     * @return {LatLng}
     */
    static computeOffsetOrigin(to: ILatLng, distance: number, heading: number): LatLng;
    /**
     * Returns the length of the given path.
     * @param path {ILatLng[] | BaseArrayClass<ILatLng>}
     * @return {number}
     */
    static computeLength(path: ILatLng[] | BaseArrayClass<ILatLng>): number;
    /**
     * Returns the area of a closed path. The computed area uses the same units as the radius.
     * @param path {ILatLng[] | BaseArrayClass<ILatLng>}.
     * @return {number}
     */
    static computeArea(path: ILatLng[] | BaseArrayClass<ILatLng>): number;
    /**
     * Returns the signed area of a closed path. The signed area may be used to determine the orientation of the path.
     * @param path {ILatLng[] | BaseArrayClass<ILatLng>}.
     * @return {number}
     */
    static computeSignedArea(path: ILatLng[] | BaseArrayClass<ILatLng>): number;
    /**
     * Returns the heading from one LatLng to another LatLng. Headings are expressed in degrees clockwise from North within the range (-180,180).
     * @param from {ILatLng}
     * @param to {ILatLng}
     * @return {number}
     */
    static computeHeading(from: ILatLng, to: ILatLng): number;
    /**
     * Returns the LatLng which lies the given fraction of the way between the origin LatLng and the destination LatLng.
     * @param from {ILatLng}     The LatLng from which to start.
     * @param to {ILatLng}       The LatLng toward which to travel.
     * @param fraction {number}  A fraction of the distance to travel from 0.0 to 1.0 .
     * @return {LatLng}
     */
    static interpolate(from: ILatLng, to: ILatLng, fraction: number): LatLng;
    /**
     * @deprecation This method is static. Please use Spherical.computeDistanceBetween()
     * @hidden
     */
    computeDistanceBetween(from: ILatLng, to: ILatLng): number;
    /**
     * @deprecation This method is static. Please use Spherical.computeOffset()
     * @hidden
     */
    computeOffset(from: ILatLng, distance: number, heading: number): LatLng;
    /**
     * @deprecation This method is static. Please use Spherical.computeOffsetOrigin()
     * @hidden
     */
    computeOffsetOrigin(to: ILatLng, distance: number, heading: number): LatLng;
    /**
     * @deprecation This method is static. Please use Spherical.computeLength()
     * @hidden
     */
    computeLength(path: ILatLng[] | BaseArrayClass<ILatLng>): number;
    /**
     * @deprecation This method is static. Please use Spherical.computeArea()
     * @hidden
     */
    computeArea(path: ILatLng[] | BaseArrayClass<ILatLng>): number;
    /**
     * @deprecation This method is static. Please use Spherical.computeSignedArea()
     * @hidden
     */
    computeSignedArea(path: ILatLng[] | BaseArrayClass<ILatLng>): number;
    /**
     * @deprecation This method is static. Please use Spherical.computeHeading()
     * @hidden
     */
    computeHeading(from: ILatLng, to: ILatLng): number;
    /**
     * @deprecation This method is static. Please use Spherical.interpolate()
     * @hidden
     */
    interpolate(from: ILatLng, to: ILatLng, fraction: number): LatLng;
}
/**
 * @hidden
 */
export declare class StreetViewPanorama extends BaseClass {
    constructor(element: string | HTMLElement, options?: StreetViewOptions);
    /**
     * Sets the point of view for the Street View panorama.
     */
    setPov(pov: StreetViewCameraPano): void;
    /**
     * Sets the StreetViewPanorama to a given location.
     */
    setPosition(cameraPosition: String | StreetViewSetPositionOption): void;
    /**
     * Toggles the ability for users to use pan around on the panorama using gestures.
     * @param gestureEnable {boolean}
     */
    setPanningGesturesEnabled(gestureEnable: boolean): void;
    /**
     * Return true if the panning gesture is enabled.
     * @return {boolean}
     */
    getPanningGesturesEnabled(): boolean;
    /**
     * Toggles the ability for users to zoom on the panorama using gestures.
     * @param gestureEnable {boolean}
     */
    setZoomGesturesEnabled(gestureEnable: boolean): void;
    /**
     * Return true if the zooming gesture is enabled.
     * @return {boolean}
     */
    getZoomGesturesEnabled(): boolean;
    /**
     * Toggles the ability for users to see street names on the panorama.
     * @param gestureEnable {boolean}
     */
    setStreetNamesEnabled(gestureEnable: boolean): void;
    /**
     * Return true if the street names control is enabled.
     * @return {boolean}
     */
    getStreetNamesEnabled(): boolean;
    /**
     * Toggles the ability for users to move between panoramas.
     * @param gestureEnable {boolean}
     */
    setNavigationEnabled(gestureEnable: boolean): void;
    /**
     * Return true if the navigation control is enabled.
     * @return {boolean}
     */
    getNavigationEnabled(): boolean;
    /**
     * Return the navigation links (StreetViewLocation.links)
     * @return {StreetViewNavigationLink[]}
     */
    getLinks(): StreetViewNavigationLink[];
    /**
     * Return the current location
     * @return {StreetViewLocation}
     */
    getLocation(): StreetViewLocation;
    /**
     * Return the current panorama id
     * @return {string}
     */
    getPanoId(): string;
    /**
     * Return the current position (StreetViewLocation.latLng)
     * @return {string}
     */
    getPosition(): ILatLng;
    /**
     * Destroy a panorama completely
     * @return {Promise<any>}
     */
    remove(): Promise<any>;
}
/**
 * @hidden
 */
export declare class GoogleMap extends BaseClass {
    constructor(element: HTMLElement | string, options?: GoogleMapOptions, __timeout?: number);
    /**
     * Changes the map div
     * @param domNode {HTMLElement | string} [options] If you want to display the map in an html element, you need to specify an element or id. If omit this argument, the map is detached from webview.
     */
    setDiv(domNode?: HTMLElement | string): void;
    /**
     * Returns the map HTML element
     * @return {HTMLElement}
     */
    getDiv(): HTMLElement;
    /**
     * Changes the map type id
     * @param mapTypeId {string}
     */
    setMapTypeId(mapTypeId: MapType | string): void;
    /**
     * Moves the camera with animation
     * @return {Promise<any>}
     */
    animateCamera(cameraPosition: CameraPosition<any>): Promise<any>;
    /**
     * Zooming in the camera with animation
     * @return {Promise<any>}
     */
    animateCameraZoomIn(): Promise<any>;
    /**
     * Zooming out the camera with animation
     * @return {Promise<any>}
     */
    animateCameraZoomOut(): Promise<any>;
    /**
     * Moves the camera without animation
     * @return {Promise<any>}
     */
    moveCamera(cameraPosition: CameraPosition<any>): Promise<any>;
    /**
     * Zooming in the camera without animation
     * @return {Promise<any>}
     */
    moveCameraZoomIn(): Promise<any>;
    /**
     * Zooming out the camera without animation
     * @return {Promise<any>}
     */
    moveCameraZoomOut(): Promise<any>;
    /**
     * Get the position of the camera.
     * @return {CameraPosition}
     */
    getCameraPosition(): CameraPosition<ILatLng>;
    /**
     * Get the current camera target position
     * @return {ILatLng}
     */
    getCameraTarget(): ILatLng;
    /**
     * Get the current camera zoom level
     * @return {number}
     */
    getCameraZoom(): number;
    /**
     * Get the current camera bearing
     * @return {number}
     */
    getCameraBearing(): number;
    /**
     * Get the current camera tilt (view angle)
     * @return {number}
     */
    getCameraTilt(): number;
    /**
     * Set the center position of the camera view
     * @param latLng {ILatLng | ILatLng[]}
     */
    setCameraTarget(latLng: ILatLng | ILatLng[]): void;
    /**
     * Set zoom level of the camera
     * @param zoomLevel {number} Zoom level
     */
    setCameraZoom(zoomLevel: number): void;
    /**
     * Set the camera view angle
     * @param tiltAngle {number} Tilt angle
     */
    setCameraTilt(tiltAngle: number): void;
    /**
     * Set camera bearing
     * @param bearing {any}
     */
    setCameraBearing(bearing: any): void;
    /**
     * Changes the center of the map by the given distance in pixels
     * @param x {number}
     * @param y {number}
     */
    panBy(x: number, y: number): void;
    /**
     * Get the current visible region (southWest and northEast)
     * @return {VisibleRegion}
     */
    getVisibleRegion(): VisibleRegion;
    /**
     * Get the current device location
     * @return {Promise<MyLocation>}
     */
    getMyLocation(options?: MyLocationOptions): Promise<MyLocation>;
    /**
     * Set false to ignore all clicks on the map
     * @param isClickable {boolean}
     */
    setClickable(isClickable: boolean): void;
    /**
     * Destroy a map completely
     * @return {Promise<any>}
     */
    remove(): Promise<any>;
    /**
     * Remove all overlays, such as marker
     * @return {Promise<any>}
     */
    clear(): Promise<any>;
    /**
     * Convert the unit from LatLng to the pixels from the left/top of the map div
     * @return {Promise<any>}
     */
    fromLatLngToPoint(latLng: ILatLng): Promise<any[]>;
    /**
     * Convert the unit from the pixels from the left/top to the LatLng
     * @return {Promise<LatLng>}
     */
    fromPointToLatLng(point: number[]): Promise<LatLng>;
    /**
     * Set true if you want to show the MyLocation control (blue dot)
     * @param enabled {boolean}
     */
    setMyLocationEnabled(enabled: boolean): void;
    /**
     * Set true if you want to show the MyLocation button
     * @param enabled {boolean}
     */
    setMyLocationButtonEnabled(enabled: boolean): void;
    /**
     * Get the currently focused building
     * @return {Promise<any>}
     */
    getFocusedBuilding(): Promise<any>;
    /**
     * Set true if you want to show the indoor map
     * @param enabled {boolean}
     */
    setIndoorEnabled(enabled: boolean): void;
    /**
     * Set true if you want to show the traffic layer
     * @param enabled {boolean}
     */
    setTrafficEnabled(enabled: boolean): void;
    /**
     * Set true if you want to show the compass button
     * @param enabled {boolean}
     */
    setCompassEnabled(enabled: boolean): void;
    /**
     * Sets the preference for whether all gestures should be enabled or disabled
     * @param enabled {boolean}
     */
    setAllGesturesEnabled(enabled: boolean): void;
    /**
     * Set visibility of the map
     * @param visible {boolean}
     */
    setVisible(visible: boolean): void;
    /**
     * Adjust the map padding (same as CSS padding rule)
     * @param top {number}
     * @param right {number}
     * @param left {number}
     * @param bottom {number}
     */
    setPadding(top: number, right?: number, bottom?: num