@giro3d/piero 1.0.0-beta.0

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

@@ -0,0 +1,20 @@
+import { Vector3 } from '../../../../node_modules/three';
+import { default as Shape } from '@giro3d/giro3d/entities/Shape';
+import { default as Measure } from '../types/Measure';
+import { HIGHLIGHT_MEASURE_COLOR } from '../constants';
+declare class Measure3D extends Shape<MeasureUserData> {
+    readonly isMeasure3D: true;
+    get from(): Vector3;
+    get length(): number;
+    get to(): Vector3;
+    constructor();
+    static isMeasure3D: (obj: unknown) => obj is Measure3D;
+    clone(): Measure3D;
+    copy(source: this): this;
+}
+export type MeasureUserData = {
+    highlightable: true;
+    highlightColor: typeof HIGHLIGHT_MEASURE_COLOR;
+    measure: Measure;
+};
+export default Measure3D;

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

@@ -0,0 +1,11 @@
+import { default as Extent } from '@giro3d/giro3d/core/geographic/Extent';
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+declare class Plane {
+    get visible(): boolean;
+    set visible(v: boolean);
+    private readonly _instance;
+    private readonly _plane;
+    constructor(instance: Instance, extent: Extent, name: string);
+    dispose(): void;
+}
+export default Plane;

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

@@ -0,0 +1,6 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+declare function addSkybox(instance: Instance): Promise<void>;
+declare const _default: {
+    addSkybox: typeof addSkybox;
+};
+export default _default;

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

@@ -0,0 +1,41 @@
+import { FeatureElevationCallback, FeatureExtrusionOffsetCallback, FeatureStyle, FeatureStyleCallback } from '@giro3d/giro3d/core/FeatureTypes';
+import { default as FeatureCollection } from '@giro3d/giro3d/entities/FeatureCollection';
+import { EntityBuilder } from '../EntityBuilder';
+import { FeatureProjectionMixin } from '../sources/mixins';
+/** Options for the Giro3D FeatureCollection */
+type FeatureCollectionConstructorOptions = ConstructorParameters<typeof FeatureCollection>[0];
+/** Options for {@link FeatureCollectionEntity} */
+export interface FeatureCollectionEntityOptions extends Partial<Pick<FeatureCollectionConstructorOptions, 'extent' | 'ignoreZ' | 'maxLevel' | 'minLevel'>>, Required<FeatureProjectionMixin> {
+    /**
+     * Set the elevation of the features received from the source.
+     * It can be a constant for every feature, or a callback.
+     * The callback version is particularly useful to derive the elevation
+     * from the properties of the feature.
+     * Requires {@link _ignoreZ} to be `false`.
+     */
+    elevation?: FeatureElevationCallback | number;
+    /**
+     * If set, this will cause 2D features to be extruded of the corresponding amount.
+     * If a single value is given, it will be used for all the vertices of every feature.
+     * If an array is given, each extruded vertex will use the corresponding value.
+     * If a callback is given, it allows to extrude each feature individually.
+     */
+    extrusionOffset?: FeatureExtrusionOffsetCallback | number;
+    /** Source to use */
+    source: 'bdtopo';
+    /**
+     * An style or a callback returning a style to style the individual features.
+     * If an object is used, the informations it contains will be used to style every
+     * feature the same way. If a function is provided, it will be called with the feature.
+     * This allows to individually style each feature.
+     */
+    style?: FeatureStyle | FeatureStyleCallback;
+}
+/**
+ * Entity for displaying 3D buildings
+ */
+export declare class FeatureCollectionEntity extends FeatureCollection {
+    constructor(options: FeatureCollectionEntityOptions);
+}
+export declare const build: EntityBuilder;
+export {};

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

@@ -0,0 +1,45 @@
+import { GetMemoryUsageContext } from '@giro3d/giro3d/core/MemoryUsage';
+import { EntityPreprocessOptions } from '@giro3d/giro3d/entities/Entity';
+import { PointCloudOptions, default as PointCloud } from '@giro3d/giro3d/entities/PointCloud';
+import { GetNodeDataOptions, PointCloudMetadata, PointCloudNode, PointCloudNodeData, PointCloudSourceBase } from '@giro3d/giro3d/sources/PointCloudSource';
+import { UrlOrData } from '../../utils/Fetcher';
+import { DataProjectionMixin, UrlOrDataMixin } from '../sources/mixins';
+export type CSVPointCloudSourceOptions = DataProjectionMixin & UrlOrDataMixin;
+/** Parameters for {@link PointCloudSource} for creating {@link PointCloudEntity} */
+export interface PointCloudSourceOptions extends DataProjectionMixin, UrlOrDataMixin {
+}
+/**
+ * Source for loading CSV (as X, Y, Z) point clouds.
+ *
+ * @see https://loaders.gl/docs/modules/csv/api-reference/csv-loader
+ */
+export declare class CSVPointCloudSource extends PointCloudSourceBase {
+    readonly dataProjection?: string;
+    readonly isCSVPointCloudSource: true;
+    readonly type = "CSVPointCloudSource";
+    readonly url: UrlOrData;
+    get loading(): boolean;
+    get progress(): number;
+    private _localVolume;
+    private _metadata;
+    private readonly _opCounter;
+    private _origin;
+    private _points;
+    private _root;
+    private _zArray;
+    constructor(options: CSVPointCloudSourceOptions);
+    dispose(): void;
+    getHierarchy(): Promise<PointCloudNode>;
+    getMemoryUsage(context: GetMemoryUsageContext): void;
+    getMetadata(): Promise<PointCloudMetadata>;
+    getNodeData(params: GetNodeDataOptions): Promise<PointCloudNodeData>;
+    protected initializeOnce(): Promise<this>;
+}
+/**
+ * Point cloud entity
+ */
+export default class PointCloudEntity extends PointCloud {
+    readonly isPointCloudEntity = true;
+    constructor(options: PointCloudOptions);
+    initialize(opts: EntityPreprocessOptions): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import { EntityBuilder } from '../EntityBuilder';
+import { Tiles3dSource, default as Tiles3dEntity } from './Tiles3dEntity';
+/** Parameters for creating {@link TiledPointCloudEntity} */
+export interface TiledPointCloudSource extends Tiles3dSource {
+    name: string;
+}
+/**
+ * Entity for displaying 3D-Tiles point clouds
+ */
+export default class TiledPointCloudEntity extends Tiles3dEntity {
+    constructor(parameters: TiledPointCloudSource);
+}
+export declare const build: EntityBuilder;

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

@@ -0,0 +1,11 @@
+import { Tiles3DOptions, default as Tiles3D } from '@giro3d/giro3d/entities/Tiles3D';
+import { UrlMixin } from '../sources/mixins';
+/** Parameters for creating {@link Tiles3dEntity} */
+export interface Tiles3dSource extends UrlMixin {
+}
+/**
+ * Entity for displaying 3D-Tiles files
+ */
+export default class Tiles3dEntity extends Tiles3D {
+    constructor(parameters: Tiles3dSource, options?: Tiles3DOptions);
+}

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

@@ -0,0 +1,48 @@
+import { default as PickOptions } from '@giro3d/giro3d/core/picking/PickOptions';
+import { default as PickResult } from '@giro3d/giro3d/core/picking/PickResult';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { Box3, Vector2, Vector3 } from '../../../../../node_modules/three';
+import { SimpleFeature } from '../../utils/OLFeatures';
+import { VectorMeshSource } from './VectorMeshEntity';
+/**
+ * Pick result on {@link VectorLabelsEntity}
+ */
+export type LabelPickResult = PickResult & {
+    entity: VectorLabelsEntity;
+    isLabelPickResult: true;
+};
+export interface VectorLabelOptions {
+    /**
+     * Callback for styling the label
+     * @param span - Label
+     * @param feature - Feature corresponding to the label
+     * @returns Nothing
+     */
+    style?: (span: HTMLSpanElement, feature: SimpleFeature) => void;
+    /**
+     * Callback for generating the text of labels
+     * @param feature - Feature corresponding to the label
+     * @param at - 3D position
+     * @returns Content of the label to create
+     */
+    text?: (feature: SimpleFeature, at: Vector3) => string;
+}
+/**
+ * Entity for displaying vector data as labels
+ */
+export default class VectorLabelsEntity extends Entity3D {
+    readonly sources: VectorMeshSource[];
+    private _labels;
+    private _styleCallback?;
+    private _textCallback;
+    constructor(sources: VectorMeshSource | VectorMeshSource[], options?: VectorLabelOptions);
+    getBoundingBox(): Box3 | null;
+    pick(coordinates: Vector2, _options?: PickOptions): LabelPickResult[];
+    updateOpacity(): void;
+    updateVisibility(): void;
+    protected preprocess(): Promise<void>;
+    private createLabel;
+    private pickLabels;
+    private raycastLabel;
+    private updateStyle;
+}

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

@@ -0,0 +1,97 @@
+import { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { PolygonOptions } from '@giro3d/giro3d/renderer/geometries/GeometryConverter';
+import { default as FeatureFormat } from 'ol/format/Feature';
+import { default as Entity3D } from '@giro3d/giro3d/entities/Entity3D';
+import { Group } from '../../../../../node_modules/three';
+import { ExtractOptional } from '../../types/utilities';
+import { FetchContext } from '../../utils/Fetcher';
+import { SimpleFeature } from '../../utils/OLFeatures';
+import { DataProjectionMixin, ElevationMixin, FeatureProjectionMixin, UrlOrDataMixin } from '../sources/mixins';
+/** Source for {@link VectorMeshEntity} */
+export interface VectorMeshSourceOptions extends DataProjectionMixin, ElevationMixin, Required<FeatureProjectionMixin>, UrlOrDataMixin {
+}
+export declare const defaultParameters: Required<ExtractOptional<VectorMeshSourceOptions>>;
+/** 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;
+    /** Context of the data */
+    context(): FetchContext;
+    /** Loads the features. Will be called only once */
+    load(instance: Instance): Promise<SimpleFeature[]>;
+}
+/** GeoJSON source */
+export declare class GeoJsonMeshSource implements VectorMeshSource {
+    elevation?: number;
+    readonly options: VectorMeshSourceOptions;
+    constructor(options: VectorMeshSourceOptions);
+    context(): FetchContext;
+    load(instance: Instance): Promise<SimpleFeature[]>;
+}
+/** OpenLayers-based source */
+export declare class OlMeshSource implements VectorMeshSource {
+    elevation?: number;
+    /** OL Feature format */
+    readonly format: FeatureFormat;
+    noDataValue?: number;
+    readonly options: VectorMeshSourceOptions;
+    constructor(format: FeatureFormat, options: VectorMeshSourceOptions);
+    context(): FetchContext;
+    load(instance: Instance): Promise<SimpleFeature[]>;
+}
+/** GPX source */
+export declare class GpxMeshSource extends OlMeshSource {
+    constructor(options: VectorMeshSourceOptions);
+}
+/** KML source */
+export declare class KmlMeshSource extends OlMeshSource {
+    constructor(options: VectorMeshSourceOptions);
+}
+/**
+ * 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 {@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): Group;
+/**
+ * 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 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[]>;
+/** 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 { default as Instance } from '@giro3d/giro3d/core/Instance';
+import { SimpleFeature } from '../../utils/OLFeatures';
+import { FetchContext } from '../../utils/Fetcher';
+import { DataProjectionMixin, ElevationMixin, FeatureProjectionMixin, UrlOrDataMixin } from './mixins';
+import { VectorMeshSource } from '../entities/VectorMeshEntity';
+/**
+ * Options for loading Geopackage files into a {@link VectorMeshEntity}
+ */
+export interface GeopackageSourceParameters extends DataProjectionMixin, ElevationMixin, Required<FeatureProjectionMixin>, UrlOrDataMixin {
+}
+/**
+ * Source for loading a Geopackage file into a {@link VectorMeshEntity}
+ */
+export default class GeopackageSource implements VectorMeshSource {
+    elevation?: number;
+    readonly options: GeopackageSourceParameters;
+    constructor(options: GeopackageSourceParameters);
+    context(): FetchContext;
+    load(instance: Instance): Promise<SimpleFeature[]>;
+}

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

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

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

@@ -0,0 +1,60 @@
+import { default as Coordinates } from '@giro3d/giro3d/core/geographic/Coordinates';
+import { UrlOrData } from '../../utils/Fetcher';
+/** 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 have a data projection */
+export interface DataProjectionMixin {
+    /** CRS of the source */
+    dataProjection?: string;
+}
+/** 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;
+}
+/** 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 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;
+}

package/dist/src/index.d.ts

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

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 { DatasetConfigImportable } from '../types/configuration/datasets';
+import { Dataset } from '../types/Dataset';
+export type LoadDatasetFromFile<O extends DatasetConfigImportable = DatasetConfigImportable> = (context: LoaderContext) => O;
+export type LoaderContext = {
+    configuration: Configuration;
+    extension: string;
+    file: File | string;
+    filename: string;
+};
+/**
+ * Loads a file and creates its Dataset.
+ *
+ * @param fileOrUrl - File to load
+ * @returns Created objects
+ * @throws `Error` if file cannot be imported (unsupported, etc.)
+ */
+declare function importFile(fileOrUrl: File | string, config: Readonly<Configuration>): Promise<Dataset>;
+/**
+ * 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;
+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: Entity3D | Object3D, 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<ColorLayerDatasetConfig | VectorLabelsDatasetConfig | VectorMeshDatasetConfig | VectorShapeDatasetConfig>;

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/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 _context;
+    private _tours;
+    initialize(context: PieroContext): Promise<void> | void;
+    private buildTours;
+    private getTours;
+    private restart;
+    private start;
+}

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

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