@giro3d/piero 25.10.0-beta.10

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

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

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 SerializedBookmark = {
+    title: string;
+    url: string;
+};
+export type BookmarkEventMap = {
+    delete: {};
+    goto: {};
+};
+export default class Bookmark extends EventDispatcher<BookmarkEventMap> {
+    readonly name: string;
+    readonly camera: CameraPosition;
+    constructor(name: string, camera: CameraPosition);
+    delete(): void;
+    goTo(): void;
+    getUrl(): URL;
+    static new(name: string, urlString: string): Bookmark;
+}

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 target: Vector3;
+    readonly focalOffset: Vector3;
+    constructor(camera: Vector3, target: Vector3, focalOffset: Vector3);
+}

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

@@ -0,0 +1,94 @@
+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 { MapConstructorOptions } from '@giro3d/giro3d/entities/Map';
+import { DatasetOrGroupConfig } from './configuration/datasets';
+import { VectorDatasetRendering } from './configuration/datasets/vector';
+/**
+ * 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?: GeoVec2 | [number, number];
+    /**
+     * Size of the map in CRS units.
+     *
+     * @deprecated Use {@link BasemapConfig.extent} field instead. Will be removed in release v24.10.
+     */
+    size?: [number, number];
+}
+/** Basemap configuration */
+export interface BasemapConfig extends ExtentConfigWithCenter, Pick<MapConstructorOptions, 'lighting' | 'contourLines' | 'graticule' | 'colorimetry' | 'side' | 'terrain' | 'backgroundColor' | 'backgroundOpacity' | 'showOutline' | 'elevationRange'> {
+    /** Extent configuration */
+    extent?: GeoExtent;
+    /**
+     * Color map configuration for Elevation layer, used when it's the only layer displayed
+     */
+    colormap: ColorMapConfig;
+    /**
+     * 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 {
+    /** Custom CRS definitions */
+    crs_definitions?: Record<CRS, string>;
+    /**
+     * 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[];
+    /** Camera configuration */
+    camera: CameraConfig | CameraConfigDeprecated;
+    /** Basemap configuration */
+    basemap: BasemapConfig;
+    /** Pointcloud display configuration */
+    pointcloud: ColorMapConfig;
+    /** Analysis tools configuration */
+    analysis: AnalysisConfig;
+    /**
+     * 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[];
+    /**
+     * When importing vector datasets, pick how to render them.
+     * @defaultValue mesh
+     */
+    importedVectorDatasetRendering?: VectorDatasetRendering | 'overlay';
+    /**
+     * 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 | OverlayVectorConfigDeprecated | OverlayVectorTileConfigDeprecated | OverlayRasterConfigDeprecated)[];
+    /** Array of bookmarks - can be empty */
+    bookmarks: BookmarkConfig[];
+}

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 DatasetOrGroupType = DatasetType | 'group';
+export type DatasetLayer = ColorLayer | MaskLayer | ElevationLayer;
+export type DatasetEventMap = {
+    visible: {};
+    opacity: {};
+    delete: {};
+    isPreloading: {};
+    isPreloaded: {};
+};
+export type DatasetGroupEventMap = DatasetEventMap & {};
+export declare abstract class DatasetBase<TConfig extends DatasetOrGroupConfig, TEventMap extends DatasetEventMap = DatasetEventMap> extends EventDispatcher<TEventMap & DatasetEventMap> {
+    readonly type: TConfig['type'];
+    readonly uuid: string;
+    readonly name: string;
+    readonly onObjectPreloaded?: OnObjectPreloaded;
+    protected _parent: Datagroup | null;
+    protected _visible: boolean;
+    protected _opacity: number;
+    protected _isPreloading: boolean;
+    protected _isPreloaded: boolean;
+    readonly config: TConfig;
+    constructor(config: TConfig);
+    get parent(): Datagroup | null;
+    set parent(v: Datagroup | null);
+    get isPreloading(): boolean;
+    set isPreloading(v: boolean);
+    get isPreloaded(): boolean;
+    set isPreloaded(v: boolean);
+    get visible(): boolean;
+    set visible(v: boolean);
+    get opacity(): number;
+    set opacity(v: number);
+    delete(): void;
+    /**
+     * Executes the callback on this object and all descendants.
+     * @param callback - Callback to execute
+     */
+    abstract traverse(callback: (dataset: DatasetOrGroup) => void): void;
+    /** Gets the leafs Dataset from this object */
+    abstract leafs(): Dataset[];
+    /**
+     * 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;
+}
+/** Dataset item */
+export declare class Dataset extends DatasetBase<DatasetConfig, DatasetEventMap> {
+    constructor(conf: DatasetConfig);
+    traverse(callback: (dataset: DatasetOrGroup) => void): void;
+    leafs(): Dataset[];
+}
+/** Datagroup item */
+export declare class Datagroup extends DatasetBase<DatagroupConfig, DatasetGroupEventMap> {
+    protected _children: DatasetOrGroup[];
+    constructor(conf: DatagroupConfig);
+    get children(): DatasetOrGroup[];
+    set children(items: DatasetOrGroup[]);
+    traverse(callback: (dataset: DatasetOrGroup) => void): void;
+    leafs(): Dataset[];
+    static isGroup: (obj: unknown) => obj is Datagroup;
+}
+/**
+ * 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[];
+/** Dataset or group item */
+export type DatasetOrGroup = Dataset | Datagroup;

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 name: string;
+    readonly attributes: AttributesGroups;
+    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>;
+    private _height;
+    constructor();
+    dispose(): void;
+    set height(z: number);
+    setPosition(x: number, y: number, z: number, width: number, height: number): void;
+    get height(): number;
+    set visible(v: boolean);
+    get visible(): boolean;
+}

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

@@ -0,0 +1,5 @@
+export interface IfcSpatialStructureElement {
+    expressID: number;
+    type: string;
+    children: never[];
+}

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

@@ -0,0 +1,20 @@
+import { EventDispatcher } from '../../../../node_modules/three';
+type LayerObjectEventMap = {
+    visible: {};
+    opacity: {};
+    delete: {};
+    isLoading: {};
+};
+export default abstract class LayerObject extends EventDispatcher<LayerObjectEventMap> {
+    readonly uuid: string;
+    private _visible;
+    private _opacity;
+    readonly name: string;
+    constructor(name: string);
+    get visible(): boolean;
+    set visible(v: boolean);
+    get opacity(): number;
+    set opacity(v: number);
+    delete(): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { default as Measure3D } from '../giro3d/Measure3D';
+import { EventDispatcher } from '../../../../node_modules/three';
+type MeasureEventMap = {
+    visible: {};
+};
+export default class Measure extends EventDispatcher<MeasureEventMap> {
+    readonly uuid: string;
+    readonly title: string;
+    private _visible;
+    private _object;
+    properties: object;
+    constructor(title: string, object: Measure3D, properties?: object);
+    get visible(): boolean;
+    set visible(v: boolean);
+    get object(): Measure3D;
+    set object(obj: Measure3D);
+    toGeoJSON(): import('geojson').Feature<import('geojson').Geometry, import('geojson').GeoJsonProperties>;
+    static toCollection(measures: Measure[]): GeoJSON.FeatureCollection;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { default as Named } from './Named';
+type MeasurementMode = 'laser';
+type MeasurementNamed = Named & {
+    value: MeasurementMode;
+};
+export declare const measurementModes: MeasurementNamed[];
+export default MeasurementMode;

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

@@ -0,0 +1,5 @@
+export default interface Named {
+    value?: string;
+    name: string;
+    description?: string;
+}

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

@@ -0,0 +1,2 @@
+type NavigationMode = 'first-person' | 'orbit' | 'position-on-map' | 'disabled';
+export default NavigationMode;

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

@@ -0,0 +1,8 @@
+export type NotificationLevel = 'info' | 'warning' | 'error' | 'success';
+export default class Notification {
+    readonly title: string;
+    readonly text: string;
+    readonly level: NotificationLevel;
+    constructor(title: string, text: string, level?: NotificationLevel);
+    static empty(): Notification;
+}

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

@@ -0,0 +1 @@
+export type OLGeometry = 'Point' | 'LineString' | 'LinearRing' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon' | 'GeometryCollection' | 'Circle';

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

@@ -0,0 +1,24 @@
+import { default as LayerObject } from './LayerObject';
+import { OverlayConfig, OverlaySourceConfig } from './configuration/layers';
+import { EventDispatcher } from '../../../../node_modules/three';
+export type OverlayOptions = Omit<OverlayConfig, 'name' | 'source'>;
+export interface Overlay extends EventDispatcher {
+    name: string;
+    source: OverlaySourceConfig;
+    uuid: string;
+    options: OverlayOptions;
+    get isLoading(): boolean;
+    set isLoading(v: boolean);
+    get visible(): boolean;
+    set visible(v: boolean);
+    get opacity(): number;
+    set opacity(v: number);
+}
+export declare class OverlayObject extends LayerObject implements Overlay {
+    private _loading;
+    readonly source: OverlaySourceConfig;
+    readonly options: OverlayOptions;
+    constructor({ name, source, ...options }: OverlayConfig);
+    get isLoading(): boolean;
+    set isLoading(v: boolean);
+}

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

@@ -0,0 +1,31 @@
+import { Style } from 'ol/style';
+import { StyleFunction } from 'ol/style/Style';
+/** Static vector style */
+export interface StaticVectorStyle {
+    /** Fill style (for polygons) */
+    fill?: FillStyle;
+    /** Stroke style (for lines and polygons) */
+    stroke?: StrokeStyle;
+    /** Point style (for points) */
+    point?: PointStyle;
+}
+export type DynamicStyleId = string;
+export type DynamicStyleCollection = Record<DynamicStyleId, Style | StyleFunction>;
+/**
+ * Vector style.
+ *
+ * Either an entry of the [Style configuration](../style.ts), or a static configuration
+ */
+export type VectorStyle = StaticVectorStyle | DynamicStyleId | 'default';
+export interface FillStyle {
+    color: string;
+}
+export interface StrokeStyle {
+    color: string;
+    width: number;
+}
+export interface PointStyle {
+    radius: number;
+    stroke: StrokeStyle;
+    fill: FillStyle;
+}

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

@@ -0,0 +1,7 @@
+import { Vector3, BufferGeometry, LineBasicMaterial, LineSegments } from '../../../../node_modules/three';
+export default class Viewbox {
+    geometry: BufferGeometry;
+    object3D: LineSegments<BufferGeometry, LineBasicMaterial>;
+    constructor();
+    setCorners(ul: Vector3, ur: Vector3, lr: Vector3, ll: Vector3): void;
+}

package/dist/src/types/configuration/analysis.d.ts

@@ -0,0 +1,26 @@
+import { GeoVec2, GeoVec3, Vec3 } from './geographic';
+export interface AnalysisConfig {
+    /** Cross section configuration */
+    cross_section: {
+        /** Default pivot point */
+        pivot: GeoVec2;
+        /** Default orientation in degrees of the cross section plane */
+        orientation: number;
+    };
+    /** Clipping box configuration */
+    clipping_box: {
+        /** Default center of the clipping box */
+        center: GeoVec3;
+        /** Default size of the clipping box */
+        size: Vec3;
+        /** Default settings for floor presets */
+        floor_preset: {
+            /** Altitude of the ground of floor 0 */
+            altitude: number;
+            /** Height of a floor */
+            size: number;
+            /** Default floor number */
+            floor: number;
+        };
+    };
+}

package/dist/src/types/configuration/bookmark.d.ts

@@ -0,0 +1,16 @@
+import { Vec3 } from './geographic';
+/**
+ * Bookmark configuration.
+ *
+ * The easiest way to define a bookmark is actually to set it in the app, export it and copy the values from the JSON file.
+ */
+export interface BookmarkConfig {
+    /** Name of the bookmark displayed in the UI */
+    title: string;
+    /** 3D position of the camera, in `default_crs` */
+    position: Vec3;
+    /** 3D position of the camera target, in `default_crs` */
+    target: Vec3;
+    /** Focal offset of the camera */
+    focalOffset: Vec3;
+}

package/dist/src/types/configuration/camera.d.ts

@@ -0,0 +1,19 @@
+import { GeoVec2, GeoVec3 } from './geographic';
+/**
+ * Deprecated camera configuration
+ *
+ * @deprecated - Use CameraConfig instead. Will be removed in release v24.7.
+ */
+export interface CameraConfigDeprecated {
+    /** Initial camera position */
+    position: GeoVec2 | [number, number];
+    /** Initial camera altitude */
+    altitude: number;
+}
+/** Camera configuration */
+export interface CameraConfig {
+    /** Initial camera position */
+    position: GeoVec3;
+    /** Initial camera target - if not provided, will use the center of the extent */
+    lookAt?: GeoVec3;
+}

package/dist/src/types/configuration/color.d.ts

@@ -0,0 +1,18 @@
+import { default as ColorMapMode } from '@giro3d/giro3d/core/ColorMapMode';
+/**
+ * Color ramp name, as supported by [chroma.js](https://gka.github.io/chroma.js/#chroma-brewer)
+ */
+export type ColorRamp = string;
+/**
+ * Color map configuration for Elevation layer, used when it's the only layer displayed
+ */
+export interface ColorMapConfig {
+    /** Value mapped to the start of the color ramp */
+    min: number;
+    /** Value mapped to the end of the color ramp */
+    max: number;
+    /** Color ramp */
+    ramp: ColorRamp;
+    /** Color map mode */
+    mode?: ColorMapMode;
+}

package/dist/src/types/configuration/datasets/cityjson.d.ts

@@ -0,0 +1,9 @@
+import { DataProjectionMixin, UrlOrDataMixin } from '../../../giro3d/sources/mixins';
+import { DatasetConfigBase, DatasetConfigMaskingMixin } from './core';
+/** CityJSON source configuration */
+export interface CityJSONDatasetSourceConfig extends UrlOrDataMixin, DataProjectionMixin {
+}
+/** CityJSON dataset configuration */
+export interface CityJSONDatasetConfig extends DatasetConfigBase<'cityjson'>, DatasetConfigMaskingMixin {
+    source: CityJSONDatasetSourceConfig;
+}

package/dist/src/types/configuration/datasets/core.d.ts

@@ -0,0 +1,49 @@
+import { DatasetOrGroup } from '../../Dataset';
+import { LayerType } from '../layers';
+import { SourceConfigElevationMixin, SourceConfigLocationMixin, SourceConfigProjectionMixin } from '../sources/core/baseConfig';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+/**
+ * Callback which is called when the dataset is preloaded into the app.
+ *
+ * This can be useful for post-processing your data (transformation, rotation, etc.).
+ *
+ * @param dataset - Dataset created
+ * @param entity - Giro3D entity created
+ */
+export type OnObjectPreloaded = (dataset: DatasetOrGroup, entity: Entity3D) => void;
+/** Base configuration for all dataset sources */
+export interface DatasetSourceConfigBase<TDatasetType extends string> {
+    /** Type of dataset */
+    type: TDatasetType;
+}
+/** Base configuration for all datasets */
+export interface DatasetConfigBase<TDatasetType extends string> {
+    /** Type of dataset */
+    type: TDatasetType;
+    /** Name of the dataset, as displayed in the UI */
+    name: string;
+    /**
+     * Loads the dataset by default when opening the app
+     * @defaultValue false
+     */
+    visible?: boolean;
+    /**
+     * Default opacity (between 0 and 1; 0: transparent, 1: opaque)
+     * @defaultValue 1
+     */
+    opacity?: number;
+    /** Callback which is called when the dataset is preloaded into the app */
+    onObjectPreloaded?: OnObjectPreloaded;
+}
+/** Mixin configuration for datasets that support masking the basemap */
+export interface DatasetConfigMaskingMixin {
+    /** Indicates whether this dataset can mask the basemap */
+    canMaskBasemap?: boolean;
+    /** Indicates whether this dataset is by default masking the basemap when loaded */
+    isMaskingBasemap?: boolean;
+}
+/** Giro3D layer types support for datasets */
+export type DatasetLayerType = Exclude<LayerType, 'elevation'>;
+/** Configuration that can be set on groups and cascade to children */
+export interface DatasetCascadingConfig extends SourceConfigProjectionMixin, SourceConfigLocationMixin, SourceConfigElevationMixin {
+}

package/dist/src/types/configuration/datasets/featureCollection.d.ts

@@ -0,0 +1,6 @@
+import { FeatureCollectionEntityOptions } from '../../../giro3d/entities/FeatureCollectionEntity';
+import { DatasetConfigBase } from './core';
+/** Buildings dataset configuration */
+export interface FeatureCollectionDatasetConfig extends DatasetConfigBase<'featureCollection'> {
+    source: FeatureCollectionEntityOptions['source'];
+}

package/dist/src/types/configuration/datasets/ifc.d.ts

@@ -0,0 +1,10 @@
+import { UrlOrDataMixin } from '../../../giro3d/sources/mixins';
+import { SourceConfigLocationMixin } from '../sources/core/baseConfig';
+import { DatasetConfigBase, DatasetConfigMaskingMixin } from './core';
+/** IFC source configuration */
+export interface IFCDatasetSourceConfig extends UrlOrDataMixin, SourceConfigLocationMixin {
+}
+/** IFC dataset configuration */
+export interface IFCDatasetConfig extends DatasetConfigBase<'ifc'>, DatasetConfigMaskingMixin {
+    source: IFCDatasetSourceConfig;
+}

package/dist/src/types/configuration/datasets/index.d.ts

@@ -0,0 +1,27 @@
+import { CityJSONDatasetConfig } from './cityjson';
+import { DatasetCascadingConfig, DatasetConfigBase, DatasetConfigMaskingMixin } from './core';
+import { FeatureCollectionDatasetConfig } from './featureCollection';
+import { IFCDatasetConfig } from './ifc';
+import { ColorLayerDatasetConfig, ElevationLayerDatasetConfig, MaskLayerDatasetConfig } from './layer';
+import { PLYDatasetConfig } from './ply';
+import { PointCloudDatasetConfig } from './pointCloud';
+import { PotreePointCloudDatasetConfig } from './potreePointCloud';
+import { TiledIfcDatasetConfig } from './tiledIfc';
+import { TiledPointCloudDatasetConfig } from './tiledPointCloud';
+import { VectorLabelsDatasetConfig, VectorMeshDatasetConfig, VectorShapeDatasetConfig } from './vector';
+export type DatasetAsMeshConfig = CityJSONDatasetConfig | PointCloudDatasetConfig | FeatureCollectionDatasetConfig | IFCDatasetConfig | PLYDatasetConfig | PointCloudDatasetConfig | PotreePointCloudDatasetConfig | TiledIfcDatasetConfig | TiledPointCloudDatasetConfig | VectorLabelsDatasetConfig | VectorMeshDatasetConfig | VectorShapeDatasetConfig;
+export type DatasetAsLayerConfig = ColorLayerDatasetConfig | ElevationLayerDatasetConfig | MaskLayerDatasetConfig;
+/** All supported datasets */
+export type DatasetConfig = DatasetAsMeshConfig | DatasetAsLayerConfig;
+export type DatasetConfigImportable = Extract<DatasetConfig, CityJSONDatasetConfig | PointCloudDatasetConfig | IFCDatasetConfig | VectorMeshDatasetConfig | VectorShapeDatasetConfig | VectorLabelsDatasetConfig | ColorLayerDatasetConfig>;
+/** List of all dataset types */
+export type DatasetType = DatasetConfig['type'];
+/** Configuration for a group of datasets */
+export interface DatagroupConfig extends DatasetConfigBase<'group'>, DatasetCascadingConfig, DatasetConfigMaskingMixin {
+    /** Datasets contained in this group */
+    children: DatasetOrGroupConfig[];
+}
+/** Configuration for dataset hierarchy */
+export type DatasetOrGroupConfig = DatasetConfig | DatagroupConfig;
+/** List of dataset types that can be imported into the app */
+export type DatasetTypeImportable = DatasetConfigImportable['type'];

package/dist/src/types/configuration/datasets/layer.d.ts

@@ -0,0 +1,43 @@
+import { ColorMapConfig } from '../color';
+import { GeoExtent } from '../geographic';
+import { ColorLayerOptions } from '@giro3d/giro3d/core/layer/ColorLayer';
+import { ElevationLayerOptions } from '@giro3d/giro3d/core/layer/ElevationLayer';
+import { Mode as InterpretationMode, InterpretationOptions } from '@giro3d/giro3d/core/layer/Interpretation';
+import { LayerOptions } from '@giro3d/giro3d/core/layer/Layer';
+import { MaskLayerOptions } from '@giro3d/giro3d/core/layer/MaskLayer';
+import { LayerSourceConfig } from '../layers';
+import { DatasetConfigBase } from './core';
+/** Mixin configuration for layer options */
+export interface LayerConfigMixin extends Pick<LayerOptions, 'showTileBorders' | 'showEmptyTextures' | 'noDataOptions' | 'preloadImages' | 'resolutionFactor'> {
+    /** Restrict the extent of the data */
+    extent?: GeoExtent;
+    /** Interpretation mode of the data */
+    interpretation?: InterpretationOptions & {
+        mode: InterpretationMode;
+    };
+    /** Color map for displaying the layer */
+    colorMap?: ColorMapConfig;
+    /** Background color of the layer */
+    backgroundColor?: string;
+}
+/** Mixin configuration for color layer options */
+export interface ColorLayerConfigMixin extends Pick<ColorLayerOptions, 'elevationRange' | 'opacity' | 'minFilter' | 'magFilter'> {
+}
+/** Mixin configuration for elevation layer options */
+export interface ElevationLayerConfigMixin extends Pick<ElevationLayerOptions, 'minmax'> {
+}
+/** Mixin configuration for mask layer options */
+export interface MaskLayerConfigMixin extends Pick<MaskLayerOptions, 'maskMode'> {
+}
+export interface LayerDatasetConfigBase<TDatasetType extends string> extends DatasetConfigBase<TDatasetType>, LayerConfigMixin {
+    source: LayerSourceConfig;
+}
+/** Color layer configuration */
+export interface ColorLayerDatasetConfig extends LayerDatasetConfigBase<'colorLayer'>, ColorLayerConfigMixin {
+}
+/** Elevation layer configuration */
+export interface ElevationLayerDatasetConfig extends LayerDatasetConfigBase<'elevationLayer'>, ElevationLayerConfigMixin {
+}
+/** Mask layer configuration */
+export interface MaskLayerDatasetConfig extends LayerDatasetConfigBase<'maskLayer'>, MaskLayerConfigMixin {
+}