@skzz/components-gis 0.0.1

package/dist/shims-vue.d.ts

@@ -0,0 +1,7 @@
+// images.d.ts
+declare module '*.png'
+declare module '*.jpg'
+declare module '*.jpeg'
+declare module '*.gif'
+declare module '*.svg'
+declare module '*.webp'

package/dist/utils/layerProviderKey.d.ts

@@ -0,0 +1,2 @@
+export function buildImageryProviderKey(config?: {}): string;
+export function buildMvtProviderKey(config?: {}): string;

package/dist/utils/layerStack.d.ts

@@ -0,0 +1,33 @@
+import type * as Cesium from 'cesium';
+export declare const LAYER_TYPE_BAND: Record<string, number>;
+type CesiumViewer = Cesium.Viewer;
+export type ImageryStackMeta = {
+    layerType: string;
+    groupKey: string;
+    stackIndex: number;
+    typeBandBase?: number;
+    subStackIndex?: number;
+    tileOrder?: number;
+};
+export type PrimitiveStackMeta = {
+    layerType: string;
+    groupKey: string;
+    stackIndex: number;
+    subStackIndex?: number;
+    tileOrder?: number;
+};
+export declare function tagImageryLayerStackMeta(imageryLayer: Cesium.ImageryLayer, meta: ImageryStackMeta): void;
+export declare function tagPrimitiveStackMeta(primitive: Cesium.Primitive | Cesium.Cesium3DTileset, meta: PrimitiveStackMeta): void;
+export declare function getBaseImageryIndex(viewer: CesiumViewer): number;
+export declare function moveImageryLayerToIndex(viewer: CesiumViewer, imageryLayer: Cesium.ImageryLayer, targetIndex: number): void;
+export declare function movePrimitiveToIndex(viewer: CesiumViewer, primitive: Cesium.Primitive | Cesium.Cesium3DTileset, targetIndex: number): void;
+export declare function syncImageryLayerStack(viewer: CesiumViewer): void;
+export declare function syncPrimitiveStack(viewer: CesiumViewer): void;
+export declare function scheduleImageryLayerStackSync(viewer: CesiumViewer, delay?: number): void;
+export declare function schedulePrimitiveStackSync(viewer: CesiumViewer, delay?: number): void;
+export declare function applyImageryStackIndex(viewer: CesiumViewer, imageryLayer: Cesium.ImageryLayer, stackIndex: number, meta?: Partial<ImageryStackMeta>): void;
+export declare function moveImageryLayersToStackIndex(viewer: CesiumViewer, imageryLayers: Cesium.ImageryLayer[], stackIndex: number, groupKey?: string, meta?: Partial<ImageryStackMeta>): void;
+export declare function applyPrimitiveStackIndex(viewer: CesiumViewer, primitive: Cesium.Primitive | Cesium.Cesium3DTileset, stackIndex: number, meta?: Partial<PrimitiveStackMeta>): void;
+export declare function addImageryLayerWithStackIndex(viewer: CesiumViewer, imageryLayer: Cesium.ImageryLayer, stackIndex: number, _typeBandBase?: number, meta?: Partial<ImageryStackMeta>): void;
+export declare function addPrimitiveWithStackIndex(viewer: CesiumViewer, primitive: Cesium.Primitive | Cesium.Cesium3DTileset, stackIndex: number, _typeBandBase?: number, meta?: Partial<PrimitiveStackMeta>): void;
+export {};

package/dist/utils/zzts3dLayerSignature.d.ts

@@ -0,0 +1,2 @@
+export function buildZzts3dRenderSignature(options?: {}): string;
+export function hasZzts3dRenderConfigChanged(prevSignature: any, nextOptions?: {}): boolean;

package/dist/zz-analysis/zz-terrain-excavation/excavationUtils.d.ts

@@ -0,0 +1,35 @@
+import { ZzTerrainExcavationConfigInput, ZzLngLatHeight, ZzTerrainExcavationConfig, ZzTerrainExcavationItem, ZzTerrainExcavationLimits } from './types';
+import * as Cesium from 'cesium';
+export declare const EXCAVATION_TRANSITION_DURATION = 260;
+export declare const EXCAVATION_WALL_TEXTURE_TILE_WIDTH = 100;
+export declare const EXCAVATION_MAX_SEGMENT_STEPS = 800;
+export declare const EXCAVATION_MAX_BOUNDARY_POSITION_COUNT = 8000;
+export declare const EXCAVATION_MAX_AREA: number;
+export declare const EXCAVATION_MAX_PERIMETER: number;
+export interface ExcavationBoundarySegment {
+    points: ZzLngLatHeight[];
+}
+export declare const defaultExcavationConfig: ZzTerrainExcavationConfig;
+export declare const mergeExcavationConfig: (config?: ZzTerrainExcavationConfigInput) => ZzTerrainExcavationConfig;
+export declare const toCesiumColor: (color: string, fallbackColor: string, opacity?: number) => Cesium.Color;
+export declare const createPrimitiveMaterial: (texture: string | undefined, color: string, opacity: number, fallbackColor: string, repeat?: Cesium.Cartesian2) => Cesium.Material;
+export declare const getWallPerimeter: (positions: Cesium.Cartesian3[]) => number;
+export declare const resolveWallTextureRepeat: (texture: string | undefined, positions: Cesium.Cartesian3[]) => Cesium.Cartesian2 | undefined;
+export declare const createTransitionEntity: (viewer: Cesium.Viewer, id: string, positions: Cesium.Cartesian3[], clampToGround?: boolean) => Cesium.Entity;
+export declare const createOversizedAreaEntity: (viewer: Cesium.Viewer, positions: Cesium.Cartesian3[], clampToGround?: boolean) => Cesium.Entity;
+export declare const waitForTransition: (duration?: number) => Promise<void>;
+export declare const toCartesian: (point: ZzLngLatHeight, height?: number) => Cesium.Cartesian3;
+export declare const toClipCartesian: (point: ZzLngLatHeight) => Cesium.Cartesian3;
+export declare const isSameLngLat: (first: ZzLngLatHeight, second: ZzLngLatHeight) => boolean;
+export declare const normalizePositions: (positions: ZzLngLatHeight[]) => ZzLngLatHeight[];
+export declare const resolveAdaptiveSampleDistance: (segmentLength: number) => 5 | 10 | 20 | 50;
+export declare const resolveBoundarySegmentSteps: (segmentLength: number) => number;
+export declare const densifyBoundarySegments: (positions: ZzLngLatHeight[]) => ExcavationBoundarySegment[];
+export declare const flattenBoundarySegments: (segments: ExcavationBoundarySegment[]) => ZzLngLatHeight[];
+export declare const calculateBoundaryPerimeter: (positions: ZzLngLatHeight[]) => number;
+export declare const calculateExcavationArea: (positions: ZzLngLatHeight[]) => number;
+export declare const resolveExcavationRangeWarning: (positions: ZzLngLatHeight[], limits: ZzTerrainExcavationLimits) => string;
+export declare const resolveExcavationLimitWarning: (boundaryPositions: ZzLngLatHeight[], limits: ZzTerrainExcavationLimits) => string;
+export declare const splitBoundaryHeightsBySegments: (segments: ExcavationBoundarySegment[], heights: number[]) => number[][];
+export declare const resolveBottomHeights: (surfaceHeights: number[], depth: number) => number[];
+export declare const normalizeItem: (item: ZzTerrainExcavationItem, style: ZzTerrainExcavationConfig["globalStyle"], createId: () => string) => Required<ZzTerrainExcavationItem>;

package/dist/zz-analysis/zz-terrain-excavation/index.vue.d.ts

@@ -0,0 +1,24 @@
+import { ZzTerrainExcavationConfigInput } from './types';
+type __VLS_Props = {
+    config?: ZzTerrainExcavationConfigInput;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    addExcavation: (item: import('./types').ZzTerrainExcavationItem) => Promise<string | null>;
+    updateExcavation: (id: string, config: Partial<import('./types').ZzTerrainExcavationItem>) => Promise<boolean>;
+    removeExcavation: (id: string) => void;
+    clearExcavations: () => void;
+    getExcavationIds: () => string[];
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "excavation-ready": (...args: any[]) => void;
+    "excavation-updated": (...args: any[]) => void;
+    "excavation-removed": (...args: any[]) => void;
+    "excavation-cleared": (...args: any[]) => void;
+    "excavation-error": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onExcavation-ready"?: ((...args: any[]) => any) | undefined;
+    "onExcavation-updated"?: ((...args: any[]) => any) | undefined;
+    "onExcavation-removed"?: ((...args: any[]) => any) | undefined;
+    "onExcavation-cleared"?: ((...args: any[]) => any) | undefined;
+    "onExcavation-error"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/zz-analysis/zz-terrain-excavation/types.d.ts

@@ -0,0 +1,59 @@
+export interface ZzLngLatHeight {
+    lng: number;
+    lat: number;
+    height?: number;
+}
+export interface ZzTerrainExcavationStyleFields {
+    sideTexture?: string;
+    bottomTexture?: string;
+    sideColor: string;
+    bottomColor: string;
+    edgeColor: string;
+    sideOpacity: number;
+    bottomOpacity: number;
+    edgeOpacity: number;
+    edgeWidth: number;
+    showSide: boolean;
+    showBottom: boolean;
+    showEdge: boolean;
+}
+export interface ZzTerrainExcavationStyle extends ZzTerrainExcavationStyleFields {
+    show: boolean;
+    height: number;
+}
+export interface ZzTerrainExcavationLimits {
+    maxBoundaryPositionCount: number;
+    maxArea: number;
+    maxPerimeter: number;
+}
+export interface ZzTerrainExcavationItem extends Partial<ZzTerrainExcavationStyleFields> {
+    id?: string;
+    positions: ZzLngLatHeight[];
+    height?: number;
+    show?: boolean;
+}
+export interface ZzTerrainExcavationConfig {
+    excavations: ZzTerrainExcavationItem[];
+    globalStyle: ZzTerrainExcavationStyle;
+    depthTestAgainstTerrain: boolean;
+    sampleTerrain: boolean;
+    enableTerrainClip: boolean;
+    autoClear: boolean;
+    limits: ZzTerrainExcavationLimits;
+}
+export type ZzTerrainExcavationConfigInput = Partial<Omit<ZzTerrainExcavationConfig, 'globalStyle' | 'limits'>> & {
+    globalStyle?: Partial<ZzTerrainExcavationStyle>;
+    limits?: Partial<ZzTerrainExcavationLimits>;
+};
+export interface ZzTerrainExcavationReadyPayload {
+    total: number;
+    excavationIds: string[];
+    methods: ZzTerrainExcavationMethods;
+}
+export interface ZzTerrainExcavationMethods {
+    addExcavation: (item: ZzTerrainExcavationItem) => Promise<string | null>;
+    updateExcavation: (id: string, config: Partial<ZzTerrainExcavationItem>) => Promise<boolean>;
+    removeExcavation: (id: string) => void;
+    clearExcavations: () => void;
+    getExcavationIds: () => string[];
+}

package/dist/zz-analysis/zz-terrain-excavation/useTerrainExcavation.d.ts

@@ -0,0 +1,34 @@
+import { ZzTerrainExcavationConfig, ZzTerrainExcavationItem, ZzTerrainExcavationMethods } from './types';
+import * as Cesium from 'cesium';
+export { defaultExcavationConfig, mergeExcavationConfig } from './excavationUtils';
+type EmitFn = (event: string, payload?: unknown) => void;
+export declare const useTerrainExcavation: (getViewer: () => Cesium.Viewer | null | undefined, getConfig: () => ZzTerrainExcavationConfig, emit: EmitFn, getPublicMethods?: () => ZzTerrainExcavationMethods, waitForFormalRender?: () => Promise<void>) => {
+    syncExcavations: (options?: {
+        forceRebuild?: boolean;
+    }) => Promise<void>;
+    addExcavation: (item: ZzTerrainExcavationItem, options?: {
+        controlledByConfig?: boolean;
+        syncSignature?: string;
+    }) => Promise<string | null>;
+    updateExcavation: (id: string, config: Partial<ZzTerrainExcavationItem>, options?: {
+        controlledByConfig?: boolean;
+        syncSignature?: string;
+    }) => Promise<boolean>;
+    removeExcavation: (id: string) => void;
+    clearExcavations: () => void;
+    applyDepthTestAgainstTerrain: () => void;
+    restoreDepthTestAgainstTerrain: () => void;
+    getMethods: () => {
+        addExcavation: (item: ZzTerrainExcavationItem, options?: {
+            controlledByConfig?: boolean;
+            syncSignature?: string;
+        }) => Promise<string | null>;
+        updateExcavation: (id: string, config: Partial<ZzTerrainExcavationItem>, options?: {
+            controlledByConfig?: boolean;
+            syncSignature?: string;
+        }) => Promise<boolean>;
+        removeExcavation: (id: string) => void;
+        clearExcavations: () => void;
+        getExcavationIds: () => string[];
+    };
+};

package/dist/zz-entity/zz-entity-point/index.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "points-ready" | "point-updated" | "point-removed" | "flyTo-completed" | "point-error", ...args: any[]) => void;
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-entity/zz-entity-polygon/index.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "flyTo-completed" | "polygons-ready" | "polygon-updated" | "polygon-removed" | "polygon-error" | "bounds-updated", ...args: any[]) => void;
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-entity/zz-entity-polyline/index.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "flyTo-completed" | "lines-ready" | "line-updated" | "line-removed" | "line-error", ...args: any[]) => void;
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-geojson/index.vue.d.ts

@@ -0,0 +1,38 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    getDataSource: () => any;
+    getEntities: () => never[];
+    flyTo: typeof flyTo;
+    removeLayer: typeof removeLayer;
+    reload: typeof loadGeoJson;
+    setVisibility: typeof setVisibility;
+    $emit: (event: "loaded" | "error" | "updated" | "click", ...args: any[]) => void;
+    geojson: string | Record<string, any>;
+    name: string;
+    style: Record<string, any>;
+    show: boolean;
+    clampToGround: boolean;
+    token: string;
+    fitToLayer: boolean;
+    fitDuration: number;
+    layerZIndex: number;
+    styleByProperty: Record<string, any>;
+    note: Record<string, any>;
+    $props: {
+        readonly geojson?: string | Record<string, any> | undefined;
+        readonly name?: string | undefined;
+        readonly style?: Record<string, any> | undefined;
+        readonly show?: boolean | undefined;
+        readonly clampToGround?: boolean | undefined;
+        readonly token?: string | undefined;
+        readonly fitToLayer?: boolean | undefined;
+        readonly fitDuration?: number | undefined;
+        readonly layerZIndex?: number | undefined;
+        readonly styleByProperty?: Record<string, any> | undefined;
+        readonly note?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+declare function flyTo(duration?: number): Promise<boolean>;
+declare function removeLayer(): void;
+declare function loadGeoJson(): Promise<void>;
+declare function setVisibility(visible: any): void;

package/dist/zz-layer/zz-layer-mvt/index.vue.d.ts

@@ -0,0 +1,16 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "loaded", ...args: any[]) => void;
+    groupKey: string;
+    stackIndex: number;
+    subStackIndex: number;
+    provider: Record<string, any>;
+    options: Record<string, any>;
+    $props: {
+        readonly groupKey?: string | undefined;
+        readonly stackIndex?: number | undefined;
+        readonly subStackIndex?: number | undefined;
+        readonly provider?: Record<string, any> | undefined;
+        readonly options?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-wms/index.vue.d.ts

@@ -0,0 +1,15 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    groupKey: string;
+    stackIndex: number;
+    subStackIndex: number;
+    provider: Record<string, any>;
+    options: Record<string, any>;
+    $props: {
+        readonly groupKey?: string | undefined;
+        readonly stackIndex?: number | undefined;
+        readonly subStackIndex?: number | undefined;
+        readonly provider?: Record<string, any> | undefined;
+        readonly options?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-wmts/index.vue.d.ts

@@ -0,0 +1,15 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    groupKey: string;
+    stackIndex: number;
+    subStackIndex: number;
+    provider: Record<string, any>;
+    options: Record<string, any>;
+    $props: {
+        readonly groupKey?: string | undefined;
+        readonly stackIndex?: number | undefined;
+        readonly subStackIndex?: number | undefined;
+        readonly provider?: Record<string, any> | undefined;
+        readonly options?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-xyz/index.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    provider: Record<string, any>;
+    options: Record<string, any>;
+    $props: {
+        readonly provider?: Record<string, any> | undefined;
+        readonly options?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-zzts/index.vue.d.ts

@@ -0,0 +1,15 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    groupKey: string;
+    stackIndex: number;
+    subStackIndex: number;
+    provider: Record<string, any>;
+    options: Record<string, any>;
+    $props: {
+        readonly groupKey?: string | undefined;
+        readonly stackIndex?: number | undefined;
+        readonly subStackIndex?: number | undefined;
+        readonly provider?: Record<string, any> | undefined;
+        readonly options?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-zzts3d/entityGrid-0.1.d.ts

@@ -0,0 +1,19 @@
+export function initEntity(options: any): Promise<any>;
+export function initEntityStatic(options: any): Promise<any>;
+export function removeEntity(id: any): void;
+export function removeEntityNotDes(id: any): void;
+export function removeAllEntities(): void;
+export function getEntityLayer(id: any): any;
+export let currentNewLevels: import('vue').ComputedRef<any>;
+export const entityGridManager: EntityGridManager;
+declare class EntityGridManager {
+    layers: Map<any, any>;
+    createLayer(options: any): Promise<any>;
+    removeLayer(id: any): void;
+    removeAllLayers(): void;
+    getLayer(id: any): any;
+    getLayerIds(): any[];
+    removeTilesByLayerId(id: any): void;
+    refreshLayer(id: any): void;
+}
+export {};

package/dist/zz-layer/zz-layer-zzts3d/entityGrid-1.0.d.ts

@@ -0,0 +1,19 @@
+export function initEntity(options: any): Promise<any>;
+export function initEntityStatic(options: any): Promise<any>;
+export function removeEntity(id: any): void;
+export function removeEntityNotDes(id: any): void;
+export function removeAllEntities(): void;
+export function getEntityLayer(id: any): any;
+export let currentNewLevels: import('vue').ComputedRef<any>;
+export const entityGridManager: EntityGridManager;
+declare class EntityGridManager {
+    layers: Map<any, any>;
+    createLayer(options: any): Promise<any>;
+    removeLayer(id: any): void;
+    removeAllLayers(): void;
+    getLayer(id: any): any;
+    getLayerIds(): any[];
+    removeTilesByLayerId(id: any): void;
+    refreshLayer(id: any): void;
+}
+export {};

package/dist/zz-layer/zz-layer-zzts3d/entityGrid.d.ts

@@ -0,0 +1,19 @@
+export function initEntity(options: any): Promise<any>;
+export function initEntityStatic(options: any): Promise<any>;
+export function removeEntity(id: any): void;
+export function removeEntityNotDes(id: any): void;
+export function removeAllEntities(): void;
+export function getEntityLayer(id: any): any;
+export let currentNewLevels: import('vue').ComputedRef<any>;
+export const entityGridManager: EntityGridManager;
+declare class EntityGridManager {
+    layers: Map<any, any>;
+    createLayer(options: any): any;
+    removeLayer(id: any): void;
+    removeAllLayers(): void;
+    getLayer(id: any): any;
+    getLayerIds(): any[];
+    removeTilesByLayerId(id: any): void;
+    refreshLayer(id: any): void;
+}
+export {};

package/dist/zz-layer/zz-layer-zzts3d/index.vue.d.ts

@@ -0,0 +1,13 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    groupKey: string;
+    stackIndex: number;
+    subStackIndex: number;
+    config: Record<string, any>;
+    $props: {
+        readonly groupKey?: string | undefined;
+        readonly stackIndex?: number | undefined;
+        readonly subStackIndex?: number | undefined;
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-zzts3d-grid/color.vue.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-zzts3d-grid/index.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "point-click", ...args: any[]) => void;
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-zzts3d-grid/interpolation.vue.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-zzts3d-grid/query.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "grid-change", ...args: any[]) => void;
+    config: Record<string, any>;
+    style: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+        readonly style?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-zzts3d-point/entityGrid.d.ts

@@ -0,0 +1,19 @@
+export function initEntity(options: any): Promise<any>;
+export function initEntityStatic(options: any): Promise<any>;
+export function removeEntity(id: any): void;
+export function removeEntityNotDes(id: any): void;
+export function removeAllEntities(): void;
+export function getEntityLayer(id: any): any;
+export let currentNewLevels: import('vue').ComputedRef<any>;
+export const entityGridManager: EntityGridManager;
+declare class EntityGridManager {
+    layers: Map<any, any>;
+    createLayer(options: any): Promise<any>;
+    removeLayer(id: any): void;
+    removeAllLayers(): void;
+    getLayer(id: any): any;
+    getLayerIds(): any[];
+    removeTilesByLayerId(id: any): void;
+    refreshLayer(id: any): void;
+}
+export {};

package/dist/zz-layer/zz-layer-zzts3d-point/index.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "point-click", ...args: any[]) => void;
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-layer/zz-layer-zzts3d-point/pointTileUtils.d.ts

@@ -0,0 +1,8 @@
+export function getPointTileRequestLevel(geoSot: any, fallbackLevel: any): number;
+export function parsePointTileGeometries(tileData: any, lodLevel: any): {
+    positions: Float64Array<ArrayBuffer>;
+    positionCount: number;
+    modelId: string;
+    lodLevel: any;
+}[];
+export function isPointLayerRequestActive({ destroyed, currentVersion, requestVersion, cancelToken, }?: {}): boolean;

package/dist/zz-layer/zz-layer-zzts3d-point/queryPoint.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "stats-change", ...args: any[]) => void;
+    config: Record<string, any>;
+    style: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+        readonly style?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-legend/index.vue.d.ts

@@ -0,0 +1,73 @@
+export interface LegendPanelItem {
+    label?: string;
+    value?: string | number;
+    valueName?: string;
+    color?: string;
+    r?: number;
+    g?: number;
+    b?: number;
+    a?: number;
+    type?: 'point' | 'line' | 'polygon' | 'range' | 'icon';
+    min?: number;
+    max?: number;
+    [key: string]: any;
+}
+export interface MultibandLegendData {
+    MultibandValueNameTop?: string;
+    MultibandValueNameBot?: string;
+    colorBand?: string[];
+}
+export interface LegendPanelData {
+    styleType?: 'multiband' | 'classified' | 'unique' | 'point' | 'line' | 'polygon' | string;
+    serviceName?: string;
+    ColorListLenList?: MultibandLegendData | LegendPanelItem[];
+    colorList?: {
+        point?: {
+            fill?: string;
+            stroke?: {
+                visible?: boolean;
+                type?: string;
+                outlineColor?: string;
+                color?: string;
+                outlineWidth?: number;
+            };
+        };
+        line?: {
+            stroke?: {
+                visible?: boolean;
+                type?: string;
+                outlineColor?: string;
+                color?: string;
+                outlineWidth?: number;
+            };
+        };
+        polygon?: {
+            fill?: string;
+            stroke?: {
+                visible?: boolean;
+                type?: string;
+                outlineColor?: string;
+                color?: string;
+                outlineWidth?: number;
+            };
+        };
+    };
+}
+type __VLS_Props = {
+    visible: boolean;
+    title?: string;
+    items?: LegendPanelItem[];
+    legendData?: LegendPanelData | string | null;
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:visible": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+}>, {
+    title: string;
+    items: LegendPanelItem[];
+    legendData: LegendPanelData | string | null;
+    position: "bottom-right" | "bottom-left" | "top-right" | "top-left";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/zz-model/zz-3dtiles/index.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: ((...args: any[]) => any) | ((evt: string, ...args: any) => void);
+    groupKey: string;
+    stackIndex: number;
+    subStackIndex: number;
+    config: Record<string, any>;
+    $props: {
+        readonly groupKey?: string | undefined;
+        readonly stackIndex?: number | undefined;
+        readonly subStackIndex?: number | undefined;
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-model/zz-gltf/index.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "model-ready" | "model-error", ...args: any[]) => void;
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/zz-terrain/index.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: ((...args: any[]) => any) | ((evt: string, ...args: any) => void);
+    config: Record<string, any>;
+    $props: {
+        readonly config?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;