// Standalone native script/session ABI v1 subset; do not replace application/web declarations with this file.
declare module 'sqsmap' {
export interface CustomEvent { readonly type:string; readonly target:Evented|NativeMap; [key:string]:unknown }
export type EventedParentData=Record<string,unknown>|(()=>Record<string,unknown>);
/** Bounded local Evented, released when the script session stops. */
export class Evented {
 constructor();
 on(type:string,listener:(event:CustomEvent)=>unknown):NativeSubscription;
 off(type:string,listener:(event:CustomEvent)=>unknown):this;
 once(type:string,listener:(event:CustomEvent)=>unknown):this;
 once(type:string):Promise<CustomEvent>;
 listens(type:string):boolean;
 fire(type:string,data?:Record<string,unknown>):this;
 fire(event:{type:string;[key:string]:unknown}):this;
 setEventedParent(parent?:Evented|NativeMap|null,data?:EventedParentData):this;
 /** Project extension: reject waits and detach parents and children. */
 destroy():void;
}

/** Native retained-session only: host-pumped callbacks, not browser/global registrations. */
export interface NativeProtocolRequest {readonly url:string;readonly resourceType:ResourceType;readonly maxBytes:number;readonly method:string}
export interface NativeProtocolSignal {readonly aborted:boolean;readonly reason:unknown;throwIfAborted():void;addEventListener(type:'abort',listener:(event:{readonly type:'abort';readonly target:NativeProtocolSignal})=>void):void;removeEventListener(type:'abort',listener:Function):void}
export interface NativeProtocolController {readonly signal:NativeProtocolSignal;abort(reason?:unknown):void}
export function addProtocol(scheme:string,handler:(request:NativeProtocolRequest,controller:NativeProtocolController)=>{data:ArrayBuffer|Uint8Array}|Promise<{data:ArrayBuffer|Uint8Array}>):void;
export function removeProtocol(scheme:string):void;
export interface TerrainSpecification {source:string;exaggeration?:number}

export interface LightTransition {duration?:number;delay?:number}
export interface LightSpecification {anchor?:'map'|'viewport';position?:readonly [number,number,number];color?:string;intensity?:number;'position-transition'?:LightTransition;'color-transition'?:LightTransition;'intensity-transition'?:LightTransition}
export interface ResolvedLightSpecification {readonly anchor:'map'|'viewport';readonly position:readonly [number,number,number];readonly color:string;readonly intensity:number}
export interface LightSetterOptions {validate?:boolean}
export interface SceneLightingSettings {readonly mode:'default'|'fixed'|'sun';readonly azimuth:number;readonly elevation:number;readonly strength:number;readonly ambient:number;readonly sunTime:'now'|number;readonly utcOffsetMinutes:number;readonly mapLight:ResolvedLightSpecification|null}
export interface SceneLightingState {readonly active:'globe'|'building'|null;readonly globe:SceneLightingSettings;readonly building:SceneLightingSettings}
export interface SceneLightingOptions {view?:'globe'|'building';reset?:boolean;mode?:'default'|'fixed'|'sun';azimuth?:number;elevation?:number;strength?:number;ambient?:number;sunTime?:'now'|number;utcOffsetMinutes?:number}
 export interface MapImageLoadResult {readonly data:{readonly width:number;readonly height:number;readonly data:Uint8Array}}
 export interface MapImageData {width:number;height:number;data:Uint8Array|Uint8ClampedArray|readonly number[]}
 /** Synchronous CPU RGBA callbacks; available in retained native script sessions only. */
 export interface StyleImageInterface extends MapImageData {
   onAdd?(map:NativeMap,id:string):void;
   render?():boolean|void;
   onRemove?():void;
 }

 export type MapImageTextFit = 'stretchOrShrink'|'stretchOnly'|'proportional';
 export interface MapImageStretchMetadata {readonly stretchX?:readonly (readonly [number,number])[];readonly stretchY?:readonly (readonly [number,number])[];readonly content?:readonly [number,number,number,number];readonly textFitWidth?:MapImageTextFit;readonly textFitHeight?:MapImageTextFit}
 export interface MapImageOptions extends MapImageStretchMetadata {pixelRatio?:number;sdf?:boolean}
 export interface MapImageSnapshot extends MapImageStretchMetadata {readonly data:{readonly width:number;readonly height:number;readonly data:Uint8Array};readonly pixelRatio:number;readonly sdf:boolean}
 export type ResourceType='Style'|'Source'|'Tile'|'Glyphs'|'SpriteJSON'|'SpriteImage'|'Image'|'Unknown';
 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?:'default'|'no-store'|'reload'|'no-cache'|'force-cache';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?:ResourcePolicy['cache'];readonly retryOn:Readonly<{network:boolean;attemptTimeout:boolean;httpStatuses:readonly number[];serverErrors:boolean}>}
 export interface ResourcesAPI {configure(configuration:ResourceConfiguration):Promise<Readonly<Required<ResourceConfiguration>>>;getConfiguration():Promise<Readonly<Required<ResourceConfiguration>>>;plan(query:ResourceQuery):Promise<ResourcePlan>}
 export interface MapImageInfo extends MapImageStretchMetadata {readonly id:string;readonly source:'runtime'|'sprite';readonly imageInstanceId:string;readonly revision:string;readonly width:number;readonly height:number;readonly byteLength:number;readonly pixelRatio:number;readonly sdf:boolean}

 export interface FeatureStateTarget {source:string;id:string|number;sourceLayer?:string;sqs?:{sourceInstanceId?:string;dataRevision?:string};[member:string]:unknown}
  export interface AttributionItem {readonly scope:'style'|'common'|'host';readonly kind:'style'|'vector'|'geojson'|'raster'|'terrain-rgb'|'raster-dem';readonly sourceId:string|null;readonly sourceInstanceId:string|null;readonly layerIds:readonly string[];readonly text:string;}
  export interface AttributionSnapshot {readonly text:string;readonly items:readonly AttributionItem[];}
  export interface GeoJSONLayerSpecification {
    id:string; type:'circle'|'line'|'fill'|'fill-extrusion'|'hillshade'|'color-relief'|'raster'|'heatmap'|'background'|'symbol'; 'source-layer'?:string; source?:string|CommonSourceOptions;
    minzoom?:number; maxzoom?:number; paint?:Record<string,unknown>;
    layout?:{visibility?:'visible'|'none';'icon-image'?:string|unknown[];'icon-size'?:number|unknown[];'icon-rotate'?:number|unknown[];'icon-offset'?:[number,number]|unknown[];'icon-anchor'?:'center'|'top'|'bottom'|'left'|'right'|'top-left'|'top-right'|'bottom-left'|'bottom-right'|unknown[];'symbol-placement'?:'point';'icon-allow-overlap'?:boolean|unknown[];'icon-ignore-placement'?:boolean|unknown[];'icon-optional'?:boolean|unknown[];'text-optional'?:boolean|unknown[];'icon-padding'?:number|unknown[];'symbol-sort-key'?:number|unknown[];'symbol-z-order'?:'auto'|'source'|'viewport-y';'text-field'?:string|unknown[];'text-size'?:number|unknown[];'text-max-width'?:number|unknown[];'text-line-height'?:number|unknown[];'text-letter-spacing'?:number|unknown[];'text-justify'?:'auto'|'left'|'center'|'right'|unknown[];'text-transform'?:'none'|'uppercase'|'lowercase'|unknown[];'text-font'?:readonly string[];'text-anchor'?:'center'|'top'|'bottom'|'left'|'right'|'top-left'|'top-right'|'bottom-left'|'bottom-right'|unknown[];'text-offset'?:[number,number]|unknown[];'text-rotate'?:number|unknown[];'text-padding'?:number|unknown[];'text-allow-overlap'?:boolean|unknown[];'text-ignore-placement'?:boolean}; filter?:unknown[]; metadata?:Record<string,unknown>;
  }
  export interface LayerIdentity {readonly id:string;readonly layerInstanceId:string}
export interface GeoJSONLayerInfo extends LayerIdentity {
    id:string; name:string; layerInstanceId:string; source:{id:string;sourceInstanceId:string}|null; sourceRevision:string; cacheRevision:string;
    type:'circle'|'line'|'fill'|'fill-extrusion'|'hillshade'|'color-relief'|'raster'|'heatmap'|'background'|'symbol'; visible:boolean; featureCount:number; warningCount:number;
    specification:GeoJSONLayerSpecification;
  }
  export interface NativeMapState {
    readonly lightingState:SceneLightingState;
    mapInstanceId: string;
    sequence: string;
    submittedSequence: number;
    appliedSequence: number;
    frameSequence: number;
    width: number;
    height: number;
    readonly cameraState?:CameraState;
    nativeView: { focus: [number, number]; scale: number; bearing: number; crs: 'EPSG:4326' | 'EPSG:3857' };
    sourceCount: number;
    layerCount: number;
    styleLayerCount:number;
    layers: { id: string; name: string; visible: boolean; featureCount: number }[];
    software: boolean;
    feedPending: boolean;
    resources: {generation:string;pending:number;styleUrl:string|null;attribution:string;message:string;repaintAfterMs:number|null};
  }
  export interface FlushOptions { render?: boolean; since?: number }
  export interface CommandReceipt {
    mapInstanceId: string;
    submittedSequence: number;
    appliedSequence: number;
    stage: 'applied' | 'rendered';
    readonly cameraState?:CameraState;
    camera: { focus: [number, number]; scale: number; bearing: number; width: number; height: number; mercator: boolean };
    frameSequence?: number;
  }
  export type CameraEventType = "movestart" | "move" | "moveend" | "zoomstart" | "zoom" | "zoomend" | "rotatestart" | "rotate" | "rotateend" | "pitchstart" | "pitch" | "pitchend" | "rollstart" | "roll" | "rollend";
  export type PointerEventType = "click"|"dblclick"|"mousedown"|"mouseup"|"mousemove"|"mouseenter"|"mouseleave"|"contextmenu";
  export type MapLayerSelector = string|readonly string[];
  export type NativeEventType = "styledata" | "style.load" | "remove" | "load" | "render" | "idle" | PointerEventType | CameraEventType | 'sourcedataloading' | 'sourcedata' | 'sourcedataabort' | 'error' | 'sqs.viewchange' | 'sqs.layerschange' | 'sqs.resourceschange' | 'sqs.scenechange' | 'sqs.playbackchange' | 'sqs.lightingchange' | 'sqs.sourceschange' | 'sqs.imageschange' | 'styleimagemissing' | 'sqs.gestureschange' | 'sqs.attributionschange' | 'move';
  export interface LifecycleWork {readonly pendingResources:number;readonly pendingSources:number;readonly animating:boolean;readonly pendingRender:boolean;readonly failed:boolean;}
  export interface LifecycleState {readonly initialized:boolean;readonly firstLoadCompleted:boolean;readonly frameSequence:number;readonly idle:boolean;readonly work:LifecycleWork;}
  export interface NativeSubscription { unsubscribe(): void }
  export interface NativeEvent {
    readonly lifecycle?:LifecycleState;
    readonly gestures?:GesturePolicy;
    readonly attributions?:AttributionSnapshot;readonly context?:"attributions"|"resourcePolicy";readonly resourceConfiguration?:Readonly<Required<ResourceConfiguration>>;
    readonly type: NativeEventType;
    readonly lightingState?:SceneLightingState;readonly reason?:string;readonly scene?:SceneSnapshot;readonly playback?:PlaybackSnapshot;
    readonly target: NativeMap;
    readonly mapInstanceId: string;
    /** Safe integer sequence; ordering may have gaps due to coalesced view events. */
    readonly sequence: number;
    /** Present for sqs.sourceschange; same field in application script hosts. */
    readonly sourceCount?: number;
    readonly styleGeneration?:string;readonly imageCount?:number;readonly runtimeByteLength?:number;
    readonly layerCount?:number; readonly method?:string; readonly id?:string;
    readonly state: NativeMapState;
    /** Present on move; common logical-pixel/WGS84 camera state. */
    readonly cameraState?: CameraState;
    readonly animation?:CameraAnimationTag;readonly error?:{code:string;message:string};
 readonly sqsLive?:LiveSourceState;readonly sqsLiveReceiver?:LiveReceiverState;
 readonly sourceId?:string;readonly sourceInstanceId?:string;readonly dataType?:'source';readonly sourceDataType?:'content';
 readonly isSourceLoaded?:boolean;readonly loading?:boolean;readonly hasData?:boolean;readonly dataRevision?:string;readonly requestRevision?:string;readonly loadError?:SourceLoadError|null;
  }
  export interface NativeCameraEvent extends NativeEvent {readonly type:CameraEventType;readonly cameraState:CameraState}
  export interface MapStyleImageMissingEvent extends NativeEvent {readonly type:'styleimagemissing';readonly id:string;readonly styleGeneration:string;}
  export interface NativeImagesEvent extends NativeEvent {readonly type:'sqs.imageschange';readonly method:'addImage'|'updateImage'|'removeImage';readonly id:string;readonly imageCount:number;readonly runtimeByteLength:number;}
  export interface NativeMoveEvent extends NativeEvent {readonly type:'move';readonly cameraState:CameraState}
  export type NativeListener = (event: NativeEvent) => void | Promise<void>;
  export type LngLatLike = [number,number] | {lng:number;lat:number};
  export type PointLike = [number,number] | {x:number;y:number};
  export interface Padding { top:number;right:number;bottom:number;left:number }
 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?:CameraState['camera']}
 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 interface CameraOptions { center?:LngLatLike;zoom?:number;bearing?:number;pitch?:number;roll?:number;padding?:number|Partial<Padding> }
  export interface FitBoundsOptions { padding?:number|Partial<Padding>;offset?:PointLike;bearing?:number;minZoom?:number;maxZoom?:number;animate?:boolean;duration?:number;linear?:boolean;easing?:(t:number)=>number;essential?:boolean }
export interface ScaleAtOptions {point?:PointLike;maxWidth?:number}
export interface ScaleAtResult {point:{x:number;y:number};position:{lng:number;lat:number};projection:'geographic'|'mercator';metersPerPixel:number;distance:number;width:number;maxWidth:number;unit:'m';pixelUnit:'css';model:'sphere-local';earthRadius:6371008.8;approximate:true}

  export interface CameraState { camera:{center:[number,number];zoom:number;bearing:number;pitch:number;roll:number;padding:Padding};projection:'geographic'|'mercator'|'globe';viewport:{width:number;height:number;pixelRatio:1} }
  /** Inline WGS84 GeoJSON source subset, shared with native scripts. No source UI is created. */
  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 QueryPixel=[number,number]|{x:number;y:number};
export interface QueryRenderedFeatureOptions {layers?:string[];filter?:unknown[];validate?:true}
export interface QueriedRenderedFeature extends QueriedSourceFeature {state:Record<string,unknown>;
 layer:GeoJSONLayerSpecification;
 sqs:{sourceInstanceId:string;dataRevision:string;featureIndex:number;layerInstanceId:string;cacheRevision:string;stateRevision:string};
}
export interface QuerySourceFeatureOptions {
 filter?:unknown[]; validate?:true; sourceLayer?:string;
 sqs?:{offset?:number;limit?:number;sourceInstanceId?:string;dataRevision?:string};
}
export interface QueriedSourceFeature extends GeoJSONFeature {
 sourceLayer?:string;
 source:string; sqs:{sourceInstanceId:string;dataRevision:string;featureIndex:number};
}
  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>;attachSource(source:SourceIdentity):Promise<void>;detachSource(source:SourceIdentity):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 type MediaCoordinates=[[number,number],[number,number],[number,number],[number,number]];
export interface MediaSourceOptions {type:'image'|'video';coordinates:MediaCoordinates;attribution?:string;url?:string;urls?:string[]}
export interface ImageSourceUpdate {url:string;coordinates?:MediaCoordinates}
export interface CanvasSourceOptions {type:'canvas';canvas:string;coordinates:MediaCoordinates;animate?:boolean;attribution?:string}
export type CommonSourceOptions=GeoJSONSourceOptions|MediaSourceOptions|CanvasSourceOptions|TileSourceOptions;
export interface MediaState {kind:'image'|'video'|'canvas';coordinates:MediaCoordinates;revision:number;frameSequence:number;paused:boolean;width:number;height:number;byteLength:number;duration?:number;currentTime?:number;canvas?:string}
export interface MediaFrame {sequence:number;width:number;height:number;data:number[]}
export interface MediaSource extends Readonly<SourceIdentity> {readonly type:'image'|'video'|'canvas';readonly dataRevision:string;updateImage(options:ImageSourceUpdate):Promise<void>;setCoordinates(coordinates:MediaCoordinates):Promise<void>;play():Promise<void>;pause():Promise<void>;readonly sqs:{getState():Promise<MediaState>;fail(reason:{code:string;message:string}):Promise<void>;submitFrame(frame:MediaFrame):Promise<{applied:boolean;state:SourceInfo}>}}
export type CommonMapSource=GeoJSONSource|MediaSource|TileSource;
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[]}
  export interface SourceIdentity {id:string;sourceInstanceId:string}
  export interface SourceLoadError {readonly code:string;readonly message:string}
 export interface SourceDataEvent {
 readonly sourceId:string;readonly sourceInstanceId:string;readonly dataType:'source';readonly sourceDataType:'content'|'metadata';
 readonly isSourceLoaded:boolean;readonly loading:boolean;readonly hasData:boolean;readonly dataRevision:string;readonly requestRevision:string;
 readonly loadError:SourceLoadError|null;readonly error?:SourceLoadError;
 }
 export interface SourceInfo extends SourceIdentity {sqsLiveReceiver?:LiveReceiverState;sqsLive?:LiveSourceState;type:'geojson'|'image'|'video'|'canvas'|'vector'|'raster'|'raster-dem';mediaState?:MediaState;tileMetadata?:TileSourceMetadata;tileState?:TileSourceState;dataRevision:string;stateRevision:string;loaded:boolean;loading:boolean;hasData:boolean;requestRevision:string;loadError:SourceLoadError|null;featureCount:number;bounds:[number,number,number,number]|null;attribution:string;promoteId:string|Record<string,string>|null;generateId:boolean;lineMetrics:boolean;cluster:boolean;supportsUpdateData:boolean;referenceCount:number}
  /** Bound to one map and one source generation; deleting/re-adding its id invalidates this handle. */
  export interface GeoJSONSource extends Readonly<SourceIdentity> {
   readonly sqs:LiveSourceAPI;
 readonly type:'geojson'; readonly dataRevision:string;
   getData():Promise<GeoJSON>;
   setData(data:GeoJSON|string):Promise<void>;
   updateData(diff:GeoJSONSourceDiff):Promise<void>;
 getClusterOptions():Promise<GetClusterOptions>;
 setClusterOptions(options:SetClusterOptions):Promise<void>;
 getClusterChildren(clusterId:number):Promise<QueriedSourceFeature[]>;
 getClusterLeaves(clusterId:number,limit?:number,offset?:number):Promise<QueriedSourceFeature[]>;
 getClusterExpansionZoom(clusterId:number):Promise<number>;

  }
 export interface NativePointerEvent extends NativeEvent {
  readonly type:PointerEventType;readonly point:Readonly<{x:number;y:number}>;readonly lngLat:Readonly<{lng:number;lat:number}>|null;
  readonly features:readonly QueriedRenderedFeature[];readonly cameraState:CameraState;
  readonly input:Readonly<{pointerType:'mouse'|'pen'|'touch';button:number;buttons:number;altKey:boolean;ctrlKey:boolean;metaKey:boolean;shiftKey:boolean}>;
 }
  export interface GesturePolicy {readonly dragPan:boolean;readonly scrollZoom:boolean;readonly doubleClickZoom:boolean;readonly keyboard:boolean;readonly keyboardRotation:boolean;readonly touchZoomRotate:boolean;readonly touchPitch:boolean;readonly touchRotation:boolean;}
  export interface GestureHandler {enable():Promise<void>;disable():Promise<void>;isEnabled():Promise<boolean>;isActive():Promise<boolean>;}
  export interface KeyboardHandler extends GestureHandler {enableRotation():Promise<void>;disableRotation():Promise<void>;}
 export interface TouchZoomRotateHandler extends KeyboardHandler {}
  export interface NativeMap {
 loaded():Promise<boolean>;
    readonly dragPan:GestureHandler;readonly scrollZoom:GestureHandler;readonly doubleClickZoom:GestureHandler;readonly keyboard:KeyboardHandler;readonly touchZoomRotate:TouchZoomRotateHandler;readonly touchPitch:GestureHandler;
    /** Native request-queue getters are asynchronous; writes remain chainable. */
    /** URL replacement; null clears. Inline GeoJSON style replacement is connected; diff:true remains unavailable. */
    getStyle():Promise<{version:8;state?:Record<string,{default:unknown}>;sources:Record<string,unknown>;layers:readonly unknown[];name?:string;metadata?:Record<string,unknown>}>;
    setStyle(style:string|null|{version:8;state?:Record<string,{default:unknown}>;sources:Record<string,unknown>;layers:readonly unknown[];name?:string;metadata?:Record<string,unknown>},options?:{diff?:false}):this;
    addLayer(specification:GeoJSONLayerSpecification,beforeId?:string):this;
    removeLayer(id:string):this; moveLayer(id:string,beforeId?:string):this;
    addImage(id:string,image:MapImageData|StyleImageInterface,options?:MapImageOptions):this;
    /** Request one real frame; repeated calls coalesce, including from render callbacks. */
    triggerRepaint():this;
    updateImage(id:string,image:MapImageData):this;removeImage(id:string):this;
    getGlyphs():Promise<string|undefined>;setGlyphs(url:string|null|undefined,options?:{validate?:true}):this;
    loadImage(url:string):Promise<MapImageLoadResult>;getImage(id:string):Promise<MapImageSnapshot|undefined>;hasImage(id:string):Promise<boolean>;listImages():Promise<readonly string[]>;
    getLayer(id:string):Promise<GeoJSONLayerSpecification|undefined>;
  queryRenderedFeatures(geometryOrOptions?:QueryPixel|[QueryPixel,QueryPixel]|QueryRenderedFeatureOptions,options?:QueryRenderedFeatureOptions):Promise<QueriedRenderedFeature[]>;
    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;
    setTerrain(options:TerrainSpecification|null):typeof map;getTerrain():Promise<Readonly<TerrainSpecification>|null>;queryTerrainElevation(point:readonly [number,number]|{lng:number;lat:number}|{lon:number;lat:number}):Promise<number|null>;
 addSource(id:string,options:CommonSourceOptions):this;
    getSource(id:string):Promise<CommonMapSource|undefined>;
  getGlobalState():Promise<Readonly<Record<string,unknown>>>;
  setGlobalStateProperty(name:string,value:unknown):this;
    setFeatureState(target:FeatureStateTarget|QueriedSourceFeature,state:Record<string,unknown>):this;
  getFeatureState(target:FeatureStateTarget|QueriedSourceFeature):Promise<Record<string,unknown>>;
  removeFeatureState(target:Omit<FeatureStateTarget,'id'> & {source:string;id?:string|number},key?:string):this;
  querySourceFeatures(id:string,options?:QuerySourceFeatureOptions):Promise<QueriedSourceFeature[]>;
    removeSource(id:string):this;
    isSourceLoaded(id:string):Promise<boolean>;
    getLight():Promise<ResolvedLightSpecification|null>;
    setLight(light:LightSpecification,options?:LightSetterOptions):this;
    readonly lighting:{state():Promise<SceneLightingState>;set(options:SceneLightingOptions):Promise<SceneLightingState>};
    getCenter(): Promise<{lng:number;lat:number}>;
    getZoom(): Promise<number>;
    getMinZoom():Promise<number>;getMaxZoom():Promise<number>;
    getPitch(): Promise<number>;
    getRoll(): Promise<number>;
    getPadding(): Promise<Padding>;
    getBounds(): Promise<[[number,number],[number,number]]>;
    getProjection(): Promise<{type:'geographic'|'mercator'|'globe'}>;
    setProjection(projection:{type:'geographic'|'mercator'|'globe'}):this;
    project(position:LngLatLike):Promise<{x:number;y:number}>;
    unproject(point:PointLike):Promise<{lng:number;lat:number}>;
    cameraForBounds(bounds: [number,number,number,number]|[LngLatLike,LngLatLike],options?:FitBoundsOptions):Promise<CameraState['camera']>;
    easeTo(options:EaseToOptions):this;flyTo(options:FlyToOptions):this;stop():this;
    isEasing():Promise<boolean>;isMoving():Promise<boolean>;isZooming():Promise<boolean>;isRotating():Promise<boolean>;
    jumpTo(options:CameraOptions):this;
    fitBounds(bounds:[number,number,number,number]|[LngLatLike,LngLatLike],options?:FitBoundsOptions):this;
    setCenter(center:LngLatLike):this;
    setZoom(zoom:number):this;
    setPitch(pitch:number):this;
    setPadding(padding:number|Partial<Padding>):this;
    resetNorth(options?:ImmediateNavigationOptions):this;
  resetNorthPitch(options?:ImmediateNavigationOptions):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;
    zoomIn(options?:ImmediateNavigationOptions):this;
    zoomOut(options?:ImmediateNavigationOptions):this;
    getBearing(): Promise<number>;
    setBearing(bearing: number): this;
    /** Host built-ins require a retained session; custom Evented names also work in one-shot scripts. */
  /** Synchronous query of listeners owned by this retained facade. */
  listens(type:string):boolean;
  fire(type:string,data?:Record<string,unknown>):this;
  fire(event:{type:string;[key:string]:unknown}):this;
  setEventedParent(parent?:Evented|NativeMap|null,data?:EventedParentData):this;
  on(type:PointerEventType,listener:(event:NativePointerEvent)=>void|Promise<void>):NativeSubscription;
  on(type:PointerEventType,layers:MapLayerSelector,listener:(event:NativePointerEvent)=>void|Promise<void>):NativeSubscription;
  off(type:PointerEventType,listener:(event:NativePointerEvent)=>void|Promise<void>):this;
  off(type:PointerEventType,layers:MapLayerSelector,listener:(event:NativePointerEvent)=>void|Promise<void>):this;
  once(type:PointerEventType,listener:(event:NativePointerEvent)=>void|Promise<void>):this;
  once(type:PointerEventType,layers:MapLayerSelector,listener:(event:NativePointerEvent)=>void|Promise<void>):this;
  once(type:PointerEventType):Promise<NativePointerEvent>;
  once(type:PointerEventType,layers:MapLayerSelector):Promise<NativePointerEvent>;
    on(type:'move',listener:(event:NativeMoveEvent)=>void|Promise<void>):NativeSubscription;
    off(type:'move',listener:(event:NativeMoveEvent)=>void|Promise<void>):this;
    once(type:'move',listener:(event:NativeMoveEvent)=>void|Promise<void>):this;
    once(type:'move'):Promise<NativeMoveEvent>;
    on(type:CameraEventType,listener:(event:NativeCameraEvent)=>void|Promise<void>):NativeSubscription;
    off(type:CameraEventType,listener:(event:NativeCameraEvent)=>void|Promise<void>):this;
    once(type:CameraEventType,listener:(event:NativeCameraEvent)=>void|Promise<void>):this;
    once(type:CameraEventType):Promise<NativeCameraEvent>;
    on(type: NativeEventType, listener: NativeListener): NativeSubscription;
    off(type: NativeEventType, listener: NativeListener): this;
    once(type: NativeEventType, listener: NativeListener): this;
    once(type: NativeEventType): Promise<NativeEvent>;

  on(type:string,listener:(event:CustomEvent)=>unknown):NativeSubscription;
  off(type:string,listener:(event:CustomEvent)=>unknown):this;
  once(type:string,listener:(event:CustomEvent)=>unknown):this;
  once(type:string):Promise<CustomEvent>;
    readonly sqs: {
      /** Label placement fade duration in milliseconds; default 300. */
      getLabelFadeDuration():Promise<number>;
      /** Finite 0..3600000 ms; independent of material and raster fades. Confirm with flush. */
      setLabelFadeDuration(ms:number):void;
      /** Integer-zoom material window in milliseconds; default 300. */
      getMaterialFadeDuration():Promise<number>;
      /** Finite 0..3600000 ms; does not change manual pattern/dash timing. Confirm with flush. */
      setMaterialFadeDuration(ms:number):void;
      readonly resources:ResourcesAPI;
      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'}>>;animations:AnimationsAPI;playbacks:PlaybacksAPI;scenes:ScenesAPI;getCapabilities():Promise<Readonly<Record<string,unknown>>>;
   getSourceInfo(id:string):Promise<SourceInfo|undefined>;
      getLayers():Promise<readonly GeoJSONLayerInfo[]>;
      setLayerMetadata(id:string,metadata:Record<string,unknown>|null):NativeMap;
      getLayerMetadata(id:string):Promise<Record<string,unknown>>;
      ready(): Promise<NativeMap>;
      /** [] for legacy one-shot; four connected events for retained sessions. */
      events(): readonly NativeEventType[];
      /** Retained session entry only. */
      disposeSession(): Promise<void>;
      getImageInfo(id:string):Promise<MapImageInfo|undefined>;gesturesState():Promise<GesturePolicy>;getAttributions():Promise<AttributionSnapshot>;
      scaleAt(options?:ScaleAtOptions):Promise<ScaleAtResult>;
      cameraState():Promise<CameraState>;lifecycleState():Promise<LifecycleState>;animationState():Promise<CameraAnimationState>;setReducedMotion(value:boolean):NativeMap;
      state(): Promise<NativeMapState>;
      addGeoJSON(data: object): Promise<string>;
      removeNativeLayer(id: string): Promise<null>;
      flush(options?: FlushOptions): Promise<CommandReceipt>;
    };
  }
  export const map: NativeMap;
/** Scene ownership is independent of a script session and of manual receiver pause. */
export interface SceneIdentity {readonly id:string;readonly sceneInstanceId:string}
export type SceneStatus='draft'|'running'|'paused'|'stopped';
export interface SceneReceiver {readonly source:SourceIdentity;readonly receiverInstanceId:string}
export interface SceneClockSnapshot extends SceneIdentity {readonly state:SceneStatus;readonly elapsedMs:number}
export interface SceneSnapshot extends SceneIdentity {readonly name:string;readonly state:SceneStatus;readonly revision:string;readonly resourceCount:number;readonly receivers:readonly SceneReceiver[];readonly sources:readonly SourceIdentity[];readonly playbacks:readonly PlaybackIdentity[]}
export interface Scene extends SceneIdentity {getState():Promise<SceneSnapshot>;getClock():Promise<SceneClockSnapshot>;start():Promise<void>;pause():Promise<void>;resume():Promise<void>;stop():Promise<void>;attachSource(source:SourceIdentity):Promise<void>;detachSource(source:SourceIdentity):Promise<void>}
export interface ScenesAPI {create(options:{id:string;name?:string}):Promise<Scene>;get(id:string):Promise<Scene|undefined>;list():Promise<readonly SceneSnapshot[]>;remove(scene:SceneIdentity):Promise<void>}
export interface SceneChangeEvent {readonly type:'sqs.scenechange';readonly reason:string;readonly scene:SceneSnapshot}

export interface PlaybackIdentity {readonly id:string;readonly playbackInstanceId:string}
export type PlaybackState='ready'|'playing'|'paused'|'stopped'|'completed'|'failed';
export interface PlaybackSnapshotBase extends PlaybackIdentity {
 readonly owner:SceneIdentity;readonly ownerState:SceneStatus;readonly source:SourceIdentity;readonly sourceRevision:string;
 readonly state:PlaybackState;readonly epoch:string;readonly elapsedMs:number;readonly positionMs:number;
 readonly durationMs:number;readonly loop:boolean;readonly delayRemainingMs:number;
 readonly error:{readonly code:string;readonly message:string}|null;
}
export interface RoutePlaybackSnapshot extends PlaybackSnapshotBase {
 readonly kind:'route';readonly target:SourceIdentity;readonly targetRevision:string;
 readonly position:readonly [number,number];readonly headingRadians:number;
}
export interface LineFrameSnapshot {readonly phase:number;readonly reveal:number;readonly opacity:number;readonly widthScale:number;readonly color:readonly [number,number,number,number]}
export interface LinePlaybackSnapshot extends PlaybackSnapshotBase {
 readonly kind:'line';readonly layer:LayerIdentity;readonly sourceStateRevision:string;readonly frame:LineFrameSnapshot;
 /** Retained effect; layer and scene visibility still apply. */
 readonly visibleEffect:boolean;
 readonly pattern?:{readonly id:string;readonly imageInstanceId:string;readonly revision:string};
}
export type PlaybackSnapshot=RoutePlaybackSnapshot|LinePlaybackSnapshot;
export interface RoutePlaybackOptions {id:string;source:SourceIdentity;target:SourceIdentity;duration?:number;offsets?:readonly number[];loop?:boolean;delay?:number}
export type LineUnit='progress'|'pixels';
export type LineEffect =
 | {type:'flow';id?:string;unit?:LineUnit;spacing?:number;trailLength?:number;fade?:'linear'|'none';phase?:number}
 | {type:'dash';id?:string;unit?:LineUnit;on:number;gap:number}
 | {type:'reveal';id?:string;start?:number;end?:number}
 | {type:'arrows';id?:string;unit?:LineUnit;spacing?:number;length?:number}
 | {type:'glow';id?:string;radius?:number;intensity?:number}
 | {type:'pattern';id?:string;image:string;unit?:LineUnit;spacing?:number};
export interface LineKeyframe<T> {offset:number;value:T}
export interface LineTracks {color?:readonly LineKeyframe<string>[];opacity?:readonly LineKeyframe<number>[];widthScale?:readonly LineKeyframe<number>[]}
export interface LineTiming {duration:number;delay?:number;loop?:boolean;direction?:'forward'|'reverse'|'alternate';easing?:'linear'|'ease-in-out';fill?:'forwards'|'none'}
export interface LinePlaybackOptions {id:string;layer:string|LayerIdentity;timing:LineTiming;effects:readonly LineEffect[];tracks?:LineTracks;stagger?:boolean;cap?:'butt'|'round';phaseField?:string;speedField?:string}
export interface Playback<T extends PlaybackSnapshot=PlaybackSnapshot> extends PlaybackIdentity {
 getState():Promise<T>;play():Promise<void>;pause():Promise<void>;stop():Promise<void>;seek(timeMs:number):Promise<void>;
 /** Resolves after the endpoint was accepted; loop waits require explicit cancellation. */
 finished():Promise<T>;
}
export interface PlaybacksAPI {get(id:string):Promise<Playback|undefined>;list():Promise<readonly PlaybackSnapshot[]>;remove(playback:PlaybackIdentity):Promise<void>}
export interface AnimationsAPI {
 route(options:RoutePlaybackOptions,owner:{owner:SceneIdentity}):Promise<Playback<RoutePlaybackSnapshot>>;
 line(options:LinePlaybackOptions,owner:{owner:SceneIdentity}):Promise<Playback<LinePlaybackSnapshot>>;
}
export interface PlaybackChangeEvent {readonly type:'sqs.playbackchange';readonly reason:string;readonly playback:PlaybackSnapshot}


export interface TileSourceMetadata {tiles:string[];minzoom:number;maxzoom:number;bounds:[number,number,number,number];scheme:'xyz'|'tms';attribution:string;tileSize:number|null;metadataLoaded:boolean;volatile:boolean;encoding?:'mapbox'|'terrarium'|'custom'}
export interface TileSourceOptions {type:'vector'|'raster'|'raster-dem';url?:string;tiles?:string[];minzoom?:number;maxzoom?:number;bounds?:[number,number,number,number];scheme?:'xyz'|'tms';attribution?:string;tileSize?:256|512;encoding?:'mvt'|'mapbox'|'terrarium'|'custom';redFactor?:number;greenFactor?:number;blueFactor?:number;baseShift?:number;promoteId?:string|Record<string,string>;volatile?:boolean}
export interface TileSource extends Readonly<SourceIdentity> {readonly type:'vector'|'raster'|'raster-dem';readonly dataRevision:string;setTiles(tiles:string[]):Promise<void>;setUrl(url:string):Promise<void>;readonly sqs:{getTileMetadata():Promise<TileSourceMetadata>}}

export interface TileSourceState {visibleTiles:number;readyTiles:number;fallbackTiles:number;pendingTiles:number;cachedTiles:number;byteLength:number}

}