@giro3d/piero 25.10.0-beta.10

package/dist/src/stores/annotations.d.ts

@@ -0,0 +1,60 @@
+import { default as Annotation } from '../types/Annotation';
+import { default as AnnotationMode } from '../types/AnnotationMode';
+export declare const useAnnotationStore: import('pinia').StoreDefinition<"annotations", Pick<{
+    count: import('vue').ComputedRef<number>;
+    showLabels: () => boolean;
+    setShowLabels: (v: boolean) => void;
+    isUserDrawing: () => boolean;
+    setIsUserDrawing: (value: boolean) => void;
+    getAnnotationMode: () => AnnotationMode;
+    setAnnotationMode: (mode: AnnotationMode) => void;
+    getAnnotations: () => Annotation[];
+    hasAnnotation: (name: string) => boolean;
+    add: (annotation: Annotation) => void;
+    remove: (annotation: Annotation) => void;
+    createPoint: () => void;
+    createLine: () => void;
+    createPolygon: () => void;
+    edit: (annotation: Annotation) => void;
+    stopEdition: () => void;
+    importAnnotationFile: (file: Blob) => void;
+    importAnnotationsFiles: (files: File[]) => void;
+}, never>, Pick<{
+    count: import('vue').ComputedRef<number>;
+    showLabels: () => boolean;
+    setShowLabels: (v: boolean) => void;
+    isUserDrawing: () => boolean;
+    setIsUserDrawing: (value: boolean) => void;
+    getAnnotationMode: () => AnnotationMode;
+    setAnnotationMode: (mode: AnnotationMode) => void;
+    getAnnotations: () => Annotation[];
+    hasAnnotation: (name: string) => boolean;
+    add: (annotation: Annotation) => void;
+    remove: (annotation: Annotation) => void;
+    createPoint: () => void;
+    createLine: () => void;
+    createPolygon: () => void;
+    edit: (annotation: Annotation) => void;
+    stopEdition: () => void;
+    importAnnotationFile: (file: Blob) => void;
+    importAnnotationsFiles: (files: File[]) => void;
+}, "count">, Pick<{
+    count: import('vue').ComputedRef<number>;
+    showLabels: () => boolean;
+    setShowLabels: (v: boolean) => void;
+    isUserDrawing: () => boolean;
+    setIsUserDrawing: (value: boolean) => void;
+    getAnnotationMode: () => AnnotationMode;
+    setAnnotationMode: (mode: AnnotationMode) => void;
+    getAnnotations: () => Annotation[];
+    hasAnnotation: (name: string) => boolean;
+    add: (annotation: Annotation) => void;
+    remove: (annotation: Annotation) => void;
+    createPoint: () => void;
+    createLine: () => void;
+    createPolygon: () => void;
+    edit: (annotation: Annotation) => void;
+    stopEdition: () => void;
+    importAnnotationFile: (file: Blob) => void;
+    importAnnotationsFiles: (files: File[]) => void;
+}, "add" | "remove" | "showLabels" | "setShowLabels" | "isUserDrawing" | "setIsUserDrawing" | "getAnnotationMode" | "setAnnotationMode" | "getAnnotations" | "hasAnnotation" | "createPoint" | "createLine" | "createPolygon" | "edit" | "stopEdition" | "importAnnotationFile" | "importAnnotationsFiles">>;

package/dist/src/stores/bookmarks.d.ts

@@ -0,0 +1,21 @@
+import { default as Bookmark } from '../types/Bookmark';
+export declare const useBookmarkStore: import('pinia').StoreDefinition<"bookmarks", Pick<{
+    count: import('vue').ComputedRef<number>;
+    add: (bookmark: Bookmark) => void;
+    remove: (bookmark: Bookmark) => void;
+    clear: () => void;
+    getBookmarks: () => Bookmark[];
+}, never>, Pick<{
+    count: import('vue').ComputedRef<number>;
+    add: (bookmark: Bookmark) => void;
+    remove: (bookmark: Bookmark) => void;
+    clear: () => void;
+    getBookmarks: () => Bookmark[];
+}, "count">, Pick<{
+    count: import('vue').ComputedRef<number>;
+    add: (bookmark: Bookmark) => void;
+    remove: (bookmark: Bookmark) => void;
+    clear: () => void;
+    getBookmarks: () => Bookmark[];
+}, "add" | "clear" | "remove" | "getBookmarks">>;
+export type BookmarkStore = ReturnType<typeof useBookmarkStore>;

package/dist/src/stores/camera.d.ts

@@ -0,0 +1,287 @@
+import { default as CameraPosition } from '../types/CameraPosition';
+import { default as NavigationMode } from '../types/NavigationMode';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { Box3, Object3D, Vector3 } from '../../../../node_modules/three';
+export declare const useCameraStore: import('pinia').StoreDefinition<"camera", Pick<{
+    getCameraPosition: () => CameraPosition;
+    getCamera3dPosition: () => {
+        x: number;
+        y: number;
+        z: number;
+        readonly isVector3: true;
+        set: (x: number, y: number, z: number) => Vector3;
+        setScalar: (scalar: number) => Vector3;
+        setX: (x: number) => Vector3;
+        setY: (y: number) => Vector3;
+        setZ: (z: number) => Vector3;
+        setComponent: (index: number, value: number) => Vector3;
+        getComponent: (index: number) => number;
+        clone: () => Vector3;
+        copy: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        add: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        addScalar: (s: number) => Vector3;
+        addVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        addScaledVector: (v: Vector3, s: number) => Vector3;
+        sub: (a: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        subScalar: (s: number) => Vector3;
+        subVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        multiply: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        multiplyScalar: (s: number) => Vector3;
+        multiplyVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        applyEuler: (euler: import('../../../../node_modules/three').Euler) => Vector3;
+        applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
+        applyMatrix3: (m: import('../../../../node_modules/three').Matrix3) => Vector3;
+        applyNormalMatrix: (m: import('../../../../node_modules/three').Matrix3) => Vector3;
+        applyMatrix4: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        applyQuaternion: (q: import('../../../../node_modules/three').QuaternionLike) => Vector3;
+        project: (camera: import('../../../../node_modules/three').Camera) => Vector3;
+        unproject: (camera: import('../../../../node_modules/three').Camera) => Vector3;
+        transformDirection: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        divide: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        divideScalar: (s: number) => Vector3;
+        min: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        max: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        clamp: (min: import('../../../../node_modules/three').Vector3Like, max: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        clampScalar: (min: number, max: number) => Vector3;
+        clampLength: (min: number, max: number) => Vector3;
+        floor: () => Vector3;
+        ceil: () => Vector3;
+        round: () => Vector3;
+        roundToZero: () => Vector3;
+        negate: () => Vector3;
+        dot: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        lengthSq: () => number;
+        length: () => number;
+        manhattanLength: () => number;
+        normalize: () => Vector3;
+        setLength: (l: number) => Vector3;
+        lerp: (v: import('../../../../node_modules/three').Vector3Like, alpha: number) => Vector3;
+        lerpVectors: (v1: import('../../../../node_modules/three').Vector3Like, v2: import('../../../../node_modules/three').Vector3Like, alpha: number) => Vector3;
+        cross: (a: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        crossVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        projectOnVector: (v: Vector3) => Vector3;
+        projectOnPlane: (planeNormal: Vector3) => Vector3;
+        reflect: (vector: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        angleTo: (v: Vector3) => number;
+        distanceTo: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        distanceToSquared: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        manhattanDistanceTo: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        setFromSpherical: (s: import('../../../../node_modules/three').Spherical) => Vector3;
+        setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
+        setFromCylindrical: (s: import('../../../../node_modules/three').Cylindrical) => Vector3;
+        setFromCylindricalCoords: (radius: number, theta: number, y: number) => Vector3;
+        setFromMatrixPosition: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        setFromMatrixScale: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        setFromMatrixColumn: (matrix: import('../../../../node_modules/three').Matrix4, index: number) => Vector3;
+        setFromMatrix3Column: (matrix: import('../../../../node_modules/three').Matrix3, index: number) => Vector3;
+        setFromEuler: (e: import('../../../../node_modules/three').Euler) => Vector3;
+        setFromColor: (color: import('../../../../node_modules/three').RGB) => Vector3;
+        equals: (v: import('../../../../node_modules/three').Vector3Like) => boolean;
+        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
+        toArray: {
+            (array?: number[] | undefined, offset?: number | undefined): number[];
+            (array?: import('../../../../node_modules/three').Vector3Tuple | undefined, offset?: 0 | undefined): import('../../../../node_modules/three').Vector3Tuple;
+            (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+        };
+        fromBufferAttribute: (attribute: import('../../../../node_modules/three').BufferAttribute | import('../../../../node_modules/three').InterleavedBufferAttribute, index: number) => Vector3;
+        random: () => Vector3;
+        randomDirection: () => Vector3;
+        [Symbol.iterator]: () => Iterator<number, any, undefined>;
+    };
+    setCameraPosition: (pos: CameraPosition) => void;
+    setCurrentPosition: (pos: CameraPosition, position3d: Vector3) => void;
+    getNavigationMode: () => NavigationMode;
+    getNavigationModeRef: () => import('vue').Ref<NavigationMode, NavigationMode>;
+    setNavigationMode: (mode: NavigationMode) => void;
+    isUserInteracting: () => boolean;
+    setIsUserInteracting: (value: boolean) => void;
+    lookTopDownAt: (obj: Box3 | Object3D | Entity3D) => void;
+}, never>, Pick<{
+    getCameraPosition: () => CameraPosition;
+    getCamera3dPosition: () => {
+        x: number;
+        y: number;
+        z: number;
+        readonly isVector3: true;
+        set: (x: number, y: number, z: number) => Vector3;
+        setScalar: (scalar: number) => Vector3;
+        setX: (x: number) => Vector3;
+        setY: (y: number) => Vector3;
+        setZ: (z: number) => Vector3;
+        setComponent: (index: number, value: number) => Vector3;
+        getComponent: (index: number) => number;
+        clone: () => Vector3;
+        copy: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        add: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        addScalar: (s: number) => Vector3;
+        addVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        addScaledVector: (v: Vector3, s: number) => Vector3;
+        sub: (a: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        subScalar: (s: number) => Vector3;
+        subVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        multiply: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        multiplyScalar: (s: number) => Vector3;
+        multiplyVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        applyEuler: (euler: import('../../../../node_modules/three').Euler) => Vector3;
+        applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
+        applyMatrix3: (m: import('../../../../node_modules/three').Matrix3) => Vector3;
+        applyNormalMatrix: (m: import('../../../../node_modules/three').Matrix3) => Vector3;
+        applyMatrix4: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        applyQuaternion: (q: import('../../../../node_modules/three').QuaternionLike) => Vector3;
+        project: (camera: import('../../../../node_modules/three').Camera) => Vector3;
+        unproject: (camera: import('../../../../node_modules/three').Camera) => Vector3;
+        transformDirection: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        divide: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        divideScalar: (s: number) => Vector3;
+        min: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        max: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        clamp: (min: import('../../../../node_modules/three').Vector3Like, max: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        clampScalar: (min: number, max: number) => Vector3;
+        clampLength: (min: number, max: number) => Vector3;
+        floor: () => Vector3;
+        ceil: () => Vector3;
+        round: () => Vector3;
+        roundToZero: () => Vector3;
+        negate: () => Vector3;
+        dot: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        lengthSq: () => number;
+        length: () => number;
+        manhattanLength: () => number;
+        normalize: () => Vector3;
+        setLength: (l: number) => Vector3;
+        lerp: (v: import('../../../../node_modules/three').Vector3Like, alpha: number) => Vector3;
+        lerpVectors: (v1: import('../../../../node_modules/three').Vector3Like, v2: import('../../../../node_modules/three').Vector3Like, alpha: number) => Vector3;
+        cross: (a: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        crossVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        projectOnVector: (v: Vector3) => Vector3;
+        projectOnPlane: (planeNormal: Vector3) => Vector3;
+        reflect: (vector: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        angleTo: (v: Vector3) => number;
+        distanceTo: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        distanceToSquared: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        manhattanDistanceTo: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        setFromSpherical: (s: import('../../../../node_modules/three').Spherical) => Vector3;
+        setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
+        setFromCylindrical: (s: import('../../../../node_modules/three').Cylindrical) => Vector3;
+        setFromCylindricalCoords: (radius: number, theta: number, y: number) => Vector3;
+        setFromMatrixPosition: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        setFromMatrixScale: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        setFromMatrixColumn: (matrix: import('../../../../node_modules/three').Matrix4, index: number) => Vector3;
+        setFromMatrix3Column: (matrix: import('../../../../node_modules/three').Matrix3, index: number) => Vector3;
+        setFromEuler: (e: import('../../../../node_modules/three').Euler) => Vector3;
+        setFromColor: (color: import('../../../../node_modules/three').RGB) => Vector3;
+        equals: (v: import('../../../../node_modules/three').Vector3Like) => boolean;
+        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
+        toArray: {
+            (array?: number[] | undefined, offset?: number | undefined): number[];
+            (array?: import('../../../../node_modules/three').Vector3Tuple | undefined, offset?: 0 | undefined): import('../../../../node_modules/three').Vector3Tuple;
+            (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+        };
+        fromBufferAttribute: (attribute: import('../../../../node_modules/three').BufferAttribute | import('../../../../node_modules/three').InterleavedBufferAttribute, index: number) => Vector3;
+        random: () => Vector3;
+        randomDirection: () => Vector3;
+        [Symbol.iterator]: () => Iterator<number, any, undefined>;
+    };
+    setCameraPosition: (pos: CameraPosition) => void;
+    setCurrentPosition: (pos: CameraPosition, position3d: Vector3) => void;
+    getNavigationMode: () => NavigationMode;
+    getNavigationModeRef: () => import('vue').Ref<NavigationMode, NavigationMode>;
+    setNavigationMode: (mode: NavigationMode) => void;
+    isUserInteracting: () => boolean;
+    setIsUserInteracting: (value: boolean) => void;
+    lookTopDownAt: (obj: Box3 | Object3D | Entity3D) => void;
+}, never>, Pick<{
+    getCameraPosition: () => CameraPosition;
+    getCamera3dPosition: () => {
+        x: number;
+        y: number;
+        z: number;
+        readonly isVector3: true;
+        set: (x: number, y: number, z: number) => Vector3;
+        setScalar: (scalar: number) => Vector3;
+        setX: (x: number) => Vector3;
+        setY: (y: number) => Vector3;
+        setZ: (z: number) => Vector3;
+        setComponent: (index: number, value: number) => Vector3;
+        getComponent: (index: number) => number;
+        clone: () => Vector3;
+        copy: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        add: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        addScalar: (s: number) => Vector3;
+        addVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        addScaledVector: (v: Vector3, s: number) => Vector3;
+        sub: (a: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        subScalar: (s: number) => Vector3;
+        subVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        multiply: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        multiplyScalar: (s: number) => Vector3;
+        multiplyVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        applyEuler: (euler: import('../../../../node_modules/three').Euler) => Vector3;
+        applyAxisAngle: (axis: Vector3, angle: number) => Vector3;
+        applyMatrix3: (m: import('../../../../node_modules/three').Matrix3) => Vector3;
+        applyNormalMatrix: (m: import('../../../../node_modules/three').Matrix3) => Vector3;
+        applyMatrix4: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        applyQuaternion: (q: import('../../../../node_modules/three').QuaternionLike) => Vector3;
+        project: (camera: import('../../../../node_modules/three').Camera) => Vector3;
+        unproject: (camera: import('../../../../node_modules/three').Camera) => Vector3;
+        transformDirection: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        divide: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        divideScalar: (s: number) => Vector3;
+        min: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        max: (v: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        clamp: (min: import('../../../../node_modules/three').Vector3Like, max: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        clampScalar: (min: number, max: number) => Vector3;
+        clampLength: (min: number, max: number) => Vector3;
+        floor: () => Vector3;
+        ceil: () => Vector3;
+        round: () => Vector3;
+        roundToZero: () => Vector3;
+        negate: () => Vector3;
+        dot: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        lengthSq: () => number;
+        length: () => number;
+        manhattanLength: () => number;
+        normalize: () => Vector3;
+        setLength: (l: number) => Vector3;
+        lerp: (v: import('../../../../node_modules/three').Vector3Like, alpha: number) => Vector3;
+        lerpVectors: (v1: import('../../../../node_modules/three').Vector3Like, v2: import('../../../../node_modules/three').Vector3Like, alpha: number) => Vector3;
+        cross: (a: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        crossVectors: (a: import('../../../../node_modules/three').Vector3Like, b: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        projectOnVector: (v: Vector3) => Vector3;
+        projectOnPlane: (planeNormal: Vector3) => Vector3;
+        reflect: (vector: import('../../../../node_modules/three').Vector3Like) => Vector3;
+        angleTo: (v: Vector3) => number;
+        distanceTo: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        distanceToSquared: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        manhattanDistanceTo: (v: import('../../../../node_modules/three').Vector3Like) => number;
+        setFromSpherical: (s: import('../../../../node_modules/three').Spherical) => Vector3;
+        setFromSphericalCoords: (r: number, phi: number, theta: number) => Vector3;
+        setFromCylindrical: (s: import('../../../../node_modules/three').Cylindrical) => Vector3;
+        setFromCylindricalCoords: (radius: number, theta: number, y: number) => Vector3;
+        setFromMatrixPosition: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        setFromMatrixScale: (m: import('../../../../node_modules/three').Matrix4) => Vector3;
+        setFromMatrixColumn: (matrix: import('../../../../node_modules/three').Matrix4, index: number) => Vector3;
+        setFromMatrix3Column: (matrix: import('../../../../node_modules/three').Matrix3, index: number) => Vector3;
+        setFromEuler: (e: import('../../../../node_modules/three').Euler) => Vector3;
+        setFromColor: (color: import('../../../../node_modules/three').RGB) => Vector3;
+        equals: (v: import('../../../../node_modules/three').Vector3Like) => boolean;
+        fromArray: (array: number[] | ArrayLike<number>, offset?: number | undefined) => Vector3;
+        toArray: {
+            (array?: number[] | undefined, offset?: number | undefined): number[];
+            (array?: import('../../../../node_modules/three').Vector3Tuple | undefined, offset?: 0 | undefined): import('../../../../node_modules/three').Vector3Tuple;
+            (array: ArrayLike<number>, offset?: number | undefined): ArrayLike<number>;
+        };
+        fromBufferAttribute: (attribute: import('../../../../node_modules/three').BufferAttribute | import('../../../../node_modules/three').InterleavedBufferAttribute, index: number) => Vector3;
+        random: () => Vector3;
+        randomDirection: () => Vector3;
+        [Symbol.iterator]: () => Iterator<number, any, undefined>;
+    };
+    setCameraPosition: (pos: CameraPosition) => void;
+    setCurrentPosition: (pos: CameraPosition, position3d: Vector3) => void;
+    getNavigationMode: () => NavigationMode;
+    getNavigationModeRef: () => import('vue').Ref<NavigationMode, NavigationMode>;
+    setNavigationMode: (mode: NavigationMode) => void;
+    isUserInteracting: () => boolean;
+    setIsUserInteracting: (value: boolean) => void;
+    lookTopDownAt: (obj: Box3 | Object3D | Entity3D) => void;
+}, "getCameraPosition" | "getCamera3dPosition" | "setCameraPosition" | "setCurrentPosition" | "getNavigationMode" | "getNavigationModeRef" | "setNavigationMode" | "isUserInteracting" | "setIsUserInteracting" | "lookTopDownAt">>;

package/dist/src/stores/datasets.d.ts

@@ -0,0 +1,49 @@
+import { Dataset, DatasetLayer, DatasetOrGroup } from '../types/Dataset';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { Box3 } from '../../../../node_modules/three';
+export declare const useDatasetStore: import('pinia').StoreDefinition<"datasets", Pick<{
+    count: import('vue').ComputedRef<number>;
+    getTree: () => DatasetOrGroup[];
+    getDatasets: () => Dataset[];
+    add: (ds: DatasetOrGroup) => DatasetOrGroup;
+    remove: (ds: DatasetOrGroup) => void;
+    importFromFile: (file: File) => void;
+    setVisible: (ds: DatasetOrGroup, newVisibility: boolean) => void;
+    getBoundingBox: (dataset: DatasetOrGroup) => Box3;
+    getEntity: (ds: DatasetOrGroup) => Entity3D | undefined;
+    getLayer: (ds: DatasetOrGroup) => DatasetLayer | undefined;
+    attachEntity: (ds: DatasetOrGroup, entity: Entity3D) => void;
+    attachLayer: (ds: DatasetOrGroup, layer: DatasetLayer) => void;
+    toggleGrid: (ds: DatasetOrGroup) => void;
+    toggleMask: (ds: DatasetOrGroup) => void;
+}, never>, Pick<{
+    count: import('vue').ComputedRef<number>;
+    getTree: () => DatasetOrGroup[];
+    getDatasets: () => Dataset[];
+    add: (ds: DatasetOrGroup) => DatasetOrGroup;
+    remove: (ds: DatasetOrGroup) => void;
+    importFromFile: (file: File) => void;
+    setVisible: (ds: DatasetOrGroup, newVisibility: boolean) => void;
+    getBoundingBox: (dataset: DatasetOrGroup) => Box3;
+    getEntity: (ds: DatasetOrGroup) => Entity3D | undefined;
+    getLayer: (ds: DatasetOrGroup) => DatasetLayer | undefined;
+    attachEntity: (ds: DatasetOrGroup, entity: Entity3D) => void;
+    attachLayer: (ds: DatasetOrGroup, layer: DatasetLayer) => void;
+    toggleGrid: (ds: DatasetOrGroup) => void;
+    toggleMask: (ds: DatasetOrGroup) => void;
+}, "count">, Pick<{
+    count: import('vue').ComputedRef<number>;
+    getTree: () => DatasetOrGroup[];
+    getDatasets: () => Dataset[];
+    add: (ds: DatasetOrGroup) => DatasetOrGroup;
+    remove: (ds: DatasetOrGroup) => void;
+    importFromFile: (file: File) => void;
+    setVisible: (ds: DatasetOrGroup, newVisibility: boolean) => void;
+    getBoundingBox: (dataset: DatasetOrGroup) => Box3;
+    getEntity: (ds: DatasetOrGroup) => Entity3D | undefined;
+    getLayer: (ds: DatasetOrGroup) => DatasetLayer | undefined;
+    attachEntity: (ds: DatasetOrGroup, entity: Entity3D) => void;
+    attachLayer: (ds: DatasetOrGroup, layer: DatasetLayer) => void;
+    toggleGrid: (ds: DatasetOrGroup) => void;
+    toggleMask: (ds: DatasetOrGroup) => void;
+}, "add" | "remove" | "getTree" | "getDatasets" | "importFromFile" | "setVisible" | "getBoundingBox" | "getEntity" | "getLayer" | "attachEntity" | "attachLayer" | "toggleGrid" | "toggleMask">>;

package/dist/src/stores/giro3d.d.ts

@@ -0,0 +1,45 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as Coordinates } from '@giro3d/giro3d/core/geographic/Coordinates';
+import { default as Extent } from '@giro3d/giro3d/core/geographic/Extent';
+import { MapConstructorOptions } from '@giro3d/giro3d/entities/Map';
+import { default as Inspector } from '@giro3d/giro3d/gui/Inspector';
+export declare const useGiro3dStore: import('pinia').StoreDefinition<"giro3d", Pick<{
+    getMainView: () => Instance | null;
+    setMainView: (instance: Instance | null) => void;
+    getMinimapView: () => Instance | null;
+    setMinimapView: (instance: Instance | null) => void;
+    getInspector: () => Inspector | null;
+    setInspector: (i: Inspector | null) => void;
+    getDefaultCameraPosition: () => Coordinates;
+    getDefaultCameraLookAt: () => Coordinates;
+    getDefaultBasemapOptions: () => Omit<MapConstructorOptions, 'extent'>;
+    getDefaultBasemapExtent: () => Extent;
+    getCRS: () => string;
+    notifyChange: () => void;
+}, never>, Pick<{
+    getMainView: () => Instance | null;
+    setMainView: (instance: Instance | null) => void;
+    getMinimapView: () => Instance | null;
+    setMinimapView: (instance: Instance | null) => void;
+    getInspector: () => Inspector | null;
+    setInspector: (i: Inspector | null) => void;
+    getDefaultCameraPosition: () => Coordinates;
+    getDefaultCameraLookAt: () => Coordinates;
+    getDefaultBasemapOptions: () => Omit<MapConstructorOptions, 'extent'>;
+    getDefaultBasemapExtent: () => Extent;
+    getCRS: () => string;
+    notifyChange: () => void;
+}, never>, Pick<{
+    getMainView: () => Instance | null;
+    setMainView: (instance: Instance | null) => void;
+    getMinimapView: () => Instance | null;
+    setMinimapView: (instance: Instance | null) => void;
+    getInspector: () => Inspector | null;
+    setInspector: (i: Inspector | null) => void;
+    getDefaultCameraPosition: () => Coordinates;
+    getDefaultCameraLookAt: () => Coordinates;
+    getDefaultBasemapOptions: () => Omit<MapConstructorOptions, 'extent'>;
+    getDefaultBasemapExtent: () => Extent;
+    getCRS: () => string;
+    notifyChange: () => void;
+}, "getMainView" | "setMainView" | "getMinimapView" | "setMinimapView" | "getInspector" | "setInspector" | "getDefaultCameraPosition" | "getDefaultCameraLookAt" | "getDefaultBasemapOptions" | "getDefaultBasemapExtent" | "getCRS" | "notifyChange">>;

package/dist/src/stores/layers.d.ts

@@ -0,0 +1,40 @@
+import { GraticuleLayer } from '../giro3d/Graticule';
+import { BaseLayer } from '../types/BaseLayer';
+import { Overlay } from '../types/Overlay';
+export declare const useLayerStore: import('pinia').StoreDefinition<"layers", Pick<{
+    basemapCount: import('vue').ComputedRef<number>;
+    getBasemaps: () => BaseLayer[];
+    getGraticuleLayer: () => GraticuleLayer | undefined;
+    setBasemapOpacity: (layer: BaseLayer, opacity: number) => void;
+    setBasemapVisibility: (layer: BaseLayer, visible: boolean) => void;
+    overlayCount: import('vue').ComputedRef<number>;
+    getOverlays: () => Overlay[];
+    setOverlayOpacity: (layer: Overlay, opacity: number) => void;
+    setOverlayVisibility: (layer: Overlay, visible: boolean) => void;
+    moveOverlayUp: (layer: Overlay) => void;
+    moveOverlayDown: (layer: Overlay) => void;
+}, never>, Pick<{
+    basemapCount: import('vue').ComputedRef<number>;
+    getBasemaps: () => BaseLayer[];
+    getGraticuleLayer: () => GraticuleLayer | undefined;
+    setBasemapOpacity: (layer: BaseLayer, opacity: number) => void;
+    setBasemapVisibility: (layer: BaseLayer, visible: boolean) => void;
+    overlayCount: import('vue').ComputedRef<number>;
+    getOverlays: () => Overlay[];
+    setOverlayOpacity: (layer: Overlay, opacity: number) => void;
+    setOverlayVisibility: (layer: Overlay, visible: boolean) => void;
+    moveOverlayUp: (layer: Overlay) => void;
+    moveOverlayDown: (layer: Overlay) => void;
+}, "basemapCount" | "overlayCount">, Pick<{
+    basemapCount: import('vue').ComputedRef<number>;
+    getBasemaps: () => BaseLayer[];
+    getGraticuleLayer: () => GraticuleLayer | undefined;
+    setBasemapOpacity: (layer: BaseLayer, opacity: number) => void;
+    setBasemapVisibility: (layer: BaseLayer, visible: boolean) => void;
+    overlayCount: import('vue').ComputedRef<number>;
+    getOverlays: () => Overlay[];
+    setOverlayOpacity: (layer: Overlay, opacity: number) => void;
+    setOverlayVisibility: (layer: Overlay, visible: boolean) => void;
+    moveOverlayUp: (layer: Overlay) => void;
+    moveOverlayDown: (layer: Overlay) => void;
+}, "getBasemaps" | "getGraticuleLayer" | "setBasemapOpacity" | "setBasemapVisibility" | "getOverlays" | "setOverlayOpacity" | "setOverlayVisibility" | "moveOverlayUp" | "moveOverlayDown">>;

package/dist/src/stores/measurement.d.ts

@@ -0,0 +1,45 @@
+import { default as Measure } from '../types/Measure';
+import { default as MeasurementMode } from '../types/MeasurementMode';
+export declare const useMeasurementStore: import('pinia').StoreDefinition<"measurement", Pick<{
+    count: import('vue').ComputedRef<number>;
+    getMeasures: () => Measure[];
+    hasMeasure: (name: string) => boolean;
+    isUserMeasuring: () => boolean;
+    setIsUserMeasuring: (value: boolean) => void;
+    getMeasurementMode: () => "laser";
+    setMeasurementMode: (mode: MeasurementMode) => void;
+    remove: (measure: Measure) => void;
+    add: (measure: Measure) => void;
+    importMeasureFile: (file: Blob) => void;
+    importMeasureFiles: (files: File[]) => void;
+    start: () => void;
+    end: () => void;
+}, never>, Pick<{
+    count: import('vue').ComputedRef<number>;
+    getMeasures: () => Measure[];
+    hasMeasure: (name: string) => boolean;
+    isUserMeasuring: () => boolean;
+    setIsUserMeasuring: (value: boolean) => void;
+    getMeasurementMode: () => "laser";
+    setMeasurementMode: (mode: MeasurementMode) => void;
+    remove: (measure: Measure) => void;
+    add: (measure: Measure) => void;
+    importMeasureFile: (file: Blob) => void;
+    importMeasureFiles: (files: File[]) => void;
+    start: () => void;
+    end: () => void;
+}, "count">, Pick<{
+    count: import('vue').ComputedRef<number>;
+    getMeasures: () => Measure[];
+    hasMeasure: (name: string) => boolean;
+    isUserMeasuring: () => boolean;
+    setIsUserMeasuring: (value: boolean) => void;
+    getMeasurementMode: () => "laser";
+    setMeasurementMode: (mode: MeasurementMode) => void;
+    remove: (measure: Measure) => void;
+    add: (measure: Measure) => void;
+    importMeasureFile: (file: Blob) => void;
+    importMeasureFiles: (files: File[]) => void;
+    start: () => void;
+    end: () => void;
+}, "add" | "remove" | "start" | "end" | "getMeasures" | "hasMeasure" | "isUserMeasuring" | "setIsUserMeasuring" | "getMeasurementMode" | "setMeasurementMode" | "importMeasureFile" | "importMeasureFiles">>;

package/dist/src/stores/modules.d.ts

@@ -0,0 +1,11 @@
+import { Module } from '../module';
+export declare const useModuleStore: import('pinia').StoreDefinition<"modules", Pick<{
+    setLoadedModules: (modules: Module[]) => void;
+    getLoadedModules: () => Module[];
+}, never>, Pick<{
+    setLoadedModules: (modules: Module[]) => void;
+    getLoadedModules: () => Module[];
+}, never>, Pick<{
+    setLoadedModules: (modules: Module[]) => void;
+    getLoadedModules: () => Module[];
+}, "setLoadedModules" | "getLoadedModules">>;

package/dist/src/stores/notifications.d.ts

@@ -0,0 +1,8 @@
+import { default as Notification } from '../types/Notification';
+export declare const useNotificationStore: import('pinia').StoreDefinition<"notifications", Pick<{
+    push: (notification: Notification) => void;
+}, never>, Pick<{
+    push: (notification: Notification) => void;
+}, never>, Pick<{
+    push: (notification: Notification) => void;
+}, "push">>;

package/dist/src/stores/statistics.d.ts

@@ -0,0 +1,8 @@
+import { Dataset } from '../types/Dataset';
+export declare const useStatisticsStore: import('pinia').StoreDefinition<"statistics", Pick<{
+    getCompatibleDatasets: () => Dataset[];
+}, never>, Pick<{
+    getCompatibleDatasets: () => Dataset[];
+}, never>, Pick<{
+    getCompatibleDatasets: () => Dataset[];
+}, "getCompatibleDatasets">>;

package/dist/src/types/Annotation.d.ts

@@ -0,0 +1,35 @@
+import { default as Shape } from '@giro3d/giro3d/entities/Shape';
+import { ColorRepresentation, EventDispatcher } from '../../../../node_modules/three';
+type EmptyEvent = {};
+type AnnotationEventMap = {
+    visible: EmptyEvent;
+    isEditing: EmptyEvent;
+};
+export type PieroShapeUserData = {
+    type: 'Point' | 'Polygon' | 'LineString' | 'MultiPoint';
+    annotation?: Annotation;
+    highlightable: boolean;
+    highlightColor: ColorRepresentation;
+    measurements: {
+        area?: number | null;
+        perimeter?: number | null;
+        minmax: [number, number];
+    };
+};
+export default class Annotation extends EventDispatcher<AnnotationEventMap> {
+    readonly uuid: string;
+    readonly title: string;
+    private _visible;
+    private _isEditing;
+    private _object;
+    properties: object;
+    constructor(title: string, object: () => Shape<PieroShapeUserData>, properties?: object);
+    get visible(): boolean;
+    set visible(v: boolean);
+    get object(): Shape<PieroShapeUserData>;
+    get isEditing(): boolean;
+    set isEditing(v: boolean);
+    toGeoJSON(): import('geojson').Feature<import('geojson').Geometry, import('geojson').GeoJsonProperties>;
+    static toCollection(annotations: Annotation[]): GeoJSON.FeatureCollection;
+}
+export {};

package/dist/src/types/AnnotationMode.d.ts

@@ -0,0 +1,7 @@
+import { default as Named } from './Named';
+type AnnotationMode = 'normal' | 'mapOnly' | 'objectsOnly';
+type AnnotationNamed = Named & {
+    value: AnnotationMode;
+};
+export declare const annotationModes: AnnotationNamed[];
+export default AnnotationMode;