@cognite/reveal 4.19.1-dev.20241025 → 4.19.1-dev.20241028

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;

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

@@ -5,10 +5,11 @@ import { CameraConfiguration } from '../../utilities';
 import { ClassificationInfo, PointCloudOctree, PickPoint } from './potree-three-loader';
 import { WellKnownAsprsPointClassCodes } from './types';
 import { PointColorType, PointShape, PointSizeType } from '../../rendering';
-import { PointCloudObjectMetadata, PointCloudObject } from '../../data-providers';
-import { CompletePointCloudAppearance, StyledPointCloudObjectCollection } from '../../pointcloud-styling';
+import { DataSourceType, PointCloudObject, PointCloudObjectMetadata } from '../../data-providers';
+import { CompletePointCloudAppearance } from '../../pointcloud-styling';
 import { Matrix4, Group, Box3, Color, type Camera, type Plane, type Ray, type WebGLRenderer } from 'three';
-export declare class PointCloudNode extends Group {
+import { StyledPointCloudVolumeCollection } from '../../pointcloud-styling';
+export declare class PointCloudNode<T extends DataSourceType = DataSourceType> extends Group {
     private readonly _cameraConfiguration?;
     private readonly _octree;
     private readonly _objectIdToAnnotationsMap;
@@ -18,7 +19,7 @@ export declare class PointCloudNode extends Group {
     private readonly _modelIdentifier;
     private readonly _sourceTransform;
     private readonly _customTransform;
-    constructor(modelIdentifier: symbol, sourceTransform: Matrix4, octree: PointCloudOctree, annotations: PointCloudObject[], classificationInfo: ClassificationInfo, cameraConfiguration?: CameraConfiguration);
+    constructor(modelIdentifier: symbol, sourceTransform: Matrix4, octree: PointCloudOctree, annotations: PointCloudObject<T>[], classificationInfo: ClassificationInfo, cameraConfiguration?: CameraConfiguration);
     get modelIdentifier(): symbol;
     get octree(): PointCloudOctree;
     get needsRedraw(): boolean;
@@ -78,13 +79,13 @@ export declare class PointCloudNode extends Group {
     setModelTransformation(matrix: Matrix4): void;
     getModelTransformation(out?: Matrix4): Matrix4;
     getCdfToDefaultModelTransformation(out?: Matrix4): Matrix4;
-    get stylableObjectAnnotationMetadata(): Iterable<PointCloudObjectMetadata>;
-    getStylableObjectMetadata(objectId: number): PointCloudObjectMetadata | undefined;
+    get stylableVolumeMetadata(): Iterable<PointCloudObjectMetadata<T>>;
+    getStylableObjectMetadata(objectId: number): PointCloudObjectMetadata<T> | undefined;
     get stylableObjectCount(): number;
     get defaultAppearance(): CompletePointCloudAppearance;
     set defaultAppearance(appearance: CompletePointCloudAppearance);
     set clippingPlanes(clippingPlanes: Plane[]);
-    assignStyledPointCloudObjectCollection(styledCollection: StyledPointCloudObjectCollection): void;
+    assignStyledPointCloudObjectCollection(styledCollection: StyledPointCloudVolumeCollection<T>): void;
     removeAllStyledPointCloudObjects(): void;
     dispose(): void;
 }

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

@@ -4,37 +4,8 @@
 import * as THREE from 'three';
 import { IntersectInput } from '../../model-base';
 import { PointCloudNode } from './PointCloudNode';
-import { AnnotationsAssetRef } from '@cognite/sdk';
-export interface IntersectPointCloudNodeResult {
-    /**
-     * Distance from camera to intersected point.
-     */
-    distance: number;
-    /**
-     * Coordinate of the intersected point.
-     */
-    point: THREE.Vector3;
-    /**
-     * Point index in the point cloud of the intersected point.
-     */
-    pointIndex: number;
-    /**
-     * Point cloud node defining what model the point is a part of.
-     */
-    pointCloudNode: PointCloudNode;
-    /**
-     * The geometry object that was intersected.
-     */
-    object: THREE.Object3D;
-    /**
-     * annotationId of the clicked object within a pointcloud.
-     */
-    annotationId: number;
-    /**
-     * asset reference of the clicked object in the pointcloud, if any.
-     */
-    assetRef?: AnnotationsAssetRef;
-}
+import { DataSourceType } from '../../data-providers';
+import { IntersectPointCloudNodeResult } from './types';
 export declare class PointCloudPickingHandler {
     private readonly _normalized;
     private readonly _raycaster;
@@ -42,5 +13,5 @@ export declare class PointCloudPickingHandler {
     private static readonly PickingWindowSize;
     constructor(renderer: THREE.WebGLRenderer);
     dispose(): void;
-    intersectPointClouds(nodes: PointCloudNode[], input: IntersectInput): IntersectPointCloudNodeResult[];
+    intersectPointClouds(nodes: PointCloudNode<DataSourceType>[], input: IntersectInput): IntersectPointCloudNodeResult<DataSourceType>[];
 }

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

@@ -3,7 +3,7 @@
  */
 import { PointCloudManager } from './PointCloudManager';
 import * as THREE from 'three';
-import { ModelDataProvider, ModelMetadataProvider, PointCloudStylableObjectProvider } from '../../data-providers';
+import { DMDataSourceType, ModelDataProvider, ModelMetadataProvider, PointCloudStylableObjectProvider } from '../../data-providers';
 import { IPointClassificationsProvider } from './classificationsProviders/IPointClassificationsProvider';
 import { PointCloudMaterialManager } from '../../rendering';
-export declare function createPointCloudManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, pointCloudStylableObjectProvider: PointCloudStylableObjectProvider, classificationsProvider: IPointClassificationsProvider, pointCloudMaterialManager: PointCloudMaterialManager, scene: THREE.Scene, renderer: THREE.WebGLRenderer): PointCloudManager;
+export declare function createPointCloudManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, pointCloudStylableObjectProvider: PointCloudStylableObjectProvider, classificationsProvider: IPointClassificationsProvider, pointCloudDMProvider: PointCloudStylableObjectProvider<DMDataSourceType>, pointCloudMaterialManager: PointCloudMaterialManager, scene: THREE.Scene, renderer: THREE.WebGLRenderer): PointCloudManager;

package/dist/packages/pointclouds/src/potree-three-loader/Potree.d.ts

@@ -4,7 +4,7 @@ import { PointCloudOctree } from './tree/PointCloudOctree';
 import { IPotree } from './types/IPotree';
 import { IPointCloudTreeNodeBase } from './tree/IPointCloudTreeNodeBase';
 import { LRU } from './utils/lru';
-import { ModelDataProvider, PointCloudObject } from '../../../data-providers';
+import { ModelDataProvider, StylableObject } from '../../../data-providers';
 export declare class QueueItem {
     pointCloudIndex: number;
     weight: number;
@@ -23,7 +23,7 @@ export declare class Potree implements IPotree {
     lru: LRU;
     constructor(modelDataProvider: ModelDataProvider, pointCloudMaterialManager: PointCloudMaterialManager);
     reset(): void;
-    loadPointCloud(baseUrl: string, fileName: string, pointCloudObjects: PointCloudObject[], modelIdentifier: symbol): Promise<PointCloudOctree>;
+    loadPointCloud(baseUrl: string, fileName: string, stylableObject: StylableObject[], modelIdentifier: symbol): Promise<PointCloudOctree>;
     updatePointClouds(pointClouds: PointCloudOctree[], camera: Camera, renderer: WebGLRenderer): void;
     set shouldLoad(value: boolean);
     private innerUpdatePointClouds;

package/dist/packages/pointclouds/src/potree-three-loader/loading/EptLoader.d.ts

@@ -1,5 +1,5 @@
-import { ModelDataProvider, PointCloudObject } from '../../../../data-providers';
+import { ModelDataProvider, StylableObject } from '../../../../data-providers';
 import { PointCloudEptGeometry } from '../geometry/PointCloudEptGeometry';
 export declare class EptLoader {
-    static load(baseUrl: string, fileName: string, modelDataProvider: ModelDataProvider, objects: PointCloudObject[]): Promise<PointCloudEptGeometry>;
+    static load(baseUrl: string, fileName: string, modelDataProvider: ModelDataProvider, stylableObjects: StylableObject[]): Promise<PointCloudEptGeometry>;
 }

package/dist/packages/pointclouds/src/potree-three-loader/types/IPotree.d.ts

@@ -1,11 +1,11 @@
 import { Camera, WebGLRenderer } from 'three';
 import { LRU } from '../utils/lru';
 import { PointCloudOctree } from '../tree/PointCloudOctree';
-import { PointCloudObject } from '../../../../data-providers';
+import { StylableObject } from '../../../../data-providers';
 export interface IPotree {
     pointBudget: number;
     maxNumNodesLoading: number;
     lru: LRU;
-    loadPointCloud(baseUrl: string, fileName: string, objects: PointCloudObject[], modelIdentifier: symbol): Promise<PointCloudOctree>;
+    loadPointCloud(baseUrl: string, fileName: string, stylableObject: StylableObject[], modelIdentifier: symbol): Promise<PointCloudOctree>;
     updatePointClouds(pointClouds: PointCloudOctree[], camera: Camera, renderer: WebGLRenderer): void;
 }

package/dist/packages/pointclouds/src/potree-three-loader/utils/createObjectIdMaps.d.ts

@@ -1,6 +1,6 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { PointCloudObject } from '../../../../data-providers';
+import { PointCloudObject, DataSourceType } from '../../../../data-providers';
 import { PointCloudObjectIdMaps } from '../../../../rendering';
-export declare function createObjectIdMaps(objects: PointCloudObject[]): PointCloudObjectIdMaps;
+export declare function createObjectIdMaps<T extends DataSourceType>(objects: PointCloudObject<T>[]): PointCloudObjectIdMaps;

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

@@ -0,0 +1,17 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../../data-providers';
+import { CognitePointCloudModel } from './CognitePointCloudModel';
+/**
+ * Type guard to check if a point cloud model is DMDataSourceType type.
+ * @param model - The object to check.
+ * @returns True if the object is of type `CognitePointCloudModel<DMDataSourceType>`, false otherwise.
+ */
+export declare function isDMPointCloudModel(model: CognitePointCloudModel<DataSourceType>): model is CognitePointCloudModel<DMDataSourceType>;
+/**
+ * Type guard to check if a point cloud model is ClassicDataSourceType type.
+ * @param model - The object to check.
+ * @returns True if the object is of type `CognitePointCloudModel<ClassicDataSourceType>`, false otherwise.
+ */
+export declare function isClassicPointCloudModel(model: CognitePointCloudModel<DataSourceType>): model is CognitePointCloudModel<ClassicDataSourceType>;

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

@@ -1,6 +1,9 @@
 /*!
  * Copyright 2021 Cognite AS
  */
+import { Object3D, Vector3 } from 'three';
+import { PointCloudNode } from './PointCloudNode';
+import { DataSourceType } from '../../data-providers';
 /**
  * ASPRS well known point class types.
  * @see {@link http://www.asprs.org/wp-content/uploads/2019/03/LAS_1_4_r14.pdf} (page 30)
@@ -77,3 +80,29 @@ export declare enum WellKnownAsprsPointClassCodes {
      */
     TemporalExclusion = 22
 }
+export type IntersectPointCloudNodeResult<T extends DataSourceType> = {
+    /**
+     * Distance from camera to intersected point.
+     */
+    distance: number;
+    /**
+     * Coordinate of the intersected point.
+     */
+    point: Vector3;
+    /**
+     * Point index in the point cloud of the intersected point.
+     */
+    pointIndex: number;
+    /**
+     * Point cloud node defining what model the point is a part of.
+     */
+    pointCloudNode: PointCloudNode<T>;
+    /**
+     * The geometry object that was intersected.
+     */
+    object: Object3D;
+    /**
+     * Volume metadata, e.g. asset reference
+     */
+    volumeMetadata?: T['pointCloudVolumeMetadata'];
+};

package/dist/packages/rendering/src/pointcloud-rendering/PointCloudObjectAppearanceTexture.d.ts

@@ -2,8 +2,9 @@
  * Copyright 2022 Cognite AS
  */
 import * as THREE from 'three';
-import { StyledPointCloudObjectCollection, PointCloudObjectCollection, CompletePointCloudAppearance } from '../../../pointcloud-styling';
+import { PointCloudAnnotationVolumeCollection, CompletePointCloudAppearance, StyledPointCloudVolumeCollection } from '../../../pointcloud-styling';
 import { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
+import { DataSourceType } from '../../../data-providers';
 export declare class PointCloudObjectAppearanceTexture {
     private readonly _objectStyleTexture;
     private _needsReconstruction;
@@ -19,8 +20,8 @@ export declare class PointCloudObjectAppearanceTexture {
     private setObjectCollectionStyle;
     private resetTexture;
     onBeforeRender(): void;
-    assignStyledObjectSet(styledCollection: StyledPointCloudObjectCollection): void;
-    removeStyledObjectSet(collection: PointCloudObjectCollection): void;
+    assignStyledObjectSet(styledCollection: StyledPointCloudVolumeCollection<DataSourceType>): void;
+    removeStyledObjectSet(collection: PointCloudAnnotationVolumeCollection): void;
     removeAllStyledObjectSets(): void;
     set defaultAppearance(appearance: CompletePointCloudAppearance);
     get defaultAppearance(): CompletePointCloudAppearance;

package/dist/packages/rendering/src/pointcloud-rendering/PointCloudObjectIdMaps.d.ts

@@ -1,7 +1,8 @@
 /*!
  * Copyright 2022 Cognite AS
  */
+import { DMInstanceRef } from '../../../data-providers';
 export type PointCloudObjectIdMaps = {
-    annotationToObjectIds: Map<number, number>;
-    objectToAnnotationIds: Map<number, number>;
+    annotationToObjectIds: Map<number | DMInstanceRef, number>;
+    objectToAnnotationIds: Map<number, number | DMInstanceRef>;
 };