Browser SDK API reference

export interface MapAppEvent {
    name: string;
    data: unknown;
}

export interface MapViewOptions {
    wasmUrl?: string | URL;
    interactive?: boolean;
    contextMenu?: false | ((event: MapContextMenuEvent, defaults: ContextMenuItem[]) => ContextMenuItem[]);
    apiToken?: string | (() => string | undefined);
    transformRequest?: RequestTransform;
    resourceTimeoutMs?: number;
    resourcePolicy?: ResourcePolicy;
    reducedMotion?: boolean;
    materialFadeDuration?: number;
    fadeDuration?: number;
    worker?: boolean;
    locale?: LocalePreference;
    createWorker?: () => Worker;
    bindings?: () => Promise<WasmBindings>;
}

export interface MapViewDefaults {
    createWorker?: () => Worker;
    bindings?: () => Promise<WasmBindings>;
}

export interface GeoJSONOptions {
    crs?: string | number;
}

export type Projection = "geographic" | "mercator" | "globe" | "auto";

export interface MapErrorEvent {
    message: string;
}

export type ContextMenuItem = {
    label: string;
    action: () => void;
    disabled?: boolean;
} | "separator";

export interface MapContextMenuEvent {
    x: number;
    y: number;
    lngLat: [number, number];
}

export interface RasterTileOptions {
    attribution?: string;
    name?: string;
    scheme?: "geographic" | "mercator";
    kind?: "image" | "terrain-rgb";
    tileSize?: number;
    exaggeration?: number;
    subdomains?: string[];
    minZoom?: number;
    maxZoom?: number;
    zoomOffset?: number;
    opacity?: number;
}

export interface LayerInfo {
    kind: "vector" | "raster";
    id: number;
    name: string;
    visible: boolean;
}

export interface LayerStyle {
    fill?: string;
    line?: string;
    lineWidth?: number;
    pointSize?: number;
    opacity?: number;
}

export interface MapViewTarget {
    center: [number, number];
    zoom: number;
}

export interface MapViewState {
    projection?: Projection;
    zoom?: number;
    pitch?: number;
    bounds?: readonly [number, number, number, number];
    center: [number, number];
    bearing: number;
    metersPerPixel: number;
}

export interface MapClickEvent extends MapPointerEvent {
    readonly x: number;
    readonly y: number;
    readonly legacyLngLat: readonly [number, number] | null;
    readonly feature: PickResult | null;
}

export interface MapMoveEvent {
    readonly cameraState: MapCameraState;
    readonly animation?: CameraAnimationTag;
    readonly error?: {
        code: string;
        message: string;
    };
}

export type MapCameraEvent = MapMoveEvent;

export interface MapViewEventMap {
    'styledata': StyleDataEvent;
    'style.load': StyleDataEvent;
    load: MapLifecycleEvent;
    render: MapLifecycleEvent;
    idle: MapLifecycleEvent;
    remove: MapLifecycleEvent;
    'sqs.scenechange': SceneChangeEvent;
    'sqs.lightingchange': LightingChangeEvent;
    'sqs.playbackchange': PlaybackChangeEvent;
    movestart: MapCameraEvent;
    moveend: MapCameraEvent;
    zoomstart: MapCameraEvent;
    zoom: MapCameraEvent;
    zoomend: MapCameraEvent;
    rotatestart: MapCameraEvent;
    rotate: MapCameraEvent;
    rotateend: MapCameraEvent;
    pitchstart: MapCameraEvent;
    pitch: MapCameraEvent;
    pitchend: MapCameraEvent;
    rollstart: MapCameraEvent;
    roll: MapCameraEvent;
    rollend: MapCameraEvent;
    move: MapMoveEvent;
    "sqs.sourceschange": SourceChangeEvent;
    sources: SourceChangeEvent;
    "sqs.imageschange": ImagesChangeEvent;
    "sqs.resourceschange": ResourcePolicyChangeEvent;
    "styleimagemissing": MapStyleImageMissingEvent;
    "sqs.gestureschange": GestureChangeEvent;
    "sqs.attributionschange": AttributionChangeEvent;
    terrain: TerrainEvent;
    sourcedataloading: SourceLifecycleEvent;
    sourcedata: SourceLifecycleEvent;
    sourcedataabort: SourceLifecycleEvent;
    "sqs.layerschange": StyleLayersChangeEvent;
    styleLayers: StyleLayersChangeEvent;
    click: MapClickEvent;
    dblclick: MapPointerEvent;
    mousedown: MapPointerEvent;
    mouseup: MapPointerEvent;
    mousemove: MapPointerEvent;
    mouseenter: MapPointerEvent;
    mouseleave: MapPointerEvent;
    contextmenu: MapPointerEvent;
    view: MapViewState;
    layers: LayerInfo[];
    error: AttributionErrorEvent | MapErrorEvent | (SourceLifecycleEvent & {
        readonly message: string;
    });
    locale: Locale;
    app: MapAppEvent;
}

export interface Backend {
    readonly backend: string;
    readonly capabilities: Record<string, unknown>;
    call(method: string, ...args: unknown[]): void;
    confirmCall<T = void>(method: string, ...args: unknown[]): Promise<T>;
    request<T>(method: string, ...args: unknown[]): Promise<T>;
    flush(options?: FlushOptions): Promise<CommandReceipt>;
    appCall(method: string, args: unknown[], transfer?: Transferable[]): void;
    appRequest<T>(method: string, args: unknown[], transfer?: Transferable[]): Promise<T>;
    destroy(): void;
}

export interface DynamicImageHost {
    dispatch(batch: DynamicImageBatch): DynamicImageDispatch | Promise<DynamicImageDispatch>;
    reconcile(state: DynamicImageState): void;
    contextLost(): void;
    clear(): void;
}

export interface DynamicImageHostScope {
    call(method: string, args: unknown[]): Promise<unknown>;
    close(): void;
}

readonly editing: EditingAPI;

readonly lighting: LightingAPI;

readonly sqs: Readonly<{
        images: Readonly<{
            createCallbackScope: (host: DynamicImageHost) => DynamicImageHostScope;
        }>;
        getMaterialFadeDuration: () => Promise<number>;
        setMaterialFadeDuration: (ms: number) => void;
        getLabelFadeDuration: () => Promise<number>;
        setLabelFadeDuration: (ms: number) => void;
        animations: AnimationsAPI;
        playbacks: PlaybacksAPI;
        scenes: ScenesAPI;
        resources: ResourcesAPI;
        getCapabilities: () => Promise<Readonly<Record<string, unknown>>>;
    }>;

readonly dragPan: GestureHandler;

readonly scrollZoom: GestureHandler;

readonly doubleClickZoom: GestureHandler;

readonly keyboard: KeyboardHandler;

readonly touchZoomRotate: TouchZoomRotateHandler;

readonly touchPitch: GestureHandler;

gesturesState(): Promise<GesturePolicy>;

readonly mapInstanceId: `${string}-${string}-${string}-${string}-${string}`;

readonly canvas: HTMLCanvasElement;

readonly offscreen: boolean;

static create(target: HTMLElement, options?: MapViewOptions): Promise<MapView>;

get locale(): Locale;

setLocale(locale: LocalePreference): void;

get text(): Messages;

get backend(): string;

get capabilities(): Record<string, unknown>;

addGeoJSON(name: string, data: string | object, options?: GeoJSONOptions): number;

loadImage(url: string, options?: MapImageLoadOptions): Promise<MapImageLoadResult>;

addImage(id: string, image: MapImageData | StyleImageInterface, options?: MapImageOptions): this;

updateImage(id: string, image: MapImageData): this;

removeImage(id: string): this;

triggerRepaint(): void;

hasImage(id: string): Promise<boolean>;

getGlyphs(): Promise<string | undefined>;

setGlyphs(url: string | null | undefined, options?: {
        validate?: true;
    }): this;

listImages(): Promise<readonly string[]>;

getImage(id: string): Promise<MapImageSnapshot | undefined>;

getImageInfo(id: string): Promise<MapImageInfo | undefined>;

onImagesChange(handler: (event: ImagesChangeEvent) => void): () => void;

addLayer(specification: GeoJSONLayerSpecification, beforeId?: string): this;

getLayer(id: string): Promise<GeoJSONLayerSpecification | undefined>;

queryRenderedFeatures(geometryOrOptions?: QueryPixel | [QueryPixel, QueryPixel] | QueryRenderedFeatureOptions, options?: QueryRenderedFeatureOptions): Promise<QueriedRenderedFeature[]>;

getStyleLayers(): Promise<readonly GeoJSONLayerInfo[]>;

setLayerMetadata(id: string, metadata: Record<string, unknown> | null): this;

getLayerMetadata(id: string): Promise<Record<string, unknown>>;

setPaintProperty(id: string, name: string, value: unknown, options?: {
        validate?: true;
    }): this;

getPaintProperty(id: string, name: string): Promise<unknown>;

setLayoutProperty(id: string, name: string, value: unknown, options?: {
        validate?: true;
    }): this;

getLayoutProperty(id: string, name: string): Promise<unknown>;

setFilter(id: string, filter: unknown[] | null, options?: {
        validate?: true;
    }): this;

getFilter(id: string): Promise<unknown[] | null>;

setLayerZoomRange(id: string, minzoom: number, maxzoom: number): this;

addSource(id: string, options: SourceOptions): this;

removeSource(id: string): this;

isSourceLoaded(id: string): Promise<boolean>;

setFeatureState(target: FeatureStateTarget | QueriedSourceFeature, state: FeatureState): this;

getFeatureState(target: FeatureStateTarget | QueriedSourceFeature): Promise<FeatureState>;

removeFeatureState(target: FeatureStateRemovalTarget, key?: string): this;

getGlobalState(): Promise<Readonly<Record<string, unknown>>>;

setGlobalStateProperty(name: string, value: unknown): this;

querySourceFeatures(id: string, options?: QuerySourceFeatureOptions): Promise<QueriedSourceFeature[]>;

getSourceInfo(id: string): Promise<SourceInfo | undefined>;

setTerrain(options: TerrainSpecification | null): this;

getTerrain(): Promise<Readonly<TerrainSpecification> | null>;

queryTerrainElevation(point: readonly [number, number] | {
        lng: number;
        lat: number;
    } | {
        lon: number;
        lat: number;
    }): Promise<number | null>;

getSource(id: string): Promise<MapSource | undefined>;

addRasterTiles(template: string, options?: RasterTileOptions): number;

removeRasterTiles(id: number): boolean;

setRasterTilesVisible(id: number, visible: boolean): boolean;

setRasterTilesOpacity(id: number, opacity: number): void;

getStyle(): Promise<import("./styles.js").StyleSpecification>;

setStyle(style: string | null | import("./styles.js").StyleSpecification, options?: StyleOptions): this;

setStyleBasemap(url: string): void;

clearStyleBasemap(): void;

setProjection(projection: Projection | ProjectionSpecification): this;

get projection(): Projection;

setGlobeView(center: [number, number], zoom?: number): void;

setModel(data: Uint8Array, placement: ModelPlacement): Promise<void>;

setModelPlacement(placement: ModelPlacement): Promise<void>;

clearModel(): Promise<void>;

getModelState(): Promise<ModelState | null>;

get basemapMessage(): string;

get basemapStatus(): BasemapStatus;

removeLayer(id: string): this;

removeLayer(id: number): boolean;

setLayerVisible(id: number, visible: boolean): boolean;

setLayerStyle(id: number, style: LayerStyle): void;

setLayerOpacity(id: number, opacity: number): void;

moveLayer(id: string, beforeId?: string): this;

moveLayer(id: number, index: number): boolean;

renameLayer(id: number, name: string): boolean;

focusLayer(id: number): void;

selectFeature(id: number, index: number): Promise<PickResult | null>;

focusFeature(id: number, index: number): void;

setView(center: [number, number], zoom: number): void;

getAttributions(): Promise<AttributionSnapshot>;

getCenter(): Promise<{
        lng: number;
        lat: number;
    }>;

getZoom(): Promise<number>;

getBearing(): Promise<number>;

getPitch(): Promise<number>;

getRoll(): Promise<number>;

getPadding(): Promise<CameraPadding>;

getBounds(): Promise<[[number, number], [number, number]]>;

getLight(): Promise<ResolvedLightSpecification | null>;

setLight(light: LightSpecification, options?: LightSetterOptions): this;

getProjection(): Promise<ProjectionSpecification>;

project(position: LngLatLike): Promise<{
        x: number;
        y: number;
    }>;

unproject(point: PointLike): Promise<{
        lng: number;
        lat: number;
    }>;

cameraForBounds(bounds: LngLatBoundsLike, options?: CameraFitOptions): Promise<PlanarCameraPose>;

getMinZoom(): Promise<number>;

getMaxZoom(): Promise<number>;

scaleAt(options?: ScaleAtOptions): Promise<ScaleAtResult>;

viewModeState(): Promise<Readonly<{
        mode: '2d' | '3d';
        projection: 'mercator' | 'geographic' | 'globe';
        pitch: number;
        terrain: boolean;
        default3dPitch: 45;
        maximumPitch: 65;
        switchMethod: 'setPitch';
        canSwitchTo3d: boolean;
        canSwitchTo2d: boolean;
        restorePolicy: 'explicit-target-pitch';
    }>>;

cameraState(): Promise<MapCameraState>;

easeTo(options: EaseToOptions): this;

flyTo(options: FlyToOptions): this;

stop(): this;

isEasing(): Promise<boolean>;

isMoving(): Promise<boolean>;

isZooming(): Promise<boolean>;

isRotating(): Promise<boolean>;

animationState(): Promise<CameraAnimationState>;

setReducedMotion(value: boolean): this;

jumpTo(options: CameraOptions): this;

fitBounds(bounds: LngLatBoundsLike, options?: CameraFitOptions): this;

setCenter(center: LngLatLike): this;

setZoom(zoom: number): this;

setPitch(pitch: number): this;

setPadding(padding: number | Partial<CameraPadding>): this;

setRoll(roll: number): this;

zoomTo(zoom: number, options?: ImmediateNavigationOptions): this;

rotateTo(bearing: number, options?: ImmediateNavigationOptions): this;

panTo(center: LngLatLike, options?: ImmediatePanOptions): this;

panBy(offset: PointLike, options?: ImmediatePanByOptions): this;

resetNorth(options?: ImmediateNavigationOptions): this;

resetNorthPitch(options?: ImmediateNavigationOptions): this;

getView(): Promise<MapViewTarget>;

setApiToken(token: MapViewOptions["apiToken"]): void;

layers(): LayerInfo[];

setVisible(layer: Pick<LayerInfo, "kind" | "id">, visible: boolean): boolean;

zoomIn(options?: ImmediateNavigationOptions): this;

zoomOut(options?: ImmediateNavigationOptions): this;

get bearing(): number;

viewState(): MapViewState;

fit(): void;

setBearing(degrees: number): this;

pan(dx: number, dy: number): void;

zoomAt(factor: number, x: number, y: number): void;

pick(x: number, y: number): Promise<PickResult | null>;

screenToLngLat(x: number, y: number): [number, number];

clearSelection(): void;

onCameraMove(handler: (event: MapMoveEvent) => void): () => void;

onCameraLifecycle(handler: (type: CameraEventType | 'error', event: MapCameraEvent) => void): () => void;

onStyleLayersChange(handler: (event: StyleLayersChangeEvent) => void): () => void;

onSourceLifecycle(handler: (type: SourceLifecycleType, event: SourceLifecycleEvent) => void): () => void;

onGesturesChange(handler: (event: GestureChangeEvent) => void): () => void;

onAttributionsChange(handler: (event: AttributionChangeEvent) => void): () => void;

onSourcesChange(handler: (event: SourceChangeEvent) => void): () => void;

listens(type: string): boolean;

on<K extends keyof MapViewEventMap>(type: K, handler: (event: MapViewEventMap[K]) => void): MapEventSubscription;

on(type: PointerEventType, layers: MapLayerSelector, handler: (event: MapPointerEvent) => void): MapEventSubscription;

on(type: string, handler: (event: EventedEvent) => unknown): MapEventSubscription;

off<K extends keyof MapViewEventMap>(type: K, handler: (event: MapViewEventMap[K]) => void): this;

off(type: PointerEventType, layers: MapLayerSelector, handler: (event: MapPointerEvent) => void): this;

off(type: string, handler: (event: EventedEvent) => unknown): this;

once<K extends keyof MapViewEventMap>(type: K): Promise<MapViewEventMap[K]>;

once<K extends keyof MapViewEventMap>(type: K, handler: (event: MapViewEventMap[K]) => void): this;

once(type: PointerEventType, layers: MapLayerSelector): Promise<MapPointerEvent>;

once(type: PointerEventType, layers: MapLayerSelector, handler: (event: MapPointerEvent) => void): this;

once(type: string): Promise<EventedEvent>;

once(type: string, handler: (event: EventedEvent) => unknown): this;

fire(event: {
        readonly type: string;
        readonly [key: string]: unknown;
    }): this;

fire(type: string, data?: Record<string, unknown>): this;

setEventedParent(parent?: EventedParent | null, data?: EventedParentData): this;

onPointerEvents(handler: (type: PointerEventType, event: MapPointerEvent) => void): () => void;

dispatchPointerEvent(input: PointerInput): Promise<MapPointerEvent>;

lifecycleState(): Promise<LifecycleState>;

loaded(): Promise<boolean>;

flush(options?: FlushOptions): Promise<MapCommitResult>;

requestRender(): void;

appCall(method: string, args?: unknown[], transfer?: Transferable[]): void;

appRequest<T = unknown>(method: string, args?: unknown[], transfer?: Transferable[]): Promise<T>;

destroy(): void;

static create(target: HTMLElement, options?: MapViewOptions): Promise<MapView>;

export interface CommandReceipt {
    submittedSequence: number;
    appliedSequence: number;
    stage: 'applied' | 'rendered';
    camera: CameraSnapshot;
    frameSequence?: number;
}

export interface MapCommitResult extends CommandReceipt {
    mapInstanceId: string;
}

export interface FlushOptions {
    render?: boolean;
    since?: number;
}

constructor(invoke: (method: string, args: unknown[]) => unknown, camera: () => CameraSnapshot, render: () => Promise<FrameReport>);

call(method: string, args: unknown[]): unknown;

confirmCall<T = void>(method: string, args: unknown[]): Promise<T>;

flush(options?: FlushOptions): Promise<CommandReceipt>;

export declare function commandError(code: string, message: string): Error & {
    code: string;
};

export type LngLatLike = [number, number] | {
    lng: number;
    lat: number;
};

export type PointLike = [number, number] | {
    x: number;
    y: number;
};

export type LngLatBoundsLike = [number, number, number, number] | [LngLatLike, LngLatLike];

export interface CameraPadding {
    top: number;
    right: number;
    bottom: number;
    left: number;
}

export interface CameraOptions {
    center?: LngLatLike;
    zoom?: number;
    bearing?: number;
    pitch?: number;
    roll?: number;
    padding?: number | Partial<CameraPadding>;
}

export interface CameraFitOptions {
    padding?: number | Partial<CameraPadding>;
    offset?: PointLike;
    bearing?: number;
    minZoom?: number;
    maxZoom?: number;
    animate?: boolean;
    duration?: number;
    linear?: boolean;
    easing?: (t: number) => number;
    essential?: boolean;
}

export interface PlanarCameraPose {
    center: [number, number];
    zoom: number;
    bearing: number;
    pitch: number;
    roll: 0;
    padding: CameraPadding;
}

export interface PlanarCameraState {
    camera: PlanarCameraPose;
    projection: 'geographic' | 'mercator';
    viewport: {
        width: number;
        height: number;
        pixelRatio: number;
    };
}

export interface ProjectionSpecification {
    type: 'geographic' | 'mercator' | 'globe';
}

export interface GlobeCameraPose {
    center: [number, number];
    zoom: number;
    bearing: number;
    pitch: number;
    roll: number;
    padding: CameraPadding;
}

export interface GlobeCameraState {
    camera: GlobeCameraPose;
    projection: 'globe';
    viewport: {
        width: number;
        height: number;
        pixelRatio: number;
    };
}

export type MapCameraState = PlanarCameraState | GlobeCameraState;

export interface ScaleAtOptions {
    point?: PointLike;
    maxWidth?: number;
}

export interface ScaleAtResult {
    point: {
        x: number;
        y: number;
    };
    position: {
        lng: number;
        lat: number;
    };
    projection: 'geographic' | 'mercator' | 'globe';
    metersPerPixel: number;
    distance: number;
    width: number;
    maxWidth: number;
    unit: 'm';
    pixelUnit: 'css';
    model: 'sphere-local';
    earthRadius: 6371008.8;
    approximate: true;
}

export interface AnimationOptions {
    duration?: number;
    animate?: boolean;
    linear?: boolean;
    easing?: (t: number) => number;
    essential?: boolean;
}

export interface EaseToOptions extends CameraOptions, AnimationOptions {
    around?: LngLatLike;
    offset?: PointLike;
    sqsShortestWorldCopy?: boolean;
}

export interface FlyToOptions extends CameraOptions, AnimationOptions {
    offset?: PointLike;
    curve?: number;
    speed?: number;
    screenSpeed?: number;
    minZoom?: number;
    maxDuration?: number;
    sqsShortestWorldCopy?: boolean;
}

export interface CameraAnimationTag {
    readonly id: string;
    readonly status: 'running' | 'completed' | 'cancelled' | 'failed';
    readonly reason: string | null;
}

export interface CameraAnimationState {
    readonly active: boolean;
    readonly animation: CameraAnimationTag | null;
    readonly reducedMotion: boolean;
    readonly elapsed?: number;
    readonly duration?: number;
    readonly target?: PlanarCameraPose | GlobeCameraPose;
}

export interface ImmediateNavigationOptions {
    around?: LngLatLike;
    offset?: PointLike;
    animate?: boolean;
    duration?: number;
    linear?: boolean;
    easing?: (t: number) => number;
    essential?: boolean;
}

export interface ImmediatePanOptions {
    offset?: PointLike;
    animate?: boolean;
    duration?: number;
    linear?: boolean;
    easing?: (t: number) => number;
    essential?: boolean;
}

export interface ImmediatePanByOptions {
    animate?: boolean;
    duration?: number;
    linear?: boolean;
    easing?: (t: number) => number;
    essential?: boolean;
}

export declare enum ResourceType {
    Style = "Style",
    Source = "Source",
    Tile = "Tile",
    Glyphs = "Glyphs",
    SpriteJSON = "SpriteJSON",
    SpriteImage = "SpriteImage",
    Image = "Image",
    Unknown = "Unknown"
}

export interface RequestParameters extends RequestInit {
    url?: string;
    type?: 'string' | 'json' | 'arrayBuffer' | 'image';
    collectResourceTiming?: boolean;
}

export type RequestTransform = (url: string, resourceType: ResourceType) => RequestParameters | undefined;

export type AddProtocolResponseData = ArrayBuffer | Uint8Array | string;

export interface GetResourceResponse<T> {
    data: T;
}

export type AddProtocolAction = (requestParameters: Readonly<RequestParameters & {
    url: string;
    resourceType: ResourceType;
    maxBytes: number;
}>, abortController: AbortController) => Promise<GetResourceResponse<AddProtocolResponseData>>;

export declare function addProtocol(customProtocol: string, loadFn: AddProtocolAction): void;

export declare function removeProtocol(customProtocol: string): void;

export interface ResourceFallback {
    prefix: string;
    replacements: string[];
    resourceTypes?: ResourceType[];
    attemptTimeoutMs?: number;
    forwardQuery?: boolean;
}

export interface ResourcePolicy {
    maxConcurrentRequests?: number;
    attemptTimeoutMs?: number;
    retries?: number;
    retryDelayMs?: number;
    cache?: RequestCache;
    fallbacks?: ResourceFallback[];
}

export interface ResourceConfiguration {
    resourceTimeoutMs?: number;
    resourcePolicy?: ResourcePolicy;
}

export interface ResourceQuery {
    url: string;
    resourceType: ResourceType;
    maxBytes: number;
    method?: string;
    forceNoStore?: boolean;
}

export interface ResourcePlan {
    readonly version: 1;
    readonly urls: readonly string[];
    readonly method: string;
    readonly resourceType: ResourceType;
    readonly maxBytes: number;
    readonly maxConcurrentRequests: number;
    readonly resourceTimeoutMs: number;
    readonly attemptTimeoutMs: number;
    readonly retries: number;
    readonly retryDelayMs: number;
    readonly cache?: RequestCache;
    readonly retryOn: Readonly<{
        network: boolean;
        attemptTimeout: boolean;
        httpStatuses: readonly number[];
        serverErrors: boolean;
    }>;
}

export interface ResourcesAPI {
    createProtocolScope(): ResourceProtocolScope;
    configure(configuration: ResourceConfiguration): Promise<Readonly<Required<ResourceConfiguration>>>;
    getConfiguration(): Promise<Readonly<Required<ResourceConfiguration>>>;
    plan(query: ResourceQuery): Promise<ResourcePlan>;
}

export interface ResourcePolicyChangeEvent {
    readonly type: 'sqs.resourceschange';
    readonly context: 'resourcePolicy';
    readonly resourceConfiguration: Readonly<Required<ResourceConfiguration>>;
}

export interface StyleSpecification {
    version: 8;
    state?: Record<string, {
        default: unknown;
    }>;
    sources: Record<string, unknown>;
    layers: readonly unknown[];
    name?: string;
    metadata?: Record<string, unknown>;
    glyphs?: string;
    sprite?: string | readonly {
        id: string;
        url: string;
    }[];
}

export interface StyleOptions {
    diff?: boolean;
}

export declare function styleUrl(style: unknown, options?: unknown): string | null | StyleSpecification;

export interface StyleLifecycleState {
    generation: number;
    revision: number;
    loaded: boolean;
}

export interface StyleDataEvent {
    type: 'styledata' | 'style.load';
    dataType: 'style';
    styleState: StyleLifecycleState;
}

export declare function immutableStyleEvent(value: StyleDataEvent): StyleDataEvent;

export declare function captureMaterialFadeDuration(ms: unknown): number;

export declare function captureLabelFadeDuration(ms: unknown): number;

export type FeatureId = string | number;

export type Position = [number, number] | [number, number, number];

export type GeoJSONGeometry = {
    type: 'Point';
    coordinates: Position;
} | {
    type: 'MultiPoint' | 'LineString';
    coordinates: Position[];
} | {
    type: 'MultiLineString' | 'Polygon';
    coordinates: Position[][];
} | {
    type: 'MultiPolygon';
    coordinates: Position[][][];
} | {
    type: 'GeometryCollection';
    geometries: GeoJSONGeometry[];
};

export interface GeoJSONFeature {
    type: 'Feature';
    id?: FeatureId;
    properties: Record<string, unknown> | null;
    geometry: GeoJSONGeometry | null;
    [member: string]: unknown;
}

export interface GeoJSONFeatureCollection {
    type: 'FeatureCollection';
    features: GeoJSONFeature[];
    [member: string]: unknown;
}

export type GeoJSON = GeoJSONGeometry | GeoJSONFeature | GeoJSONFeatureCollection;

export type ClusterPropertySpecification = ['+' | '-' | '*' | '/' | 'min' | 'max' | 'all' | 'any' | 'concat' | unknown[], unknown[] | number | boolean | string];

export interface GetClusterOptions {
    cluster: boolean;
    clusterRadius: number;
    clusterMaxZoom: number;
}

export interface SetClusterOptions {
    cluster?: boolean;
    clusterRadius?: number;
    clusterMaxZoom?: number;
}

export interface LiveSourceOptions {
    fields: Record<string, 'string' | 'number' | 'boolean'>;
    allowDelta?: boolean;
}

export interface LivePoint {
    id: string;
    coordinate: [number, number];
    properties: Record<string, string | number | boolean | null>;
}

export type LiveUpdate = {
    kind: 'snapshot';
    epoch: string;
    sequence: string;
    points: LivePoint[];
} | {
    kind: 'delta';
    epoch: string;
    baseSequence: string;
    sequence: string;
    upserts: LivePoint[];
    deletes: string[];
};

export interface LiveSourceState {
    initialized: boolean;
    epoch: string | null;
    sequence: string | null;
    protocolRevision: string;
    pointCount: number;
    allowDelta: boolean;
    fields: Record<string, 'string' | 'number' | 'boolean'>;
}

export interface LiveUpdateResult {
    applied: boolean;
    state: LiveSourceState;
    dataRevision: string;
}

export interface LiveSourceSnapshot {
    source: SourceIdentity;
    state: LiveSourceState;
    data: GeoJSONFeatureCollection;
}

export interface LiveReceiverOptions {
    owner?: SceneIdentity;
    protocol?: 'gis-live-v1';
    transport: {
        type: 'http-poll';
        url: string;
        intervalMs?: number;
    } | {
        type: 'websocket';
        url: string;
        reconnectDelayMs?: number;
    };
}

export interface LiveReceiverIdentity extends SourceIdentity {
    receiverInstanceId: string;
}

export interface LiveReceiverState {
    owner?: SceneIdentity;
    ownerState?: SceneStatus;
    source: SourceIdentity;
    receiverInstanceId: string;
    transport: 'http-poll' | 'websocket';
    connection?: 'connecting' | 'open' | 'retrying' | 'paused' | 'stopped';
    status: 'running' | 'paused' | 'stopped';
    loading: boolean;
    intervalMs: number;
    lastError: SourceLoadError | null;
    dataRevision: string;
}

export interface LiveReceiver extends Readonly<LiveReceiverIdentity> {
    getState(): Promise<LiveReceiverState>;
    pause(): Promise<void>;
    resume(): Promise<void>;
    stop(): Promise<void>;
}

export interface LiveSourceAPI {
    connectLive(options: LiveReceiverOptions): Promise<LiveReceiver>;
    getLiveReceiver(): Promise<LiveReceiver | undefined>;
    applyLiveUpdate(frame: LiveUpdate): Promise<LiveUpdateResult>;
    getLiveState(): Promise<LiveSourceState>;
    freezeLiveSnapshot(): Promise<LiveSourceSnapshot>;
}

export interface GeoJSONSourceOptions {
    sqsLive?: LiveSourceOptions;
    type: 'geojson';
    lineMetrics?: boolean;
    data: GeoJSON | string;
    attribution?: string;
    promoteId?: string;
    generateId?: boolean;
    cluster?: boolean;
    clusterRadius?: number;
    clusterMaxZoom?: number;
    clusterMinPoints?: number;
    clusterProperties?: Record<string, ClusterPropertySpecification>;
}

export interface GeoJSONFeatureDiff {
    id: FeatureId;
    newGeometry?: GeoJSONGeometry | null;
    removeAllProperties?: boolean;
    removeProperties?: string[];
    addOrUpdateProperties?: {
        key: string;
        value: unknown;
    }[];
}

export interface GeoJSONSourceDiff {
    removeAll?: boolean;
    remove?: FeatureId[];
    add?: GeoJSONFeature[];
    update?: GeoJSONFeatureDiff[];
}