js-sdk.api.md

API Report File for "@feltmaps/js-sdk"

Do not edit this file. It is a report generated by API Extractor.

import { ao as AggregationConfig } from './types-NOlNQi4k.js';
import { A as AggregationMethod } from './types-NOlNQi4k.js';
import { Q as CircleElementCreate } from './types-NOlNQi4k.js';
import { R as CircleElementRead } from './types-NOlNQi4k.js';
import { U as CircleElementUpdate } from './types-NOlNQi4k.js';
import { aF as CircleToolSettings } from './types-NOlNQi4k.js';
import { C as ConfigurableToolType } from './types-NOlNQi4k.js';
import { E as Element_2 } from './types-NOlNQi4k.js';
import { d as ElementChangeCallbackParams } from './types-NOlNQi4k.js';
import { f as ElementCreate } from './types-NOlNQi4k.js';
import { b as ElementGroup } from './types-NOlNQi4k.js';
import { e as ElementGroupChangeCallbackParams } from './types-NOlNQi4k.js';
import { ar as ElementGroupNode } from './types-NOlNQi4k.js';
import { as as ElementNode } from './types-NOlNQi4k.js';
import { g as ElementUpdate } from './types-NOlNQi4k.js';
import { z as EntityNode } from './types-NOlNQi4k.js';
import { s as Feature } from './types-NOlNQi4k.js';
import { at as FeatureNode } from './types-NOlNQi4k.js';
import { B as FeatureSelection } from './types-NOlNQi4k.js';
import { aw as FeltBoundary } from './types-NOlNQi4k.js';
import { ax as FeltZoom } from './types-NOlNQi4k.js';
import { al as FilterExpression } from './types-NOlNQi4k.js';
import { am as FilterLogicGate } from './types-NOlNQi4k.js';
import { F as Filters } from './types-NOlNQi4k.js';
import { an as FilterTernary } from './types-NOlNQi4k.js';
import { G as Geometry } from './types-NOlNQi4k.js';
import { c as GetElementGroupsConstraint } from './types-NOlNQi4k.js';
import { a as GetElementsConstraint } from './types-NOlNQi4k.js';
import { x as GetLayerCalculationParams } from './types-NOlNQi4k.js';
import { u as GetLayerCategoriesGroup } from './types-NOlNQi4k.js';
import { t as GetLayerCategoriesParams } from './types-NOlNQi4k.js';
import { k as GetLayerGroupsConstraint } from './types-NOlNQi4k.js';
import { w as GetLayerHistogramBin } from './types-NOlNQi4k.js';
import { v as GetLayerHistogramParams } from './types-NOlNQi4k.js';
import { h as GetLayersConstraint } from './types-NOlNQi4k.js';
import { r as GetRenderedFeaturesConstraint } from './types-NOlNQi4k.js';
import { W as HighlighterElementCreate } from './types-NOlNQi4k.js';
import { X as HighlighterElementRead } from './types-NOlNQi4k.js';
import { Y as HighlighterElementUpdate } from './types-NOlNQi4k.js';
import { aG as HighlighterToolSettings } from './types-NOlNQi4k.js';
import { Z as ImageElementCreate } from './types-NOlNQi4k.js';
import { _ as ImageElementRead } from './types-NOlNQi4k.js';
import { $ as ImageElementUpdate } from './types-NOlNQi4k.js';
import { I as InputToolSettings } from './types-NOlNQi4k.js';
import { J } from './types-NOlNQi4k.js';
import { ay as LatLng } from './types-NOlNQi4k.js';
import { L as Layer } from './types-NOlNQi4k.js';
import { i as LayerChangeCallbackParams } from './types-NOlNQi4k.js';
import { q as LayerFilters } from './types-NOlNQi4k.js';
import { j as LayerGroup } from './types-NOlNQi4k.js';
import { l as LayerGroupChangeCallbackParams } from './types-NOlNQi4k.js';
import { au as LayerGroupNode } from './types-NOlNQi4k.js';
import { av as LayerNode } from './types-NOlNQi4k.js';
import { aj as LayerProcessingStatus } from './types-NOlNQi4k.js';
import { n as LegendItem } from './types-NOlNQi4k.js';
import { p as LegendItemChangeCallbackParams } from './types-NOlNQi4k.js';
import { m as LegendItemIdentifier } from './types-NOlNQi4k.js';
import { o as LegendItemsConstraint } from './types-NOlNQi4k.js';
import { az as LineStringGeometry } from './types-NOlNQi4k.js';
import { aH as LineToolSettings } from './types-NOlNQi4k.js';
import { a0 as LinkElementRead } from './types-NOlNQi4k.js';
import { aA as LngLatTuple } from './types-NOlNQi4k.js';
import { y as MapDetails } from './types-NOlNQi4k.js';
import { M as MapInteractionEvent } from './types-NOlNQi4k.js';
import { a1 as MarkerElementCreate } from './types-NOlNQi4k.js';
import { a2 as MarkerElementRead } from './types-NOlNQi4k.js';
import { a3 as MarkerElementUpdate } from './types-NOlNQi4k.js';
import { aI as MarkerToolSettings } from './types-NOlNQi4k.js';
import { ap as MultiAggregationConfig } from './types-NOlNQi4k.js';
import { aB as MultiLineStringGeometry } from './types-NOlNQi4k.js';
import { aC as MultiPolygonGeometry } from './types-NOlNQi4k.js';
import { a4 as NoteElementCreate } from './types-NOlNQi4k.js';
import { a5 as NoteElementRead } from './types-NOlNQi4k.js';
import { a6 as NoteElementUpdate } from './types-NOlNQi4k.js';
import { aJ as NoteToolSettings } from './types-NOlNQi4k.js';
import { a7 as PathElementCreate } from './types-NOlNQi4k.js';
import { a8 as PathElementRead } from './types-NOlNQi4k.js';
import { a9 as PathElementUpdate } from './types-NOlNQi4k.js';
import { aK as PinToolSettings } from './types-NOlNQi4k.js';
import { aa as PlaceElementCreate } from './types-NOlNQi4k.js';
import { ab as PlaceElementRead } from './types-NOlNQi4k.js';
import { ac as PlaceElementUpdate } from './types-NOlNQi4k.js';
import { aL as PlaceFrame } from './types-NOlNQi4k.js';
import { aM as PlaceSymbol } from './types-NOlNQi4k.js';
import { aD as PointGeometry } from './types-NOlNQi4k.js';
import { ad as PolygonElementCreate } from './types-NOlNQi4k.js';
import { ae as PolygonElementRead } from './types-NOlNQi4k.js';
import { af as PolygonElementUpdate } from './types-NOlNQi4k.js';
import { aE as PolygonGeometry } from './types-NOlNQi4k.js';
import { aN as PolygonToolSettings } from './types-NOlNQi4k.js';
import { ak as RasterValue } from './types-NOlNQi4k.js';
import { aO as RouteToolSettings } from './types-NOlNQi4k.js';
import { K as SetViewportCenterZoomParams } from './types-NOlNQi4k.js';
import { S as SetVisibilityRequest } from './types-NOlNQi4k.js';
import { ag as TextElementCreate } from './types-NOlNQi4k.js';
import { ah as TextElementRead } from './types-NOlNQi4k.js';
import { ai as TextElementUpdate } from './types-NOlNQi4k.js';
import { aP as TextToolSettings } from './types-NOlNQi4k.js';
import { H as ToolSettingsChangeEvent } from './types-NOlNQi4k.js';
import { D as ToolSettingsMap } from './types-NOlNQi4k.js';
import { T as ToolType } from './types-NOlNQi4k.js';
import { aq as ValueConfiguration } from './types-NOlNQi4k.js';
import { P as ViewportCenterZoom } from './types-NOlNQi4k.js';
import { N as ViewportConstraints } from './types-NOlNQi4k.js';
import { O as ViewportFitBoundsParams } from './types-NOlNQi4k.js';
import { V as ViewportState } from './types-NOlNQi4k.js';
import { z } from 'zod';

export { AggregationConfig }

export { AggregationMethod }

export { CircleElementCreate }

export { CircleElementRead }

export { CircleElementUpdate }

export { CircleToolSettings }

export { ConfigurableToolType }

export { Element_2 as Element }

export { ElementChangeCallbackParams }

export { ElementCreate }

export { ElementGroup }

export { ElementGroupChangeCallbackParams }

export { ElementGroupNode }

export { ElementNode }

// @public
export interface ElementsController {
    createElement(element: ElementCreate): Promise<Element_2>;
    deleteElement(id: string): Promise<void>;
    getElement(
    id: string): Promise<Element_2 | null>;
    getElementGeometry(
    id: string): Promise<Geometry | null>;
    getElementGroup(id: string): Promise<ElementGroup | null>;
    getElementGroups(
    constraint?: GetElementGroupsConstraint): Promise<Array<ElementGroup | null>>;
    getElements(
    constraint?: GetElementsConstraint): Promise<Array<Element_2 | null>>;
    onElementChange(args: {
        options: {
            id: string;
        };
        handler: (
        change: ElementChangeCallbackParams) => void;
    }): VoidFunction;
    onElementCreate(args: {
        handler: (change: ElementChangeCallbackParams) => void;
    }): VoidFunction;
    onElementDelete(args: {
        options: {
            id: string;
        };
        handler: () => void;
    }): VoidFunction;
    onElementGroupChange(args: {
        options: {
            id: string;
        };
        handler: (change: ElementGroupChangeCallbackParams) => void;
    }): VoidFunction;
    setElementGroupVisibility(visibility: SetVisibilityRequest): Promise<void>;
    updateElement(element: ElementUpdate): Promise<Element_2>;
}

export { ElementUpdate }

export { EntityNode }

export { Feature }

export { FeatureNode }

export { FeatureSelection }

// @public
export const Felt: {
    embed(container: HTMLElement, mapId: string, options?: FeltEmbedOptions): Promise<FeltController>;
    connect(feltWindow: Window): Promise<FeltController>;
};

export { FeltBoundary }

// @public
export interface FeltController extends ViewportController, UiController, LayersController, ElementsController, SelectionController, InteractionsController, ToolsController, InteractionsController, MiscController {
    iframe: HTMLIFrameElement | null;
}

// Warning: (ae-forgotten-export) The symbol "FeltEmbedOptionsSchema" needs to be exported by the entry point client.d.ts
//
// @public
export interface FeltEmbedOptions extends J<typeof FeltEmbedOptionsSchema> {
    // (undocumented)
    initialViewport?: ViewportCenterZoom;
    // (undocumented)
    uiControls?: UiControlsOptions;
}

// @internal (undocumented)
const FeltEmbedOptionsSchema: z.ZodObject<{
    origin: z.ZodOptional<z.ZodString>;
    token: z.ZodOptional<z.ZodString>;
    uiControls: z.ZodOptional<z.ZodObject<{
        showLegend: z.ZodOptional<z.ZodBoolean>;
        cooperativeGestures: z.ZodOptional<z.ZodBoolean>;
        fullScreenButton: z.ZodOptional<z.ZodBoolean>;
        geolocation: z.ZodOptional<z.ZodBoolean>;
        zoomControls: z.ZodOptional<z.ZodBoolean>;
        scaleBar: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        showLegend?: boolean | undefined;
        cooperativeGestures?: boolean | undefined;
        fullScreenButton?: boolean | undefined;
        geolocation?: boolean | undefined;
        zoomControls?: boolean | undefined;
        scaleBar?: boolean | undefined;
    }, {
        showLegend?: boolean | undefined;
        cooperativeGestures?: boolean | undefined;
        fullScreenButton?: boolean | undefined;
        geolocation?: boolean | undefined;
        zoomControls?: boolean | undefined;
        scaleBar?: boolean | undefined;
    }>>;
    initialViewport: z.ZodOptional<z.ZodObject<{
        center: z.ZodObject<{
            latitude: z.ZodNumber;
            longitude: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            latitude: number;
            longitude: number;
        }, {
            latitude: number;
            longitude: number;
        }>;
        zoom: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        zoom: number;
        center: {
            latitude: number;
            longitude: number;
        };
    }, {
        zoom: number;
        center: {
            latitude: number;
            longitude: number;
        };
    }>>;
}, "strip", z.ZodTypeAny, {
    origin?: string | undefined;
    token?: string | undefined;
    uiControls?: {
        showLegend?: boolean | undefined;
        cooperativeGestures?: boolean | undefined;
        fullScreenButton?: boolean | undefined;
        geolocation?: boolean | undefined;
        zoomControls?: boolean | undefined;
        scaleBar?: boolean | undefined;
    } | undefined;
    initialViewport?: {
        zoom: number;
        center: {
            latitude: number;
            longitude: number;
        };
    } | undefined;
}, {
    origin?: string | undefined;
    token?: string | undefined;
    uiControls?: {
        showLegend?: boolean | undefined;
        cooperativeGestures?: boolean | undefined;
        fullScreenButton?: boolean | undefined;
        geolocation?: boolean | undefined;
        zoomControls?: boolean | undefined;
        scaleBar?: boolean | undefined;
    } | undefined;
    initialViewport?: {
        zoom: number;
        center: {
            latitude: number;
            longitude: number;
        };
    } | undefined;
}>;

export { FeltZoom }

export { FilterExpression }

export { FilterLogicGate }

export { Filters }

export { FilterTernary }

export { Geometry }

export { GetElementGroupsConstraint }

export { GetElementsConstraint }

export { GetLayerCalculationParams }

export { GetLayerCategoriesGroup }

export { GetLayerCategoriesParams }

export { GetLayerGroupsConstraint }

export { GetLayerHistogramBin }

export { GetLayerHistogramParams }

export { GetLayersConstraint }

export { GetRenderedFeaturesConstraint }

export { HighlighterElementCreate }

export { HighlighterElementRead }

export { HighlighterElementUpdate }

export { HighlighterToolSettings }

export { ImageElementCreate }

export { ImageElementRead }

export { ImageElementUpdate }

export { InputToolSettings }

// @public
export interface InteractionsController {
    onPointerClick(params: {
        handler: (event: MapInteractionEvent) => void;
    }): VoidFunction;
    onPointerMove(
    params: {
        handler: (event: MapInteractionEvent) => void;
    }): VoidFunction;
}

export { LatLng }

export { Layer }

export { LayerChangeCallbackParams }

export { LayerFilters }

export { LayerGroup }

export { LayerGroupChangeCallbackParams }

export { LayerGroupNode }

export { LayerNode }

export { LayerProcessingStatus }

// @public
export interface LayersController {
    getAggregates<T extends AggregationMethod | "count">(params: GetLayerCalculationParams<T>): Promise<Record<T, number | null>>;
    getCategoryData(params: GetLayerCategoriesParams): Promise<Array<GetLayerCategoriesGroup>>;
    getHistogramData(params: GetLayerHistogramParams): Promise<Array<GetLayerHistogramBin>>;
    getLayer(
    id: string): Promise<Layer | null>;
    getLayerFilters(layerId: string): Promise<LayerFilters | null>;
    getLayerGroup(id: string): Promise<LayerGroup | null>;
    getLayerGroups(
    constraint?: GetLayerGroupsConstraint): Promise<Array<LayerGroup | null>>;
    getLayers(
    constraint?: GetLayersConstraint): Promise<Array<Layer | null>>;
    getLegendItem(id: LegendItemIdentifier): Promise<LegendItem | null>;
    getLegendItems(constraint?: LegendItemsConstraint): Promise<Array<LegendItem | null>>;
    getRenderedFeatures(
    params?: GetRenderedFeaturesConstraint): Promise<Array<Feature>>;
    onLayerChange(args: {
        options: {
            id: string;
        };
        handler: (
        change: LayerChangeCallbackParams) => void;
    }): VoidFunction;
    onLayerGroupChange(args: {
        options: {
            id: string;
        };
        handler: (change: LayerGroupChangeCallbackParams) => void;
    }): VoidFunction;
    onLegendItemChange(args: {
        options: LegendItemIdentifier;
        handler: (change: LegendItemChangeCallbackParams) => void;
    }): VoidFunction;
    setLayerFilters(params: {
        layerId: string;
        filters: Filters;
        note?: string;
    }): Promise<void>;
    setLayerGroupLegendVisibility(params: SetVisibilityRequest): Promise<void>;
    setLayerGroupVisibility(visibility: SetVisibilityRequest): Promise<void>;
    setLayerLegendVisibility(params: SetVisibilityRequest): Promise<void>;
    setLayerStyle(params: {
        id: string;
        style: object;
    }): Promise<void>;
    setLayerVisibility(visibility: SetVisibilityRequest): Promise<void>;
    setLegendItemVisibility(visibility: {
        show?: Array<LegendItemIdentifier>;
        hide?: Array<LegendItemIdentifier>;
    }): Promise<void>;
}

export { LegendItem }

export { LegendItemChangeCallbackParams }

export { LegendItemIdentifier }

export { LegendItemsConstraint }

export { LineStringGeometry }

export { LineToolSettings }

export { LinkElementRead }

export { LngLatTuple }

export { MapDetails }

export { MapInteractionEvent }

export { MarkerElementCreate }

export { MarkerElementRead }

export { MarkerElementUpdate }

export { MarkerToolSettings }

// @public
export interface MiscController {
    getMapDetails(): Promise<MapDetails>;
}

export { MultiAggregationConfig }

export { MultiLineStringGeometry }

export { MultiPolygonGeometry }

export { NoteElementCreate }

export { NoteElementRead }

export { NoteElementUpdate }

export { NoteToolSettings }

// Warning: (ae-forgotten-export) The symbol "UiOnMapInteractionsOptionsSchema" needs to be exported by the entry point client.d.ts
//
// @public
export interface OnMapInteractionsOptions extends J<typeof UiOnMapInteractionsOptionsSchema> {
}

export { PathElementCreate }

export { PathElementRead }

export { PathElementUpdate }

export { PinToolSettings }

export { PlaceElementCreate }

export { PlaceElementRead }

export { PlaceElementUpdate }

export { PlaceFrame }

export { PlaceSymbol }

export { PointGeometry }

export { PolygonElementCreate }

export { PolygonElementRead }

export { PolygonElementUpdate }

export { PolygonGeometry }

export { PolygonToolSettings }

export { RasterValue }

export { RouteToolSettings }

// @public
export interface SelectionController {
    clearSelection(params?: {
        features?: boolean;
        elements?: boolean;
    }): Promise<void>;
    getSelection(): Promise<EntityNode[]>;
    onSelectionChange(params: {
        handler: (change: {
            selection: EntityNode[];
        }) => void;
    }): VoidFunction;
    selectFeature(params: FeatureSelection): Promise<void>;
}

export { SetViewportCenterZoomParams }

export { SetVisibilityRequest }

export { TextElementCreate }

export { TextElementRead }

export { TextElementUpdate }

export { TextToolSettings }

// @public
export interface ToolsController {
    getTool(): Promise<ToolType | null>;
    getToolSettings<T extends ConfigurableToolType>(tool: T): Promise<ToolSettingsMap[T]>;
    onToolChange(args: {
        handler: (tool: ToolType | null) => void;
    }): VoidFunction;
    onToolSettingsChange(args: {
        handler: (settings: ToolSettingsChangeEvent) => void;
    }): VoidFunction;
    setTool(tool: ToolType | null): void;
    setToolSettings(settings: InputToolSettings): void;
}

export { ToolSettingsChangeEvent }

export { ToolSettingsMap }

export { ToolType }

// @public
export interface UiController {
    setOnMapInteractionsUi(options: OnMapInteractionsOptions): void;
    updateUiControls(controls: UiControlsOptions): void;
}

// Warning: (ae-forgotten-export) The symbol "UiControlsOptionsSchema" needs to be exported by the entry point client.d.ts
//
// @public (undocumented)
export interface UiControlsOptions extends J<typeof UiControlsOptionsSchema> {
}

// @internal (undocumented)
const UiControlsOptionsSchema: z.ZodObject<{
    showLegend: z.ZodOptional<z.ZodBoolean>;
    cooperativeGestures: z.ZodOptional<z.ZodBoolean>;
    fullScreenButton: z.ZodOptional<z.ZodBoolean>;
    geolocation: z.ZodOptional<z.ZodBoolean>;
    zoomControls: z.ZodOptional<z.ZodBoolean>;
    scaleBar: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    showLegend?: boolean | undefined;
    cooperativeGestures?: boolean | undefined;
    fullScreenButton?: boolean | undefined;
    geolocation?: boolean | undefined;
    zoomControls?: boolean | undefined;
    scaleBar?: boolean | undefined;
}, {
    showLegend?: boolean | undefined;
    cooperativeGestures?: boolean | undefined;
    fullScreenButton?: boolean | undefined;
    geolocation?: boolean | undefined;
    zoomControls?: boolean | undefined;
    scaleBar?: boolean | undefined;
}>;

// @internal (undocumented)
const UiOnMapInteractionsOptionsSchema: z.ZodObject<{
    featureSelectPanel: z.ZodOptional<z.ZodBoolean>;
    featureHoverPanel: z.ZodOptional<z.ZodBoolean>;
    elementSelectPanel: z.ZodOptional<z.ZodBoolean>;
    linkClickOpen: z.ZodOptional<z.ZodBoolean>;
    imageLightboxOpen: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    featureSelectPanel?: boolean | undefined;
    featureHoverPanel?: boolean | undefined;
    elementSelectPanel?: boolean | undefined;
    linkClickOpen?: boolean | undefined;
    imageLightboxOpen?: boolean | undefined;
}, {
    featureSelectPanel?: boolean | undefined;
    featureHoverPanel?: boolean | undefined;
    elementSelectPanel?: boolean | undefined;
    linkClickOpen?: boolean | undefined;
    imageLightboxOpen?: boolean | undefined;
}>;

export { ValueConfiguration }

export { ViewportCenterZoom }

export { ViewportConstraints }

// @public
export interface ViewportController {
    fitViewportToBounds(bounds: ViewportFitBoundsParams): void;
    getViewport(): Promise<ViewportState>;
    getViewportConstraints(): Promise<ViewportConstraints | null>;
    onMapIdle(args: {
        handler: () => void;
    }): VoidFunction;
    onViewportMove(args: {
        handler: (viewport: ViewportState) => void;
    }): VoidFunction;
    onViewportMoveEnd(args: {
        handler: (viewport: ViewportState) => void;
    }): VoidFunction;
    setViewport(viewport: SetViewportCenterZoomParams): void;
    setViewportConstraints(constraints: Partial<ViewportConstraints> | null): void;
}

export { ViewportFitBoundsParams }

export { ViewportState }

// (No @packageDocumentation comment for this package)