@artsdatabanken/nbic-map-component 0.3.0

package/dist/index.d.cts

@@ -0,0 +1,805 @@
+import { Tile, Feature as Feature$1 } from 'ol';
+import { Extent } from 'ol/extent';
+import Feature, { FeatureLike } from 'ol/Feature';
+import BaseLayer from 'ol/layer/Base';
+import { Geometry } from 'ol/geom';
+import VectorSource from 'ol/source/Vector';
+import Control from 'ol/control/Control';
+import { Type } from 'ol/geom/Geometry';
+import { Coordinate } from 'ol/coordinate';
+import { GeoJsonProperties, Position, Feature as Feature$2, Geometry as Geometry$1, FeatureCollection } from 'geojson';
+import OlMap from 'ol/Map';
+
+type MapCoord = [number, number];
+type DrawKind = 'Point' | 'LineString' | 'Polygon' | 'Circle' | 'Text' | 'Box';
+interface ControlInit {
+    fullscreen?: boolean;
+    scaleLine?: boolean;
+    geolocation?: boolean;
+    geolocationFollow?: boolean;
+    zoom?: boolean;
+    attribution?: boolean;
+}
+type BufferUnits = 'meters' | 'kilometers' | 'miles' | 'feet';
+type InteractiveBuffer = boolean | ({
+    interactive?: boolean;
+    distance?: number;
+    units?: BufferUnits;
+    steps?: number;
+    style?: DrawStyleOptions;
+    replaceOriginal?: boolean;
+    /** Line cap style for line buffers (turf): 'round' | 'flat' | 'square' */
+    cap?: 'round' | 'flat' | 'square';
+    /** Line join style for polygons (turf): 'round' | 'mitre' | 'bevel' */
+    join?: 'round' | 'mitre' | 'bevel';
+});
+interface DrawStyleOptions {
+    strokeColor?: string;
+    strokeWidth?: number;
+    fillColor?: string;
+    pointRadius?: number;
+    text?: {
+        label?: string;
+        font?: string;
+        fillColor?: string;
+        strokeColor?: string;
+        strokeWidth?: number;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    icon?: {
+        src: string;
+        scale?: number;
+        size?: [number, number];
+        anchor?: [number, number];
+        anchorXUnits?: 'fraction' | 'pixels';
+        anchorYUnits?: 'fraction' | 'pixels';
+        rotation?: number;
+        opacity?: number;
+        color?: string;
+    };
+}
+interface DrawOptions {
+    kind: DrawKind;
+    style?: DrawStyleOptions;
+    snap?: boolean;
+    buffer?: InteractiveBuffer;
+}
+interface DrawExportOptions {
+    pretty?: boolean;
+}
+interface DrawImportOptions {
+    clearExisting?: boolean;
+}
+interface MapInit {
+    target: string | HTMLElement;
+    center?: MapCoord;
+    zoom?: number;
+    projection?: string;
+    enableDefaults?: boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    controls?: ControlInit;
+}
+interface WMTSDefOptions {
+    url: string;
+    layer: string;
+    format?: string;
+    style?: string;
+    matrixSet?: string;
+    /** When WMTS server uses non-EPSG matrix set ids (e.g. 'default028mm') */
+    matrixSetId?: string;
+    projection?: string;
+    tileSize?: number;
+    levels?: number;
+    wrapX?: boolean;
+    opacity?: number;
+    attribution?: string;
+    extent?: Extent;
+    /** Provide a full custom WMTS tile grid (overrides auto-build) */
+    /** KVP URL param override hook (rarely needed) */
+    urlParamOverrides?: Record<string, string>;
+    tileLoadFunction?: (tile: Tile, src: string) => void;
+}
+interface WFSDefOptions {
+    url: string;
+    typeName: string;
+    version?: '2.0.0' | '1.1.0';
+    srsName?: string;
+    outputFormat?: string;
+    geometryName?: string;
+    maxFeatures?: number;
+    headers?: Record<string, string>;
+    params?: Record<string, string | number>;
+    strategy?: 'bbox' | 'all';
+    featureNS?: string;
+    featureType?: string;
+    minZoomToLoad?: number;
+}
+interface ThumbnailMarkerOptions {
+    /** property name on the feature holding image url */
+    property?: string;
+    /** used when no thumbnail is present */
+    fallbackMaterialIcon?: string;
+    /** image size (source pixel size) */
+    imageSize?: [number, number];
+    /** icon scale for the image */
+    imageScale?: number;
+    /** square "frame" radius */
+    frameRadius?: number;
+    /** frame border width */
+    frameBorderWidth?: number;
+    /** frame border color */
+    frameBorderColor?: string;
+    /** frame fill color */
+    frameFillColor?: string;
+    /** frame displacement */
+    frameDisplacement?: [number, number];
+    /** triangle radius */
+    pinRadius?: number;
+    /** pin fill color */
+    pinFillColor?: string;
+    /** triangle rotation */
+    pinRotation?: number;
+    /** crossOrigin for thumbnails */
+    crossOrigin?: '' | 'anonymous' | 'use-credentials';
+}
+interface SimpleStyleOptions {
+    thumbnailMarker?: ThumbnailMarkerOptions;
+    fillColor?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    circle?: {
+        radius?: number;
+        fillColor?: string;
+        strokeColor?: string;
+        strokeWidth?: number;
+        units?: 'px' | 'map';
+        radiusProperty?: string;
+        segments?: number;
+        gradient?: {
+            color: string;
+            outerScale?: number;
+            stops?: Array<[number, number]>;
+        };
+    };
+    text?: {
+        label?: string;
+        font?: string;
+        fillColor?: string;
+        strokeColor?: string;
+        strokeWidth?: number;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    icon?: {
+        /** e.g. '/assets/icons/marker.svg' */
+        src: string;
+        /** 1 = 100% */
+        scale?: number;
+        /** 0..1 if using fraction; or pixels if using 'pixels' units */
+        anchor?: [number, number];
+        anchorXUnits?: 'fraction' | 'pixels';
+        anchorYUnits?: 'fraction' | 'pixels';
+        /** [w, h] of the source image (optional, but helps layout) */
+        size?: [number, number];
+        rotation?: number;
+        opacity?: number;
+        /** Optional tint for SVGs (works for inline-colorable SVGs) */
+        color?: string;
+    };
+}
+interface RawStyleOptions {
+    instance: unknown;
+}
+type StyleRef = {
+    ref: string;
+};
+type StyleDef = {
+    type: 'simple';
+    options?: SimpleStyleOptions;
+} | {
+    type: 'raw';
+    options: RawStyleOptions;
+} | StyleRef;
+interface HitResult {
+    layerId: string;
+    featureId?: string | number;
+    properties?: Record<string, unknown>;
+    coordinate: MapCoord;
+}
+interface CameraState {
+    center: MapCoord;
+    zoom: number;
+}
+interface XYZDefOptions {
+    url: string;
+    minZoom?: number;
+    maxZoom?: number;
+    attributions?: string | string[];
+    tileSize?: number;
+}
+interface XYZDefOptions {
+    url: string;
+    minZoom?: number;
+    maxZoom?: number;
+    attributions?: string | string[];
+    tileSize?: number;
+}
+interface GeoJSONDefOptions {
+    url?: string;
+    /** Inline GeoJSON string (Feature or FeatureCollection) */
+    text?: string;
+    /** CRS of the GeoJSON data if different from the map (no reprojection if omitted) */
+    dataProjection?: string;
+    featureProjection?: string;
+}
+type SourceDef = {
+    type: 'osm';
+} | {
+    type: 'xyz';
+    options: XYZDefOptions;
+} | {
+    type: 'wmts';
+    options: WMTSDefOptions;
+} | {
+    type: 'wfs';
+    options: WFSDefOptions;
+} | {
+    type: 'geojson';
+    options: GeoJSONDefOptions;
+} | {
+    type: 'memory';
+};
+type SourceInput = SourceDef;
+interface AdoptLayerOptions {
+    base?: 'regional' | 'super';
+    zIndex?: number;
+    pickable?: boolean;
+    role?: 'overlay' | 'hover' | 'draw';
+}
+interface EnableEditingOptions {
+    showVertices?: boolean;
+    showVerticesPersistent?: boolean;
+    vertexStyle?: DrawStyleOptions;
+}
+interface LayerDef {
+    id: string;
+    name?: string;
+    kind: 'tile' | 'raster' | 'vector';
+    source: SourceInput;
+    style?: StyleDef;
+    visible?: boolean;
+    zIndex?: number;
+    zIndexPinned?: boolean;
+    base?: boolean | 'super' | 'regional';
+    background?: string;
+    minZoom?: number;
+    maxZoom?: number;
+    opacity?: number;
+    pickable?: boolean;
+    hover?: {
+        cursor?: string;
+        hitTolerance?: number;
+        clusterBehavior?: 'bubble' | 'unwrapSingle';
+        style?: DrawStyleOptions;
+        clusterStyle?: DrawStyleOptions;
+        singleClusterStyle?: DrawStyleOptions;
+    };
+    cluster?: {
+        enabled: boolean;
+        distance?: number;
+        minDistance?: number;
+        style?: StyleDef;
+        keepSingleAsCluster?: boolean;
+        countField?: string;
+        maxClusterPoints?: number;
+    };
+}
+interface UpdateGeoJSONLayerOptions {
+    mode?: 'replace' | 'merge';
+    dataProjection?: string;
+    keepStyles?: boolean;
+    idProperty?: string;
+}
+interface HoverInfoOptions {
+    /** Pixel tolerance for hit-testing. Default: 5 */
+    hitTolerance?: number;
+    /** Outline color. Default: '#ffcc00' */
+    outlineColor?: string;
+    /** Outline width in px. Default: 3 */
+    outlineWidth?: number;
+}
+interface InsertGeomOptions {
+    /** CRS of the incoming coordinates. If omitted, assume map/view projection. */
+    dataProjection?: string;
+}
+
+type MapEventMap = {
+    ready: void;
+    destroy: void;
+    'camera:changed': CameraState;
+    'layer:added': {
+        layerId: string;
+    };
+    'layer:removed': {
+        layerId: string;
+    };
+    'pointer:move': {
+        coordinate: MapCoord;
+    };
+    'pointer:click': {
+        features: {
+            feature: Feature;
+            layer: BaseLayer;
+        }[];
+        clickCoordinate: Coordinate;
+    } | {
+        clickCoordinate: Coordinate;
+        features: null;
+    };
+    'extent:changed': {
+        extent: Extent;
+    };
+    'baselayer:changed': {
+        layerId: string | null;
+    };
+    'hover:info': {
+        coordinate: MapCoord;
+        items: {
+            feature: Feature;
+            layer: BaseLayer;
+        }[];
+    } | null;
+    'draw:start': {
+        kind: string;
+    };
+    'draw:end': {
+        feature: Feature<Geometry>;
+    };
+    'draw:imported': {
+        count: number;
+    };
+    'draw:cleared': {
+        count: number;
+    };
+    'draw:vertex': {
+        kind: string;
+        index: number;
+        coordinate: MapCoord;
+    };
+    'draw:vertexRemoved': {
+        kind: string;
+        index: number;
+    };
+    'edit:modified': {
+        count: number;
+        feature: Feature<Geometry>;
+    };
+    'edit:undo': {
+        feature: Feature<Geometry>;
+    };
+    'geo:position': {
+        coordinate: MapCoord;
+        accuracy?: number;
+    } | null;
+    'geo:error': {
+        message: string;
+    };
+    'fullscreen:change': {
+        active: boolean;
+    };
+    'controls:scaleline': {
+        visible: boolean;
+    };
+    'controls:zoom': {
+        visible: boolean;
+    };
+    'controls:attribution': {
+        visible: boolean;
+    };
+    'base:changed': {
+        regional: string | null;
+        super: string | null;
+    };
+    'buffer:created': {
+        baseFeature: Feature<Geometry>;
+        bufferFeature: Feature<Geometry>;
+        distance: number;
+        units: string;
+    };
+    'buffer:interactive:start': {
+        mode: Type;
+    };
+    'select:changed': {
+        layerId: string;
+        featureId: string | number;
+    } | null;
+    error: {
+        scope: string;
+        message: string;
+        detail?: unknown;
+    };
+};
+declare const MapEvents: {
+    readonly Ready: "ready";
+    readonly Destroy: "destroy";
+    readonly CameraChanged: "camera:changed";
+    readonly ExtentChanged: "extent:changed";
+    readonly LayerAdded: "layer:added";
+    readonly LayerRemoved: "layer:removed";
+    readonly PointerMove: "pointer:move";
+    readonly PointerClick: "pointer:click";
+    readonly BaselayerChanged: "baselayer:changed";
+    readonly BaseChanged: "base:changed";
+    readonly HoverInfo: "hover:info";
+    readonly Error: "error";
+    readonly DrawStart: "draw:start";
+    readonly DrawEnd: "draw:end";
+    readonly DrawImported: "draw:imported";
+    readonly DrawCleared: "draw:cleared";
+    readonly DrawVertex: "draw:vertex";
+    readonly DrawVertexRemoved: "draw:vertexRemoved";
+    readonly GeoPosition: "geo:position";
+    readonly GeoError: "geo:error";
+    readonly FullscreenChange: "fullscreen:change";
+    readonly ScaleLineControl: "controls:scaleline";
+    readonly ZoomControl: "controls:zoom";
+    readonly AttributionControl: "controls:attribution";
+    readonly BufferCreated: "buffer:created";
+    readonly BufferInteractiveStart: "buffer:interactive:start";
+    readonly EditModified: "edit:modified";
+};
+type MapEventName = keyof MapEventMap;
+type MapEventPayload<K extends MapEventName> = MapEventMap[K];
+
+interface MapEngine {
+    init(init: MapInit): Promise<void>;
+    destroy(): void;
+    getCamera(): CameraState;
+    getExtent(): Extent;
+    setCenter(center: MapCoord): void;
+    setZoom(zoom: number): void;
+    fitExtent(extent: Extent, padding: number): void;
+    addLayer(def: LayerDef): void;
+    removeLayer(layerId: string): void;
+    updateGeoJSONLayer(layerId: string, geojson: string, opts?: UpdateGeoJSONLayerOptions): void;
+    setLayerVisibility(layerId: string, visible: boolean): void;
+    reorderLayers(order: string[]): void;
+    setActiveBase(layerId: string): void;
+    adoptLayer(id: string, layer: BaseLayer, opts?: AdoptLayerOptions): void;
+    adoptControl(control: Control, id?: string): string;
+    removeControl(id: string): boolean;
+    listCustomControlIds(): string[];
+    getCustomControl(id: string): Control | undefined;
+    listLayerIds(): string[];
+    listBaseLayerIds(): string[];
+    listOverlayLayerIds(): string[];
+    getLayerById(id: string): BaseLayer | null;
+    ejectLayer(id: string): void;
+    getFeatureCount(layerId: string): number;
+    getFeatures(layerId: string): Feature$1<Geometry>[] | null;
+    analyzeSelfIntersections(feature: FeatureLike): Promise<{
+        valid: boolean;
+        intersections?: unknown;
+    }>;
+    pickAt(pixel: [number, number]): HitResult | null;
+    activateHoverInfo(options?: HoverInfoOptions): void;
+    deactivateHoverInfo(): void;
+    startDrawing(opts: DrawOptions): void;
+    stopDrawing(): void;
+    enableDrawEditing(opts?: EnableEditingOptions): void;
+    disableDrawEditing(): void;
+    undoLastPoint(): void;
+    undoEdit(): void;
+    finishCurrent(): void;
+    abortCurrent(): void;
+    clearDrawn(): void;
+    setDrawnFeatureStyle(feature: Feature$1<Geometry>, style: DrawStyleOptions): void;
+    clearDrawnFeatureStyle(feature: Feature$1<Geometry>): void;
+    setFeatureStyle(layerId: string, featureId: string | number, style: DrawStyleOptions): boolean;
+    clearFeatureStyle(layerId: string, featureId: string | number): boolean;
+    exportDrawnGeoJSON(opts?: DrawExportOptions): string;
+    importDrawnGeoJSON(geojson: string, opts?: DrawImportOptions): void;
+    enterFullScreen(): void;
+    leaveFullScreen(): void;
+    showScaleLine(): void;
+    hideScaleLine(): void;
+    showZoomControl(): void;
+    hideZoomControl(): void;
+    showAttribution(): void;
+    hideAttribution(): void;
+    activateGeolocation(follow?: boolean): void;
+    deactivateGeolocation(): void;
+    zoomToGeolocation(maxZoom?: number): Promise<boolean>;
+    getVectorLayerSource(layerId: string): VectorSource<FeatureLike> | null;
+    addPoint(layerId: string, coord: MapCoord, properties?: Record<string, unknown>, style?: DrawStyleOptions, opts?: InsertGeomOptions): boolean;
+    removeAllFromLayer(layerId: string): boolean;
+    transformCoordsFrom(coord: [number, number], from: string, to: string): [number, number];
+    transformCoordsArrayFrom(coords: number[][], from: string, to: string): number[][];
+    transformExtentFrom(extent: Extent, from: string, to: string): number[] | null;
+    zoomToFeature(layerId: string, featureId: string, opts?: {
+        maxZoom?: number;
+        padding?: number;
+    }): boolean;
+    zoomToLayer(layerId: string, opts?: {
+        maxZoom?: number;
+        padding?: number;
+    }): boolean;
+    zoomToExtent(extent: Extent, opts?: {
+        maxZoom?: number;
+        padding?: number;
+    }): boolean;
+    fitGeometry(geom: Geometry, opts?: {
+        maxZoom?: number;
+        padding?: number;
+    }): boolean;
+    selectFeature(layerId: string, featureId: string | number, style?: DrawStyleOptions, coordinates?: [number, number]): boolean;
+    clearSelection(): void;
+    getSelection(): {
+        layerId: string;
+        featureId: string | number;
+    } | null;
+    getTargetElement(): HTMLElement | null;
+    getCenterFromExtent(extent: Extent): MapCoord;
+}
+
+declare class MapAPI {
+    private engine;
+    private events;
+    private layerDefs;
+    constructor(init: MapInit, engine?: MapEngine);
+    on<K extends keyof MapEventMap>(type: K, cb: (payload: MapEventMap[K]) => void): () => void;
+    off<K extends keyof MapEventMap>(type: K, cb: (payload: MapEventMap[K]) => void): void;
+    once<K extends keyof MapEventMap>(type: K, cb: (payload: MapEventMap[K]) => void): void;
+    destroy(): void;
+    getCamera(): CameraState;
+    getExtent(): Extent;
+    /** Return all layers marked as base (in insertion order). */
+    getBaseLayerIds(): string[];
+    getOverlayLayerIds(): string[];
+    /** If you still want full LayerDef[] for config-only layers, keep these: */
+    getBaseLayers(): LayerDef[];
+    getOverlayLayers(): LayerDef[];
+    /** Or add engine-backed variants that return live OL layers: */
+    getLayerById(id: string): BaseLayer | null;
+    adoptControl(control: Control, id?: string): string;
+    removeControl(id: string): boolean;
+    listCustomControlIds(): string[];
+    getCustomControl(id: string): Control | undefined;
+    setCenter(center: MapCoord): void;
+    setZoom(zoom: number): void;
+    fitExtent(extent: Extent, padding?: number): void;
+    addLayer(layer: LayerDef): void;
+    removeLayer(layerId: string): void;
+    updateGeoJSONLayer(layerId: string, geojson: string, opts?: UpdateGeoJSONLayerOptions): void;
+    setLayerVisibility(layerId: string, visible: boolean): void;
+    reorderLayers(order: string[]): void;
+    addPoint(layerId: string, coord: MapCoord, properties?: Record<string, unknown>, style?: DrawStyleOptions, opts?: InsertGeomOptions): boolean;
+    removeAllFromLayer(layerId: string): boolean;
+    adoptLayer(id: string, layer: BaseLayer, opts?: AdoptLayerOptions): void;
+    ejectLayer(id: string): void;
+    getFeatureCount(layerId: string): number;
+    getFeatures(layerId: string): Feature$1<Geometry>[] | null;
+    activateHoverInfo(options?: HoverInfoOptions): void;
+    deactivateHoverInfo(): void;
+    pickAt(pixel: [number, number]): HitResult | null;
+    startDrawing(opts: DrawOptions): void;
+    stopDrawing(): void;
+    enableDrawEditing(opts?: EnableEditingOptions): void;
+    disableDrawEditing(): void;
+    setDrawnFeatureStyle(feature: Feature$1<Geometry>, style: DrawStyleOptions): void;
+    clearDrawnFeatureStyle(feature: Feature$1<Geometry>): void;
+    setFeatureStyle(layerId: string, featureId: string | number, style: DrawStyleOptions): boolean;
+    clearFeatureStyle(layerId: string, featureId: string | number): boolean;
+    undoLastPoint(): void;
+    undoEdit(): void;
+    finishCurrent(): void;
+    abortCurrent(): void;
+    clearDrawn(): void;
+    exportDrawnGeoJSON(opts?: DrawExportOptions): string;
+    importDrawnGeoJSON(text: string, opts?: DrawImportOptions): void;
+    analyzeSelfIntersections(feature: FeatureLike): Promise<{
+        valid: boolean;
+        intersections?: unknown;
+    }>;
+    enterFullScreen(): void;
+    leaveFullScreen(): void;
+    showScaleLine(): void;
+    hideScaleLine(): void;
+    showZoomControl(): void;
+    hideZoomControl(): void;
+    showAttribution(): void;
+    hideAttribution(): void;
+    activateGeolocation(follow?: boolean): void;
+    deactivateGeolocation(): void;
+    zoomToGeolocation(maxZoom?: number): Promise<boolean>;
+    transformCoordsFrom(coord: [number, number], from: string, to: string): [number, number];
+    transformCoordsArrayFrom(coords: number[][], from: string, to: string): number[][];
+    transformExtentFrom(extent: Extent, from: string, to: string): number[] | null;
+    zoomToFeature(layerId: string, featureId: string, opts?: {
+        maxZoom?: number;
+        padding?: number;
+    }): boolean;
+    zoomToLayer(layerId: string, opts?: {
+        maxZoom?: number;
+        padding?: number;
+    }): boolean;
+    zoomToExtent(extent: Extent, opts?: {
+        maxZoom?: number;
+        padding?: number;
+    }): boolean;
+    fitGeometry(geom: Geometry, opts?: {
+        maxZoom?: number;
+        padding?: number;
+    }): boolean;
+    selectFeature(layerId: string, featureId: string | number, style?: DrawStyleOptions, coordinates?: [number, number]): boolean;
+    clearSelection(): void;
+    getSelection(): {
+        layerId: string;
+        featureId: string | number;
+    } | null;
+    getTargetElement(): HTMLElement | null;
+    getCenterFromExtent(extent: Extent): MapCoord;
+}
+
+declare function createMap(target: string | HTMLElement, rawConfig: unknown): MapAPI;
+
+type IdGetter<T> = (item: T, index: number) => string | number | undefined;
+type PropsGetter<T> = (item: T, index: number) => GeoJsonProperties | undefined;
+type PointGetter<T> = (item: T, index: number) => {
+    lon: number;
+    lat: number;
+} | null;
+type LineGetter<T> = (item: T, index: number) => Position[] | null;
+type PolyGetter<T> = (item: T, index: number) => Position[][] | null;
+type GeometryKind = 'Point' | 'LineString' | 'Polygon';
+interface CommonOptions<T> {
+    id?: IdGetter<T>;
+    props?: PropsGetter<T>;
+    skipInvalid?: boolean;
+    filterNull?: boolean;
+}
+interface PointBuildOptions<T> extends CommonOptions<T> {
+    kind: 'Point';
+    getPoint: PointGetter<T>;
+}
+interface LineBuildOptions<T> extends CommonOptions<T> {
+    kind: 'LineString';
+    getLine: LineGetter<T>;
+}
+interface PolyBuildOptions<T> extends CommonOptions<T> {
+    kind: 'Polygon';
+    getPolygon: PolyGetter<T>;
+}
+type BuildOptions<T> = PointBuildOptions<T> | LineBuildOptions<T> | PolyBuildOptions<T>;
+declare function toFeature<T>(item: T, index: number, opts: BuildOptions<T>): Feature$2<Geometry$1, GeoJsonProperties> | null;
+declare function toFeatureCollection<T>(items: T[], opts: BuildOptions<T>): FeatureCollection;
+/** Handy for cluster label totals (supports your `countField` behavior) */
+declare function sumProperty(features: Feature$2[], field?: string): number;
+
+type index$2_BuildOptions<T> = BuildOptions<T>;
+type index$2_CommonOptions<T> = CommonOptions<T>;
+type index$2_GeometryKind = GeometryKind;
+type index$2_IdGetter<T> = IdGetter<T>;
+type index$2_LineBuildOptions<T> = LineBuildOptions<T>;
+type index$2_LineGetter<T> = LineGetter<T>;
+type index$2_PointBuildOptions<T> = PointBuildOptions<T>;
+type index$2_PointGetter<T> = PointGetter<T>;
+type index$2_PolyBuildOptions<T> = PolyBuildOptions<T>;
+type index$2_PolyGetter<T> = PolyGetter<T>;
+type index$2_PropsGetter<T> = PropsGetter<T>;
+declare const index$2_sumProperty: typeof sumProperty;
+declare const index$2_toFeature: typeof toFeature;
+declare const index$2_toFeatureCollection: typeof toFeatureCollection;
+declare namespace index$2 {
+  export { type index$2_BuildOptions as BuildOptions, type index$2_CommonOptions as CommonOptions, type index$2_GeometryKind as GeometryKind, type index$2_IdGetter as IdGetter, type index$2_LineBuildOptions as LineBuildOptions, type index$2_LineGetter as LineGetter, type index$2_PointBuildOptions as PointBuildOptions, type index$2_PointGetter as PointGetter, type index$2_PolyBuildOptions as PolyBuildOptions, type index$2_PolyGetter as PolyGetter, type index$2_PropsGetter as PropsGetter, index$2_sumProperty as sumProperty, index$2_toFeature as toFeature, index$2_toFeatureCollection as toFeatureCollection };
+}
+
+declare function ensureClosedRing(ring: number[][]): number[][];
+/**
+ * Compute area (m²) from a lon/lat ring (EPSG:4326).
+ * `ring` is an array of [lon, lat] coordinates.
+ */
+declare function areaFromLonLatRing(ring: number[][]): number;
+declare function areaToString(m2: number): string;
+declare function getCenterFromPolygon(polygonCoordinates: number[][]): MapCoord | null;
+/** Compute centroid from an array of coordinates.
+ * @param coordinates Array of [x, y] coordinates.
+ * @returns Centroid as [x, y] or null if input is invalid.
+ */
+declare function getCentroid(coordinates: number[][]): MapCoord | null;
+declare function getExtentFromPolygon(polygonCoordinates: number[][]): number[] | null;
+declare function isExtentInside(inner: number[], outer: number[]): boolean;
+declare function isPointInsideExtent(coord: MapCoord, extent: number[]): boolean;
+
+/**
+ * Transforms a coordinate from a given projection into the map's view projection.
+ * If `from` is not specified or already matches the view projection, it returns the same coord.
+ */
+declare function toViewCoord(map: OlMap, coord: [number, number], from?: string): [number, number];
+/**
+ * Transforms a coordinate from map view projection to another projection (default: WGS84).
+ */
+declare function toDataCoord(map: OlMap, coord: [number, number], to?: string): [number, number];
+declare function transformCoordsArrayFrom(coords: number[][], from: string, to: string): number[][];
+declare function transformCoordsFrom(coords: [number, number], from: string, to: string): [number, number];
+declare function transformExtentFrom(extent: Extent, from: string, to: string): number[] | null;
+declare function getCenterFromExtent(extent: number[]): MapCoord;
+
+declare const index$1_areaFromLonLatRing: typeof areaFromLonLatRing;
+declare const index$1_areaToString: typeof areaToString;
+declare const index$1_ensureClosedRing: typeof ensureClosedRing;
+declare const index$1_getCenterFromExtent: typeof getCenterFromExtent;
+declare const index$1_getCenterFromPolygon: typeof getCenterFromPolygon;
+declare const index$1_getCentroid: typeof getCentroid;
+declare const index$1_getExtentFromPolygon: typeof getExtentFromPolygon;
+declare const index$1_isExtentInside: typeof isExtentInside;
+declare const index$1_isPointInsideExtent: typeof isPointInsideExtent;
+declare const index$1_toDataCoord: typeof toDataCoord;
+declare const index$1_toViewCoord: typeof toViewCoord;
+declare const index$1_transformCoordsArrayFrom: typeof transformCoordsArrayFrom;
+declare const index$1_transformCoordsFrom: typeof transformCoordsFrom;
+declare const index$1_transformExtentFrom: typeof transformExtentFrom;
+declare namespace index$1 {
+  export { index$1_areaFromLonLatRing as areaFromLonLatRing, index$1_areaToString as areaToString, index$1_ensureClosedRing as ensureClosedRing, index$1_getCenterFromExtent as getCenterFromExtent, index$1_getCenterFromPolygon as getCenterFromPolygon, index$1_getCentroid as getCentroid, index$1_getExtentFromPolygon as getExtentFromPolygon, index$1_isExtentInside as isExtentInside, index$1_isPointInsideExtent as isPointInsideExtent, index$1_toDataCoord as toDataCoord, index$1_toViewCoord as toViewCoord, index$1_transformCoordsArrayFrom as transformCoordsArrayFrom, index$1_transformCoordsFrom as transformCoordsFrom, index$1_transformExtentFrom as transformExtentFrom };
+}
+
+declare const svalbardBaseLayer: LayerDef;
+declare const janmayenBaseLayer: LayerDef;
+declare const topografiskBaseLayer: LayerDef;
+declare const topo4graatoneBaseLayer: LayerDef;
+declare const nib: LayerDef;
+declare const osm: LayerDef;
+
+declare const norwayCoordinate: number[];
+declare const administrativeEnheterKommune: LayerDef;
+declare const administrativeEnheterFylke: LayerDef;
+
+declare const index_administrativeEnheterFylke: typeof administrativeEnheterFylke;
+declare const index_administrativeEnheterKommune: typeof administrativeEnheterKommune;
+declare const index_janmayenBaseLayer: typeof janmayenBaseLayer;
+declare const index_nib: typeof nib;
+declare const index_norwayCoordinate: typeof norwayCoordinate;
+declare const index_osm: typeof osm;
+declare const index_svalbardBaseLayer: typeof svalbardBaseLayer;
+declare const index_topo4graatoneBaseLayer: typeof topo4graatoneBaseLayer;
+declare const index_topografiskBaseLayer: typeof topografiskBaseLayer;
+declare namespace index {
+  export { index_administrativeEnheterFylke as administrativeEnheterFylke, index_administrativeEnheterKommune as administrativeEnheterKommune, index_janmayenBaseLayer as janmayenBaseLayer, index_nib as nib, index_norwayCoordinate as norwayCoordinate, index_osm as osm, index_svalbardBaseLayer as svalbardBaseLayer, index_topo4graatoneBaseLayer as topo4graatoneBaseLayer, index_topografiskBaseLayer as topografiskBaseLayer };
+}
+
+/**
+ * Handles fetching, storing, and renewing tokens for Norge i Bilder aerial photo services.
+ */
+interface NibTokenConfig {
+    tokenUrl?: string;
+    storageKey?: string;
+    expiryMarginMinutes?: number;
+    retryIntervalMs?: number;
+    onTokenFetched?: (token: string) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Token object stored in localStorage
+ */
+interface NibToken {
+    value: string;
+    expires: number;
+    when: number;
+}
+interface NibTokenManager {
+    init(): Promise<void>;
+    getToken(): string;
+    getTokenInfo(): NibToken | null;
+    refreshToken(force?: boolean): Promise<string>;
+    onTokenChange(callback: (token: string) => void): () => void;
+    dispose(): void;
+    isInitialized(): boolean;
+}
+/**
+ * Create a NiB token manager instance
+ */
+declare function createNibToken(config?: NibTokenConfig): NibTokenManager;
+
+export { type LayerDef, type MapEventName, type MapEventPayload, MapEvents, type MapInit, MapAPI as NbicMapComponent, type NibToken, type NibTokenConfig, type NibTokenManager, createMap, createNibToken, index$2 as nbicMapGeojson, index as nbicMapPresets, index$1 as nbicMapUtils };