@giro3d/piero 25.10.0-beta.10

package/dist/src/giro3d/entities/VectorMeshEntity.d.ts

@@ -0,0 +1,97 @@
+import { ExtractOptional } from '../../types/utilities';
+import { FetchContext } from '../../utils/Fetcher';
+import { SimpleFeature } from '../../utils/OLFeatures';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { PolygonOptions } from '@giro3d/giro3d/renderer/geometries/GeometryConverter';
+import { default as FeatureFormat } from 'ol/format/Feature';
+import { Group } from '../../../../../node_modules/three';
+import { DataProjectionMixin, ElevationMixin, FeatureProjectionMixin, UrlOrDataMixin } from '../sources/mixins';
+/** Source for {@link VectorMeshEntity} */
+export interface VectorMeshSourceOptions extends UrlOrDataMixin, DataProjectionMixin, Required<FeatureProjectionMixin>, ElevationMixin {
+}
+export declare const defaultParameters: Required<ExtractOptional<VectorMeshSourceOptions>>;
+/**
+ * Converts a GeoJSON object into a list of GeoJSON features
+ * @param json - GeoJSON object
+ * @returns Array of GeoJSON features
+ */
+export declare function toGeoJSONFeatures(json: GeoJSON.GeoJSON): GeoJSON.Feature[];
+/**
+ * Converts GeoJSON features into OpenLayers features.
+ * Will handle reprojection if needed.
+ * Will fetch elevation if `parameters.fetchElevation` is `true`.
+ *
+ * @param features - Array of GeoJSON features
+ * @param parameters - Loader parameters
+ * @returns Array of simple features, where unsupported features are discarded
+ */
+export declare function geojsonToOlFeatures(instance: Instance, features: GeoJSON.Feature[], parameters: VectorMeshSourceOptions): Promise<SimpleFeature[]>;
+/**
+ * Converts loaded data into OpenLayers {@link SimpleFeature}s.
+ * Will handle reprojection if needed.
+ * Will fetch elevation if `parameters.fetchElevation` is `true`.
+ *
+ * @param data - Loaded data
+ * @param format - OpenLayers format used for decoding `data`
+ * @param parameters - Loader parameters
+ * @returns Array of simple features, where unsupported features are discarded
+ */
+export declare function toOlFeatures(instance: Instance, data: string, format: FeatureFormat, parameters: VectorMeshSourceOptions): Promise<SimpleFeature[]>;
+/**
+ * Converts {@link SimpleFeature}s into a Three.js `Group`.
+ * Assumes features are already in the correct CRS.
+ * If Z-coordinates are missing in the features (`null` or equal to `noDataValue`),
+ * they are filled at `options?.elevation` or at `defaultElevation`.
+ *
+ * @param features - Features to convert
+ * @param options - GeometryConverter options
+ * @param defaultElevation - Default elevation if not provided via options
+ * @param noDataValue - Value considered as no data for filling Z.
+ * @returns Group containing all meshes for all features
+ */
+export declare function olFeaturestoGroup(features: SimpleFeature[], options?: PolygonOptions, defaultElevation?: number, noDataValue?: number): Promise<Group>;
+/** Interface to implement for a new source for {@link VectorMeshEntity} */
+export interface VectorMeshSource {
+    /** Elevation of the features */
+    elevation?: number;
+    /** No data value for elevation */
+    noDataValue?: number;
+    /** Loads the features. Will be called only once */
+    load(instance: Instance): Promise<SimpleFeature[]>;
+    /** Context of the data */
+    context(): FetchContext;
+}
+/** OpenLayers-based source */
+export declare class OlMeshSource implements VectorMeshSource {
+    elevation?: number;
+    noDataValue?: number;
+    /** OL Feature format */
+    readonly format: FeatureFormat;
+    readonly options: VectorMeshSourceOptions;
+    constructor(format: FeatureFormat, options: VectorMeshSourceOptions);
+    load(instance: Instance): Promise<SimpleFeature[]>;
+    context(): FetchContext;
+}
+/** GPX source */
+export declare class GpxMeshSource extends OlMeshSource {
+    constructor(options: VectorMeshSourceOptions);
+}
+/** KML source */
+export declare class KmlMeshSource extends OlMeshSource {
+    constructor(options: VectorMeshSourceOptions);
+}
+/** GeoJSON source */
+export declare class GeoJsonMeshSource implements VectorMeshSource {
+    elevation?: number;
+    readonly options: VectorMeshSourceOptions;
+    constructor(options: VectorMeshSourceOptions);
+    load(instance: Instance): Promise<SimpleFeature[]>;
+    context(): FetchContext;
+}
+/** Entity for displaying vector data as meshes */
+export default class VectorMeshEntity extends Entity3D {
+    readonly sources: VectorMeshSource[];
+    constructor(sources: VectorMeshSource | VectorMeshSource[]);
+    protected preprocess(): Promise<void>;
+}

package/dist/src/giro3d/entities/VectorShapeEntity.d.ts

@@ -0,0 +1,8 @@
+import { default as Shape } from '@giro3d/giro3d/entities/Shape';
+import { VectorMeshSource } from './VectorMeshEntity';
+/** Entity for displaying vector data as meshes */
+export default class VectorShapeEntity extends Shape {
+    readonly source: VectorMeshSource;
+    constructor(source: VectorMeshSource);
+    protected preprocess(): Promise<void>;
+}

package/dist/src/giro3d/entities/flatPointCloud.d.ts

@@ -0,0 +1,2 @@
+import { EntityBuilder } from '../EntityBuilder';
+export declare const build: EntityBuilder;

package/dist/src/giro3d/entities/tiledIfc.d.ts

@@ -0,0 +1,2 @@
+import { EntityBuilder } from '../EntityBuilder';
+export declare const build: EntityBuilder;

package/dist/src/giro3d/entities/vector.d.ts

@@ -0,0 +1,2 @@
+import { EntityBuilder } from '../EntityBuilder';
+export declare const build: EntityBuilder;

package/dist/src/giro3d/sources/GeopackageSource.d.ts

@@ -0,0 +1,20 @@
+import { FetchContext } from '../../utils/Fetcher';
+import { SimpleFeature } from '../../utils/OLFeatures';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { VectorMeshSource } from '../entities/VectorMeshEntity';
+import { DataProjectionMixin, ElevationMixin, FeatureProjectionMixin, UrlOrDataMixin } from './mixins';
+/**
+ * Options for loading Geopackage files into a {@link VectorMeshEntity}
+ */
+export interface GeopackageSourceParameters extends UrlOrDataMixin, DataProjectionMixin, Required<FeatureProjectionMixin>, ElevationMixin {
+}
+/**
+ * Source for loading a Geopackage file into a {@link VectorMeshEntity}
+ */
+export default class GeopackageSource implements VectorMeshSource {
+    elevation?: number;
+    readonly options: GeopackageSourceParameters;
+    constructor(options: GeopackageSourceParameters);
+    load(instance: Instance): Promise<SimpleFeature[]>;
+    context(): FetchContext;
+}

package/dist/src/giro3d/sources/ShapefileSource.d.ts

@@ -0,0 +1,20 @@
+import { FetchContext } from '../../utils/Fetcher';
+import { SimpleFeature } from '../../utils/OLFeatures';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { VectorMeshSource } from '../entities/VectorMeshEntity';
+import { DataProjectionMixin, ElevationMixin, FeatureProjectionMixin, UrlOrDataMixin } from './mixins';
+/**
+ * Options for loading Shapefile files into a {@link VectorMeshEntity}
+ */
+export interface ShapefileSourceParameters extends UrlOrDataMixin, DataProjectionMixin, Required<FeatureProjectionMixin>, ElevationMixin {
+}
+/**
+ * Source for loading a Shapefile file into a {@link VectorMeshEntity}
+ */
+export default class ShapefileSource implements VectorMeshSource {
+    elevation?: number;
+    readonly options: ShapefileSourceParameters;
+    constructor(options: ShapefileSourceParameters);
+    load(instance: Instance): Promise<SimpleFeature[]>;
+    context(): FetchContext;
+}

package/dist/src/giro3d/sources/mixins.d.ts

@@ -0,0 +1,60 @@
+import { UrlOrData } from '../../utils/Fetcher';
+import { default as Coordinates } from '@giro3d/giro3d/core/geographic/Coordinates';
+/** Mixin configuration for sources that require a URL */
+export interface UrlMixin {
+    /** URL of the source */
+    url: string;
+}
+/** Mixin configuration for sources that require a URL or Blob */
+export interface UrlOrDataMixin {
+    /** URL of the source */
+    url: UrlOrData;
+}
+/** Mixin configuration for sources that may have a data projection */
+export interface DataProjectionMixin {
+    /** CRS of the source */
+    dataProjection?: string;
+}
+/** Mixin configuration for sources that may have a feature projection */
+export interface FeatureProjectionMixin {
+    /** CRS of the target, should be the instance's CRS */
+    featureProjection?: string;
+}
+/** Mixin configuration for sources that may set their geolocation */
+export interface CoordinatesMixin {
+    /** Location, should be in the instance's CRS */
+    at?: Coordinates;
+}
+/** Mixin configuration for sources that may require elevation configuration */
+export interface ElevationMixin {
+    /**
+     * Elevation of data
+     *
+     * @defaultValue 0
+     */
+    elevation?: number;
+    /**
+     * Fetch elevation from provider
+     *
+     * @defaultValue false
+     */
+    fetchElevation?: boolean;
+    /**
+     * Fetch elevation from map instead of API
+     *
+     * @defaultValue false
+     */
+    fetchElevationFast?: boolean;
+    /**
+     * When fetching elevation, add this offset
+     *
+     * @defaultValue 0.1
+     */
+    fetchElevationOffset?: number;
+    /**
+     * When fetching or setting elevation, consider this value as no data
+     *
+     * @defaultValue 0
+     */
+    noDataValue?: number;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,17 @@
+import { PieroContext } from './context';
+import { default as createPieroApp } from './createPieroApp';
+import { BookmarkEvents, PieroEmptyEvent, PieroEvents, PieroGlobalEvents } from './events';
+import { EntityBuilder } from './giro3d/EntityBuilder';
+import { LoadDatasetFromFile } from './loaders/loader';
+import { fillObject3DUserData, UserData } from './loaders/userData';
+import { Module } from './module';
+import { AttributeExtractorFn } from './services/Picker';
+import { default as Bookmark } from './types/Bookmark';
+import { Configuration } from './types/Configuration';
+import { Attribute, AttributesGroups } from './types/Feature';
+import { default as Fetcher } from './utils/Fetcher';
+import { default as Projections } from './utils/Projections';
+import { default as BookmarkApi } from './api/BookmarkApi';
+import { default as DatasetApi } from './api/DatasetApi';
+import { default as ViewApi } from './api/ViewApi';
+export { Attribute, AttributeExtractorFn, AttributesGroups, Bookmark, BookmarkApi, BookmarkEvents, Configuration, DatasetApi, EntityBuilder, Fetcher, LoadDatasetFromFile, Module, PieroContext, PieroEmptyEvent, PieroEvents, PieroGlobalEvents, Projections, UserData, ViewApi, createPieroApp, fillObject3DUserData, };

package/dist/src/loaders/csv.d.ts

@@ -0,0 +1,3 @@
+import { PointCloudDatasetConfig } from '../types/configuration/datasets/pointCloud';
+import { LoadDatasetFromFile } from './loader';
+export declare const load: LoadDatasetFromFile<PointCloudDatasetConfig>;

package/dist/src/loaders/las.d.ts

@@ -0,0 +1,3 @@
+import { PointCloudDatasetConfig } from '../types/configuration/datasets/pointCloud';
+import { LoadDatasetFromFile } from './loader';
+export declare const load: LoadDatasetFromFile<PointCloudDatasetConfig>;

package/dist/src/loaders/loader.d.ts

@@ -0,0 +1,29 @@
+import { Configuration } from '../types/Configuration';
+import { Dataset } from '../types/Dataset';
+import { DatasetConfigImportable } from '../types/configuration/datasets';
+export type LoaderContext = {
+    file: File;
+    extension: string;
+    filename: string;
+    configuration: Configuration;
+};
+export type LoadDatasetFromFile<O extends DatasetConfigImportable = DatasetConfigImportable> = (context: LoaderContext) => O;
+/**
+ * Registers a custom loader for a specific file extension.
+ * If a loader for the same extension exists, it is replaced by the new one.
+ * @param fileExtension - The file extension, without the dot.
+ * @param loader - The loader to use.
+ */
+export declare function registerLoader(fileExtension: string, loader: LoadDatasetFromFile): void;
+/**
+ * Loads a file and creates its Dataset.
+ *
+ * @param file - File to load
+ * @returns Created objects
+ * @throws `Error` if file cannot be imported (unsupported, etc.)
+ */
+declare function importFile(file: File, config: Readonly<Configuration>): Promise<Dataset>;
+declare const _default: {
+    importFile: typeof importFile;
+};
+export default _default;

package/dist/src/loaders/loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/loaders/userData.d.ts

@@ -0,0 +1,8 @@
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { Object3D } from '../../../../node_modules/three';
+/** User data to be set on the loaded entities */
+export interface UserData {
+    /** File that the entity was loaded from */
+    filename?: string | null;
+}
+export declare function fillObject3DUserData(root: Object3D | Entity3D, userData: UserData): void;

package/dist/src/loaders/vector.d.ts

@@ -0,0 +1,4 @@
+import { ColorLayerDatasetConfig } from '../types/configuration/datasets/layer';
+import { VectorLabelsDatasetConfig, VectorMeshDatasetConfig, VectorShapeDatasetConfig } from '../types/configuration/datasets/vector';
+import { LoadDatasetFromFile } from './loader';
+export declare const load: LoadDatasetFromFile<VectorMeshDatasetConfig | VectorShapeDatasetConfig | VectorLabelsDatasetConfig | ColorLayerDatasetConfig>;

package/dist/src/module.d.ts

@@ -0,0 +1,11 @@
+import { PieroContext } from './context';
+export interface Module {
+    /**
+     * The readable name of the module.
+     */
+    name: string;
+    /**
+     * Initialize this module on the Piero context.
+     */
+    initialize(context: PieroContext): Promise<void> | void;
+}

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

@@ -0,0 +1,10 @@
+import { PieroContext } from '../context';
+import { EntityBuilder } from '../giro3d/EntityBuilder';
+import { LoadDatasetFromFile } from '../loaders/loader';
+import { Module } from '../module';
+export declare const loader: LoadDatasetFromFile;
+export declare const entityBuilder: EntityBuilder;
+export default class CityJSONLoader implements Module {
+    readonly name = "CityJSON";
+    initialize(context: PieroContext): Promise<void> | void;
+}

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

@@ -0,0 +1,9 @@
+import { PieroContext } from '../context';
+import { Module } from '../module';
+/**
+ * Loads IFC (Industry Foundation Classes) files.
+ */
+export default class IFCLoader implements Module {
+    readonly name = "IFC";
+    initialize(context: PieroContext): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+import { PieroContext } from '../context';
+import { Module } from '../module';
+/**
+ * Loads .ply files.
+ */
+export default class PLYLoader implements Module {
+    readonly name = "PLY";
+    initialize(context: PieroContext): Promise<void> | void;
+}

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

@@ -0,0 +1,9 @@
+import { PieroContext } from '../context';
+import { Module } from '../module';
+/**
+ * Loads [Potree](https://potree.github.io/) datasets.
+ */
+export default class PotreeLoader implements Module {
+    readonly name = "Potree";
+    initialize(context: PieroContext): Promise<void> | void;
+}

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

@@ -0,0 +1,17 @@
+import { PieroContext } from '../context';
+import { Module } from '../module';
+/**
+ * Provides a guided tour of the application.
+ */
+export default class TourModule implements Module {
+    readonly name = "Tour";
+    private _camera;
+    private _cameraCallback;
+    private _tours;
+    private _context;
+    initialize(context: PieroContext): Promise<void> | void;
+    private getTours;
+    private start;
+    private restart;
+    private buildTours;
+}

package/dist/src/modules/cityjson/CityJSONEntity.d.ts

@@ -0,0 +1,79 @@
+import { DataProjectionMixin, FeatureProjectionMixin, UrlOrDataMixin } from '../../giro3d/sources/mixins';
+import { default as PickOptions } from '@giro3d/giro3d/core/picking/PickOptions';
+import { default as PickResult } from '@giro3d/giro3d/core/picking/PickResult';
+import { default as PickableFeatures } from '@giro3d/giro3d/core/picking/PickableFeatures';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { CityObjectsMesh } from 'cityjson-threejs-loader';
+import { Vector2 } from '../../../../../node_modules/three';
+/**
+ * Object returned by CityJSON's `resolveIntersectionInfo`, used when picking
+ */
+export interface CityJSONIntersectionInfo {
+    vertexId: number;
+    objectIndex: number;
+    objectId: string;
+    geometryIndex: number;
+    boundaryIndex: number;
+    objectTypeIndex: number;
+    surfaceTypeIndex: number;
+    lodIndex: number;
+}
+/**
+ * Feature returned when picking on CityJSON objects
+ */
+export interface CityJSONFeature {
+    /** Intersection info from CityJSON library */
+    cityjsonInfo: CityJSONIntersectionInfo;
+    /** CityJSON object picked */
+    citymodel: any;
+}
+/**
+ * Pick result on {@link CityJSONEntity | CityJSON entities}
+ */
+export interface CityJSONPickResult extends PickResult<CityJSONFeature> {
+    isCityJSONPickResult: true;
+    entity: CityJSONEntity;
+    object: CityObjectsMesh;
+    features?: CityJSONFeature[];
+}
+export declare const isCityJSONPickResult: (obj: unknown) => obj is CityJSONPickResult;
+/**
+ * Source interface for {@link CityJSONEntity}
+ */
+export interface CityJSONSource extends UrlOrDataMixin, DataProjectionMixin, Required<FeatureProjectionMixin> {
+}
+/**
+ * Entity for displaying a CityJSON file
+ */
+export default class CityJSONEntity extends Entity3D implements PickableFeatures<CityJSONFeature, CityJSONPickResult> {
+    readonly isCityJSONEntity = true;
+    readonly isPickableFeatures = true;
+    readonly type = "CityJSONEntity";
+    readonly source: CityJSONSource;
+    private _availableLods;
+    private _displayedLodIdx;
+    private _showSemantics;
+    constructor(source: CityJSONSource);
+    /** Array of the available Levels Of Details in this CityJSON model */
+    get availableLods(): string[] | null;
+    /**
+     * Gets the displayed index of Level Of Details, from {@link availableLods}.
+     * If `-1` or out of bounds, displays all levels.
+     */
+    get displayedLodIdx(): number;
+    /**
+     * Sets the displayed index of Level Of Details, from {@link availableLods}.
+     * If `-1` or out of bounds, displays all levels.
+     * @param lodIdx - Index from {@link availableLods}
+     */
+    set displayedLodIdx(lodIdx: number);
+    /** Gets whether the theme uses semantics or not */
+    get showSemantics(): boolean;
+    /** Sets whether the theme uses semantics or not */
+    set showSemantics(v: boolean);
+    private traverseCityMaterials;
+    preprocess(): Promise<void>;
+    pick(canvasCoords: Vector2, options?: PickOptions): CityJSONPickResult[];
+    pickFeaturesFrom(pickedResult: CityJSONPickResult): CityJSONFeature[];
+    static isCityJSONEntity: (obj: object) => obj is CityJSONEntity;
+}

package/dist/src/modules/cityjson/CityJSONEntityInspector.d.ts

@@ -0,0 +1,8 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as EntityInspector } from '@giro3d/giro3d/gui/EntityInspector';
+import { default as GUI } from 'lil-gui';
+import { default as CityJSONEntity } from './CityJSONEntity';
+export default class CityJSONEntityInspector extends EntityInspector<CityJSONEntity> {
+    availableLods: string;
+    constructor(parentGui: GUI, instance: Instance, entity: CityJSONEntity);
+}

package/dist/src/modules/ifc/IfcEntity.d.ts

@@ -0,0 +1,87 @@
+import { default as PickOptions } from '@giro3d/giro3d/core/picking/PickOptions';
+import { default as PickResult } from '@giro3d/giro3d/core/picking/PickResult';
+import { default as PickableFeatures } from '@giro3d/giro3d/core/picking/PickableFeatures';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { FragmentMesh } from 'bim-fragment/fragment-mesh';
+import { FragmentIdMap } from 'openbim-components';
+import { Vector2 } from '../../../../../node_modules/three';
+import { CoordinatesMixin, UrlOrDataMixin } from '../../giro3d/sources/mixins';
+type FragmentTypeName = 'selection' | 'bbox';
+export declare enum ClassificationSystem {
+    STOREY = "storeys",
+    ENTITY = "entities"
+}
+export type ClassificationItem = {
+    name: string;
+    treeItemName: string;
+    children: ClassificationItem[];
+    fragments: FragmentIdMap;
+};
+export interface IFCProperty {
+    parentName: string;
+    name: string;
+    value: number | null;
+}
+export interface IFCFeature {
+    itemProperties: {
+        [attribute: string]: any;
+    };
+    ifcProperties: IFCProperty[];
+}
+export interface IFCPickResult extends PickResult<IFCFeature> {
+    isIFCPickResult: true;
+    entity: IfcEntity;
+    object: FragmentMesh;
+    features?: IFCFeature[];
+}
+export declare const isIFCPickResult: (obj: unknown) => obj is IFCPickResult;
+/** Source interface for {@link IfcEntity} */
+export interface IfcSource extends UrlOrDataMixin, CoordinatesMixin {
+    /** Name of the IFC */
+    name: string;
+}
+/**
+ * Entity for displaying an IFC file
+ */
+export default class IfcEntity extends Entity3D implements PickableFeatures<IFCFeature, IFCPickResult> {
+    readonly isIfcEntity: true;
+    readonly isPickableFeatures: true;
+    readonly type: "IfcEntity";
+    private readonly _source;
+    private _components;
+    private _model;
+    private _fragmentManager;
+    private _fragmentClassifier;
+    private _ifcSelection;
+    private _indexMap;
+    private _classificationCache;
+    private _fragmentBoundingBox;
+    constructor(source: IfcSource);
+    protected preprocess(): Promise<void>;
+    private initializeEntityIndexes;
+    private setEntityIndex;
+    getProperty(expressID: number): {
+        name: string;
+        value: number | null;
+    } | null;
+    getProperties(expressID: string): IFCProperty[];
+    private regenerateClassification;
+    protected initClassification(): Promise<void>;
+    getClassification(): ClassificationItem[];
+    private addHighlightToFragment;
+    clearHighlight(name?: FragmentTypeName): void;
+    private regenerate;
+    private addComposites;
+    private updateFragmentFill;
+    highlight(name: FragmentTypeName, mesh: FragmentMesh, itemId: string): void;
+    highlightById(ids: FragmentIdMap, name?: FragmentTypeName): void;
+    getBoundingBoxById(ids: FragmentIdMap): import('../../../../../node_modules/three').Box3 | undefined;
+    pick(canvasCoords: Vector2, options?: PickOptions): IFCPickResult[];
+    pickFeaturesFrom(pickedResult: IFCPickResult): {
+        itemProperties: any;
+        ifcProperties: IFCProperty[];
+    }[];
+    static isIFCEntity: (obj: unknown) => obj is IfcEntity;
+    static isIFCPickResult: (obj: unknown) => obj is IFCPickResult;
+}
+export {};

package/dist/src/modules/ifc/IfcEntityInspector.d.ts

@@ -0,0 +1,7 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as EntityInspector } from '@giro3d/giro3d/gui/EntityInspector';
+import { default as GUI } from 'lil-gui';
+import { default as IfcEntity } from './IfcEntity';
+export default class IfcEntityInspector extends EntityInspector<IfcEntity> {
+    constructor(parentGui: GUI, instance: Instance, entity: IfcEntity);
+}

package/dist/src/modules/ifc/IfcPropertyView.vue.d.ts

@@ -0,0 +1,6 @@
+import { Dataset } from '../../types/Dataset';
+type __VLS_Props = {
+    dataset: Dataset;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/modules/ifc/IfcSubtree.vue.d.ts

@@ -0,0 +1,7 @@
+import { default as IfcEntity, ClassificationItem } from './IfcEntity';
+type __VLS_Props = {
+    ifcEntity: IfcEntity;
+    classificationElement: ClassificationItem;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,6 @@
+import { default as CityJSONLoader } from './CityJSONLoader';
+import { default as IFCLoader } from './IFCLoader';
+import { default as PLYLoader } from './PLYLoader';
+import { default as PotreeLoader } from './PotreeLoader';
+import { default as Tour } from './Tour';
+export { CityJSONLoader, IFCLoader, PLYLoader, PotreeLoader, Tour };

package/dist/src/modules/ply/PlyEntity.d.ts

@@ -0,0 +1,33 @@
+import { CoordinatesMixin, FeatureProjectionMixin, UrlOrDataMixin } from '../../giro3d/sources/mixins';
+import { default as PickResult } from '@giro3d/giro3d/core/picking/PickResult';
+import { default as PickableFeatures } from '@giro3d/giro3d/core/picking/PickableFeatures';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { Color, Mesh } from '../../../../../node_modules/three';
+/** Parameters for creating {@link PlyEntity} */
+export interface PlySource extends UrlOrDataMixin, Required<CoordinatesMixin>, Required<FeatureProjectionMixin> {
+}
+/**
+ * Feature returned when picking on Ply objects
+ */
+export interface PlyFeature {
+    color: Color;
+}
+/**
+ * PLY 3D object implementing our picking
+ */
+export declare class PlyMesh extends Mesh implements PickableFeatures<PlyFeature> {
+    readonly isPickableFeatures = true;
+    readonly isPlyMesh = true;
+    pickFeaturesFrom(pickedResult: PickResult): PlyFeature[];
+    static isPlyMesh: (obj: unknown) => obj is PlyMesh;
+    static isPlyPickResult: (obj: unknown) => obj is PickResult<PlyFeature>;
+}
+/**
+ * Entity for displaying a PLY file
+ */
+export default class PlyEntity extends Entity3D {
+    readonly isPlyEntity = true;
+    readonly source: PlySource;
+    constructor(source: PlySource);
+    protected preprocess(): Promise<void>;
+}

package/dist/src/providers/Alticoding.d.ts

@@ -0,0 +1,32 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { default as Coordinates } from '@giro3d/giro3d/core/geographic/Coordinates';
+/**
+ * Alticoder method
+ */
+export type Alticoder = (coordinates: Coordinates[]) => Promise<void>;
+/**
+ * Alticoder using {@link IgnProvider}.
+ */
+export declare const IgnAlticoder: (coordinates: Coordinates[]) => Promise<void>;
+/**
+ * Alticoder generator using (only) the map
+ *
+ * @param instance - Giro3D instance
+ * @returns Alticoder
+ */
+export declare const mapAlticoderGenerator: (instance: Instance) => Alticoder;
+/**
+ * Alticoder generator using multiple ones
+ * @param alticoders - List of alticoders to use
+ * @param noDataValue - No data value
+ * @returns
+ */
+export declare const alticoders: (alticoders: Alticoder[], noDataValue?: number) => Alticoder;
+/**
+ * Alticoder generator using the map if fast
+ *
+ * @param instance - Giro3D instance
+ * @param fast - Fast alticoding
+ * @returns Alticoder
+ */
+export declare const alticoderGenerator: (instance: Instance, fast: boolean, noDataValue?: number) => Alticoder;