/**
 * pacem v0.51.10-faraday (https://js.pacem.it)
 * Copyright 2025 Pacem (https://pacem.it)
 * Licensed under Apache-2.0
 */
declare namespace Pacem.Maps {
    type StructuredAddress = {
        city?: string;
        country?: string;
        countryCode?: string;
        province?: string;
        provinceCode?: string;
        zipCode?: string;
        houseNumber?: string;
        streetName?: string;
        state?: string;
        village?: string;
        type?: string;
    };
    type Address = {
        fullAddress: string;
        position: Position;
        address?: StructuredAddress;
    };
    interface LatLng {
        readonly lat: number;
        readonly lng: number;
    }
    interface Position extends LatLng {
        altitude: number;
    }
    class LatLng {
        static get Empty(): LatLng;
        static isEmpty(l: LatLng): boolean;
        static isLatLng(obj: any): obj is LatLng;
        static translate(start: LatLng, delta: LatLng): LatLng;
        static equals(a: LatLng, b: LatLng): boolean;
    }
    interface LatLngBounds {
        ne: LatLng;
        sw: LatLng;
    }
    class LatLngBounds {
        static get Empty(): LatLngBounds;
        static isEmpty(bnds: LatLngBounds): boolean;
        static isPoint(bnds: LatLngBounds): boolean;
        static isLatLngBounds(obj: any): obj is LatLngBounds;
        static union(bnds: LatLngBounds, p: LatLng): LatLngBounds;
        static union(bnds1: LatLngBounds, bnds2: LatLngBounds): LatLngBounds;
        static equals(a: LatLngBounds, b: LatLngBounds): boolean;
    }
    class MapProjection {
        #private;
        private _pixelSize;
        private _bounds;
        private _normalizedSize;
        constructor(_pixelSize: Size, _bounds: LatLngBounds, _normalizedSize?: number);
        private _latLngToWorldNormalizedPoint;
        private _worldNormalizedPointToLatLng;
        private _latLngToPoint;
        private _pointToLatLng;
        private static _haversine;
        /**
         * Distance in meters between two locations.
         * @param from First location.
         * @param to Second location.
         */
        static distanceBetween(from: LatLng, to: LatLng, r?: number): number;
        static latLngToPoint(latLng: LatLng, bounds: LatLngBounds, size: Size): Point;
        static pointToLatLng(point: Point, size: Size, bounds: LatLngBounds): LatLng;
    }
}
declare namespace Pacem.Components.Maps {
    export enum MapType {
        ROAD = "road",
        SATELLITE = "satellite",
        HYBRID = "hybrid",
        TERRAIN = "terrain",
        HIGH_CONTRAST = "high_contrast"
    }
    export enum MapColorScheme {
        LIGHT = "light",
        DARK = "dark",
        SYSTEM = "system"
    }
    export const MapConsts: {
        DEFAULT_COORDS: {
            lat: number;
            lng: number;
        };
    };
    class LatLng extends Pacem.Maps.LatLng {
    }
    class LatLngBounds extends Pacem.Maps.LatLngBounds {
    }
    type Address = Pacem.Maps.Address;
    /** @deprecated */
    export function isLatLng(obj: any): obj is Pacem.Maps.LatLng;
    /** @deprecated */
    export function isLatLngBounds(obj: any): obj is Pacem.Maps.LatLngBounds;
    export type Icon = {
        url: string;
        anchor: Point;
        size: Size;
        html: string | false;
    };
    export const LatLngConverter: PropertyConverter;
    export const LatLngBoundsConverter: PropertyConverter;
    export class MapUtils {
        static parseCoords(input: string | number[] | LatLng): [number, number];
        static expandBounds(bnds: any[], latLng: LatLng | number[]): void;
        static isContentEmpty(element: HTMLElement): boolean;
    }
    export abstract class MapRelevantElement extends PacemEventTarget {
        get map(): PacemMapElement;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        hide: boolean;
        inactive: boolean;
        viewActivatedCallback(): void;
        disconnectedCallback(): void;
    }
    export interface MapHandle {
        map: any;
        container: HTMLElement;
    }
    export type MapViewOptions = {
        zoom: number;
        center: LatLng;
        type: string | MapType;
        theme?: MapColorScheme;
        tilt: number;
        heading: number;
    };
    export type MapEventArgs = {
        position?: LatLng;
    };
    export class MapEvent extends CustomTypedEvent<MapEventArgs> {
        constructor(type: string, args?: MapEventArgs);
    }
    export interface MapGeocoder {
        reverseGeocode(latLng: LatLng, maxResults?: number): Promise<Address[]>;
        geocode(address: string, maxResults?: number): Promise<Address[]>;
    }
    export class PacemMapGeocodeElement extends PacemEventTarget {
        #private;
        adapter: PacemMapAdapterElement;
        maxResults: number;
        debounce: number;
        results: Address[];
        search: string;
        position: LatLng;
        get fetching(): boolean;
        private _guards;
        propertyChangedCallback(name: string, old: any, val: any, first: any): void;
        private _broadcastFetchingUpdate;
        private _fetch;
        private _debounce;
        reverseGeocode(position?: LatLng, maxResults?: number): void;
        geocode(search?: string, maxResults?: number): void;
        private _successCallback;
        private _errorCallback;
    }
    export abstract class PacemMapAdapterElement extends PacemEventTarget implements MapGeocoder {
        #private;
        abstract geocode(address: string, maxResults?: number): Promise<Address[]>;
        abstract reverseGeocode(latLng: LatLng | [number, number], maxResults?: number): Promise<Address[]>;
        /**
        * Forces the map redraw.
        */
        abstract invalidateSize(map: PacemMapElement): any;
        /**
         * Returns the viewport {@link LatLngBounds}.
         * @param map
         */
        protected abstract getBounds(map: PacemMapElement): LatLngBounds;
        active: boolean;
        protected abstract isActive(): boolean;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        protected abstract buildLayerAdapterFor(map: PacemMapElement): LayerAdapter;
        protected get layerAdapters(): WeakMap<PacemMapElement, LayerAdapter>;
        protected abstract buildOverlayAdapterFor(map: PacemMapElement): OverlayAdapter;
        protected get overlayAdapters(): WeakMap<PacemMapElement, OverlayAdapter>;
        protected get markerAdapters(): WeakMap<PacemMapElement, MarkerAdapter>;
        protected abstract buildMarkerAdapterFor(map: PacemMapElement): MarkerAdapter;
        protected get shapeAdapters(): WeakMap<PacemMapElement, ShapeAdapter>;
        protected abstract buildShapeAdapterFor(map: PacemMapElement): ShapeAdapter;
        protected hasMap(map: PacemMapElement): boolean;
        protected enrolledMaps(): IterableIterator<PacemMapElement>;
        protected tryGetMap(map: PacemMapElement): MapHandle;
        getMap(map: PacemMapElement): any;
        /**
         * Initializes the map and returns its corresponding DOM element.
         * @param map {PacemMapElement} Container for the map
         */
        initialize(map: PacemMapElement): Promise<HTMLElement>;
        protected abstract init(map: PacemMapElement): Promise<MapHandle>;
        /**
         * Disposes the resources attached to the map.
         * @param map {PacemMapElement} The map
         */
        destroy(map: PacemMapElement): void;
        protected abstract dispose(map: PacemMapElement): void;
        /**
         * Removes a map element.
         * @param item {MapRelevantElement} item to be removed
         */
        removeItem(item: MapRelevantElement): void;
        /**
         * Draws a map element.
         * @param item {MapRelevantElement} item to be drawn
         */
        drawItem(item: MapRelevantElement): void;
        /**
         * Shows the infowindow relevant to a map element (if any).
         * @param item {MapRelevantElement} item whose infowindow must be displayed
         */
        popupInfoWindow(item: MapRelevantElement): void;
        /**
         * Hides the infowindow relevant to a map element (if any).
         * @param item {MapRelevantElement} item whose infowindow must be hidden
         */
        popoutInfoWindow(item: MapRelevantElement): void;
        protected abstract setViewNative(ctrl: PacemMapElement, options: Partial<MapViewOptions>): any;
        /**
         * Sets the viewport of the map.
         * @param center {LatLng} position
         * @param zoom {Number} zoom level
         */
        setView(ctrl: PacemMapElement, zoom: number): any;
        setView(ctrl: PacemMapElement, center: LatLng, zoom?: number): any;
        setView(ctrl: PacemMapElement, options: Partial<MapViewOptions>): any;
        protected abstract fitBoundsNative(map: PacemMapElement, bounds: LatLngBounds, padding?: {
            top: number;
            bottom: number;
            left: number;
            right: number;
        }): any;
        /** When implemented in a derived class, sets the viewport of the map so that it can fit all its content. */
        fitBounds(map?: PacemMapElement, onlyIfAutofit?: boolean): void;
        private _fitBounds;
        protected updateMapElement(ctrl: PacemMapElement, center: LatLng, zoom: number): any;
        protected updateMapElement(ctrl: PacemMapElement, options: Partial<MapViewOptions>): any;
        /**
         * When implemented in a derived class, takes a full snapshot of the map.
         * @param map {PacemMapElement} snaphot target
         * @param type Output mime type
         * @param quality Compression quality
         */
        abstract snapshot(map: PacemMapElement, type?: string, quality?: number): PromiseLike<Blob>;
    }
    export abstract class MapItemAdapter<TAdapter extends PacemMapAdapterElement, TMap> {
        private _map;
        private _adapter;
        constructor(_map: PacemMapElement, _adapter?: TAdapter);
        get adapter(): TAdapter;
        get map(): PacemMapElement;
        protected getMap(item: MapRelevantElement): TMap;
    }
    export interface OverlayAdapter {
        readonly map: PacemMapElement;
        readonly adapter: PacemMapAdapterElement;
        removeOverlay(item: PacemMapOverlayElement): void;
        drawOverlay(item: PacemMapOverlayElement): void;
    }
    export abstract class PacemOverlayAdapter<TAdapter extends PacemMapAdapterElement, TMap, TOverlay> extends MapItemAdapter<TAdapter, TMap> implements OverlayAdapter {
        #private;
        constructor(map: PacemMapElement, adapter?: TAdapter);
        protected get layers(): Map<PacemMapOverlayElement, TOverlay>;
        protected abstract deleteOverlay(overlay: TOverlay, map: TMap): void;
        protected abstract buildOverlay(item: PacemMapOverlayElement, map: TMap): TOverlay;
        protected abstract setBounds(item: TOverlay, map: TMap, bounds: LatLngBounds): void;
        protected onOverlayLoad(item: PacemMapOverlayElement, evt?: any): void;
        protected ensureOverlay(item: PacemMapOverlayElement, map: TMap): TOverlay;
        removeOverlay(item: PacemMapOverlayElement): void;
        protected abstract updateOverlay(overlay: TOverlay, map: TMap, item: PacemMapOverlayElement): void;
        drawOverlay(item: PacemMapOverlayElement): void;
    }
    export abstract class PacemMapOverlayElement extends MapRelevantElement {
        bounds: LatLngBounds;
    }
    export class PacemMapOverlayImageElement extends PacemMapOverlayElement {
        src: string;
    }
    export interface LayerAdapter {
        readonly map: PacemMapElement;
        readonly adapter: PacemMapAdapterElement;
        removeLayer(item: PacemMapLayerElement): void;
        drawLayer(item: PacemMapLayerElement): void;
    }
    export abstract class PacemLayerAdapter<TAdapter extends PacemMapAdapterElement, TMap, TLayer> extends MapItemAdapter<TAdapter, TMap> implements LayerAdapter {
        #private;
        constructor(map: PacemMapElement, adapter?: TAdapter);
        protected get layers(): Map<PacemMapLayerElement, TLayer>;
        protected onTileLoad(item: PacemMapLayerElement, evt?: any): void;
        protected abstract addLoadEventListener(layer: TLayer, map: TMap, callback: (e: any) => void): void;
        protected abstract removeLoadEventListener(layer: TLayer, map: TMap, callback: (e: any) => void): void;
        protected abstract deleteLayer(layer: TLayer, map: TMap): void;
        protected abstract buildLayer(item: PacemMapLayerElement, map: TMap): TLayer;
        protected ensureLayer(item: PacemMapLayerElement, map: TMap): TLayer;
        removeLayer(item: PacemMapLayerElement): void;
        drawLayer(item: PacemMapLayerElement): void;
    }
    export class PacemMapLayerElement extends MapRelevantElement {
        url: string;
        /** Gets or sets the names of the layers to include (mandatory for WMS layers). */
        include: string[];
        mode: 'wms' | 'tms' | string;
        minZoom: number;
        maxZoom: number;
    }
    /** Contract to handle markers
     * relevant to a specific @see PacemMapElement.*/
    export interface MarkerAdapter {
        readonly map: PacemMapElement;
        readonly adapter: PacemMapAdapterElement;
        removeMarker(item: PacemMapMarkerElement): void;
        drawMarker(item: PacemMapMarkerElement): void;
        openInfoWindow(item: PacemMapMarkerElement, evt?: google.maps.MapMouseEvent): any;
        closeInfoWindow(item: PacemMapMarkerElement, evt?: google.maps.MapMouseEvent): any;
        getBounds(filter?: (m: PacemMapMarkerElement) => boolean): LatLngBounds;
    }
    export abstract class PacemMarkerAdapter<TAdapter extends PacemMapAdapterElement, TMap, TMarker, TInfoWindow> extends MapItemAdapter<TAdapter, TMap> implements MarkerAdapter {
        #private;
        constructor(map: PacemMapElement, adapter?: TAdapter);
        protected get mapAutomaticallyScrollsOnDrag(): boolean;
        getBounds(filter?: (p: PacemMapMarkerElement) => boolean): LatLngBounds;
        protected get markers(): Map<PacemMapMarkerElement, TMarker>;
        protected get infoWindows(): Map<PacemMapMarkerElement, TInfoWindow>;
        protected abstract getMarkerPosition(marker: TMarker): LatLng;
        protected onDragEnd(item: PacemMapMarkerElement, evt?: any): void;
        protected onClick(item: PacemMapMarkerElement, evt?: any): void;
        protected onInfoOpen(item: PacemMapMarkerElement): void;
        protected onInfoClose(item: PacemMapMarkerElement): void;
        protected abstract buildMarker(item: PacemMapMarkerElement, map: TMap): TMarker;
        protected abstract addClickEventListener(marker: TMarker, map: TMap, callback: (e: any) => void): any;
        protected abstract addDragEventListener(marker: TMarker, map: TMap, callback: (e: any) => void): any;
        protected abstract addDragEndEventListener(marker: TMarker, map: TMap, callback: (e: any) => void): any;
        protected ensureMarker(item: PacemMapMarkerElement, map: TMap): TMarker;
        protected abstract setPosition(marker: TMarker, position: LatLng): void;
        protected abstract setIcon(marker: TMarker, icon: string | Icon): void;
        protected abstract setLabel(marker: TMarker, label: string): void;
        protected abstract setDraggable(marker: TMarker, draggable: boolean): void;
        protected abstract deleteMarker(marker: TMarker, map: TMap): void;
        protected abstract deleteInfoWindow(info: TInfoWindow, map: TMap): void;
        removeMarker(item: PacemMapMarkerElement): void;
        drawMarker(item: PacemMapMarkerElement): void;
        abstract closeInfo(info: TInfoWindow): void;
        abstract openInfo(info: TInfoWindow, content: string, map: TMap, marker: TMarker): void;
        closeInfoWindow(item: PacemMapMarkerElement, evt?: any): void;
        protected abstract buildInfoWindow(item: PacemMapMarkerElement): TInfoWindow;
        protected abstract addCloseClickEventListener(info: TInfoWindow, map: TMap, callback: (e: any) => void): any;
        protected ensureInfoWindow(item: PacemMapMarkerElement, map: TMap): TInfoWindow;
        protected abstract setContent(info: TInfoWindow, content: string): void;
        openInfoWindow(item: PacemMapMarkerElement, evt?: google.maps.MapMouseEvent): void;
    }
    export class PacemMapMarkerElement extends MapRelevantElement {
        position: LatLng;
        icon: Icon | string;
        caption: string;
        draggable: boolean;
        onDragEnd(position: LatLng): void;
        onClick(position: LatLng): void;
        onInfoOpen(): void;
        onInfoClose(): void;
    }
    export interface ShapeAdapter {
        readonly map: PacemMapElement;
        readonly adapter: PacemMapAdapterElement;
        removeShape(item: PacemMapShapeElement): void;
        drawShape(item: PacemMapShapeElement): void;
        getBounds(filter?: (m: PacemMapShapeElement) => boolean): LatLngBounds;
    }
    export abstract class PacemShapeAdapter<TAdapter extends PacemMapAdapterElement, TMap, TShape> extends MapItemAdapter<TAdapter, TMap> implements ShapeAdapter {
        #private;
        constructor(map: PacemMapElement, adapter?: TAdapter);
        protected get shapes(): Map<PacemMapShapeElement, TShape>;
        protected abstract deleteShape(shape: TShape, map: TMap): void;
        protected abstract getShapeBounds(shape: TShape): LatLngBounds;
        getBounds(filter?: (p: PacemMapShapeElement) => boolean): LatLngBounds;
        removeShape(item: PacemMapShapeElement): void;
        protected abstract getShapePosition(obj: TShape | any): LatLng;
        private _dispatchEvent;
        protected onDragStart(item: PacemMapShapeElement, evt?: any): void;
        protected onDragEnd(item: PacemMapShapeElement, evt?: any): void;
        private _translateShape;
        protected onDrag(item: PacemMapShapeElement, evt?: any): void;
        protected onClick(item: PacemMapShapeElement, evt?: any): void;
        protected abstract buildShape(item: PacemMapShapeElement, map: TMap): TShape;
        protected abstract addClickEventListener(shape: TShape, callback: (e: any) => void): any;
        protected abstract addDragEventListener(shape: TShape, callback: (e: any) => void): any;
        protected abstract addDragEndEventListener(shape: TShape, callback: (e: any) => void): any;
        protected abstract addDragStartEventListener(shape: TShape, callback: (e: any) => void): any;
        protected ensureShape(item: PacemMapShapeElement, map: TMap): TShape;
        protected abstract setShape(shape: TShape, item: PacemMapShapeElement): void;
        protected abstract setEditable(shape: TShape, editable: boolean): void;
        protected abstract setDraggable(shape: TShape, draggable: boolean): void;
        drawShape(item: PacemMapShapeElement): void;
    }
    export type ShapeStroke = {
        color: string;
        alpha: number;
        thickness: number;
    };
    export type ShapeFill = {
        color: string;
        alpha: number;
    };
    export class PacemMapShapeElement extends MapRelevantElement {
        draggable: boolean;
        editable: boolean;
        stroke: ShapeStroke;
        fill: ShapeFill;
    }
    export class PacemMapPolylineElement extends PacemMapShapeElement {
        vertices: LatLng[];
    }
    export class PacemMapPolygonElement extends PacemMapShapeElement {
        vertices: LatLng[];
    }
    export class PacemMapCircleElement extends PacemMapShapeElement {
        center: LatLng;
        radius: number;
    }
    export class PacemMapElement extends PacemEventTarget {
        #private;
        zoom: number;
        center: LatLng;
        updateBounds(bounds: LatLngBounds): void;
        get bounds(): LatLngBounds;
        type: "roadmap" | "satellite" | "hybrid" | "terrain" | string | MapType;
        theme: MapColorScheme;
        scale: boolean;
        mousewheel: boolean;
        /**
        * zoom control position
        */
        zoomControl: "topleft" | "topright" | "bottomleft" | "bottomright";
        draggable: boolean;
        doubleClickZoom: boolean;
        keyboardShortcuts: boolean;
        /** Gets or sets whether to autofit the bounds whenever the map gets refreshed. */
        autofit: boolean;
        paddingTop: number;
        paddingLeft: number;
        paddingRight: number;
        paddingBottom: number;
        adapter: PacemMapAdapterElement;
        target: HTMLElement;
        tilt: number;
        heading: number;
        get container(): HTMLElement;
        register(item: MapRelevantElement): void;
        unregister(item: MapRelevantElement): void;
        private _draw;
        private _erase;
        private _drawHandler;
        private _listenToActiveAdapter;
        private _switchAdapter;
        viewActivatedCallback(): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _initialized;
        private _container;
        private _resizer;
        private _afterInit;
        private _dismissContainer;
        private _dismissResizer;
        private _setupContainer;
        private _setupResizer;
        private _detach;
        disconnectedCallback(): void;
        private _resizeHandler;
        onResize(e?: Event): void;
    }
    export {};
}
declare namespace Pacem.Components.Maps {
    type AzureMapsAddress = {
        country: string;
        countryCode: string;
        countryCodeISO3: string;
        /** e.g. Italian province. */
        countrySecondarySubdivision: string;
        /** e.g. Italian region. */
        countrySubdivision: string;
        /** Full address in one piece of string. */
        freeformAddress: string;
        /** Village (backup). */
        localName: string;
        /** City. */
        municipality: string;
        postalCode: string;
        streetName: string;
        street: string;
        streetNumber: string;
        buildingNumber: string;
        /** Village.*/
        municipalitySubdivision?: string;
    };
    /** Reverse geocoding API response */
    type AzureMapsReverseResponse = {
        addresses: {
            address: AzureMapsAddress;
            position: string;
        }[];
        summary: {
            numResults: number;
            queryTime: number;
        };
    };
    /** Geocoding API response */
    type AzureMapsResponse = {
        results: {
            address: AzureMapsAddress;
            position: {
                lat: number;
                lon: number;
            };
        }[];
        summary: {
            numResults: number;
            queryTime: number;
        };
    };
    class PacemAzureMapAdapterElement extends PacemMapAdapterElement {
        #private;
        geocode(address: string, maxResults?: number): Promise<Pacem.Maps.Address[]>;
        reverseGeocode(latLng: Pacem.Maps.LatLng | [number, number], maxResults?: number): Promise<Pacem.Maps.Address[]>;
        protected getBounds(ctrl: PacemMapElement): Pacem.Maps.LatLngBounds;
        protected isActive(): boolean;
        protected buildOverlayAdapterFor(map: PacemMapElement): OverlayAdapter;
        protected buildMarkerAdapterFor(map: PacemMapElement): MarkerAdapter;
        protected buildShapeAdapterFor(map: PacemMapElement): ShapeAdapter;
        protected buildLayerAdapterFor(map: PacemMapElement): LayerAdapter;
        protected setViewNative(ctrl: PacemMapElement, options: Partial<MapViewOptions>): void;
        snapshot(ctrl: PacemMapElement, type?: string, quality?: number): Promise<Blob>;
        subscriptionKey: string;
        language: string;
        protected dispose(ctrl: PacemMapElement): void;
        protected init(container: PacemMapElement): Promise<MapHandle>;
        invalidateSize(ctrl: PacemMapElement): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        private _spinMapUpdateHandler;
        private _updateMap;
        private static _getBounds;
        protected fitBoundsNative(ctrl: PacemMapElement, bnds: Pacem.Maps.LatLngBounds, padding?: {
            top: number;
            bottom: number;
            left: number;
            right: number;
        }): void;
    }
}
declare namespace Pacem.Components.Maps {
    type LatLng = Pacem.Maps.Position & {
        timestamp: Date | string | number;
        heading?: number;
        speed?: number;
    };
    export class PacemMapGeolocateElement extends PacemEventTarget {
        #private;
        private _checkPermission;
        position: LatLng;
        permission: PermissionState;
        maximumAge: number;
        timeout: number;
        get fetching(): boolean;
        private _setFetching;
        fetch(): void;
        viewActivatedCallback(): void;
        private _successCallback;
        private _errToString;
        private _errorCallback;
    }
    export {};
}
declare namespace Pacem.Components.Maps {
    class LatLng extends Pacem.Maps.LatLng {
    }
    class LatLngBounds extends Pacem.Maps.LatLngBounds {
    }
    type Address = Pacem.Maps.Address;
    export class PacemGoogleMapAdapterElement extends PacemMapAdapterElement {
        #private;
        geocode(address: string, maxResults?: number): Promise<Address[]>;
        reverseGeocode(latLng: LatLng | [number, number], maxResults?: number): Promise<Address[]>;
        protected getBounds(map: PacemMapElement): LatLngBounds;
        protected isActive(): boolean;
        protected buildMarkerAdapterFor(map: PacemMapElement): MarkerAdapter;
        protected buildOverlayAdapterFor(map: PacemMapElement): OverlayAdapter;
        protected buildShapeAdapterFor(map: PacemMapElement): ShapeAdapter;
        protected buildLayerAdapterFor(map: PacemMapElement): LayerAdapter;
        getMaxAvailableZoom(latLng: LatLng): Promise<number>;
        apiKey: string;
        version: string;
        language: string;
        region: string;
        defaultOptions: Partial<google.maps.MapOptions>;
        libraries: string[];
        snapshot(ctrl: PacemMapElement, type?: string, quality?: number): Promise<Blob>;
        protected setViewNative(ctrl: PacemMapElement, options: Partial<MapViewOptions>): void;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        protected dispose(map: PacemMapElement): void;
        private _updateMapOptions;
        private _buildMapOptions;
        private _bootstrapDebounced;
        private _bootstrap;
        protected init(container: PacemMapElement): Promise<MapHandle>;
        invalidateSize(ctrl: PacemMapElement): void;
        private _spinMapUpdateHandler;
        protected fitBoundsNative(ctrl: PacemMapElement, bounds: LatLngBounds, padding?: google.maps.Padding): void;
        private _getPadding;
        /**
         @deprecated
         */
        private _padBounds;
        private _redrawMap;
    }
    export {};
}
declare namespace Pacem.Components.Maps {
    type LatLng = Pacem.Maps.LatLng;
    type LatLngBounds = Pacem.Maps.LatLngBounds;
    type Address = Pacem.Maps.Address;
    export const LayerLoadEventName = "layerload";
    export class PacemLeafletMapAdapterElement extends PacemMapAdapterElement {
        #private;
        protected buildOverlayAdapterFor(map: PacemMapElement): OverlayAdapter;
        geocode(address: string, maxResults?: number): Promise<Address[]>;
        reverseGeocode(latLng: LatLng | [number, number], _?: number): Promise<Address[]>;
        protected getBounds(ctrl: PacemMapElement): LatLngBounds;
        protected isActive(): boolean;
        protected setViewNative(ctrl: PacemMapElement, options: Partial<MapViewOptions>): void;
        protected buildMarkerAdapterFor(map: PacemMapElement): MarkerAdapter;
        protected buildShapeAdapterFor(map: PacemMapElement): ShapeAdapter;
        protected buildLayerAdapterFor(map: PacemMapElement): LayerAdapter;
        snapshot(map: PacemMapElement, type?: string, quality?: number): Promise<Blob>;
        tiles: string;
        attribution: string;
        propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
        protected dispose(ctrl: PacemMapElement): void;
        protected init(container: PacemMapElement): Promise<MapHandle>;
        private _tileLayerLoadHandler;
        dispatchLayerLoadEvent(layer: any): void;
        invalidateSize(ctrl: PacemMapElement): void;
        private _mapUpdateHandler;
        private _idleFiller;
        protected fitBoundsNative(ctrl: PacemMapElement, bounds: LatLngBounds, padding?: {
            top: number;
            left: number;
            right: number;
            bottom: number;
        }): void;
        private _redrawMap;
    }
    export {};
}
