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

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[]>;

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";
+};