@maptalks/vt 0.94.0 → 0.96.0

package/dist/maptalks.vt.d.ts

@@ -0,0 +1,955 @@
+/*!
+ * @maptalks/vt v0.96.0
+ * LICENSE : undefined
+ * (c) 2016-2024 maptalks.org
+ */
+import * as maptalks from 'maptalks';
+import { FillSymbol, LineSymbol, MarkerCommonSymbol, TextSymbol, LayerIdentifyOptionsType, TileLayerOptionsType, LayerJSONType, OverlayLayerOptionsType } from 'maptalks';
+import { reshader, GroundPainter, createREGL } from '@maptalks/gl';
+
+interface FillDataConfig {
+    type?: "fill";
+}
+interface LineDataConfig {
+    type?: "line";
+}
+interface IconDataConfig {
+    type?: "point";
+}
+interface TextDataConfig {
+    type?: "point";
+}
+interface LitDataConfig {
+    type?: "3d-extrusion" | "line-extrusion";
+    altitudeProperty?: string | null;
+    minHeightProperty?: string | null;
+    altitudeScale?: number;
+    defaultAltitude?: number;
+    topThickness?: number;
+    top?: boolean;
+    side?: boolean;
+}
+type VtDataConfig = FillDataConfig | LineDataConfig | IconDataConfig | TextDataConfig | LitDataConfig;
+interface VtSceneConfig {
+    collision?: boolean;
+    fading?: boolean;
+    fadingDuration?: number;
+    fadeInDelay?: number;
+    fadeOutDelay?: number;
+    uniquePlacement?: number;
+    depthFunc?: "always" | "<=";
+    depthRange?: number[];
+}
+interface LitMaterial {
+    baseColorTexture?: string | null;
+    baseColorFactor?: number[];
+    hsv?: number[];
+    baseColorIntensity?: number;
+    contrast?: number;
+    outputSRGB?: number;
+    metallicRoughnessTexture?: string | null;
+    roughnessFactor?: number[];
+    metallicFactor?: number[];
+    normalTexture?: string | null;
+    uvScale?: number[];
+    uvOffset?: number[];
+    uvRotation?: number;
+    uvOffsetAnim?: number[];
+    normalMapFactor?: number;
+    emissiveTexture?: string | null;
+    emissiveFactor?: number[];
+    emitColorFactor?: number;
+    emitMultiplicative?: number;
+}
+interface LitSymbol {
+    bloom?: boolean;
+    ssr?: boolean;
+    polygonOpacity?: number;
+    material?: LitMaterial;
+}
+interface WaterSymbol {
+    ssr?: boolean;
+    texWaveNormal?: string | null;
+    texWavePerturbation?: string | null;
+    waterBaseColor?: number[];
+    contrast?: number;
+    hsv?: number[];
+    uvScale?: number;
+    animation?: boolean;
+    waterSpeed?: number;
+    waterDirection?: number;
+}
+type VtSymbol = FillSymbol | LineSymbol | MarkerCommonSymbol | TextSymbol | WaterSymbol | LitSymbol;
+interface BackgroundConfig {
+    enable: boolean;
+    renderPlugin: {
+        type: "fill";
+        sceneConfig: VtSceneConfig;
+    };
+    symbol: FillSymbol;
+}
+
+/**
+ * Style:
+ * [
+ *  {
+ *     renderPlugin : { ... },
+ *     filter : [],
+ *     symbol : { ... }
+ *  }
+ * ]
+ */
+declare class VectorTileLayer extends maptalks.TileLayer {
+    VERSION: string;
+    ready: boolean;
+    options: VectorTileLayerOptionsType;
+    static loadFrom(url: string, fetchOptions: Record<string, any>): Promise<VectorTileLayer>;
+    constructor(id: string, options: VectorTileLayerOptionsType);
+    /**
+     * 设置url处理函数。
+     *
+     * @english
+     * Set URL processing function.
+     * @param modifier - URL processing function
+     * @return this
+     */
+    setURLModifier(modifier: Function): this;
+    /**
+     * 获取url处理函数。
+     *
+     * @english
+     * Get URL processing function.
+     * @return url modifier
+     */
+    getURLModifier(): Function;
+    onAdd(): void;
+    /**
+     * 设置数据状态。
+     *
+     * @english
+     * Set state of feature.
+     * @param source - layer source
+     * @param state - feature state
+     * @return this
+     */
+    setFeatureState(source: {
+        id: string;
+        layer: string;
+    }, state: unknown): this;
+    /**
+     * 删除数据状态。
+     *
+     * @english
+     * Remove state of feature.
+     * @param source - layer source
+     * @param key - object key
+     * @return this
+     */
+    removeFeatureState(source: {
+        id: string;
+        layer: string;
+    }, key: string | number | object): this;
+    /**
+     * 获取数据状态。
+     *
+     * @english
+     * Get state of feature.
+     * @param source - layer source
+     * @return feature state
+     */
+    getFeatureState(source: any): unknown;
+    protected _prepareOptions(): void;
+    onWorkerReady(): void;
+    /**
+     * 更新图层配置。
+     *
+     * @english
+     * Update layer config.
+     * @param conf - layer config
+     * @return void
+     */
+    onConfig(conf: object): void;
+    /**
+     * 获取worker参数。
+     *
+     * @english
+     * Get worker options.
+     * @return worker options
+     */
+    getWorkerOptions(): Record<string, any>;
+    /**
+     * 设置图层样式。
+     *
+     * @english
+     * Set the style of layer.
+     * @param style - vt style object
+     * @return this
+     */
+    setStyle(style: any): this;
+    queryTilePointTerrain(point: any, terrainTileInfo: any, tilePoint: any, extent: any, res: any): any;
+    queryTerrainTiles(tileInfo: object): any;
+    /**
+     * 获取图层的polygonOffsetCount，用于GroupGLLayer全局管理polygonOffset。
+     *
+     * @english
+     * Get the polygonOffsetCount of layer,used for GroupGLLayer global management of polygonOffset.
+     * @return polygonOffsetCount
+     */
+    getPolygonOffsetCount(): any;
+    /**
+     * 获取图层的polygonOffset，用于GroupGLLayer全局管理polygonOffset
+     *
+     * @english
+     * Get the polygonOffset of layer,used for GroupGLLayer global management of polygonOffset
+     * @return polygonOffset
+     */
+    getPolygonOffset(): number;
+    /**
+     * 设置图层的polygonOffset
+     *
+     * @english
+     * Set the polygonOffset of layer
+     * @return this
+     */
+    setPolygonOffset(offset: number, total?: number): this;
+    /**
+     * 获取图层的polygonOffset总数。
+     *
+     * @english
+     * Get the total polygonOffset of layer
+     * @return total polygonOffset
+     */
+    getTotalPolygonOffset(): number;
+    /**
+     * 获取已经渲染的features。
+     *
+     * @english
+     * Get rendered features of layer
+     * @return rendered features
+     */
+    getRenderedFeatures(): any;
+    getRenderedFeaturesAsync(options?: AsyncFeatureQueryOptions): Promise<unknown>;
+    /**
+     * 高亮整个图层
+     *
+     * @english
+     * Outline the layer
+     * @return this
+     */
+    outlineAll(): this;
+    /**
+     * 高亮数据
+     *
+     * @english
+     * Outline features
+     * @param idx            - style index
+     * @param featureIds     - feature ids
+     * @return this
+     */
+    outline(idx: number, featureIds: number[]): this;
+    /**
+     * 高亮数据
+     *
+     * @english
+     * Outline features
+     * @param idx  - style index
+     * @return this
+     */
+    outlineBatch(idx: number): this;
+    /**
+     * 高亮数据
+     *
+     * @english
+     * Outline features
+     * @param featureIds     - feature ids
+     * @return this
+     */
+    outlineFeatures(featureIds: number[]): this;
+    /**
+     * 取消高亮
+     *
+     * @english
+     * Cancel outline
+     * @return this
+     */
+    cancelOutline(): this;
+    highlight(highlights: any): this;
+    cancelHighlight(ids: number): this;
+    cancelAllHighlight(): this;
+    /**
+     * 更新 SceneConfig
+     *
+     * @english
+     * Update sceneConfig
+     * @param idx - style name or index
+     * @param sceneConfig   - properties of sceneConfig
+     * @return this
+     */
+    updateSceneConfig(idx: string | number, sceneConfig: VtSceneConfig): this;
+    /**
+     * 更新 feature 的 SceneConfig
+     *
+     * @english
+     * Update feature sceneConfig
+     * @param idx - feature index
+     * @param styleIdx - style index
+     * @param sceneConfig   - properties of sceneConfig
+     * @return this
+     */
+    updateFeatureSceneConfig(idx: number, styleIdx: number, sceneConfig: VtSceneConfig): this;
+    /**
+     * 更新 dataConfig
+     *
+     * @english
+     * Update dataConfig
+     * @param idx - style name or index
+     * @param dataConfig   - properties of dataConfig
+     * @return this
+     */
+    updateDataConfig(idx: number | string, dataConfig: VtDataConfig): this;
+    /**
+     * 更新 feature 的 dataConfig
+     *
+     * @english
+     * Update feature dataConfig
+     * @param idx - feature index
+     * @param styleIdx - style index
+     * @param dataConfig   - properties of dataConfig
+     * @return this
+     */
+    updateFeatureDataConfig(idx: number, styleIdx: number, dataConfig: VtDataConfig): this;
+    /**
+     * 更新 symbol
+     *
+     * @english
+     * Update symbol
+     * @param idx - style name or index
+     * @param symbol   - properties of symbol
+     * @return this
+     */
+    updateSymbol(idx: number | string, symbol: VtSymbol): this;
+    /**
+     * 更新 feature symbol
+     *
+     * @english
+     * Update symbol
+     * @param idx - style name or index
+     * @param symbol   - properties of symbol
+     * @return this
+     */
+    updateFeatureSymbol(idx: number, feaStyleIdx: number, symbol: VtSymbol): this;
+    isDefaultRender(): any;
+    /**
+     * 校验style是否合法
+     *
+     * @english
+     * Validate style
+     * @return void
+     */
+    validateStyle(): void;
+    /**
+     * 获取当前 style
+     *
+     * @english
+     * Get style
+     * @return style
+     */
+    getStyle(): any;
+    /**
+     * 获取图层的背景设置
+     *
+     * @english
+     * Get Background config of the layer
+     * @return backgroundConfig
+     */
+    getGroundConfig(): BackgroundConfig;
+    getComputedStyle(): any;
+    /**
+     * 识别给定坐标的数据
+     *
+     * @english
+     * Identify the data on the given container point
+     * @param coordinate - coordinate to identify
+     * @param options=null - options
+     * @param options.tolerance=0 - identify tolerance in pixel
+     * @param options.count=null - result count
+     * @return data identified
+     */
+    identify(coordinate: maptalks.Coordinate, options?: LayerIdentifyOptionsType): object[];
+    /**
+     * 识别给定点的数据
+     *
+     * @english
+     * Identify the data on the given container point
+     * @param point - point to identify
+     * @param options=null - options
+     * @param options.tolerance=0 - identify tolerance in pixel
+     * @param options.count=0 - result count
+     * @return data identified
+     */
+    identifyAtPoint(point: maptalks.Point, options?: {
+        tolerance?: number;
+        count?: number;
+        filter?: (feature: any) => boolean;
+    }): object[];
+    /**
+     * A separate collision index for background tiles
+     * To avoid conflict with current zoom's tiles
+     * @returns {CollisionIndex}
+     */
+    /**
+     * Clear layer's background tiles collision index.
+     */
+    /**
+     * Return vector tile data's schema, including layers, properties, data types
+     * Will return all zoom's schema if z is undefined
+     * @param {Number} [z=undefined] - tile's zoom, optional
+     * @returns {Object} data schema
+     */
+    /**
+     * 返回矢量瓦片数据的重要信息，包括图层、属性和数据类型
+     *
+     * @english
+     * Return vector tile data's schema, including layers, properties, data types
+     * @param z=undefined - tile's zoom, optional
+     * @return data schema
+     */
+    getDataSchema(z: number): object;
+    onRemove(): void;
+    static fromJSON(layerJSON: object): VectorTileLayer;
+    static registerPlugin(Plugin: {
+        type: string;
+        [key: string]: unknown;
+    }): void;
+    static getPlugins(): any;
+    static compressStyleJSON(json: object | object[]): object;
+}
+
+type VectorTileLayerOptionsType = {
+    renderer?: "gl";
+    altitudeProperty?: string;
+    features?: boolean;
+    schema?: boolean;
+    collision?: boolean;
+    collisionBuffserSize?: number;
+    picking?: boolean;
+    pickingPoint?: boolean;
+    pickingGeometry?: boolean;
+    glyphSdfLimitPerFrame?: number;
+    antialias?: boolean;
+    iconErrorUrl?: string;
+    collisionFrameLimit?: number;
+    defaultRendering?: boolean;
+    textGamma?: number;
+    maxIconSize?: number;
+    workarounds?: {
+        "win-intel-gpu-crash"?: boolean;
+    };
+    styleScale?: number;
+    enableAltitude?: true;
+    debugTileData?: boolean;
+    altitudeQueryTimeLimitPerFrame?: number;
+    workerGlyph?: boolean;
+    featureIdProperty?: string;
+    currentTilesFirst?: true;
+    style?: any;
+} & TileLayerOptionsType;
+type AsyncFeatureQueryOptions = {
+    countPerTime?: number;
+};
+
+declare class MapboxVectorTileLayer extends VectorTileLayer {
+    getTileUrl(x: number, y: number, z: number): string;
+    static fromJSON(layerJSON: object): MapboxVectorTileLayer;
+}
+
+declare class GeoJSONVectorTileLayer extends VectorTileLayer {
+    options: GeoJSONVectorTileLayerOptionsType;
+    features: Record<string, any>;
+    constructor(id: string, options: GeoJSONVectorTileLayerOptionsType);
+    onAdd(): void;
+    protected _prepareOptions(): void;
+    getWorkerOptions(): Record<string, any>;
+    setData(data: any): this;
+    getExtent(): maptalks.Extent;
+    onWorkerReady(err?: any, params?: any): void;
+    getData(): Record<string, any>;
+    getTileUrl(x: number, y: number, z: number): string;
+    getFeature(id: string): any;
+    static fromJSON(layerJSON: LayerJSONType): GeoJSONVectorTileLayer | null;
+}
+
+type GeoJSONVectorTileLayerOptionsType = {
+    features?: string;
+    tileBuffer?: number;
+    extent?: number;
+    pyramidMode?: 1;
+    simplifyTolerance?: number;
+    tileStackDepth?: number;
+    generateOMBB?: boolean;
+    data?: any;
+    convertFn?: (data: any) => any;
+} & VectorTileLayerOptionsType;
+
+declare const WorkerConnection_base: {
+    new (workerKey: string): {
+        initializing: boolean;
+        workerKey: string;
+        workerPool: {
+            active: {
+                [key: number]: boolean;
+            };
+            workerCount: number;
+            workers: Worker[];
+            acquire(id: number): Worker[];
+            release(id: number): void;
+            addMessage(workerId: number, data: any, buffers: ArrayBuffer[]): void;
+            commit(): void;
+            getWorkers(): Worker[];
+            broadcastIdleMessage(messageRatio: number): any;
+        };
+        currentActor: number;
+        actorId: number;
+        workers: Worker[];
+        callbacks: {
+            [key: string]: Function;
+        };
+        callbackID: number;
+        receiveFn: any;
+        created(): void;
+        isActive(): boolean;
+        broadcast<T = any>(data: T, buffers: ArrayBuffer[], cb: Function): any;
+        send<T_1 = any>(data: T_1, buffers: ArrayBuffer[], cb: Function, workerId?: number): any;
+        receive(message: maptalks.Message<any>): void;
+        remove(): void;
+        post(data: any, buffers: ArrayBuffer[], targetID: number): number;
+        getDedicatedWorker(): number;
+    };
+};
+declare class WorkerConnection extends WorkerConnection_base {
+    constructor(workerKey: any, layer: any);
+    _layer: any;
+    _mapId: any;
+    _workerLayerId: string;
+    _isDedicated: boolean;
+    _dedicatedVTWorkers: {};
+    _iconRequestor: any;
+    _glyphRequestor: any;
+    initialize(cb: any): void;
+    addLayer(cb: any): void;
+    abortTile(url: any, cb: any): void;
+    removeLayer(cb: any): void;
+    updateStyle(style: any, cb: any): void;
+    updateOptions(options: any, cb: any): void;
+    loadTile(context: any, cb: any): void;
+    fetchIconGlyphs({ icons, glyphs }: {
+        icons: any;
+        glyphs: any;
+    }, cb: any): void;
+    setData(geojson: any, cb: any): void;
+    _getTileKey(tileInfo: any): any;
+}
+
+declare class DebugPainter {
+    constructor(regl: any, map: any, color: any);
+    _regl: any;
+    _map: any;
+    _color: any;
+    draw(debugInfo: any, transform: any, tileSize: any, extent: any, fbo: any): void;
+    _data: any;
+    _textData: any;
+    _extent: any;
+    _debugInfoCanvas: HTMLCanvasElement;
+    _texture: any;
+    delete(): void;
+    _init(): void;
+    _texCoordData: any;
+    _command: any;
+}
+//# sourceMappingURL=DebugPainter.d.ts.map
+
+declare class TileStencilRenderer {
+    constructor(regl: any, canvas: any, map: any);
+    _regl: any;
+    _geometry: reshader.Geometry;
+    _scene: reshader.Scene;
+    _meshes: any[];
+    _counter: number;
+    _canvas: any;
+    _map: any;
+    start(): void;
+    /**
+     * 添加一个瓦片
+     * @param {Number} ref - stencil ref value
+     * @param {Number} extent - vector tile extent: 4096 or 8192
+     * @param {Number[]} transform - tile transform matrix
+     */
+    add(ref: number, EXTENT: any, transform: number[]): void;
+    render(fbo: any): void;
+    _getMesh(): any;
+    _init(regl: any): void;
+    _shader: reshader.MeshShader;
+    _renderer: reshader.Renderer;
+    remove(): void;
+}
+
+declare class VectorTileLayerRenderer extends maptalks.renderer.TileLayerCanvasRenderer {
+    constructor(layer: any);
+    supportRenderMode(): boolean;
+    ready: boolean;
+    _styleCounter: number;
+    _requestingMVT: {};
+    _plugins: {};
+    _featurePlugins: {};
+    getTileLevelValue(tileInfo: any, currentTileZoom: any): number;
+    getWorkerConnection(): WorkerConnection;
+    getStyleCounter(): number;
+    setStyle(): void;
+    _workersyncing: boolean;
+    _needRetire: boolean;
+    _preservePrevTiles(): void;
+    _prevTilesInView: maptalks.TilesInViewType;
+    _parentTiles: any[];
+    _childTiles: any[];
+    _tileZoom: any;
+    updateOptions(conf: any): void;
+    updateSceneConfig(type: any, idx: any, sceneConfig: any): void;
+    updateDataConfig(type: any, idx: any, dataConfig: any, old: any): void;
+    updateSymbol(type: any, idx: any, symbol: any): any;
+    needRetireFrames(): boolean;
+    isAnimating(): boolean;
+    _highlightFrametime: any;
+    needToRefreshTerrainTileOnZooming(): boolean;
+    _isInGroupGLLayer(): boolean;
+    regl: any;
+    glOptions: any;
+    pickingFBO: any;
+    _debugPainter: DebugPainter;
+    _groundPainter: GroundPainter;
+    _createREGLContext(canvas: any): {
+        gl: any;
+        attributes: any;
+        regl: createREGL.Regl;
+    };
+    _prepareWorker(): void;
+    _workerConn: WorkerConnection;
+    checkResources(): any[];
+    _drawTiles(tiles: any, parentTiles: any, childTiles: any, placeholders: any, context: any): void;
+    _deletePrevPlugins(): void;
+    draw(timestamp: any, parentContext: any): void;
+    _frameTime: any;
+    _zScale: number;
+    _parentContext: any;
+    _currentTimestamp: any;
+    _setPluginIndex(): void;
+    _prepareRender(): void;
+    _pluginOffsets: any;
+    _polygonOffsetIndex: number;
+    getFrameTimestamp(): any;
+    drawOnInteracting(event: any, timestamp: any, parentContext: any): void;
+    drawOutline(fbo: any): void;
+    getAnalysisMeshes(): any[];
+    getShadowMeshes(): any[];
+    isForeground(mesh: any): boolean;
+    _getTileZoomDiff(mesh: any): number;
+    isTileNearCamera(mesh: any): boolean;
+    isBackTile(id: any): boolean;
+    loadTileQueue(tileQueue: any): void;
+    loadTile(tileInfo: any): {};
+    getTileGLScale(z: any): number;
+    getCentimeterToPoint(z: any): number;
+    getRenderedFeatures(): {
+        tile: {
+            id: any;
+            x: any;
+            y: any;
+            z: any;
+            url: any;
+        };
+        current: boolean;
+        features: any[];
+    }[];
+    _onReceiveMVTData(url: any, err: any, data: any): void;
+    _parseTileData(styleType: any, i: any, pluginData: any, features: any): {
+        isUpdated: boolean;
+        layer: {
+            layer: any;
+            type: any;
+        };
+    };
+    _updateSchema(target: any, source: any): void;
+    _updatePluginIfNecessary(styleType: any, i: any, data: any): {
+        style: any;
+        isUpdated: boolean;
+    };
+    _layerPlugins: {};
+    _getFramePlugins(tileData: any): any;
+    _getAllPlugins(): any[];
+    _getStylePlugins(styleCounter: any): any;
+    _getFeaturePlugins(styleCounter: any): any;
+    _startFrame(timestamp: any, filter: any): void;
+    _endFrame(timestamp: any): void;
+    getPolygonOffsetCount(): number;
+    _drawDebug(): void;
+    _isVisitable(plugin: any): true | 0 | 1 | 2;
+    _getPluginContext(plugin: any, polygonOffsetIndex: any, cameraPosition: any, timestamp: any): {
+        regl: any;
+        layer: any;
+        gl: maptalks.TileRenderingContext;
+        isRenderingTerrain: boolean;
+        isRenderingTerrainSkin: any;
+        sceneConfig: any;
+        pluginIndex: any;
+        polygonOffsetIndex: any;
+        cameraPosition: any;
+        timestamp: any;
+    };
+    _hasMesh(meshes: any): boolean;
+    _drawTileStencil(fbo: any, painter: any): void;
+    _stencilRenderer: TileStencilRenderer;
+    _addTileStencil(tileInfo: any, ref: any): void;
+    onDrawTileStart(context: any): void;
+    _vtCurrentTiles: {};
+    _vtBgTiles: {};
+    _stencilTiles: any;
+    isEnableTileStencil(): boolean;
+    setTerrainHelper(terrainLayer: any): void;
+    _terrainLayer: any;
+    getTerrainHelper(): any;
+    drawTileOnTerrain(...args: any[]): void;
+    createTerrainTexture(regl: any): any;
+    _terrainDepthStencil: any;
+    deleteTerrainTexture(texture: any): void;
+    renderTerrainSkin(terrainRegl: any, terrainLayer: any, skinImages: any): void;
+    _drawTerrainTile(tile: any): void;
+    _endTerrainFrame(skinImages: any): void;
+    drawTile(tileInfo: any, tileData: any, filter: any): void;
+    _createOneTile(tileInfo: any, tileData: any): void;
+    checkTileInQueue(tileData: any): boolean;
+    pick(x: any, y: any, options: any): any[];
+    deleteTile(tile: any): void;
+    abortTileLoading(tileImage: any, tileInfo: any): void;
+    resizeCanvas(canvasSize: any): void;
+    _clearPlugin(): void;
+    plugins: {};
+    hitDetect(point: any): boolean;
+    _initPlugins(): any;
+    _createRenderPlugin(config: any): any;
+    _createGLContext(canvas: any, options: any): any;
+    _getCentiMeterScale(res: any): number;
+    debugFBO(id: any, fbo: any): void;
+    _getDefaultRenderPlugin(type: any): {
+        plugin: any;
+        symbol: {
+            markerFill: string;
+            markerSize: number;
+            markerOpacity: number;
+            lineColor?: undefined;
+            lineOpacity?: undefined;
+            polygonFill?: undefined;
+            polygonOpacity?: undefined;
+        } | {
+            lineColor: string;
+            lineOpacity: number;
+            markerFill?: undefined;
+            markerSize?: undefined;
+            markerOpacity?: undefined;
+            polygonFill?: undefined;
+            polygonOpacity?: undefined;
+        } | {
+            polygonFill: string;
+            polygonOpacity: number;
+            markerFill?: undefined;
+            markerSize?: undefined;
+            markerOpacity?: undefined;
+            lineColor?: undefined;
+            lineOpacity?: undefined;
+        };
+        renderPlugin: {
+            type: string;
+            dataConfig: {
+                type: string;
+                only2D: boolean;
+            };
+            sceneConfig?: undefined;
+        } | {
+            type: string;
+            dataConfig: {
+                type: string;
+                only2D: boolean;
+            };
+            sceneConfig: {
+                antialias: boolean;
+            };
+        };
+    };
+    _isVisible(): boolean;
+    isEnableWorkAround(key: any): boolean;
+    getZScale(): number;
+    outline(idx: any, featureIds: any): void;
+    _outline: any[];
+    outlineFeatures(featureIds: any): void;
+    outlineBatch(idx: any): void;
+    outlineAll(): void;
+    _outlineAll: boolean;
+    paintOutlineAll(fbo: any): void;
+    paintOutline(fbo: any, idx: any, featureIds: any): void;
+    paintBatchOutline(fbo: any, idx: any): void;
+    cancelOutline(): void;
+    setZIndex(...args: any[]): any;
+    consumeTile(tileImage: any, tileInfo: any): void;
+    onTileError(tileImage: any, tileInfo: any): void;
+    _retirePrevTile(tileInfo: any): void;
+    highlight(highlights: any): void;
+    _highlighted: Map<any, any>;
+    _highlightUpdated: boolean;
+    cancelHighlight(names: any): void;
+    cancelAllHighlight(): void;
+    _getLayerOpacity(): any;
+}
+
+declare class Vector3DLayer extends maptalks.OverlayLayer {
+    static registerPainter(name: string, clazz: unknown): void;
+    static get3DPainterClass(name: string): any;
+    setURLModifier(modifier: Function): this;
+    getURLModifier(): Function;
+    getEvents(): any;
+    onConfig(conf: unknown): void;
+    updateSymbol(idx: number, symbol: Record<string, any>): this;
+    /**
+     * 获取图层的polygonOffsetCount
+     * 用于GroupGLLayer全局管理polygonOffset
+     */
+    getPolygonOffsetCount(): 0 | 1;
+    /**
+     * 获取图层的polygonOffset
+     * 用于GroupGLLayer全局管理polygonOffset
+     */
+    getPolygonOffset(): number;
+    setPolygonOffset(offset: number, total: number): this;
+    getTotalPolygonOffset(): number;
+    /**
+     * Identify the geometries on the given coordinate
+     * @param  {maptalks.Coordinate} coordinate   - coordinate to identify
+     * @param  {Object} [options=null]  - options
+     * @param  {Object} [options.tolerance=0] - identify tolerance in pixel
+     * @param  {Object} [options.count=null]  - result count
+     * @return {Geometry[]} geometries identified
+     */
+    identify(coordinate: maptalks.Coordinate, options?: LayerIdentifyOptionsType): maptalks.Geometry[];
+    /**
+     * Identify the geometries on the given container point
+     * @param  point   - point to identify
+     * @param  [options=null]  - options
+     * @param  [options.tolerance=0] - identify tolerance in pixel
+     * @param  [options.count=null]  - result count
+     * @return geometries identified
+     */
+    identifyAtPoint(point: maptalks.Point, options?: {
+        tolerance?: number;
+        count?: number;
+        filter?: (picked: any) => boolean;
+    }): any[];
+    getComputedStyle(): {
+        style: any;
+    };
+    outlineAll(): this;
+    outline(geoIds: string[]): this;
+    cancelOutline(): this;
+    /**
+     * Export the Layer's JSON. <br>
+     * @return {Object} layer's JSON
+     */
+    toJSON(): any;
+    getTileSize(): maptalks.Size;
+}
+//# sourceMappingURL=Vector3DLayer.d.ts.map
+
+declare namespace ICON_PAINTER_SCENECONFIG {
+    let collision: boolean;
+    let fading: boolean;
+    let fadingDuration: number;
+    let fadeInDelay: number;
+    let fadeOutDelay: number;
+    let uniquePlacement: boolean;
+    let depthFunc: string;
+}
+
+interface PointLayerOptions extends OverlayLayerOptionsType {
+    glyphSdfLimitPerFrame?: number;
+    iconErrorUrl?: string;
+    workarounds?: {
+        "win-intel-gpu-crash"?: boolean;
+    };
+    sceneConfig?: typeof ICON_PAINTER_SCENECONFIG;
+    collisionFrameLimit?: number;
+}
+declare class PointLayer extends Vector3DLayer {
+    options: PointLayerOptions;
+    /**
+     * Reproduce a PointLayer from layer's JSON.
+     * @param  {Object} layerJSON - layer's JSON
+     * @return {PointLayer}
+     * @static
+     * @private
+     * @function
+     */
+    static fromJSON(json: object): PointLayer;
+    constructor(...args: any);
+    getPolygonOffsetCount(): 0 | 1;
+    getPolygonOffset(): number;
+}
+//# sourceMappingURL=PointLayer.d.ts.map
+
+declare class LineStringLayer extends Vector3DLayer {
+    /**
+     * Reproduce a LineStringLayer from layer's JSON.
+     * @param  {Object} layerJSON - layer's JSON
+     * @return {LineStringLayer}
+     * @static
+     * @private
+     * @function
+     */
+    static fromJSON(json: object): LineStringLayer;
+}
+//# sourceMappingURL=LineStringLayer.d.ts.map
+
+declare class PolygonLayer extends Vector3DLayer {
+    /**
+     * Reproduce a PolygonLayer from layer's JSON.
+     * @param  {Object} layerJSON - layer's JSON
+     * @return {PolygonLayer}
+     * @static
+     * @private
+     * @function
+     */
+    static fromJSON(json: object): PolygonLayer;
+}
+
+interface ExtrudePolygonLayerOptions extends OverlayLayerOptionsType {
+    dataConfig: LitDataConfig;
+    material: LitMaterial;
+    sideMaterial: LitMaterial;
+}
+declare class ExtrudePolygonLayer extends Vector3DLayer {
+    options: ExtrudePolygonLayerOptions;
+    /**
+     * Reproduce a PolygonLayer from layer's JSON.
+     * @param  {Object} layerJSON - layer's JSON
+     * @return {PolygonLayer}
+     * @static
+     * @private
+     * @function
+     */
+    static fromJSON(json: object): ExtrudePolygonLayer;
+    getPolygonOffsetCount(): 0 | 1;
+    getPolygonOffset(): number;
+    onConfig(conf: Record<string, any>): void;
+    updateMaterial(matInfo: LitMaterial): this;
+    updateSideMaterial(matInfo: LitMaterial): this;
+    updateDataConfig(dataConfig: LitDataConfig): this;
+}
+//# sourceMappingURL=ExtrudePolygonLayer.d.ts.map
+
+export { ExtrudePolygonLayer, GeoJSONVectorTileLayer, LineStringLayer, MapboxVectorTileLayer, PointLayer, PolygonLayer, Vector3DLayer, VectorTileLayer, VectorTileLayerRenderer };
+//# sourceMappingURL=maptalks.vt.d.ts.map