/// <reference types="google.maps" />
import { AfterContentInit, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, QueryList, SimpleChanges } from '@angular/core';
import { ExgMapGoogleAPIWrapper, ExgMapFitBoundsService } from '../services';
export declare type ControlPosition = keyof typeof google.maps.ControlPosition;
export declare abstract class ExgMapControlDirective {
    position: ControlPosition | undefined;
    abstract getOptions(): Partial<google.maps.MapOptions>;
}
export declare class ExgMapFullscreenControlDirective extends ExgMapControlDirective {
    getOptions(): Partial<google.maps.MapOptions>;
}
export declare class ExgMapTypeControlDirective extends ExgMapControlDirective {
    mapTypeIds: (keyof typeof google.maps.MapTypeId)[] | undefined;
    style: keyof typeof google.maps.MapTypeControlStyle | undefined;
    getOptions(): Partial<google.maps.MapOptions>;
}
export declare class ExgMapPanControlDirective extends ExgMapControlDirective {
    getOptions(): Partial<google.maps.MapOptions>;
}
export declare class ExgMapRotateControlDirective extends ExgMapControlDirective {
    getOptions(): Partial<google.maps.MapOptions>;
}
export declare class ExgMapScaleControlDirective extends ExgMapControlDirective {
    getOptions(): Partial<google.maps.MapOptions>;
}
export declare class ExgMapStreetViewControlDirective extends ExgMapControlDirective {
    getOptions(): Partial<google.maps.MapOptions>;
}
export declare class ExgMapZoomControlDirective extends ExgMapControlDirective {
    style: any;
    getOptions(): Partial<google.maps.MapOptions>;
}
export declare class ExgMapComponent implements OnChanges, AfterContentInit, OnDestroy {
    private _elem;
    private _mapsWrapper;
    private _platformId;
    protected _fitBoundsService: ExgMapFitBoundsService;
    private _zone;
    /**
     * Map attributes that can change over time
     */
    private static _mapOptionsAttributes;
    /**
     * Longitude for map center
     */
    longitude: number;
    /**
     * Latitude for map center.
     */
    latitude: number;
    /**
     * Zoomlevel for map. Default: 8.
     */
    zoom: number;
    /**
     * Minimum zoom level allowed for map. (optional) default: no limit
     */
    minZoom: number | undefined;
    /**
     * Maximum zoom level allowed for map. (optional) default: no limit
     */
    maxZoom: number | undefined;
    /**
     * The control size for the default map controls. Only governs the controls made by the Maps API itself
     */
    controlSize: number | undefined;
    /**
     * Enables/disables if map is draggable.
     */
    draggable: boolean;
    /**
     * Disable zoom on double click. Default: false (allowed)
     */
    disableDoubleClickZoom: boolean;
    /**
     * Enables/disables all default UI of the Google map. Please note: When the map is created, this
     * value cannot get updated.
     */
    disableDefaultUI: boolean;
    /**
     * If false, disables scrollwheel zooming on the map. The scrollwheel is enabled by default.
     */
    scrollwheel: boolean;
    /**
     * Color used for the background of the Map div. This color will be visible when tiles have not
     * yet loaded as the user pans. This option can only be set when the map is initialized.
     */
    backgroundColor: string | undefined;
    /**
     * The name or url of the cursor to display when mousing over a draggable map. This property uses
     * the css  * cursor attribute to change the icon. As with the css property, you must specify at
     * least one fallback cursor that is not a URL. For example:
     * [draggableCursor]="'url(http://www.example.com/icon.png), auto;'"
     */
    draggableCursor: string | undefined;
    /**
     * The name or url of the cursor to display when the map is being dragged. This property uses the
     * css cursor attribute to change the icon. As with the css property, you must specify at least
     * one fallback cursor that is not a URL. For example:
     * [draggingCursor]="'url(http://www.example.com/icon.png), auto;'"
     */
    draggingCursor: string | undefined;
    /**
     * If false, prevents the map from being controlled by the keyboard. Keyboard shortcuts are
     * enabled by default.
     */
    keyboardShortcuts: boolean;
    /**
     * Styles to apply to each of the default map types. Note that for Satellite/Hybrid and Terrain
     * modes, these styles will only apply to labels and geometry.
     */
    styles: google.maps.MapTypeStyle[];
    /**
     * When true and the latitude and/or longitude values changes, the Google Maps panTo method is
     * used to
     * center the map. See: https://developers.google.com/maps/documentation/javascript/reference#Map
     */
    usePanning: boolean;
    /**
     * Sets the viewport to contain the given bounds.
     * If this option to `true`, the bounds get automatically computed from all elements that use the {@link ExgMapFitBoundsService}
     * directive.
     */
    fitBounds: google.maps.LatLngBoundsLiteral | google.maps.LatLngBounds | boolean;
    /**
     * Padding amount for the bounds.
     */
    fitBoundsPadding: number | google.maps.Padding | undefined;
    /**
     * The map mapTypeId. Defaults to 'roadmap'.
     */
    mapTypeId: keyof typeof google.maps.MapTypeId;
    /**
     * When false, map icons are not clickable. A map icon represents a point of interest,
     * also known as a POI. By default map icons are clickable.
     */
    clickableIcons: boolean;
    /**
     * A map icon represents a point of interest, also known as a POI.
     * When map icons are clickable by default, an info window is displayed.
     * When this property is set to false, the info window will not be shown but the click event
     * will still fire
     */
    showDefaultInfoWindow: boolean;
    /**
     * This setting controls how gestures on the map are handled.
     * Allowed values:
     * - 'cooperative' (Two-finger touch gestures pan and zoom the map. One-finger touch gestures are not handled by the map.)
     * - 'greedy'      (All touch gestures pan or zoom the map.)
     * - 'none'        (The map cannot be panned or zoomed by user gestures.)
     * - 'auto'        [default] (Gesture handling is either cooperative or greedy, depending on whether the page is scrollable or not.
     */
    gestureHandling: string | null | undefined;
    /**
     * Controls the automatic switching behavior for the angle of incidence of
     * the map. The only allowed values are 0 and 45. The value 0 causes the map
     * to always use a 0° overhead view regardless of the zoom level and
     * viewport. The value 45 causes the tilt angle to automatically switch to
     * 45 whenever 45° imagery is available for the current zoom level and
     * viewport, and switch back to 0 whenever 45° imagery is not available
     * (this is the default behavior). 45° imagery is only available for
     * satellite and hybrid map types, within some locations, and at some zoom
     * levels. Note: getTilt returns the current tilt angle, not the value
     * specified by this option. Because getTilt and this option refer to
     * different things, do not bind() the tilt property; doing so may yield
     * unpredictable effects. (Default of ExgMap is 0 (disabled). Enable it with value 45.)
     */
    tilt: number;
    /**
     * Options for restricting the bounds of the map.
     * User cannot pan or zoom away from restricted area.
     */
    restriction: google.maps.MapRestriction | undefined;
    private _observableSubscriptions;
    private _fitBoundsSubscription;
    /**
     * This event emitter gets emitted when the user clicks on the map (but not when they click on a
     * marker or infoWindow).
     */
    mapClick: EventEmitter<google.maps.MapMouseEvent | google.maps.IconMouseEvent>;
    /**
     * This event emitter gets emitted when the user right-clicks on the map (but not when they click
     * on a marker or infoWindow).
     */
    mapRightClick: EventEmitter<google.maps.MapMouseEvent>;
    /**
     * This event emitter gets emitted when the user double-clicks on the map (but not when they click
     * on a marker or infoWindow).
     */
    mapDblClick: EventEmitter<google.maps.MapMouseEvent>;
    /**
     * This event emitter is fired when the map center changes.
     */
    centerChange: EventEmitter<google.maps.LatLngLiteral>;
    /**
     * This event is fired when the viewport bounds have changed.
     */
    boundsChange: EventEmitter<google.maps.LatLngBounds>;
    /**
     * This event is fired when the mapTypeId property changes.
     */
    mapTypeIdChange: EventEmitter<string>;
    /**
     * This event is fired when the map becomes idle after panning or zooming.
     */
    idle: EventEmitter<void>;
    /**
     * This event is fired when the zoom level has changed.
     */
    zoomChange: EventEmitter<number>;
    /**
     * This event is fired when the google map is fully initialized.
     * You get the google.maps.Map instance as a result of this EventEmitter.
     */
    mapReady: EventEmitter<any>;
    /**
     * This event is fired when the visible tiles have finished loading.
     */
    tilesLoaded: EventEmitter<void>;
    mapControls: QueryList<ExgMapControlDirective> | undefined;
    constructor(_elem: ElementRef, _mapsWrapper: ExgMapGoogleAPIWrapper, _platformId: Object, _fitBoundsService: ExgMapFitBoundsService, _zone: NgZone);
    /** @internal */
    ngAfterContentInit(): void;
    private _initMapInstance;
    getAllChildren: (htmlElement: any) => any[];
    /** @internal */
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private _updateMapOptionsChanges;
    /**
     * Triggers a resize event on the google map instance.
     * When recenter is true, the of the google map gets called with the current lat/lng values or fitBounds value to recenter the map.
     * Returns a promise that gets resolved after the event was triggered.
     */
    triggerResize(recenter?: boolean): Promise<void>;
    private _updatePosition;
    private _setCenter;
    private _fitBounds;
    private _subscribeToFitBoundsUpdates;
    protected _updateBounds(bounds: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding): void;
    private _isLatLngBoundsLiteral;
    private _handleMapCenterChange;
    private _handleBoundsChange;
    private _handleMapTypeIdChange;
    private _handleMapZoomChange;
    private _handleIdleEvent;
    private _handleTilesLoadedEvent;
    private _handleMapMouseEvents;
    _handleControlChange(): void;
    _setControls(): void;
}
//# sourceMappingURL=exg-map.component.d.ts.map