@acorex/components 19.15.0-next.9 → 20.0.1

package/map/index.d.ts

@@ -1,7 +1,661 @@
-export * from './lib/map.component';
-export * from './lib/map.config';
-export * from './lib/map.module';
-export * from './lib/map.service';
-export * from './lib/map.type';
-export * from './lib/map.utility';
-export * from './lib/map.world-map';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, InjectionToken, EventEmitter } from '@angular/core';
+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;
+}
+/**
+ * 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 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
+     * 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 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 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>;
+    private mapContainer;
+    private leafletService;
+    private rendered;
+    private onLatitudeChangedSubscription?;
+    private onLongitudeChangedSubscription?;
+    private onZoomChangedSubscription?;
+    private onLocationFoundSubscription?;
+    private onMarkerChangedSubscription?;
+    private onMarkerAddedSubscription?;
+    private onPolygonChangedSubscription?;
+    private onPolygonAddedSubscription?;
+    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.
+     */
+    addMarker(location: AXMapMarker | AXMapMarker[]): Promise<void>;
+    /**
+     * @description
+     * Adds a polygon to the specified location on the map.
+     * @param location - The location where the polygon should be placed.
+     * @param clickCallback - Optional callback for polygon click events.
+     */
+    addPolygon(location: AXMapPolygon | AXMapPolygon[], clickCallback?: (event: L.LeafletMouseEvent) => void): 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 draw event subscriptions
+     */
+    private setupDrawEventSubscriptions;
+    /**
+     * Unsubscribe from draw events
+     */
+    private unsubscribeFromDrawEvents;
+    /**
+     * @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;
+    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; }; "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"; "onMarkerChanged": "onMarkerChanged"; "onPolygonAdded": "onPolygonAdded"; "onPolygonChanged": "onPolygonChanged"; "onLocationFound": "onLocationFound"; "onPoiChanged": "onPoiChanged"; "onPoiAdded": "onPoiAdded"; "onMapReady": "onMapReady"; }, 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;
+    /**
+     * 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 the user's location is found.
+     */
+    onLocationFound: EventEmitter<AXMapLocation>;
+    /**
+     * Emits when polygon data changes.
+     */
+    onPolygonChanged: EventEmitter<AXMapPolygon[]>;
+    /**
+     * Emits when a polygon is added.
+     */
+    onPolygonAdded: 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[]): 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[], clickCallback?: (event: L.LeafletMouseEvent) => void): 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>;
+    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 };