import * as _angular_core from '@angular/core';
import { OnDestroy, InjectionToken, EventEmitter } from '@angular/core';
import { NXComponent } from '@acorex/cdk/common';
import * as i1 from '@angular/common';
import * as leaflet from 'leaflet';

interface AXMapLatLng {
    latitude: number;
    longitude: number;
}
/**
 * Represents a marker on the map with position and optional display properties.
 *
 * @example
 * ```typescript
 * const marker: AXMapMarker = {
 *   latitude: 51.505,
 *   longitude: -0.09,
 *   title: "London",
 *   popup: "Capital of UK",
 *   popupOpen: false,
 *   popupCloseButton: true,
 *   iconKey: "map-marker" // Icon key to be resolved by icon resolver service
 *   // OR
 *   icon: "<svg>...</svg>" // Direct SVG content or image URL
 * };
 * ```
 */
interface AXMapMarker extends AXMapLatLng {
    title?: string;
    iconKey?: string;
    popup?: string;
    popupOpen?: boolean;
    popupCloseButton?: boolean;
    /**
     * If true, the marker cannot be deleted or moved/edited via draw interactions
     */
    isLocked?: boolean;
    /**
     * Optional unique identifier for id-based operations
     */
    id?: string | number;
}
/**
 * Represents a Point of Interest marker on the map with the same properties as AXMapMarker.
 */
interface AXPoiMarker extends AXMapLatLng {
    title?: string;
    iconKey?: string;
    popup?: string;
    popupOpen?: boolean;
    popupCloseButton?: boolean;
    minZoom?: number;
}
interface AXMapLocation extends AXMapMarker {
    precision?: number;
}
interface AXMapPolygon {
    points: AXMapLatLng[];
    title?: string;
    color?: string;
}
interface AXMapData {
    markers: AXMapMarker[];
    polygons: AXMapPolygon[];
    pois: AXPoiMarker[];
}
type AXMapControlPlace = 'topleft' | 'topright' | 'bottomleft' | 'bottomright';

/**
 * @description
 * The `AXMapComponent` provides an interactive map powered by Leaflet. It supports markers, location tracking,
 * and configurable zoom, latitude, longitude, and marker behavior. The component allows easy integration and
 * manipulation of map features.
 *
 * @example
 * <ax-map [latitude]="51.505" [longitude]="-0.09" [zoomLevel]="13" [hasMarker]="true"></ax-map>
 */
declare class AXMapComponent extends NXComponent implements OnDestroy {
    #private;
    /**
     * @description
     * Zoom level of the map.
     */
    zoomLevel: _angular_core.ModelSignal<number>;
    /**
     * @description
     * Latitude of the map center.
     */
    latitude: _angular_core.ModelSignal<number>;
    /**
     * @description
     * Longitude of the map center.
     */
    longitude: _angular_core.ModelSignal<number>;
    /**
     * @description
     * Maximum number of markers allowed on the map.
     * @default 0
     */
    maxMarker: _angular_core.InputSignal<number>;
    /**
     * @description
     * Maximum number of polygons allowed on the map.
     * @default 0
     */
    maxPolygon: _angular_core.InputSignal<number>;
    /**
     * @description
     * Whether the map should have a marker control.
     * @default false
     */
    hasDraw: _angular_core.InputSignal<boolean>;
    /**
     * @description
     * Whether the map should have a location control.
     * @default false
     */
    hasLocator: _angular_core.InputSignal<boolean>;
    /**
     * @description
     * Whether map should contain all draw items.
     * @default false
     */
    fitToDraw: _angular_core.InputSignal<boolean>;
    /**
     * @description
     * Whether map draw has to limit in area.
     * @default undefined
     */
    limitDraw: _angular_core.InputSignal<AXMapPolygon[]>;
    /**
     * @description
     * Whether to include POIs when fitting the map to draw items.
     * @default false
     */
    addPoiToFitDraw: _angular_core.InputSignal<boolean>;
    /**
     * @description
     * If true, user can add a marker by clicking/tapping on the map.
     * @default false
     */
    addMarkerOnTap: _angular_core.InputSignal<boolean>;
    /**
     * @description
     * Position of the marker control on the map.
     * @default 'topleft'
     */
    markerPlace: _angular_core.InputSignal<AXMapControlPlace>;
    /**
     * @description
     * Position of the locate control on the map.
     * @default 'bottomright'
     */
    locatePlace: _angular_core.InputSignal<AXMapControlPlace>;
    /**
     * @description
     * Minimum zoom level at which POI markers become visible.
     * @default 10
     */
    poiMinZoom: _angular_core.InputSignal<number>;
    /**
     * @description
     * Array or single marker location(s) to be placed on the map.
     * @default undefined
     */
    markers: _angular_core.InputSignal<AXMapMarker | AXMapMarker[]>;
    /**
     * @description
     * Array or single polygon location(s) to be placed on the map.
     * @default undefined
     */
    polygons: _angular_core.InputSignal<AXMapPolygon | AXMapPolygon[]>;
    /**
     * @description
     * Array or single POI marker(s) to be placed on the map.
     * @default undefined
     */
    pois: _angular_core.InputSignal<AXPoiMarker | AXPoiMarker[]>;
    /**
     * @description
     * Event triggered when a new marker is added to the map.
     */
    onMarkerAdded: _angular_core.OutputEmitterRef<AXMapMarker>;
    /**
     * @description
     * Event triggered when a marker is clicked on the map.
     */
    onMarkerClick: _angular_core.OutputEmitterRef<AXMapMarker>;
    /**
     * @description
     * Event triggered when marker positions are changed on the map.
     */
    onMarkerChanged: _angular_core.OutputEmitterRef<AXMapMarker[]>;
    /**
     * @description
     * Event triggered when a new polygon is added to the map.
     */
    onPolygonAdded: _angular_core.OutputEmitterRef<AXMapPolygon>;
    /**
     * @description
     * Event triggered when a polygon is clicked on the map.
     */
    onPolygonClick: _angular_core.OutputEmitterRef<AXMapPolygon>;
    /**
     * @description
     * Event triggered when polygon positions are changed on the map.
     */
    onPolygonChanged: _angular_core.OutputEmitterRef<AXMapPolygon[]>;
    /**
     * @description
     * Event triggered when a location is found via the location control.
     */
    onLocationFound: _angular_core.OutputEmitterRef<AXMapMarker>;
    /**
     * @description
     * Event triggered when POI positions are changed on the map.
     */
    onPoiChanged: _angular_core.OutputEmitterRef<AXPoiMarker[]>;
    /**
     * @description
     * Event triggered when a new POI is added to the map.
     */
    onPoiAdded: _angular_core.OutputEmitterRef<AXPoiMarker>;
    /**
     * @description
     * Event triggered map is loaded.
     */
    onMapReady: _angular_core.OutputEmitterRef<void>;
    /**
     * @description
     * Event triggered when map loading/initialization fails.
     */
    onLoadError: _angular_core.OutputEmitterRef<Error>;
    private mapContainer;
    private leafletService;
    private rendered;
    private onLatitudeChangedSubscription?;
    private onLongitudeChangedSubscription?;
    private onZoomChangedSubscription?;
    private onLocationFoundSubscription?;
    private onMarkerChangedSubscription?;
    private onMarkerAddedSubscription?;
    private onMarkerClickSubscription?;
    private onPolygonChangedSubscription?;
    private onPolygonAddedSubscription?;
    private onPolygonClickSubscription?;
    private onPoiChangedSubscription?;
    private onPoiAddedSubscription?;
    /**
     * @description
     * Adds a marker to the specified location on the map.
     * @param location - The location where the marker should be placed.
     * @param emitEvents - Whether to emit events for the marker.
     */
    addMarker(location: AXMapMarker | AXMapMarker[], emitEvents?: boolean): Promise<void>;
    /**
     * @description
     * Removes markers by id or location; if not provided removes all markers
     */
    removeMarker(location?: AXMapMarker | AXMapMarker[]): void;
    /**
     * @description
     * Adds a polygon to the specified location on the map.
     * @param location - The location where the polygon should be placed.
     * @param emitEvents - Whether to emit events for the polygon.
     */
    addPolygon(location: AXMapPolygon | AXMapPolygon[], emitEvents?: boolean): void;
    /**
     * @description
     * Removes polygons by id or geometry; if not provided removes all polygons
     */
    removePolygon(location?: AXMapPolygon | AXMapPolygon[]): void;
    /**
     * @description
     * Retrieves all markers currently placed on the map.
     * @returns An array of `AXMapMarker` representing all markers.
     */
    getMarkers(): AXMapMarker[];
    /**
     * @description
     * Retrieves all polygons currently placed on the map.
     * @returns An array of `AXMapPolygon` representing all polygons.
     */
    getPolygons(): AXMapPolygon[];
    /**
     * @description
     * Retrieves all POI markers currently placed on the map.
     * @returns An array of `AXPoiMarker` representing all POI markers.
     */
    getPois(): AXPoiMarker[];
    /**
     * @description
     * Clear all markers and polygons
     */
    clearDrawItems(): void;
    /**
     * @description
     * Get all markers and polygons
     */
    getDrawItem(): AXMapData;
    /**
     * @description
     * set markers and polygons
     */
    setDrawItem(data: AXMapData): Promise<void>;
    /**
     * Adjusts the map view to fit all markers and polygons currently on the map.
     */
    fitBoundsToDrawItems(): void;
    /**
     * @description
     * Sets the boundary limit for drawing
     * @param data - The polygon data defining the boundary
     */
    setLimitDraw(data: AXMapPolygon[]): void;
    /**
     * @description
     * Removes the boundary limit for drawing
     */
    removeLimitDraw(): void;
    /**
     * @description
     * Flies the map to a specific location with optional zoom, marker placement, and animation duration.
     *
     * @param location - The target location to fly to.
     * @param zoom - Optional zoom level for the map.
     * @param setMarker - Whether to set a marker at the destination.
     * @param duration - Optional duration for the fly animation.
     */
    flyTo(location: AXMapMarker, zoom?: number, setMarker?: boolean, duration?: number): void;
    /**
     * Setup map event listeners
     */
    private setupMapEvents;
    /**
     * Setup map movement event subscriptions
     */
    private setupMapMovementEvents;
    /**
     * Setup draw event subscriptions
     */
    private setupDrawEventSubscriptions;
    /**
     * Setup marker event subscriptions
     */
    private setupMarkerEventSubscriptions;
    /**
     * Setup polygon event subscriptions
     */
    private setupPolygonEventSubscriptions;
    /**
     * Setup POI event subscriptions
     */
    private setupPoiEventSubscriptions;
    /**
     * Unsubscribe from draw events
     */
    private unsubscribeFromDrawEvents;
    /**
     * Unsubscribe from marker events
     */
    private unsubscribeMarkerEvents;
    /**
     * Unsubscribe from polygon events
     */
    private unsubscribePolygonEvents;
    /**
     * Unsubscribe from POI events
     */
    private unsubscribePoiEvents;
    /**
     * @description
     * Update popup for a specific marker
     * @param marker - The marker to update
     * @param popup - The new popup text
     * @param open - Whether the popup should be opened after update
     * @param closeButton - Whether the popup should have a close button
     * @returns True if the update was successful, false otherwise
     */
    updateMarkerPopup(marker: AXMapMarker, popup: string, open?: boolean, closeButton?: boolean): boolean;
    /**
     * @description
     * Update popup for multiple markers
     * @param updates - Array of marker popup updates
     * @returns Number of markers successfully updated
     */
    updateMarkersPopups(updates: {
        marker: AXMapMarker;
        popup: string;
        open?: boolean;
        closeButton?: boolean;
    }[]): number;
    /**
     * @description
     * Refreshes POIs from providers, clearing existing POIs first
     */
    refreshPois(): Promise<void>;
    /**
     * Cleanup function that destroys the map and unsubscribes from all subscriptions.
     */
    ngOnDestroy(): void;
    /**
     * Unsubscribe from all event subscriptions
     */
    private unsubscribeFromAllEvents;
    /**
     * Unsubscribe from map-level events
     */
    private unsubscribeFromMapEvents;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMapComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMapComponent, "ax-map", never, { "zoomLevel": { "alias": "zoomLevel"; "required": false; "isSignal": true; }; "latitude": { "alias": "latitude"; "required": false; "isSignal": true; }; "longitude": { "alias": "longitude"; "required": false; "isSignal": true; }; "maxMarker": { "alias": "maxMarker"; "required": false; "isSignal": true; }; "maxPolygon": { "alias": "maxPolygon"; "required": false; "isSignal": true; }; "hasDraw": { "alias": "hasDraw"; "required": false; "isSignal": true; }; "hasLocator": { "alias": "hasLocator"; "required": false; "isSignal": true; }; "fitToDraw": { "alias": "fitToDraw"; "required": false; "isSignal": true; }; "limitDraw": { "alias": "limitDraw"; "required": false; "isSignal": true; }; "addPoiToFitDraw": { "alias": "addPoiToFitDraw"; "required": false; "isSignal": true; }; "addMarkerOnTap": { "alias": "addMarkerOnTap"; "required": false; "isSignal": true; }; "markerPlace": { "alias": "markerPlace"; "required": false; "isSignal": true; }; "locatePlace": { "alias": "locatePlace"; "required": false; "isSignal": true; }; "poiMinZoom": { "alias": "poiMinZoom"; "required": false; "isSignal": true; }; "markers": { "alias": "markers"; "required": false; "isSignal": true; }; "polygons": { "alias": "polygons"; "required": false; "isSignal": true; }; "pois": { "alias": "pois"; "required": false; "isSignal": true; }; }, { "zoomLevel": "zoomLevelChange"; "latitude": "latitudeChange"; "longitude": "longitudeChange"; "onMarkerAdded": "onMarkerAdded"; "onMarkerClick": "onMarkerClick"; "onMarkerChanged": "onMarkerChanged"; "onPolygonAdded": "onPolygonAdded"; "onPolygonClick": "onPolygonClick"; "onPolygonChanged": "onPolygonChanged"; "onLocationFound": "onLocationFound"; "onPoiChanged": "onPoiChanged"; "onPoiAdded": "onPoiAdded"; "onMapReady": "onMapReady"; "onLoadError": "onLoadError"; }, never, never, true, never>;
}

interface AXMapConfig {
    layers: string;
    layers2x: string;
    markerIcon: string;
    markerIcon2x: string;
    markerShadow: string;
}
declare const AX_MAP_CONFIG: InjectionToken<AXMapConfig>;
declare const baseUrl = "/assets/images/leaflet/";
declare const AXMapDefaultConfig: AXMapConfig;
type PartialMapConfig = Partial<AXMapConfig>;
declare function mapConfig(config?: PartialMapConfig): AXMapConfig;

declare class AXMapModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMapModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMapModule, never, [typeof i1.CommonModule, typeof AXMapComponent], [typeof AXMapComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMapModule>;
}

/**
 * Service for managing Leaflet maps and related functionalities.
 */
declare class AXLeafletService {
    private mapConfig;
    private iconResolver;
    private poiProviderService;
    private defaultIcon;
    private position;
    private maxMarkers;
    private maxPolygons;
    private polygonColor;
    private poiMinZoom;
    private poiMarkers;
    protected L: typeof leaflet;
    private map?;
    private drawControl?;
    private locateControl?;
    private drawnItems;
    private poiLayer?;
    private boundary;
    private boundaryLayer;
    private _addMarkerOnTapEnabled;
    private _isCurrentlyDrawing;
    private _hasDrawControl;
    /**
     * Emits when the zoom level of the map changes.
     */
    onZoomChanged: EventEmitter<number>;
    /**
     * Emits when the longitude of the map center changes.
     */
    onLongitudeChanged: EventEmitter<number>;
    /**
     * Emits when the latitude of the map center changes.
     */
    onLatitudeChanged: EventEmitter<number>;
    /**
     * Emits when marker data changes.
     */
    onMarkerChanged: EventEmitter<AXMapMarker[]>;
    /**
     * Emits when a poi is added.
     */
    onPoiAdded: EventEmitter<AXPoiMarker>;
    /**
     * Emits when a poi is changed.
     */
    onPoiChanged: EventEmitter<AXPoiMarker[]>;
    /**
     * Emits when a marker is added.
     */
    onMarkerAdded: EventEmitter<AXMapMarker>;
    /**
     * Emits when a marker is clicked.
     */
    onMarkerClick: EventEmitter<AXMapMarker>;
    /**
     * Emits when the user's location is found.
     */
    onLocationFound: EventEmitter<AXMapLocation>;
    /**
     * Emits when polygon data changes.
     */
    onPolygonChanged: EventEmitter<AXMapPolygon[]>;
    /**
     * Emits when an error occurs during map load/initialization
     */
    onLoadError: EventEmitter<Error>;
    /**
     * Emits when a polygon is added.
     */
    onPolygonAdded: EventEmitter<AXMapPolygon>;
    /**
     * Emits when a polygon is clicked.
     */
    onPolygonClick: EventEmitter<AXMapPolygon>;
    /**
     * Loads the Leaflet library and its plugins.
     */
    loadLeaflet(): Promise<void>;
    /**
     * Initializes the Leaflet map.
     * @param mapElement The HTML element to render the map in.
     * @param location The initial map center.
     * @param zoom The initial zoom level. Defaults to 13.
     */
    initMap(mapElement: HTMLElement, location: AXMapLatLng, zoom?: number): Promise<void>;
    private handleZoomChange;
    private handleCenterChange;
    /**
     * Creates a custom icon from SVG string or URL using the icon resolver if possible
     * @param iconSrc Path to the icon, SVG string, or icon key
     * @returns Leaflet icon
     */
    setCustomIcon(iconSrc: string): Promise<any>;
    /**
     * Creates a Leaflet icon from SVG or URL
     * @param iconSrc The icon source (SVG string or URL)
     * @returns Leaflet icon
     */
    private createLeafletIcon;
    /**
     * Gets the Leaflet map instance.
     * @returns The Leaflet map instance, or undefined if not initialized.
     */
    getMap(): L.Map | undefined;
    /**
     * Gets the Leaflet package.
     * @returns The Leaflet package.
     */
    getLeafletPackage(): typeof leaflet;
    /**
     * Sets the zoom level of the map.
     * @param zoom The desired zoom level.
     */
    setZoomLevel(zoom: number): void;
    /**
     * Sets the center of the map.
     * @param location The new center location.
     */
    setCenter(location: AXMapLatLng): void;
    /**
     * Flies to a specific location on the map.
     * @param location The target location.
     * @param zoom The target zoom level (optional).
     * @param setMarker Whether to add a marker at the destination after flying.
     * @param duration The duration of the fly animation in seconds.
     */
    flyTo(location: AXMapLatLng, zoom?: number, setMarker?: boolean, duration?: number): void;
    /**
     * Gets all markers currently on the map.
     * @returns An array of AXMapMarker objects.
     */
    getMarkers(): AXMapMarker[];
    /**
     * Gets all polygons currently on the map.
     * @returns An array of AXMapPolygon objects.
     */
    getPolygons(): AXMapPolygon[];
    /**
     * Gets POI markers from the POI layer.
     * @returns Array of POI markers.
     */
    getPois(): AXPoiMarker[];
    /**
     * Adds a draw control to the map for creating markers and polygons.
     * @param position The position of the control on the map. Defaults to 'topleft'.
     * @param maxMarkers The maximum number of markers allowed. Defaults to 1.
     * @param maxPolygons The maximum number of polygons allowed. Defaults to 1.
     * @param PolygonColor The default color for polygons.
     */
    addDrawControl(position?: AXMapControlPlace, maxMarkers?: number, maxPolygons?: number, PolygonColor?: string): void;
    /**
     * Adds a locate control to the map.
     * @param position The position of the control on the map. Defaults to 'bottomright'.
     */
    addLocateControl(position?: AXMapControlPlace): void;
    private availableColors;
    private getRandomColorName;
    /**
     * Removes the draw control from the map.
     */
    removeDrawControl(): void;
    /**
     * Removes the locate control from the map.
     */
    removeLocateControl(): void;
    /**
     * Clears all drawn items, including markers, polygons, and POIs.
     * @param clearPois Whether to clear POI markers as well. Defaults to false.
     */
    clearDrawItems(clearPois?: boolean): void;
    /**
     * Gets the current drawn items (markers and polygons).
     * @returns An object containing arrays of markers and polygons.
     */
    getDrawItem(): AXMapData;
    /**
     * Sets the drawn items (markers and polygons) on the map.
     * @param data An object containing arrays of markers and polygons.
     */
    setDrawItem(data: AXMapData): Promise<void>;
    /**
     * Adjusts the map view to fit all markers, polygons, and boundaries currently on the map.
     * POIs are included based on the includePois parameter.
     */
    fitBoundsToDrawItems(includePois?: boolean): void;
    /**
     * Sets a boundary for restricting markers and polygons.
     * @param boundaryPolygon The polygon defining the boundary area.
     */
    setBoundary(boundaryPolygons: AXMapPolygon[]): void;
    isPointInPolygon(point: AXMapLatLng, polygon: AXMapPolygon): boolean;
    /**
     * Removes the boundary, allowing unrestricted drawing.
     */
    removeBoundary(): void;
    /**
     * Destroys the map instance and removes all event listeners.
     */
    destroyMap(): void;
    /**
     * Updates a marker's popup text and options
     * @param marker The marker to update
     * @param popup The new popup text
     * @param open Whether the popup should be opened after update
     * @param closeButton Whether the popup should have a close button
     * @returns True if the update was successful, false otherwise
     */
    updateMarkerPopup(marker: AXMapMarker, popup: string, open?: boolean, closeButton?: boolean): boolean;
    /**
     * Finds a marker layer by its latitude and longitude
     * @param marker The marker to find
     * @returns The Leaflet marker layer or undefined if not found
     */
    private findMarkerLayer;
    /**
     * Updates popups for multiple markers in a single operation
     * @param updates Array of marker popup updates
     * @returns Number of markers successfully updated
     */
    updateMarkerPopups(updates: {
        marker: AXMapMarker;
        popup: string;
        open?: boolean;
        closeButton?: boolean;
    }[]): number;
    /**
     * Adds a marker or markers to the map.
     * @param locations The marker or markers to add.
     */
    addMarker(locations: AXMapMarker | AXMapMarker[], emitEvents?: boolean): Promise<void>;
    /**
     * Adds a polygon or polygons to the map, respecting the boundary if set.
     * @param polygons The polygon or polygons to add.
     * @param clickCallback Optional callback function to be executed on polygon click.
     */
    addPolygon(polygons: AXMapPolygon | AXMapPolygon[], emitEvents?: boolean): void;
    /**
     * Adds a POI marker to the map.
     * @param locations One or more POI markers to add.
     */
    addPoi(locations: AXPoiMarker | AXPoiMarker[]): Promise<void>;
    /**
     * Updates the visibility of POI markers based on the current zoom level
     * @param currentZoom The current zoom level of the map
     */
    private updatePoiVisibility;
    /**
     * Sets the minimum zoom level at which POI markers become visible
     * @param minZoom The minimum zoom level (default is 10)
     */
    setPoiMinZoom(minZoom: number): void;
    /**
     * Gets the current minimum zoom level for POI visibility
     * @returns The minimum zoom level
     */
    getPoiMinZoom(): number;
    /**
     * Loads POIs from all registered providers
     */
    loadPoisFromProviders(): Promise<void>;
    /**
     * Refreshes POIs from providers, clearing existing POIs first
     */
    refreshPois(): Promise<void>;
    /**
     * Refreshes POIs from a specific provider by key
     * @param providerKey The key of the provider to refresh
     */
    refreshPoiByProvider(providerKey: string): Promise<void>;
    /**
     * Sets whether markers can be added by clicking/tapping on the map
     * @param enabled Whether to enable marker-on-tap functionality
     */
    setAddMarkerOnTap(enabled: boolean): void;
    /**
     * Checks if the map is currently in drawing mode
     * @returns True if currently drawing
     */
    private _isDrawingMode;
    /**
     * Removes markers by id or location. If no location provided, removes all markers.
     */
    removeMarker(locations?: AXMapMarker | AXMapMarker[]): void;
    /**
     * Removes polygons by id or geometry. If no location provided, removes all polygons.
     */
    removePolygon(locations?: AXMapPolygon | AXMapPolygon[]): void;
    setMaxMarkers(maxMarkers: number): void;
    setMaxPolygons(maxPolygons: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXLeafletService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXLeafletService>;
}

declare function AXConvertGeoJSONToAXMapPolygons(geoJSON: any): AXMapPolygon[];

declare const AX_WORLD_GEO_JSON: {
    type: string;
    features: ({
        type: string;
        id: string;
        properties: {
            name: string;
        };
        geometry: {
            type: string;
            coordinates: number[][][];
        };
    } | {
        type: string;
        id: string;
        properties: {
            name: string;
        };
        geometry: {
            type: string;
            coordinates: number[][][][];
        };
    })[];
};
declare const AX_WORLD_COUNTRIES: {
    id: string;
    text: string;
}[];

interface AXPoiProvider {
    get key(): string;
    provide(): Promise<AXPoiMarker[]>;
}
declare const AX_MAP_POI_PROVIDER: InjectionToken<AXPoiProvider[]>;
declare class AXPoiProviderService {
    private providers;
    private cache;
    getList(): Promise<AXPoiMarker[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPoiProviderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPoiProviderService>;
}

export { AXConvertGeoJSONToAXMapPolygons, AXLeafletService, AXMapComponent, AXMapDefaultConfig, AXMapModule, AXPoiProviderService, AX_MAP_CONFIG, AX_MAP_POI_PROVIDER, AX_WORLD_COUNTRIES, AX_WORLD_GEO_JSON, baseUrl, mapConfig };
export type { AXMapConfig, AXMapControlPlace, AXMapData, AXMapLatLng, AXMapLocation, AXMapMarker, AXMapPolygon, AXPoiMarker, AXPoiProvider, PartialMapConfig };
