@cognite/reveal 4.19.1 → 4.20.0-dev.20241030

package/dist/packages/data-providers/src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/getDMPointCloudVolumeCollectionQuery.d.ts

@@ -0,0 +1,81 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { DMInstanceRef } from '../types';
+declare const getDMPointCloudVolumeQuery: (revisionRef: DMInstanceRef) => {
+    readonly with: {
+        readonly pointCloudVolumes: {
+            readonly nodes: {
+                readonly filter: {
+                    readonly and: [{
+                        readonly hasData: [{
+                            readonly externalId: "CognitePointCloudVolume";
+                            readonly space: "cdf_cdm";
+                            readonly version: "v1";
+                            readonly type: "view";
+                        }];
+                    }, import("@cognite/sdk").TableExpressionContainsAnyFilterV3];
+                };
+            };
+            readonly limit: 1000;
+        };
+        readonly object3D: {
+            readonly nodes: {
+                readonly from: "pointCloudVolumes";
+                readonly through: {
+                    readonly view: {
+                        readonly externalId: "CognitePointCloudVolume";
+                        readonly space: "cdf_cdm";
+                        readonly version: "v1";
+                        readonly type: "view";
+                    };
+                    readonly identifier: "object3D";
+                };
+                readonly direction: "outwards";
+            };
+            readonly limit: 1000;
+        };
+        readonly assets: {
+            readonly nodes: {
+                readonly from: "object3D";
+                readonly through: {
+                    readonly view: {
+                        readonly externalId: "CogniteVisualizable";
+                        readonly space: "cdf_cdm";
+                        readonly version: "v1";
+                        readonly type: "view";
+                    };
+                    readonly identifier: "object3D";
+                };
+            };
+            readonly limit: 1000;
+        };
+    };
+    readonly select: {
+        readonly pointCloudVolumes: {
+            readonly sources: [{
+                readonly source: {
+                    readonly externalId: "CognitePointCloudVolume";
+                    readonly space: "cdf_cdm";
+                    readonly version: "v1";
+                    readonly type: "view";
+                };
+                readonly properties: ["revisions", "volumeReferences", "volumeType", "volume", "object3D"];
+            }];
+        };
+        readonly assets: {
+            readonly sources: [{
+                readonly source: {
+                    readonly externalId: "CogniteAsset";
+                    readonly space: "cdf_cdm";
+                    readonly version: "v1";
+                    readonly type: "view";
+                };
+                readonly properties: ["name", "description", "object3D"];
+            }];
+        };
+    };
+};
+export type CdfDMPointCloudVolumeQuery = ReturnType<typeof getDMPointCloudVolumeQuery>;
+export declare function getDMPointCloudVolumeCollectionQuery(revisionExternalId: string, space: string): CdfDMPointCloudVolumeQuery;
+export {};

package/dist/packages/data-providers/src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/types.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { DMInstanceRef } from '../types';
+export type AssetProperties = {
+    object3D: DMInstanceRef;
+    name: string;
+    description: string;
+};
+export declare const ASSET_PROPERTIES_LIST: ["name", "description", "object3D"];
+export declare const pointCloudVolumeFilter: {
+    readonly hasData: [{
+        readonly externalId: "CognitePointCloudVolume";
+        readonly space: "cdf_cdm";
+        readonly version: "v1";
+        readonly type: "view";
+    }];
+};
+export declare const POINT_CLOUD_VOLUME_REVISIONS_REFERENCE: ["revisions", "volumeReferences"];
+export declare const POINT_CLOUD_VOLUME_REVISIONS_PROPERTIES_LIST: ["revisions", "volumeReferences", "volumeType", "volume"];
+export declare const POINT_CLOUD_VOLUME_REVISIONS_OBJECT3D_PROPERTIES_LIST: ["revisions", "volumeReferences", "volumeType", "volume", "object3D"];
+export type PointCloudVolumeRevisionProperties = {
+    revisions: DMInstanceRef[];
+    volumeReferences: string[];
+};
+export type PointCloudVolumeRevisionVolumeProperties = PointCloudVolumeRevisionProperties & {
+    volumeType: string;
+    volume: number[];
+};
+export type PointCloudVolumeObject3DProperties = PointCloudVolumeRevisionVolumeProperties & {
+    object3D: DMInstanceRef;
+};

package/dist/packages/data-providers/src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/utils.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { TableExpressionContainsAnyFilterV3 } from '@cognite/sdk';
+import { DMInstanceRef } from '../types';
+export declare function getRevisionContainsAnyFilter(revisionReferences: DMInstanceRef[]): TableExpressionContainsAnyFilterV3;

package/dist/packages/data-providers/src/pointcloud-stylable-object-providers/types.d.ts

@@ -4,36 +4,39 @@
 import { StylableObject } from './StylableObject';
 import { IShape } from '../../../utilities';
 import { Box3 } from 'three';
-import { AnnotationsAssetRef } from '@cognite/sdk';
-export type CdfPointCloudObjectAnnotation = {
+import { AnnotationsAssetRef, DirectRelationReference } from '@cognite/sdk';
+import { ClassicDataSourceType, DataSourceType } from '../DataSourceType';
+/**
+ * @public
+ * CDF Data model instance reference
+ */
+export type DMInstanceRef = DirectRelationReference;
+type VolumeAnnotation = {
     annotationId: number;
     asset?: AnnotationsAssetRef;
+};
+type VolumeDMReference = {
+    instanceRef: DMInstanceRef;
+    asset?: DMInstanceRef;
+};
+export type VolumeMetadata = VolumeAnnotation | VolumeDMReference;
+export type CdfPointCloudObjectAnnotation = {
+    volumeMetadata: VolumeMetadata;
     region: IShape[];
 };
+export declare function isVolumeAnnotation(volumeMetadata: VolumeMetadata): volumeMetadata is VolumeAnnotation;
+export declare function isVolumeDMReference(volumeMetadata: VolumeMetadata): volumeMetadata is VolumeDMReference;
 /**
  * @public
  * Metadata for a single point cloud object
  */
-export type PointCloudObjectMetadata = {
-    /**
-     * The CDF Annotation ID associated with the point cloud object.
-     */
-    annotationId: number;
-    /**
-     * The CDF Asset ID associated with the point cloud object, if any.
-     *
-     * @deprecated Use {@link PointCloudObjectMetadata.assetRef} instead.
-     */
-    assetId?: number;
-    /**
-     * Asset identifiers for asset associated with this point cloud object, if any.
-     */
-    assetRef?: AnnotationsAssetRef;
-    /**
-     * The bounding box of this annotation
-     */
+export type PointCloudObjectMetadata<T extends DataSourceType = ClassicDataSourceType> = {
     boundingBox: Box3;
-};
-export type PointCloudObject = PointCloudObjectMetadata & {
+} & T['pointCloudVolumeMetadata'];
+/**
+ * Point cloud object containing point cloud volume or annotation metadata and stylable object
+ */
+export type PointCloudObject<T extends DataSourceType = ClassicDataSourceType> = PointCloudObjectMetadata<T> & {
     stylableObject: StylableObject;
 };
+export {};

package/dist/packages/data-providers/src/requests/fetchDMModelIdFromRevisionId.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+export declare function fetchDMModelIdFromRevisionId(revisionExternalId: string, space: string, sdk: CogniteClient | undefined): Promise<{
+    modelId: number;
+    revisionId: number;
+}>;

package/dist/packages/data-providers/src/utilities/constants.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+export declare const CORE_DM_SPACE = "cdf_cdm";
+export declare const CORE_DM_3D_CONTAINER_SPACE = "cdf_cdm_3d";
+export declare const COGNITE_POINT_CLOUD_VOLUME_SOURCE: {
+    readonly externalId: "CognitePointCloudVolume";
+    readonly space: "cdf_cdm";
+    readonly version: "v1";
+    readonly type: "view";
+};
+export declare const COGNITE_ASSET_SOURCE: {
+    readonly externalId: "CogniteAsset";
+    readonly space: "cdf_cdm";
+    readonly version: "v1";
+    readonly type: "view";
+};
+export declare const COGNITE_VISUALIZABLE_SOURCE: {
+    readonly externalId: "CogniteVisualizable";
+    readonly space: "cdf_cdm";
+    readonly version: "v1";
+    readonly type: "view";
+};
+export declare const COGNITE_3D_REVISION_SOURCE: {
+    readonly externalId: "Cognite3DRevision";
+    readonly space: "cdf_cdm";
+    readonly version: "v1";
+    readonly type: "view";
+};

package/dist/packages/data-providers/src/utilities/internalAddModelOptions.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { GeometryFilter } from '../../../cad-model';
+import { ClassicModelIdentifierType, InternalDataSourceType, LocalModelIdentifierType } from '../DataSourceType';
+/**
+ * Model options common to all model types.
+ */
+export type CommonModelOptions = {
+    /**
+     * An optional local file which will be used to load the data.
+     */
+    localPath?: string;
+    /**
+     * An optional geometryFilter which will be applied to loading model.
+     */
+    geometryFilter?: GeometryFilter;
+};
+export type LocalAddModelOptions = CommonModelOptions & LocalModelIdentifierType;
+export type InternalAddModelOptions<T extends InternalDataSourceType> = CommonModelOptions & T['modelIdentifier'];
+export type AddModelOptionsWithModelRevisionId<T extends InternalDataSourceType> = InternalAddModelOptions<T> & {
+    classicModelRevisionId: ClassicModelIdentifierType;
+};

package/dist/packages/data-providers/src/utilities/utils.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { TableExpressionEqualsFilterV3 } from '@cognite/sdk/dist/src';
+import { PointCloudObject } from '../pointcloud-stylable-object-providers/types';
+import { ClassicDataSourceType, DMDataSourceType, DataSourceType } from '../DataSourceType';
+/**
+ * Type guard to check if a point cloud object contains data type DMDataSourceType
+ * @param pointCloudObject - The object to check
+ * @returns True if the object is of type `PointCloudObject<DMDataSourceType>`, false otherwise
+ */
+export declare function isDMPointCloudVolumeObject(pointCloudObject: PointCloudObject<DataSourceType>): pointCloudObject is PointCloudObject<DMDataSourceType>;
+/**
+ * Type guard to check if a point cloud object contains data type ClassicDataSourceType
+ * @param pointCloudObject - The object to check
+ * @returns True if the object is of type `PointCloudObject<ClassicDataSourceType>`, false otherwise
+ */
+export declare function isClassicPointCloudVolumeObject(pointCloudObject: PointCloudObject<DataSourceType>): pointCloudObject is PointCloudObject<ClassicDataSourceType>;
+/**
+ * Type guard to check if the point cloud metadata is of type DMDataSourceType
+ * @param pointCloudMetadata - The metadata object to check
+ * @returns True if the object is of type `PointCloudObjectMetadata<DMDataSourceType>`, false otherwise
+ */
+export declare function isDMPointCloudVolume(pointCloudMetadata: DataSourceType['pointCloudVolumeMetadata']): pointCloudMetadata is DMDataSourceType['pointCloudVolumeMetadata'];
+/**
+ * Type guard to check if the point cloud metadata is of type ClassicDataSourceType
+ * @param pointCloudMetadata - The metadata object to check
+ * @returns True if the object is of type `PointCloudObjectMetadata<ClassicDataSourceType>`, false otherwise
+ */
+export declare function isClassicPointCloudVolume(pointCloudMetadata: DataSourceType['pointCloudVolumeMetadata']): pointCloudMetadata is ClassicDataSourceType['pointCloudVolumeMetadata'];
+export declare function getNodeExternalIdEqualsFilter<T extends string>(externalId: T): TableExpressionEqualsFilterV3;
+export declare function getNodeSpaceEqualsFilter<T extends string>(space: T): TableExpressionEqualsFilterV3;

package/dist/packages/pointcloud-styling/index.d.ts

@@ -2,6 +2,8 @@
  * Copyright 2022 Cognite AS
  */
 export { CompletePointCloudAppearance, PointCloudAppearance, DefaultPointCloudAppearance, applyDefaultsToPointCloudAppearance } from './src/PointCloudAppearance';
-export { StyledPointCloudObjectCollection } from './src/StyledPointCloudObjectCollection';
-export { PointCloudObjectCollection } from './src/PointCloudObjectCollection';
+export { StyledPointCloudObjectCollection, StyledPointCloudVolumeCollection } from './src/StyledPointCloudVolumeCollection';
+export { PointCloudObjectCollection, PointCloudAnnotationVolumeCollection } from './src/PointCloudObjectCollection';
 export { AnnotationIdPointCloudObjectCollection } from './src/AnnotationIdPointCloudObjectCollection';
+export { PointCloudDMVolumeCollection } from './src/PointCloudDMVolumeCollection';
+export { isPointCloudObjectCollection, isDMInstanceRefPointCloudObjectCollection } from './src/utils';

package/dist/packages/pointcloud-styling/src/AnnotationIdPointCloudObjectCollection.d.ts

@@ -1,11 +1,11 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { PointCloudObjectCollection } from './PointCloudObjectCollection';
+import { PointCloudAnnotationVolumeCollection } from './PointCloudObjectCollection';
 /**
- * A simple PointCloudObjectCollection that consists of an explicitly provided list of annotation IDs
+ * A simple PointCloudAnnotationVolumeCollection that consists of an explicitly provided list of annotation IDs
  */
-export declare class AnnotationIdPointCloudObjectCollection extends PointCloudObjectCollection {
+export declare class AnnotationIdPointCloudObjectCollection extends PointCloudAnnotationVolumeCollection {
     private readonly _annotationIds;
     constructor(ids: Iterable<number>);
     getAnnotationIds(): Iterable<number>;

package/dist/packages/pointcloud-styling/src/PointCloudDMVolumeCollection.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { DMInstanceRef } from '../../data-providers';
+/**
+ * A simple PointCloudDMVolumeCollection that consists of an explicitly provided list of data model instance.
+ */
+export declare class PointCloudDMVolumeCollection {
+    private readonly _dataModelInstanceRef;
+    constructor(ids: Iterable<DMInstanceRef>);
+    /**
+     * Gets data model external IDs for the objects represented by this PointCloudDMVolumeCollection instance
+     */
+    getDataModelInstanceRefs(): Iterable<DMInstanceRef>;
+    /**
+     * Is the collection is still loading data in the background i.e. not yet ready for use
+     */
+    get isLoading(): false;
+}

package/dist/packages/pointcloud-styling/src/PointCloudObjectCollection.d.ts

@@ -4,20 +4,32 @@
 /**
  * Base class for collections of point cloud objects intended for styling operations
  */
-export declare abstract class PointCloudObjectCollection {
+export declare abstract class PointCloudAnnotationVolumeCollection {
     private readonly _changedEvent;
     /**
-     * @returns annotation IDs of the annotations for the objects represented by this PointCloudObjectCollection instance
+     * annotation IDs of the annotations for the objects represented by this PointCloudObjectCollection instance
      */
     abstract getAnnotationIds(): Iterable<number>;
     /**
-     * @returns whether the collection is still loading data in the background i.e. not yet ready for use
+     * Whether the collection is still loading data in the background i.e. not yet ready for use
      */
     abstract get isLoading(): boolean;
+    /**
+     * Register an event listener on this collection
+     */
     on(event: 'changed', listener: () => void): void;
+    /**
+     * Unregister an event listener on this collection
+     */
     off(event: 'changed', listener: () => void): void;
     /**
      * Triggers the changed-event.
      */
     protected notifyChanged(): void;
 }
+/**
+ * Alias for PointCloudAnnotationVolumeCollection
+ * @deprecated Use {@link PointCloudAnnotationVolumeCollection} instead
+ */
+export declare abstract class PointCloudObjectCollection extends PointCloudAnnotationVolumeCollection {
+}

package/dist/packages/pointcloud-styling/src/StyledPointCloudVolumeCollection.d.ts

@@ -0,0 +1,41 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { CompletePointCloudAppearance } from './PointCloudAppearance';
+import { ClassicDataSourceType, DataSourceType } from '../../data-providers';
+/**
+ * Represents either an PointCloudAnnotationVolumeCollection or PointCloudDMVolumeCollection
+ * that is associated with an appearance.
+ */
+export declare class StyledPointCloudVolumeCollection<T extends DataSourceType> {
+    /**
+     * The volume collection this StyledPointCloudVolumeCollection represents
+     * @deprecated
+     */
+    objectCollection: T['pointCloudCollectionType'];
+    /**
+     * The appearance applied by the current StyledPointCloudVolumeCollection
+     */
+    style: CompletePointCloudAppearance;
+    /**
+     * Get the volume collection for this StyledPointCloudVolumeCollection
+     */
+    get volumeCollection(): T['pointCloudCollectionType'];
+    constructor(
+    /**
+     * The volume collection this StyledPointCloudVolumeCollection represents
+     * @deprecated
+     */
+    objectCollection: T['pointCloudCollectionType'], 
+    /**
+     * The appearance applied by the current StyledPointCloudVolumeCollection
+     */
+    style: CompletePointCloudAppearance);
+}
+/**
+ * Represents either an PointCloudAnnotationVolumeCollection or PointCloudDMVolumeCollection
+ * that is associated with an appearance.
+ * @deprecated USe StyledPointCoudVolumeCollection instead
+ */
+export declare class StyledPointCloudObjectCollection extends StyledPointCloudVolumeCollection<ClassicDataSourceType> {
+}

package/dist/packages/pointcloud-styling/src/utils.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { PointCloudDMVolumeCollection } from './PointCloudDMVolumeCollection';
+import { PointCloudAnnotationVolumeCollection } from './PointCloudObjectCollection';
+export declare function isPointCloudObjectCollection(collection: PointCloudAnnotationVolumeCollection | PointCloudDMVolumeCollection): collection is PointCloudAnnotationVolumeCollection;
+export declare function isDMInstanceRefPointCloudObjectCollection(collection: PointCloudAnnotationVolumeCollection | PointCloudDMVolumeCollection): collection is PointCloudDMVolumeCollection;

package/dist/packages/pointclouds/index.d.ts

@@ -9,6 +9,7 @@ export { createPointCloudManager } from './src/createPointCloudManager';
 export { PointCloudBudget } from './src/PointCloudBudget';
 export { PointCloudIntersection } from './src/PointCloudIntersection';
 export { CognitePointCloudModel } from './src/CognitePointCloudModel';
+export { isDMPointCloudModel, isClassicPointCloudModel } from './src/typeGuards';
 export { PointCloudLoadingStateHandler } from './src/PointCloudLoadingStateHandler';
 export { PointCloudFactory } from './src/PointCloudFactory';
 export { IPointClassificationsProvider } from './src/classificationsProviders/IPointClassificationsProvider';

package/dist/packages/pointclouds/src/CognitePointCloudModel.d.ts

@@ -6,21 +6,30 @@ import { CameraConfiguration } from '../../utilities';
 import { WellKnownAsprsPointClassCodes } from './types';
 import { PointColorType, PointShape, PointSizeType } from '../../rendering';
 import { SupportedModelTypes } from '../../model-base';
-import { PointCloudObjectMetadata } from '../../data-providers';
-import { StyledPointCloudObjectCollection, PointCloudObjectCollection, PointCloudAppearance } from '../../pointcloud-styling';
+import { ClassicDataSourceType, DataSourceType, PointCloudObjectMetadata } from '../../data-providers';
+import { PointCloudAppearance, StyledPointCloudVolumeCollection } from '../../pointcloud-styling';
 /**
  * Represents a point clouds model loaded from CDF.
  * @noInheritDoc
  * @module @cognite/reveal
  */
-export declare class CognitePointCloudModel {
+export declare class CognitePointCloudModel<T extends DataSourceType = ClassicDataSourceType> {
     readonly type: SupportedModelTypes;
+    /**
+     * The modelId of the point cloud model in Cognite Data Fusion. 0 if not applicable
+     * @deprecated Use modelIdentifier instead
+     */
     readonly modelId: number;
     /**
-     * The modelId of the point cloud model in Cognite Data Fusion.
+     * The revisionId of the specific model revision in Cognite Data Fusion. 0 if not applicable
+     * @deprecated Use modelIdentifier instead
      */
     readonly revisionId: number;
-    private readonly _styledObjectCollections;
+    /**
+     * The identifier of this model
+     */
+    readonly modelIdentifier: T['modelIdentifier'];
+    private readonly _styledVolumeCollections;
     /**
      * Used to clean up memory.
      */
@@ -190,19 +199,33 @@ export declare class CognitePointCloudModel {
      * Gets the object collections that have been assigned a style
      * @returns All object collections and their associated style
      */
-    get styledCollections(): StyledPointCloudObjectCollection[];
+    get styledCollections(): StyledPointCloudVolumeCollection<T>[];
+    /**
+     * Gets array of stylable objects for the point cloud model.
+     * @returns All stylable objects for this model
+     * * @example
+     * ```js
+     * model.stylableObjects.forEach(pointCloudMetadata => console.log(pointCloudMetadata.annotationId));
+     * // or
+     * model.stylableObjects.forEach(pointCloudMetadata => {
+     *   if (isDMPointCloudVolume(pointCloudMetadata))
+     *      console.log(pointCloudMetadata.volumeInstanceRef);
+     *   });
+     * ```
+     */
+    get stylableObjects(): PointCloudObjectMetadata<T>[];
     /**
      * Assign a style to a collection of objects. If the object collection has been assigned
      * a style previously, the previous style will be replaced by the new one.
      * @param objectCollection The object collection to assign a style to
      * @param appearance The style to assign to the object collection
      */
-    assignStyledObjectCollection(objectCollection: PointCloudObjectCollection, appearance: PointCloudAppearance): void;
+    assignStyledObjectCollection(objectCollection: T['pointCloudCollectionType'], appearance: PointCloudAppearance): void;
     /**
      * Unassign style from an already styled object collection.
      * @param objectCollection The object collection from which to remove the style
      */
-    unassignStyledObjectCollection(objectCollection: PointCloudObjectCollection): void;
+    unassignStyledObjectCollection(objectCollection: T['pointCloudCollectionType']): void;
     /**
      * Removes styling on all object collections in this model
      */
@@ -212,6 +235,7 @@ export declare class CognitePointCloudModel {
      */
     get stylableObjectCount(): number;
     /**
+     * @deprecated Use {@link CognitePointCloudModel.stylableObjects}
      * Iterates through all stylable objects for this model
      * @example
      * ```js
@@ -220,5 +244,5 @@ export declare class CognitePointCloudModel {
      * );
      * ```
      */
-    traverseStylableObjects(callback: (annotationMetadata: PointCloudObjectMetadata) => void): void;
+    traverseStylableObjects(callback: (annotationMetadata: PointCloudObjectMetadata<T>) => void): void;
 }

package/dist/packages/pointclouds/src/PointCloudFactory.d.ts

@@ -4,15 +4,17 @@
 import { PointCloudNode } from './PointCloudNode';
 import { PointCloudMetadata } from './PointCloudMetadata';
 import { Potree } from './potree-three-loader';
-import { PointCloudStylableObjectProvider } from '../../data-providers';
+import { DMDataSourceType, DataSourceType, PointCloudStylableObjectProvider } from '../../data-providers';
 import { IPointClassificationsProvider } from './classificationsProviders/IPointClassificationsProvider';
 import { PointCloudMaterialManager } from '../../rendering';
+import { ModelIdentifier } from '../../data-providers/src/ModelIdentifier';
 export declare class PointCloudFactory {
     private readonly _potreeInstance;
     private readonly _pointCloudObjectProvider;
+    private readonly _pointCloudDMProvider;
     private readonly _classificationsProvider;
     private readonly _pointCloudMaterialManager;
-    constructor(potreeInstance: Potree, pointCloudObjectProvider: PointCloudStylableObjectProvider, classificationsProvider: IPointClassificationsProvider, pointCloudMaterialManager: PointCloudMaterialManager);
+    constructor(potreeInstance: Potree, pointCloudObjectProvider: PointCloudStylableObjectProvider, pointCloudDMProvider: PointCloudStylableObjectProvider<DMDataSourceType>, classificationsProvider: IPointClassificationsProvider, pointCloudMaterialManager: PointCloudMaterialManager);
     dispose(): void;
-    createModel(modelMetadata: PointCloudMetadata): Promise<PointCloudNode>;
+    createModel<T extends DataSourceType>(identifier: T['modelIdentifier'], modelIdentifier: ModelIdentifier, modelMetadata: PointCloudMetadata): Promise<PointCloudNode<T>>;
 }

package/dist/packages/pointclouds/src/PointCloudIntersection.d.ts

@@ -4,7 +4,11 @@
 import { AnnotationsAssetRef } from '@cognite/sdk';
 import { CognitePointCloudModel } from './CognitePointCloudModel';
 import type { Vector3 } from 'three';
-export type PointCloudIntersection = {
+import { ClassicDataSourceType, DataSourceType } from '../../data-providers';
+/**
+ * An intersection with a point cloud model. Contains metadata of the first intersected volume, if any
+ */
+export type PointCloudIntersection<T extends DataSourceType = ClassicDataSourceType> = {
     /**
      * The intersection type.
      */
@@ -12,7 +16,7 @@ export type PointCloudIntersection = {
     /**
      * The model that was intersected.
      */
-    model: CognitePointCloudModel;
+    model: CognitePointCloudModel<T>;
     /**
      * Coordinate of the intersection.
      */
@@ -27,10 +31,16 @@ export type PointCloudIntersection = {
     distanceToCamera: number;
     /**
      * Annotation Id of the intersected object within a pointcloud. (0 if not applicable)
+     * @deprecated Use `volumeMetadata` instead
      */
     annotationId: number;
     /**
      * Reference to the asset associated to the intersected point cloud object, if any.
+     * @deprecated use `volumeMetadata` instead
      */
     assetRef?: AnnotationsAssetRef;
+    /**
+     * Point cloud volume reference associated with the intersected point cloud volume, if any.
+     */
+    volumeMetadata?: T['pointCloudVolumeMetadata'];
 };

package/dist/packages/pointclouds/src/PointCloudLoadingStateHandler.d.ts

@@ -4,6 +4,7 @@
 import { LoadingState } from '../../model-base';
 import { Observable } from 'rxjs';
 import { PointCloudNode } from './PointCloudNode';
+import { DataSourceType } from '../../data-providers';
 /**
  * Wrapper around Potree.Group with type information and
  * basic functionality.
@@ -24,7 +25,7 @@ export declare class PointCloudLoadingStateHandler {
     onModelRemoved(): void;
     resetFrameStats(): void;
     private createLoadingStateObservable;
-    updatePointBuffersHash(pointCloudNodes: PointCloudNode[]): void;
+    updatePointBuffersHash(pointCloudNodes: PointCloudNode<DataSourceType>[]): void;
     /**
      * Generates a hash for the current loaded points to allow determining if we have
      * loaded data since last redraw.

package/dist/packages/pointclouds/src/PointCloudManager.d.ts

@@ -8,7 +8,7 @@ import { PointCloudNode } from './PointCloudNode';
 import { PointCloudMetadataRepository } from './PointCloudMetadataRepository';
 import { Potree } from './potree-three-loader';
 import { Observable } from 'rxjs';
-import { ModelIdentifier } from '../../data-providers';
+import { ModelIdentifier, AddModelOptionsWithModelRevisionId, DataSourceType } from '../../data-providers';
 import { PointCloudMaterialManager } from '../../rendering';
 import { Mesh } from 'three';
 export declare class PointCloudManager {
@@ -34,8 +34,8 @@ export declare class PointCloudManager {
     getLoadingStateObserver(): Observable<LoadingState>;
     updatePointClouds(camera: THREE.PerspectiveCamera): void;
     updateCamera(camera: THREE.PerspectiveCamera): void;
-    addModel(modelIdentifier: ModelIdentifier): Promise<PointCloudNode>;
-    removeModel(node: PointCloudNode): void;
+    addModel<T extends DataSourceType>(identifier: AddModelOptionsWithModelRevisionId<T>, modelIdentifier: ModelIdentifier): Promise<PointCloudNode<T>>;
+    removeModel<T extends DataSourceType>(node: PointCloudNode<T>): void;
     dispose(): void;
     private loadedModelsObservable;
     createDrawResetTrigger(): Mesh;