@giro3d/piero 1.0.0-beta.0

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<{
+    add: (annotation: Annotation) => void;
+    count: import('vue').ComputedRef<number>;
+    createLine: () => void;
+    createPoint: () => void;
+    createPolygon: () => void;
+    edit: (annotation: Annotation) => void;
+    getAnnotationMode: () => AnnotationMode;
+    getAnnotations: () => Annotation[];
+    hasAnnotation: (name: string) => boolean;
+    importAnnotationFile: (file: Blob) => void;
+    importAnnotationsFiles: (files: File[]) => void;
+    isUserDrawing: () => boolean;
+    remove: (annotation: Annotation) => void;
+    setAnnotationMode: (mode: AnnotationMode) => void;
+    setIsUserDrawing: (value: boolean) => void;
+    setShowLabels: (v: boolean) => void;
+    showLabels: () => boolean;
+    stopEdition: () => void;
+}, never>, Pick<{
+    add: (annotation: Annotation) => void;
+    count: import('vue').ComputedRef<number>;
+    createLine: () => void;
+    createPoint: () => void;
+    createPolygon: () => void;
+    edit: (annotation: Annotation) => void;
+    getAnnotationMode: () => AnnotationMode;
+    getAnnotations: () => Annotation[];
+    hasAnnotation: (name: string) => boolean;
+    importAnnotationFile: (file: Blob) => void;
+    importAnnotationsFiles: (files: File[]) => void;
+    isUserDrawing: () => boolean;
+    remove: (annotation: Annotation) => void;
+    setAnnotationMode: (mode: AnnotationMode) => void;
+    setIsUserDrawing: (value: boolean) => void;
+    setShowLabels: (v: boolean) => void;
+    showLabels: () => boolean;
+    stopEdition: () => void;
+}, "count">, Pick<{
+    add: (annotation: Annotation) => void;
+    count: import('vue').ComputedRef<number>;
+    createLine: () => void;
+    createPoint: () => void;
+    createPolygon: () => void;
+    edit: (annotation: Annotation) => void;
+    getAnnotationMode: () => AnnotationMode;
+    getAnnotations: () => Annotation[];
+    hasAnnotation: (name: string) => boolean;
+    importAnnotationFile: (file: Blob) => void;
+    importAnnotationsFiles: (files: File[]) => void;
+    isUserDrawing: () => boolean;
+    remove: (annotation: Annotation) => void;
+    setAnnotationMode: (mode: AnnotationMode) => void;
+    setIsUserDrawing: (value: boolean) => void;
+    setShowLabels: (v: boolean) => void;
+    showLabels: () => boolean;
+    stopEdition: () => void;
+}, "add" | "remove" | "createLine" | "createPoint" | "createPolygon" | "edit" | "getAnnotationMode" | "getAnnotations" | "hasAnnotation" | "importAnnotationFile" | "importAnnotationsFiles" | "isUserDrawing" | "setAnnotationMode" | "setIsUserDrawing" | "setShowLabels" | "showLabels" | "stopEdition">>;

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<{
+    add: (bookmark: Bookmark) => void;
+    clear: () => void;
+    count: import('vue').ComputedRef<number>;
+    getBookmarks: () => Bookmark[];
+    remove: (bookmark: Bookmark) => void;
+}, never>, Pick<{
+    add: (bookmark: Bookmark) => void;
+    clear: () => void;
+    count: import('vue').ComputedRef<number>;
+    getBookmarks: () => Bookmark[];
+    remove: (bookmark: Bookmark) => void;
+}, "count">, Pick<{
+    add: (bookmark: Bookmark) => void;
+    clear: () => void;
+    count: import('vue').ComputedRef<number>;
+    getBookmarks: () => Bookmark[];
+    remove: (bookmark: Bookmark) => void;
+}, "add" | "clear" | "getBookmarks" | "remove">>;
+export type BookmarkStore = ReturnType<typeof useBookmarkStore>;

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

@@ -0,0 +1,39 @@
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { Box3, Object3D, Vector3 } from '../../../../node_modules/three';
+import { Ref } from 'vue';
+import { default as CameraPosition } from '../types/CameraPosition';
+import { default as NavigationMode } from '../types/NavigationMode';
+export declare const useCameraStore: import('pinia').StoreDefinition<"camera", Pick<{
+    getCamera3dPosition: () => Vector3;
+    getCameraPosition: () => CameraPosition;
+    getNavigationMode: () => NavigationMode;
+    getNavigationModeRef: () => Ref<NavigationMode>;
+    isUserInteracting: () => boolean;
+    lookTopDownAt: (obj: Box3 | Entity3D | Object3D) => void;
+    setCameraPosition: (pos: CameraPosition) => void;
+    setCurrentPosition: (pos: CameraPosition, position3d: Vector3) => void;
+    setIsUserInteracting: (value: boolean) => void;
+    setNavigationMode: (mode: NavigationMode) => void;
+}, never>, Pick<{
+    getCamera3dPosition: () => Vector3;
+    getCameraPosition: () => CameraPosition;
+    getNavigationMode: () => NavigationMode;
+    getNavigationModeRef: () => Ref<NavigationMode>;
+    isUserInteracting: () => boolean;
+    lookTopDownAt: (obj: Box3 | Entity3D | Object3D) => void;
+    setCameraPosition: (pos: CameraPosition) => void;
+    setCurrentPosition: (pos: CameraPosition, position3d: Vector3) => void;
+    setIsUserInteracting: (value: boolean) => void;
+    setNavigationMode: (mode: NavigationMode) => void;
+}, never>, Pick<{
+    getCamera3dPosition: () => Vector3;
+    getCameraPosition: () => CameraPosition;
+    getNavigationMode: () => NavigationMode;
+    getNavigationModeRef: () => Ref<NavigationMode>;
+    isUserInteracting: () => boolean;
+    lookTopDownAt: (obj: Box3 | Entity3D | Object3D) => void;
+    setCameraPosition: (pos: CameraPosition) => void;
+    setCurrentPosition: (pos: CameraPosition, position3d: Vector3) => void;
+    setIsUserInteracting: (value: boolean) => void;
+    setNavigationMode: (mode: NavigationMode) => void;
+}, "getCamera3dPosition" | "getCameraPosition" | "getNavigationMode" | "getNavigationModeRef" | "isUserInteracting" | "lookTopDownAt" | "setCameraPosition" | "setCurrentPosition" | "setIsUserInteracting" | "setNavigationMode">>;

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

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

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

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

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;
+    getOverlays: () => Overlay[];
+    moveOverlayDown: (layer: Overlay) => void;
+    moveOverlayUp: (layer: Overlay) => void;
+    overlayCount: import('vue').ComputedRef<number>;
+    setBasemapOpacity: (layer: BaseLayer, opacity: number) => void;
+    setBasemapVisibility: (layer: BaseLayer, visible: boolean) => void;
+    setOverlayOpacity: (layer: Overlay, opacity: number) => void;
+    setOverlayVisibility: (layer: Overlay, visible: boolean) => void;
+}, never>, Pick<{
+    basemapCount: import('vue').ComputedRef<number>;
+    getBasemaps: () => BaseLayer[];
+    getGraticuleLayer: () => GraticuleLayer | undefined;
+    getOverlays: () => Overlay[];
+    moveOverlayDown: (layer: Overlay) => void;
+    moveOverlayUp: (layer: Overlay) => void;
+    overlayCount: import('vue').ComputedRef<number>;
+    setBasemapOpacity: (layer: BaseLayer, opacity: number) => void;
+    setBasemapVisibility: (layer: BaseLayer, visible: boolean) => void;
+    setOverlayOpacity: (layer: Overlay, opacity: number) => void;
+    setOverlayVisibility: (layer: Overlay, visible: boolean) => void;
+}, "basemapCount" | "overlayCount">, Pick<{
+    basemapCount: import('vue').ComputedRef<number>;
+    getBasemaps: () => BaseLayer[];
+    getGraticuleLayer: () => GraticuleLayer | undefined;
+    getOverlays: () => Overlay[];
+    moveOverlayDown: (layer: Overlay) => void;
+    moveOverlayUp: (layer: Overlay) => void;
+    overlayCount: import('vue').ComputedRef<number>;
+    setBasemapOpacity: (layer: BaseLayer, opacity: number) => void;
+    setBasemapVisibility: (layer: BaseLayer, visible: boolean) => void;
+    setOverlayOpacity: (layer: Overlay, opacity: number) => void;
+    setOverlayVisibility: (layer: Overlay, visible: boolean) => void;
+}, "getBasemaps" | "getGraticuleLayer" | "getOverlays" | "moveOverlayDown" | "moveOverlayUp" | "setBasemapOpacity" | "setBasemapVisibility" | "setOverlayOpacity" | "setOverlayVisibility">>;

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<{
+    add: (measure: Measure) => void;
+    count: import('vue').ComputedRef<number>;
+    end: () => void;
+    getMeasurementMode: () => MeasurementMode;
+    getMeasures: () => Measure[];
+    hasMeasure: (name: string) => boolean;
+    importMeasureFile: (file: Blob) => void;
+    importMeasureFiles: (files: File[]) => void;
+    isUserMeasuring: () => boolean;
+    remove: (measure: Measure) => void;
+    setIsUserMeasuring: (value: boolean) => void;
+    setMeasurementMode: (mode: MeasurementMode) => void;
+    start: () => void;
+}, never>, Pick<{
+    add: (measure: Measure) => void;
+    count: import('vue').ComputedRef<number>;
+    end: () => void;
+    getMeasurementMode: () => MeasurementMode;
+    getMeasures: () => Measure[];
+    hasMeasure: (name: string) => boolean;
+    importMeasureFile: (file: Blob) => void;
+    importMeasureFiles: (files: File[]) => void;
+    isUserMeasuring: () => boolean;
+    remove: (measure: Measure) => void;
+    setIsUserMeasuring: (value: boolean) => void;
+    setMeasurementMode: (mode: MeasurementMode) => void;
+    start: () => void;
+}, "count">, Pick<{
+    add: (measure: Measure) => void;
+    count: import('vue').ComputedRef<number>;
+    end: () => void;
+    getMeasurementMode: () => MeasurementMode;
+    getMeasures: () => Measure[];
+    hasMeasure: (name: string) => boolean;
+    importMeasureFile: (file: Blob) => void;
+    importMeasureFiles: (files: File[]) => void;
+    isUserMeasuring: () => boolean;
+    remove: (measure: Measure) => void;
+    setIsUserMeasuring: (value: boolean) => void;
+    setMeasurementMode: (mode: MeasurementMode) => void;
+    start: () => void;
+}, "add" | "remove" | "end" | "start" | "getMeasurementMode" | "getMeasures" | "hasMeasure" | "importMeasureFile" | "importMeasureFiles" | "isUserMeasuring" | "setIsUserMeasuring" | "setMeasurementMode">>;

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

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

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 AnnotationEventMap = {
+    isEditing: EmptyEvent;
+    visible: EmptyEvent;
+};
+type EmptyEvent = {};
+export type PieroShapeUserData = {
+    annotation?: Annotation;
+    highlightable: boolean;
+    highlightColor: ColorRepresentation;
+    measurements: {
+        area?: number | null;
+        minmax: [number, number];
+        perimeter?: number | null;
+    };
+    type: 'LineString' | 'MultiPoint' | 'Point' | 'Polygon';
+};
+export default class Annotation extends EventDispatcher<AnnotationEventMap> {
+    properties: object;
+    readonly title: string;
+    readonly uuid: string;
+    get isEditing(): boolean;
+    set isEditing(v: boolean);
+    get object(): Shape<PieroShapeUserData>;
+    get visible(): boolean;
+    set visible(v: boolean);
+    private _isEditing;
+    private _object;
+    private _visible;
+    constructor(title: string, object: () => Shape<PieroShapeUserData>, properties?: object);
+    static toCollection(annotations: Annotation[]): GeoJSON.FeatureCollection;
+    toGeoJSON(): GeoJSON.Feature;
+}
+export {};

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

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

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

@@ -0,0 +1,30 @@
+import { default as ColorLayer } from '@giro3d/giro3d/core/layer/ColorLayer';
+import { default as ElevationLayer } from '@giro3d/giro3d/core/layer/ElevationLayer';
+import { default as MaskLayer } from '@giro3d/giro3d/core/layer/MaskLayer';
+import { EventDispatcher } from '../../../../node_modules/three';
+import { BasemapLayerSourceConfig, LayerConfig, LayerType } from './configuration/layers';
+import { default as LayerObject } from './LayerObject';
+export interface BaseLayer extends EventDispatcher {
+    name: string;
+    options: BaseLayerOptions<LayerConfig>;
+    source: BasemapLayerSourceConfig;
+    type: LayerType;
+    uuid: string;
+    get isLoading(): boolean;
+    set isLoading(v: boolean);
+    get opacity(): number;
+    set opacity(v: number);
+    get visible(): boolean;
+    set visible(v: boolean);
+}
+export type BaseLayerOptions<TLayerType extends LayerConfig> = Omit<TLayerType, 'name' | 'source' | 'type'>;
+export type BasemapLayer = ColorLayer | ElevationLayer | MaskLayer;
+export declare class BaseLayerObject extends LayerObject implements BaseLayer {
+    readonly options: BaseLayerOptions<LayerConfig>;
+    readonly source: BasemapLayerSourceConfig;
+    readonly type: LayerType;
+    get isLoading(): boolean;
+    set isLoading(v: boolean);
+    private _loading;
+    constructor({ name, source, type, ...options }: LayerConfig);
+}

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

@@ -0,0 +1,19 @@
+import { EventDispatcher } from '../../../../node_modules/three';
+import { default as CameraPosition } from './CameraPosition';
+export type BookmarkEventMap = {
+    delete: {};
+    goto: {};
+};
+export type SerializedBookmark = {
+    title: string;
+    url: string;
+};
+export default class Bookmark extends EventDispatcher<BookmarkEventMap> {
+    readonly camera: CameraPosition;
+    readonly name: string;
+    constructor(name: string, camera: CameraPosition);
+    static new(name: string, urlString: string): Bookmark;
+    delete(): void;
+    getUrl(): URL;
+    goTo(): void;
+}

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

@@ -0,0 +1,7 @@
+import { Vector3 } from '../../../../node_modules/three';
+export default class CameraPosition {
+    readonly camera: Vector3;
+    readonly focalOffset: Vector3;
+    readonly target: Vector3;
+    constructor(camera: Vector3, target: Vector3, focalOffset: Vector3);
+}

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

@@ -0,0 +1,106 @@
+import { MapConstructorOptions } from '@giro3d/giro3d/entities/Map';
+import { AnalysisConfig } from './configuration/analysis';
+import { BookmarkConfig } from './configuration/bookmark';
+import { CameraConfig, CameraConfigDeprecated } from './configuration/camera';
+import { ColorMapConfig } from './configuration/color';
+import { ExperimentalFeatures } from './configuration/features';
+import { CRS, GeoExtent, GeoVec2 } from './configuration/geographic';
+import { LayerConfig, OverlayConfig, OverlayRasterConfigDeprecated, OverlayVectorConfigDeprecated, OverlayVectorTileConfigDeprecated } from './configuration/layers';
+import { DatasetOrGroupConfig } from './configuration/datasets';
+import { VectorDatasetRendering } from './configuration/datasets/vector';
+/** Basemap configuration */
+export interface BasemapConfig extends ExtentConfigWithCenter, Pick<MapConstructorOptions, 'backgroundColor' | 'backgroundOpacity' | 'colorimetry' | 'contourLines' | 'elevationRange' | 'graticule' | 'lighting' | 'showOutline' | 'side' | 'terrain'> {
+    /**
+     * Color map configuration for Elevation layer, used when it's the only layer displayed
+     */
+    colormap: ColorMapConfig;
+    /** Extent configuration */
+    extent?: GeoExtent;
+    /**
+     * Layers
+     *
+     * Layers define how the 3D map is displayed:
+     * - The elevation layer defines how the map is rendered in 3D,
+     * - Color layers define how the map appears, they are typically imagery or plan.
+     *
+     * There should be exactly one elevation layer and one or several color layers.
+     */
+    layers: LayerConfig[];
+}
+/** Piero configuration */
+export interface Configuration {
+    /** Analysis tools configuration */
+    analysis: AnalysisConfig;
+    /** Basemap configuration */
+    basemap: BasemapConfig;
+    /** Array of bookmarks - can be empty */
+    bookmarks: BookmarkConfig[];
+    /** Camera configuration */
+    camera: CameraConfig | CameraConfigDeprecated;
+    /** Custom CRS definitions */
+    crs_definitions?: Record<CRS, string>;
+    /**
+     * Array of datasets to display
+     *
+     * Datasets define the 3D data displayed in the app.
+     *
+     * Datasets can be organized in groups; some parameters are then inherited to their children.
+     *
+     * Some dataset types support loading multiple URLs into one dataset. For these types, you can set an array of URLs for the `url` field.
+     */
+    datasets: DatasetOrGroupConfig[];
+    /**
+     * The default CRS to be used in the view
+     *
+     * Requires the CRS to be geocentric.
+     * Requires the CRS to be registered.
+     */
+    default_crs: CRS;
+    /** Experimental features to switch on */
+    enabled_features?: ExperimentalFeatures[];
+    /**
+     * When importing vector datasets as meshes, select if the app should fetch elevation.
+     * @defaultValue true
+     */
+    importedMeshDatasetFetchElevation?: boolean;
+    /**
+     * When importing vector datasets as meshes, select how to fetch elevation.
+     * By default (true), it will query the default Alticoder service (ie. IGN).
+     * We recommend turning it on in case of large datasets (querying would be slow) or if outside France (won't work)
+     * @defaultValue false
+     */
+    importedMeshDatasetFetchElevationFast?: boolean;
+    /**
+     * When importing vector datasets, pick how to render them.
+     * @defaultValue mesh
+     */
+    importedVectorDatasetRendering?: 'overlay' | VectorDatasetRendering;
+    /**
+     * Array of overlays to display on the 2.5D map - can be empty
+     *
+     * Overlays define data that are merged into the 2.5D map.
+     * These are typically vector data or rasters with transparent backgrounds.
+     */
+    overlays: (OverlayConfig | OverlayRasterConfigDeprecated | OverlayVectorConfigDeprecated | OverlayVectorTileConfigDeprecated)[];
+    /** Pointcloud display configuration */
+    pointcloud: ColorMapConfig;
+}
+/**
+ * Extent configuration
+ *
+ * @deprecated Use {@link BasemapConfig.extent} field instead. Will be removed in release v24.10.
+ */
+export interface ExtentConfigWithCenter {
+    /**
+     * Center of the map.
+     *
+     * @deprecated Use {@link BasemapConfig.extent} field instead. Will be removed in release v24.10.
+     */
+    center?: [number, number] | GeoVec2;
+    /**
+     * Size of the map in CRS units.
+     *
+     * @deprecated Use {@link BasemapConfig.extent} field instead. Will be removed in release v24.10.
+     */
+    size?: [number, number];
+}

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

@@ -0,0 +1,78 @@
+import { default as ColorLayer } from '@giro3d/giro3d/core/layer/ColorLayer';
+import { default as ElevationLayer } from '@giro3d/giro3d/core/layer/ElevationLayer';
+import { default as MaskLayer } from '@giro3d/giro3d/core/layer/MaskLayer';
+import { EventDispatcher } from '../../../../node_modules/three';
+import { DatagroupConfig, DatasetConfig, DatasetOrGroupConfig, DatasetType } from './configuration/datasets';
+import { DatasetCascadingConfig, OnObjectPreloaded } from './configuration/datasets/core';
+export type DatasetEventMap = {
+    delete: {};
+    isPreloaded: {};
+    isPreloading: {};
+    opacity: {};
+    visible: {};
+};
+export type DatasetGroupEventMap = DatasetEventMap & {};
+export type DatasetLayer = ColorLayer | ElevationLayer | MaskLayer;
+/** Dataset or group item */
+export type DatasetOrGroup = Datagroup | Dataset;
+export type DatasetOrGroupType = 'group' | DatasetType;
+export declare abstract class DatasetBase<TConfig extends DatasetOrGroupConfig, TEventMap extends DatasetEventMap = DatasetEventMap> extends EventDispatcher<DatasetEventMap & TEventMap> {
+    readonly config: TConfig;
+    readonly name: string;
+    readonly onObjectPreloaded?: OnObjectPreloaded;
+    readonly type: TConfig['type'];
+    readonly uuid: string;
+    get isPreloaded(): boolean;
+    set isPreloaded(v: boolean);
+    get isPreloading(): boolean;
+    set isPreloading(v: boolean);
+    get opacity(): number;
+    set opacity(v: number);
+    get parent(): Datagroup | null;
+    set parent(v: Datagroup | null);
+    get visible(): boolean;
+    set visible(v: boolean);
+    protected _isPreloaded: boolean;
+    protected _isPreloading: boolean;
+    protected _opacity: number;
+    protected _parent: Datagroup | null;
+    protected _visible: boolean;
+    constructor(config: TConfig);
+    delete(): void;
+    /**
+     * Gets the value of a property from this object or its ancestors.
+     * @param propertyName - Name of the property
+     * @returns Value
+     */
+    get<K extends keyof DatasetCascadingConfig>(propertyName: K): DatasetCascadingConfig[K] | undefined;
+    /** Gets the leafs Dataset from this object */
+    abstract leafs(): Dataset[];
+    /**
+     * Executes the callback on this object and all descendants.
+     * @param callback - Callback to execute
+     */
+    abstract traverse(callback: (dataset: DatasetOrGroup) => void): void;
+}
+/** Datagroup item */
+export declare class Datagroup extends DatasetBase<DatagroupConfig, DatasetGroupEventMap> {
+    get children(): DatasetOrGroup[];
+    set children(items: DatasetOrGroup[]);
+    protected _children: DatasetOrGroup[];
+    constructor(conf: DatagroupConfig);
+    static isGroup: (obj: unknown) => obj is Datagroup;
+    leafs(): Dataset[];
+    traverse(callback: (dataset: DatasetOrGroup) => void): void;
+}
+/** Dataset item */
+export declare class Dataset extends DatasetBase<DatasetConfig, DatasetEventMap> {
+    constructor(conf: DatasetConfig);
+    leafs(): Dataset[];
+    traverse(callback: (dataset: DatasetOrGroup) => void): void;
+}
+/**
+ * Creates a hierarchy of DatasetOrGroup from an array of configuration.
+ * @param datasets - Datasets
+ * @param parent - Parent datagroup, if any
+ * @returns Hierarchy of DatasetOrGroup
+ */
+export declare function parseDatasetConfig(datasets: DatasetOrGroupConfig[], parent?: Datagroup): DatasetOrGroup[];

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

@@ -0,0 +1,13 @@
+import { Vector3 } from '../../../../node_modules/three';
+export interface Attribute {
+    key: string;
+    value: unknown;
+}
+export type AttributesGroups = Map<string, Attribute[]>;
+export default class Feature {
+    readonly attributes: AttributesGroups;
+    readonly name: string;
+    readonly parent: string;
+    readonly point: Vector3;
+    constructor(name: string, parent: string, attributes: AttributesGroups, point: Vector3);
+}

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

@@ -0,0 +1,14 @@
+import { Mesh, MeshBasicMaterial, PlaneGeometry } from '../../../../node_modules/three';
+export default class FloodingPlane {
+    geometry: PlaneGeometry;
+    material: MeshBasicMaterial;
+    object3D: Mesh<PlaneGeometry, MeshBasicMaterial>;
+    set height(z: number);
+    get height(): number;
+    set visible(v: boolean);
+    get visible(): boolean;
+    private _height;
+    constructor();
+    dispose(): void;
+    setPosition(x: number, y: number, z: number, width: number, height: number): void;
+}