@cognite/reveal 4.19.1 → 4.20.0-dev.20241030

package/dist/packages/api/src/public/migration/Cognite3DViewer.d.ts

@@ -5,13 +5,15 @@ import * as THREE from 'three';
 import { PointerEventDelegate, SceneRenderedDelegate, DisposedDelegate, BeforeSceneRenderedDelegate, CustomObjectIntersectInput, ICustomObject } from '../../../../utilities';
 import { CogniteCadModel } from '../../../../cad-model';
 import { PointCloudBudget, CognitePointCloudModel } from '../../../../pointclouds';
-import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersection, CadModelBudget, ResolutionOptions, RenderParameters, AnyIntersection } from './types';
+import { AddImage360Options, Cognite3DViewerOptions, Intersection, CadModelBudget, ResolutionOptions, RenderParameters, AnyIntersection, AddModelOptions } from './types';
 import { CogniteModel, Image360WithCollection } from '../types';
 import { ViewerState } from '../../utilities/ViewStateHelper';
 import { CameraManager, CameraChangeDelegate, CameraStopDelegate } from '../../../../camera-manager';
 import { Image360DataModelIdentifier } from '../../../../data-providers';
 import { SupportedModelTypes } from '../../../../model-base';
 import { Image360Collection, Image360, Image360Revision, Image360AnnotationIntersection } from '../../../../360-images';
+import { ClassicDataSourceType, DataSourceType } from '../../../../data-providers';
+import { Image360Action } from '../../../../360-images/src/Image360Action';
 /**
  * @example
  * ```js
@@ -22,7 +24,7 @@ import { Image360Collection, Image360, Image360Revision, Image360AnnotationInter
  * ```
  * @module @cognite/reveal
  */
-export declare class Cognite3DViewer {
+export declare class Cognite3DViewer<DataSourceT extends DataSourceType = ClassicDataSourceType> {
     private readonly _domElementResizeObserver;
     private readonly _image360ApiHelper;
     /**
@@ -98,7 +100,7 @@ export declare class Cognite3DViewer {
     /**
      * Gets a list of models currently added to the viewer.
      */
-    get models(): CogniteModel[];
+    get models(): CogniteModel<DataSourceT>[];
     constructor(options: Cognite3DViewerOptions);
     /**
      * Set options to control resolution of the viewer. This includes
@@ -239,7 +241,7 @@ export declare class Cognite3DViewer {
      * });
      * ```
      */
-    addModel(options: AddModelOptions): Promise<CogniteModel>;
+    addModel(options: AddModelOptions<DataSourceT>): Promise<CogniteModel<DataSourceT>>;
     /**
      * Add a new CAD 3D model to the viewer.
      * Call {@link Cognite3DViewer.fitCameraToModel} to see the model after the model has loaded.
@@ -255,7 +257,7 @@ export declare class Cognite3DViewer {
      * });
      * ```
      */
-    addCadModel(options: AddModelOptions): Promise<CogniteCadModel>;
+    addCadModel<T extends DataSourceT>(options: AddModelOptions<T>): Promise<CogniteCadModel>;
     private addCadModelWithSequencer;
     /**
      * Add a new pointcloud 3D model to the viewer.
@@ -272,14 +274,14 @@ export declare class Cognite3DViewer {
      * });
      * ```
      */
-    addPointCloudModel(options: AddModelOptions): Promise<CognitePointCloudModel>;
+    addPointCloudModel(options: AddModelOptions<DataSourceT>): Promise<CognitePointCloudModel<DataSourceT>>;
     private addPointCloudModelWithSequencer;
     /**
      * Adds a set of 360 images to the scene from the /datamodels API in Cognite Data Fusion.
      * @param datasource The data data source which holds the references to the 360 image sets.
      * @param dataModelIdentifier The search parameters to apply when querying Cognite Datamodels that contains the 360 images.
      */
-    add360ImageSet(datasource: 'datamodels', dataModelIdentifier: Image360DataModelIdentifier): Promise<Image360Collection>;
+    add360ImageSet(datasource: 'datamodels', dataModelIdentifier: Image360DataModelIdentifier): Promise<Image360Collection<DataSourceT & ClassicDataSourceType>>;
     /**
      * Adds a set of 360 images to the scene from the /events API in Cognite Data Fusion.
      * @param datasource The CDF data source which holds the references to the 360 image sets.
@@ -293,43 +295,55 @@ export declare class Cognite3DViewer {
      */
     add360ImageSet(datasource: 'events', eventFilter: {
         [key: string]: string;
-    }, add360ImageOptions?: AddImage360Options): Promise<Image360Collection>;
+    }, add360ImageOptions?: AddImage360Options): Promise<Image360Collection<DataSourceT & ClassicDataSourceType>>;
     /**
      * Returns a list of added 360 image collections.
      */
-    get360ImageCollections(): Image360Collection[];
+    get360ImageCollections(): Image360Collection<DataSourceT>[];
     /**
      * Returns the currently entered 360 image.
      */
-    getActive360ImageInfo(): Image360WithCollection | undefined;
+    getActive360ImageInfo(): Image360WithCollection<DataSourceT> | undefined;
     /**
      * Remove a set of 360 images.
      * @param image360Entities
      * @deprecated
      */
-    remove360Images(...image360Entities: Image360[]): Promise<void>;
+    remove360Images(...image360Entities: Image360<DataSourceT>[]): Promise<void>;
     /**
      * Removes a previously added 360 image collection from the viewer.
      * @param imageCollection Collection to remove.
      */
-    remove360ImageSet(imageCollection: Image360Collection): void;
+    remove360ImageSet(imageCollection: Image360Collection<DataSourceT>): void;
     /**
      * Enter visualization of a 360 image.
      * @param image360 The 360 image to enter.
      * @param revision The image revision to use. If not provided the newest revision will be shown.
      */
-    enter360Image(image360: Image360, revision?: Image360Revision): Promise<void>;
+    enter360Image(image360: Image360<DataSourceT>, revision?: Image360Revision<DataSourceT>): Promise<void>;
     /**
      * Exit visualization of the 360 image.
      */
     exit360Image(): void;
+    /**
+     * Check if a 360 image action can be done.
+     * @param action The action to check if can be done.
+     * @beta
+     */
+    canDo360Action(action: Image360Action): boolean;
+    /**
+     * Do a 360 image action.
+     * @param action The action to do.
+     * @beta
+     */
+    do360Action(action: Image360Action): Promise<void>;
     /**
      * Removes a model that was previously added using {@link Cognite3DViewer.addModel},
      * {@link Cognite3DViewer.addCadModel} or {@link Cognite3DViewer.addPointCloudModel}
      * .
      * @param model
      */
-    removeModel(model: CogniteModel): void;
+    removeModel(model: CogniteModel<DataSourceT>): void;
     /**
      * Use to determine of which type the model is.
      *
@@ -487,7 +501,7 @@ export declare class Cognite3DViewer {
      * is used as a fallback.
      * @param model The model to load camera settings from.
      */
-    loadCameraFromModel(model: CogniteModel): void;
+    loadCameraFromModel(model: CogniteModel<DataSourceT>): void;
     /**
      * Move camera to a place where the 3D model is visible.
      * It uses the bounding box of the 3D model and calls {@link Cognite3DViewer.fitCameraToBoundingBox}.
@@ -507,14 +521,14 @@ export declare class Cognite3DViewer {
      * viewer.fitCameraToModel(model, 0);
      * ```
      */
-    fitCameraToModel(model: CogniteModel, duration?: number): void;
+    fitCameraToModel(model: CogniteModel<DataSourceT>, duration?: number): void;
     /**
      * Move camera to a place where a set of 3D models are visible.
      * @param models Optional 3D models to focus the camera on. If no models are provided the camera will fit to all models.
      * @param duration The duration of the animation moving the camera. Set this to 0 (zero) to disable animation.
      * @param restrictToMostGeometry If true, attempt to remove junk geometry from the boundingBox to allow setting a good camera position.
      */
-    fitCameraToModels(models?: CogniteModel[], duration?: number, restrictToMostGeometry?: boolean): void;
+    fitCameraToModels(models?: CogniteModel<DataSourceT>[], duration?: number, restrictToMostGeometry?: boolean): void;
     /**
      * Move camera to a place where a all objects in the scene are visible.
      * @param duration The duration of the animation moving the camera. Set this to 0 (zero) to disable animation.
@@ -654,7 +668,7 @@ export declare class Cognite3DViewer {
      *   );
      * ```
      */
-    getIntersectionFromPixel(offsetX: number, offsetY: number): Promise<null | Intersection>;
+    getIntersectionFromPixel(offsetX: number, offsetY: number): Promise<null | Intersection<DataSourceT>>;
     /**
      * Raycasting model(s) for finding where the ray intersects with all models, including custom objects.
      * @param pixelCoords Pixel coordinate in pixels (relative to the domElement).
@@ -668,7 +682,7 @@ export declare class Cognite3DViewer {
     getAnyIntersectionFromPixel(pixelCoords: THREE.Vector2, options?: {
         stopOnHitting360Icon?: boolean;
         predicate?: (customObject: ICustomObject) => boolean;
-    }): Promise<AnyIntersection | undefined>;
+    }): Promise<AnyIntersection<DataSourceT> | undefined>;
     /**
      * Event function to click on 360 images.
      * @param event The event type.

package/dist/packages/api/src/public/migration/types.d.ts

@@ -5,12 +5,14 @@ import { CogniteClient } from '@cognite/sdk';
 import { CadModelBudget } from '../../../../cad-geometry-loaders';
 import { PointCloudBudget, PointCloudIntersection } from '../../../../pointclouds';
 import { CameraManager } from '../../../../camera-manager';
-import { GeometryFilter, CogniteCadModel } from '../../../../cad-model';
+import { CogniteCadModel } from '../../../../cad-model';
 import { DataSource } from '../../../../data-source';
 import { EdlOptions } from '../../../../rendering';
+import { CommonModelOptions } from '../../../../data-providers';
 import { Image360AnnotationFilterOptions } from '../../../../360-images';
 import type { Vector2, WebGLRenderTarget, WebGLRenderer, Matrix4, Vector3 } from 'three';
 import { CustomObjectIntersection } from '../../../../utilities';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../../../../data-providers';
 /**
  * Callback to monitor loaded requests and progress.
  * Use OnLoadingCallback instead of onProgress/onComplete.
@@ -160,12 +162,15 @@ export interface Cognite3DViewerOptions {
 /**
  * @module @cognite/reveal
  */
-export interface AddModelOptions {
-    modelId: number;
-    revisionId: number;
-    localPath?: string;
-    geometryFilter?: GeometryFilter;
-}
+export type AddModelOptions<T extends DataSourceType = ClassicDataSourceType> = CommonModelOptions & T['modelIdentifier'];
+/**
+ * Add model options for models of classic format, identified by modelId and revisionId.
+ */
+export type ClassicAddModelOptions = AddModelOptions<ClassicDataSourceType>;
+/**
+ * Add model options for models of DM format, identified by revisionExternalId and revisionSpace.
+ */
+export type DMAddModelOptions = AddModelOptions<DMDataSourceType>;
 export type AddImage360Options = {
     /**
      * An optional transformation which will be applied to all 360 images that are fetched.
@@ -231,13 +236,13 @@ export type ResolutionOptions = {
  * Represents the result from {@link Cognite3DViewer.getIntersectionFromPixel}.
  * @module @cognite/reveal
  */
-export type Intersection = CadIntersection | PointCloudIntersection;
+export type Intersection<T extends DataSourceType = ClassicDataSourceType> = CadIntersection | PointCloudIntersection<T>;
 /**
  * Represents the result from {@link Cognite3DViewer.getAnyIntersectionFromPixel}.
  * @module @cognite/reveal
  * @beta
  */
-export type AnyIntersection = CadIntersection | PointCloudIntersection | CustomObjectIntersection;
+export type AnyIntersection<T extends DataSourceType = DataSourceType> = CadIntersection | PointCloudIntersection<T> | CustomObjectIntersection;
 /**
  * @module @cognite/reveal
  */

package/dist/packages/api/src/public/types.d.ts

@@ -3,18 +3,19 @@
  */
 import { Image360, Image360Collection } from '../../../360-images';
 import { CogniteCadModel } from '../../../cad-model';
+import { ClassicDataSourceType, DataSourceType } from '../../../data-providers/src/DataSourceType';
 import { CognitePointCloudModel } from '../../../pointclouds';
 /**
  * Type abstraction for CogniteCadModel or CognitePointCloudModel;.
  */
-export type CogniteModel = CogniteCadModel | CognitePointCloudModel;
+export type CogniteModel<T extends DataSourceType = ClassicDataSourceType> = CogniteCadModel | CognitePointCloudModel<T>;
 export { WellKnownAsprsPointClassCodes } from '../../../pointclouds';
 export { PointShape, PointColorType, PointSizeType } from '../../../rendering';
 /**
  * A tuple of a 360 image and its collection.
  */
-export type Image360WithCollection = {
-    image360Collection: Image360Collection;
-    image360: Image360;
+export type Image360WithCollection<T extends DataSourceType = ClassicDataSourceType> = {
+    image360Collection: Image360Collection<T>;
+    image360: Image360<T>;
 };
 export * from './migration/types';

package/dist/packages/api/src/storage/RevealManagerHelper.d.ts

@@ -2,9 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { AddModelOptions } from '../public/migration/types';
 import { RevealManager } from '../public/RevealManager';
 import { RevealOptions } from '../public/RevealOptions';
+import { InternalDataSourceType, DataSourceType, AddModelOptionsWithModelRevisionId } from '../../../data-providers';
 import { DataSource } from '../../../data-source';
 import { SceneHandler } from '../../../utilities';
 import { CadNode } from '../../../cad-model';
@@ -18,8 +18,9 @@ import { CameraManager } from '../../../camera-manager';
  */
 export declare class RevealManagerHelper {
     private readonly _revealManager;
-    addCadModel: (model: AddModelOptions) => Promise<CadNode>;
-    addPointCloudModel: (model: AddModelOptions) => Promise<PointCloudNode>;
+    addPointCloudModel<T extends DataSourceType>(model: AddModelOptionsWithModelRevisionId<T>): Promise<PointCloudNode<T>>;
+    addCadModel<T extends InternalDataSourceType>(model: AddModelOptionsWithModelRevisionId<T>): Promise<CadNode>;
+    private readonly _type;
     private constructor();
     private constructor();
     /**
@@ -57,7 +58,7 @@ export declare class RevealManagerHelper {
     private static addLocalPointCloudModel;
     /**
      * Add a CDF hosted point cloud model.
-     * @param model
+     * @param identifier
      * @param revealManager
      */
     private static addCdfPointCloudModel;

package/dist/packages/api/src/utilities/ViewStateHelper.d.ts

@@ -1,6 +1,7 @@
 import { Cognite3DViewer } from '../public/migration/Cognite3DViewer';
 import { CogniteClient } from '@cognite/sdk';
 import { SerializableNodeAppearance } from '../../../cad-styling/src/NodeAppearance';
+import { DataSourceType } from '../../../data-providers';
 export type ViewerState = {
     camera?: {
         position: {
@@ -34,11 +35,11 @@ export type ModelState = {
         appearance: SerializableNodeAppearance;
     }[];
 };
-export declare class ViewStateHelper {
+export declare class ViewStateHelper<T extends DataSourceType> {
     private readonly _viewer;
     private readonly _cdfClient;
     private get _cameraManager();
-    constructor(viewer: Cognite3DViewer, cdfClient: CogniteClient);
+    constructor(viewer: Cognite3DViewer<T>, cdfClient: CogniteClient);
     getCurrentState(): ViewerState;
     setState(viewerState: ViewerState): Promise<void>;
     private getModelsState;

package/dist/packages/api/src/utilities/utils.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { AddModelOptions } from '../public/migration/types';
+import { DataSourceType } from '../../../data-providers';
+import { LocalAddModelOptions } from '../../../data-providers/src/utilities/internalAddModelOptions';
+export declare function getModelAndRevisionId(options: AddModelOptions<DataSourceType> | LocalAddModelOptions, sdk: CogniteClient | undefined): Promise<{
+    modelId: number;
+    revisionId: number;
+}>;

package/dist/packages/data-providers/index.d.ts

@@ -12,13 +12,19 @@ export { LocalModelDataProvider } from './src/model-data-providers/LocalModelDat
 export { LocalModelIdentifier } from './src/model-identifiers/LocalModelIdentifier';
 export { LocalModelMetadataProvider } from './src/metadata-providers/LocalModelMetadataProvider';
 export { Local360ImageProvider } from './src/image-360-data-providers/Local360ImageProvider';
-export { ModelIdentifier } from './src/ModelIdentifier';
+export { ModelIdentifier, createModelIdentifier } from './src/ModelIdentifier';
 export { ModelMetadataProvider } from './src/ModelMetadataProvider';
 export { ModelDataProvider } from './src/ModelDataProvider';
-export { PointCloudObjectMetadata, PointCloudObject } from './src/pointcloud-stylable-object-providers/types';
+export { PointCloudObjectMetadata, PointCloudObject, DMInstanceRef } from './src/pointcloud-stylable-object-providers/types';
 export { PointCloudStylableObjectProvider } from './src/PointCloudStylableObjectProvider';
 export { StylableObject, SerializableStylableObject } from './src/pointcloud-stylable-object-providers/StylableObject';
 export { CdfPointCloudStylableObjectProvider } from './src/pointcloud-stylable-object-providers/CdfPointCloudStylableObjectProvider';
 export { DummyPointCloudStylableObjectProvider } from './src/pointcloud-stylable-object-providers/DummyPointCloudStylableObjectProvider';
+export { CdfPointCloudDMStylableObjectProvider } from './src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/CdfPointCloudDMStylableObjectProvider';
+export { DummyPointCloudDMStylableObjectProvider } from './src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/DummyPointCloudDMStylableObjectProvider';
 export { Image360Provider, Image360DataProvider } from './src/Image360Provider';
 export { BinaryFileProvider, JsonFileProvider, File3dFormat, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face, Image360Texture, Image360FileDescriptor, ImageAssetLinkAnnotationInfo } from './src/types';
+export { fetchDMModelIdFromRevisionId } from './src/requests/fetchDMModelIdFromRevisionId';
+export { isDMPointCloudVolumeObject, isClassicPointCloudVolumeObject, isDMPointCloudVolume, isClassicPointCloudVolume } from './src/utilities/utils';
+export { DataSourceType, ClassicDataSourceType, DMDataSourceType, ClassicModelIdentifierType, DMModelIdentifierType, isClassicIdentifier, isDMIdentifier, InternalDataSourceType, LocalDataSourceType, LocalModelIdentifierType, isLocalIdentifier, GenericDataSourceType } from './src/DataSourceType';
+export { LocalAddModelOptions, CommonModelOptions, InternalAddModelOptions, AddModelOptionsWithModelRevisionId } from './src/utilities/internalAddModelOptions';

package/dist/packages/data-providers/src/DataSourceType.d.ts

@@ -0,0 +1,127 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { AnnotationModel, AnnotationsAssetRef } from '@cognite/sdk';
+import { Image360DataModelIdentifier } from './image-360-data-providers/descriptor-providers/datamodels/Cdf360DataModelsDescriptorProvider';
+import { DMInstanceRef } from './pointcloud-stylable-object-providers/types';
+import { PointCloudAnnotationVolumeCollection, PointCloudDMVolumeCollection } from '../../pointcloud-styling';
+/**
+ * Model identifier for classic CDF models, referenced by modelId and revisionId
+ */
+export type ClassicModelIdentifierType = {
+    modelId: number;
+    revisionId: number;
+};
+/**
+ * Model identifier for DM-based models, referenced by externalId and space of the model revision
+ */
+export type DMModelIdentifierType = {
+    revisionExternalId: string;
+    revisionSpace: string;
+};
+export type LocalModelIdentifierType = {
+    localPath: string;
+};
+/**
+ * Data source type for classic models
+ */
+export type ClassicDataSourceType = {
+    /**
+     * The classic point cloud model identifier associated with the object which include modelId and revisionId.
+     */
+    modelIdentifier: ClassicModelIdentifierType;
+    /**
+     * The classic point cloud volume metadata containing reference associated with the object which includes annotationId
+     * and asset reference if any.
+     */
+    pointCloudVolumeMetadata: {
+        annotationId: number;
+        assetRef?: AnnotationsAssetRef;
+    };
+    /**
+     * Point cloud volume collection type
+     */
+    pointCloudCollectionType: PointCloudAnnotationVolumeCollection;
+    /**
+     * Identifier type for Event- or DM-based 360 images
+     */
+    image360Identifier: {
+        [key: string]: string;
+    } | Image360DataModelIdentifier;
+    /**
+     * Type of classic 360 annotations
+     */
+    image360AnnotationType: AnnotationModel;
+    /**
+     * Marker to make this type inconstructable
+     */
+    _never: never;
+};
+/**
+ * Data source type for DM models
+ */
+export type DMDataSourceType = {
+    /**
+     * The CDF point cloud volume metadata containing reference associated with the object which includes externalId, space
+     * and asset reference if any.
+     */
+    pointCloudVolumeMetadata: {
+        volumeInstanceRef: DMInstanceRef;
+        assetRef?: DMInstanceRef;
+    };
+    /**
+     * Point cloud volume collection type
+     */
+    pointCloudCollectionType: PointCloudDMVolumeCollection;
+    /**
+     * The DM point cloud model identifier associated with the object, consisting of revision externalId and revision space
+     */
+    modelIdentifier: DMModelIdentifierType;
+    /**
+     * Identifier type for DM 360 collections
+     */
+    image360Identifier: Image360DataModelIdentifier;
+    /**
+     * Type of CoreDM 360 image annotations (to be defined)
+     */
+    image360AnnotationType: never;
+    /**
+     * Marker to make this type inconstructable
+     */
+    _never: never;
+};
+/**
+ * Data source type for local models
+ */
+export type LocalDataSourceType = {
+    modelIdentifier: LocalModelIdentifierType;
+    pointCloudVolumeMetadata: any;
+    pointCloudCollectionType: any;
+    _never: never;
+};
+/**
+ * Common data source type
+ */
+export type DataSourceType = ClassicDataSourceType | DMDataSourceType;
+/**
+ * A DataSourceType used internally to allow for flexibility and generic testing
+ */
+export type GenericDataSourceType = {
+    modelIdentifier: any;
+    pointCloudVolumeMetadata: any;
+    pointCloudCollectionType: any;
+    image360Identifier: any;
+    image360AnnotationType: any;
+    _never: never;
+};
+/**
+ * Internal model identifiers
+ */
+export type InternalModelIdentifier = ClassicModelIdentifierType | DMModelIdentifierType | LocalModelIdentifierType;
+/**
+ * Alias for internal + external data source types
+ */
+export type InternalDataSourceType = DataSourceType | LocalDataSourceType;
+export declare function isClassicIdentifier(identifier: InternalModelIdentifier): identifier is ClassicModelIdentifierType;
+export declare function isDMIdentifier(identifier: InternalModelIdentifier): identifier is DMModelIdentifierType;
+export declare function isLocalIdentifier(identifier: InternalModelIdentifier): identifier is LocalModelIdentifierType;

package/dist/packages/data-providers/src/ModelIdentifier.d.ts

@@ -1,6 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
+import { ClassicModelIdentifierType, DMModelIdentifierType, LocalModelIdentifierType } from './DataSourceType';
 /**
  * Identifies a 3D model. Typically, implementations will use {@link CdfModelIdentifier}.
  */
@@ -10,3 +11,4 @@ export interface ModelIdentifier {
      */
     readonly revealInternalId: symbol;
 }
+export declare function createModelIdentifier(identifier: ClassicModelIdentifierType | (DMModelIdentifierType & ClassicModelIdentifierType) | LocalModelIdentifierType): ModelIdentifier;

package/dist/packages/data-providers/src/PointCloudStylableObjectProvider.d.ts

@@ -1,8 +1,8 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { ModelIdentifier } from './ModelIdentifier';
+import { ClassicDataSourceType, DataSourceType } from './DataSourceType';
 import { PointCloudObject } from './pointcloud-stylable-object-providers/types';
-export interface PointCloudStylableObjectProvider {
-    getPointCloudObjects(modelIdentifier: ModelIdentifier): Promise<PointCloudObject[]>;
+export interface PointCloudStylableObjectProvider<T extends DataSourceType = ClassicDataSourceType> {
+    getPointCloudObjects(identifier: T['modelIdentifier']): Promise<PointCloudObject<T>[]>;
 }

package/dist/packages/data-providers/src/model-identifiers/DMModelIdentifier.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { ClassicModelIdentifierType, DMModelIdentifierType } from '../DataSourceType';
+import { CdfModelIdentifier } from './CdfModelIdentifier';
+export declare class DMModelIdentifier extends CdfModelIdentifier {
+    readonly revealInternalId: symbol;
+    readonly revisionExternalId: string;
+    readonly revisionSpace: string;
+    constructor({ modelId, revisionId, revisionExternalId, revisionSpace }: DMModelIdentifierType & ClassicModelIdentifierType);
+    toString(): string;
+}

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

@@ -2,14 +2,14 @@
  * Copyright 2022 Cognite AS
  */
 import { CogniteClient } from '@cognite/sdk';
-import { ModelIdentifier } from '../ModelIdentifier';
 import { PointCloudObject } from './types';
 import { PointCloudStylableObjectProvider } from '../PointCloudStylableObjectProvider';
-export declare class CdfPointCloudStylableObjectProvider implements PointCloudStylableObjectProvider {
+import { ClassicDataSourceType, ClassicModelIdentifierType } from '../DataSourceType';
+export declare class CdfPointCloudStylableObjectProvider implements PointCloudStylableObjectProvider<ClassicDataSourceType> {
     private readonly _sdk;
     constructor(sdk: CogniteClient);
     private annotationGeometryToRevealShapes;
     private is3dObjectAnnotation;
     private fetchAnnotations;
-    getPointCloudObjects(modelIdentifier: ModelIdentifier): Promise<PointCloudObject[]>;
+    getPointCloudObjects(modelIdentifier: ClassicModelIdentifierType): Promise<PointCloudObject[]>;
 }

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

@@ -1,9 +1,9 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { ModelIdentifier } from '../ModelIdentifier';
+import { ClassicDataSourceType, ClassicModelIdentifierType } from '../DataSourceType';
 import { PointCloudStylableObjectProvider } from '../PointCloudStylableObjectProvider';
 import { PointCloudObject } from './types';
-export declare class DummyPointCloudStylableObjectProvider implements PointCloudStylableObjectProvider {
-    getPointCloudObjects(_modelIdentifier: ModelIdentifier): Promise<PointCloudObject[]>;
+export declare class DummyPointCloudStylableObjectProvider implements PointCloudStylableObjectProvider<ClassicDataSourceType> {
+    getPointCloudObjects(_modelIdentifier: ClassicModelIdentifierType): Promise<PointCloudObject[]>;
 }

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

@@ -2,4 +2,5 @@
  * Copyright 2022 Cognite AS
  */
 import { PointCloudObject, CdfPointCloudObjectAnnotation } from './types';
-export declare function cdfAnnotationsToObjectInfo(annotations: CdfPointCloudObjectAnnotation[]): PointCloudObject[];
+import { DataSourceType } from '../DataSourceType';
+export declare function cdfAnnotationsToObjectInfo<T extends DataSourceType>(annotations: CdfPointCloudObjectAnnotation[]): PointCloudObject<T>[];

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

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { PointCloudStylableObjectProvider } from '../../PointCloudStylableObjectProvider';
+import { PointCloudObject } from '../types';
+import { DMDataSourceType, DMModelIdentifierType } from '../../DataSourceType';
+export declare class CdfPointCloudDMStylableObjectProvider implements PointCloudStylableObjectProvider<DMDataSourceType> {
+    private readonly _dmsSdk;
+    constructor(sdk: CogniteClient);
+    getPointCloudObjects(modelIdentifier: DMModelIdentifierType): Promise<PointCloudObject<DMDataSourceType>[]>;
+}

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

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { DMDataSourceType, DMModelIdentifierType } from '../../DataSourceType';
+import { PointCloudStylableObjectProvider } from '../../PointCloudStylableObjectProvider';
+import { PointCloudObject } from '../types';
+export declare class DummyPointCloudDMStylableObjectProvider implements PointCloudStylableObjectProvider<DMDataSourceType> {
+    getPointCloudObjects(_modelIdentifier: DMModelIdentifierType): Promise<PointCloudObject<DMDataSourceType>[]>;
+}

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

@@ -0,0 +1,4 @@
+import { DataModelsSdk } from '../../DataModelsSdk';
+import { CdfPointCloudObjectAnnotation } from '../types';
+import { DMModelIdentifierType } from '../../DataSourceType';
+export declare function getDMPointCloudObjects(dmsSdk: DataModelsSdk, modelIdentifier: DMModelIdentifierType): Promise<CdfPointCloudObjectAnnotation[]>;