@cognite/reveal 4.22.0 → 4.23.0-dev.20250122

package/dist/packages/data-providers/src/image-360-data-providers/cdm/properties.d.ts

@@ -0,0 +1,36 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import type { DirectRelationReference } from '@cognite/sdk';
+export type AssetSimpleProperties = {
+    object3D: DirectRelationReference;
+    name: string;
+    description: string;
+};
+export type CoreDmImage360CollectionProperties = {
+    name: string;
+};
+export type CoreDmImage360Properties = {
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+    eulerRotationX: number;
+    eulerRotationY: number;
+    eulerRotationZ: number;
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    front: DirectRelationReference;
+    back: DirectRelationReference;
+    left: DirectRelationReference;
+    right: DirectRelationReference;
+    top: DirectRelationReference;
+    bottom: DirectRelationReference;
+    collection360: DirectRelationReference;
+    station360: DirectRelationReference;
+    takenAt: number;
+};
+export type CoreDmImage360AnnotationProperties = {
+    polygon: number[];
+    formatVersion: string;
+};

package/dist/packages/data-providers/src/image-360-data-providers/cdm/queryFilters.d.ts

@@ -0,0 +1,23 @@
+export declare const isCoreDmImage360CollectionFilter: {
+    readonly and: [{
+        hasData: {
+            readonly type: "view";
+            readonly space: "cdf_cdm";
+            readonly externalId: "Cognite3DRevision";
+            readonly version: "v1";
+        }[];
+    }, {
+        readonly equals: {
+            readonly property: ["cdf_cdm_3d", "Cognite3DRevision", "type"];
+            readonly value: "Image360";
+        };
+    }];
+};
+export declare const isCoreDmImage360Filter: {
+    readonly hasData: [{
+        readonly type: "view";
+        readonly space: "cdf_cdm";
+        readonly externalId: "Cognite360Image";
+        readonly version: "v1";
+    }];
+};

package/dist/packages/data-providers/src/image-360-data-providers/cdm/queryNodesAndEdges.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import type { EdgeDefinition, NodeDefinition, NodeOrEdge, CogniteClient, QueryRequest, ViewReference } from '@cognite/sdk';
+export declare function queryNodesAndEdges<TQueryRequest extends QueryRequest, TypedSelectSources extends SelectSourceWithParams = SelectSourceWithParams>(query: TQueryRequest, sdk: CogniteClient): Promise<QueryResult<TQueryRequest, TypedSelectSources>>;
+export type SelectSourceWithParams = Array<{
+    source: ViewReference;
+    properties: Record<string, unknown>;
+}>;
+type SELECT = 'select';
+type WITH = 'with';
+type LIMIT = 'limit';
+type NODES = 'nodes';
+type EDGES = 'edges';
+type PROPERTIES = 'properties';
+type SOURCES = 'sources';
+type SOURCE = 'source';
+type SPACE = 'space';
+type EXTERNALID = 'externalId';
+type VERSION = 'version';
+type ALLPROPERTIES = '*';
+type InstanceType<TQueryRequest extends QueryRequest, SelectKey extends keyof TQueryRequest[SELECT]> = Exclude<keyof TQueryRequest[WITH][SelectKey], LIMIT> extends NODES ? Omit<NodeDefinition, PROPERTIES> : Exclude<keyof TQueryRequest[WITH][SelectKey], LIMIT> extends EDGES ? Omit<EdgeDefinition, PROPERTIES> : Omit<NodeOrEdge, PROPERTIES>;
+type TypedSourceProperty<SelectSource extends NonNullable<QueryRequest[SELECT][keyof QueryRequest[SELECT]][SOURCES]>[number], TypedSelectSourcePropertyMap extends SelectSourceWithParams = SelectSourceWithParams> = Extract<TypedSelectSourcePropertyMap[number], Pick<SelectSource, SOURCE>>[PROPERTIES];
+type QueryResult<TQueryRequest extends QueryRequest, TSelectSourceWithParams extends SelectSourceWithParams = SelectSourceWithParams> = {
+    items: {
+        [SELECT_KEY in keyof TQueryRequest[SELECT]]: Array<InstanceType<TQueryRequest, SELECT_KEY> & {
+            properties: {
+                [SELECT_SOURCE in NonNullable<NonNullable<TQueryRequest[SELECT][SELECT_KEY]>[SOURCES]>[number] as SELECT_SOURCE[SOURCE][SPACE]]: {
+                    [SELECT_SOURCE_VAR in SELECT_SOURCE as `${SELECT_SOURCE_VAR[SOURCE][EXTERNALID]}/${SELECT_SOURCE_VAR[SOURCE][VERSION]}`]: SELECT_SOURCE_VAR[PROPERTIES][0] extends ALLPROPERTIES ? Record<string, unknown> : {
+                        [SELECT_SOURCE_PROPERTY in SELECT_SOURCE_VAR[PROPERTIES][number]]: TypedSourceProperty<SELECT_SOURCE_VAR, TSelectSourceWithParams>[SELECT_SOURCE_PROPERTY] extends never ? unknown : TypedSourceProperty<SELECT_SOURCE_VAR, TSelectSourceWithParams>[SELECT_SOURCE_PROPERTY];
+                    };
+                };
+            };
+        }>;
+    };
+    nextCursor?: Partial<{
+        [SELECT_SOURCE_KEY in keyof TQueryRequest[SELECT]]: string;
+    }>;
+};
+export {};

package/dist/packages/data-providers/src/image-360-data-providers/cdm/queryProperties.d.ts

@@ -0,0 +1,4 @@
+export declare const ASSET_SIMPLE_PROPERTIES_LIST: ["name", "description", "object3D"];
+export declare const CORE_DM_IMAGE_360_COLLECTION_PROPERTIES_LIST: ["name"];
+export declare const CORE_DM_IMAGE_360_PROPERTIES_LIST: ["translationX", "translationY", "translationZ", "eulerRotationX", "eulerRotationY", "eulerRotationZ", "scaleX", "scaleY", "scaleZ", "front", "back", "left", "right", "top", "bottom", "collection360", "station360", "takenAt"];
+export declare const CORE_DM_IMAGE_360_ANNOTATIONS_PROPERTIES_LIST: ["polygon", "formatVersion"];

package/dist/packages/data-providers/src/image-360-data-providers/cdm/sources.d.ts

@@ -0,0 +1,42 @@
+export declare const COGNITE_ASSET_VIEW_REFERENCE: {
+    readonly type: "view";
+    readonly externalId: "CogniteAsset";
+    readonly space: "cdf_cdm";
+    readonly version: "v1";
+};
+export declare const COGNITE_OBJECT_3D_VIEW_REFERENCE: {
+    readonly type: "view";
+    readonly externalId: "Cognite3DObject";
+    readonly space: "cdf_cdm";
+    readonly version: "v1";
+};
+export declare const COGNITE_VISUALIZABLE_VIEW_REFERENCE: {
+    readonly type: "view";
+    readonly externalId: "CogniteVisualizable";
+    readonly space: "cdf_cdm";
+    readonly version: "v1";
+};
+export declare const CORE_DM_IMAGE_360_VIEW_REFERENCE: {
+    readonly type: "view";
+    readonly space: "cdf_cdm";
+    readonly externalId: "Cognite360Image";
+    readonly version: "v1";
+};
+export declare const CORE_DM_IMAGE_360_COLLECTION_VIEW_REFERENCE: {
+    readonly type: "view";
+    readonly space: "cdf_cdm";
+    readonly externalId: "Cognite360ImageCollection";
+    readonly version: "v1";
+};
+export declare const CORE_DM_IMAGE_360_ANNOTATION_VIEW_REFERENCE: {
+    readonly type: "view";
+    readonly space: "cdf_cdm";
+    readonly externalId: "Cognite360ImageAnnotation";
+    readonly version: "v1";
+};
+export declare const CORE_DM_3D_REVISION_VIEW_REFERENCE: {
+    readonly type: "view";
+    readonly space: "cdf_cdm";
+    readonly externalId: "Cognite3DRevision";
+    readonly version: "v1";
+};

package/dist/packages/data-providers/src/image-360-data-providers/cdm/transformCdmAnnotations.d.ts

@@ -0,0 +1,4 @@
+import { CoreDmImage360Annotation } from './types';
+import { GetImage360AnnotationsFromCollectionResponse } from './fetchCoreDm360AnnotationsForCollection';
+import { GetImage360FromRevisionResponse } from './fetchCoreDm360AnnotationsForRevision';
+export declare function transformAnnotations(queryResponse: GetImage360AnnotationsFromCollectionResponse | GetImage360FromRevisionResponse): CoreDmImage360Annotation[];

package/dist/packages/data-providers/src/image-360-data-providers/cdm/types.d.ts

@@ -0,0 +1,51 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { Vector3 } from 'three';
+import { AssetSimpleProperties, CoreDmImage360AnnotationProperties, CoreDmImage360Properties } from './properties';
+import { COGNITE_ASSET_VIEW_REFERENCE, CORE_DM_IMAGE_360_ANNOTATION_VIEW_REFERENCE, CORE_DM_IMAGE_360_VIEW_REFERENCE } from './sources';
+import { DMInstanceRef } from '../../../../utilities';
+/**
+ * Data contained in a single CoreDM-based annotation
+ */
+export type CoreDmImage360Annotation = {
+    /**
+     * The source type of the annotation. Always 'dm'
+     */
+    sourceType: 'dm';
+    /**
+     * The DM identifier for this annotation
+     */
+    annotationIdentifier: DMInstanceRef;
+    /**
+     * The DM identifier for the asset instance connected to this
+     * annotation, if any
+     */
+    assetRef?: DMInstanceRef;
+    /**
+     * The Polygon outlining the annotation inside the 360 image
+     */
+    polygon: Vector3[];
+    /**
+     * The status of the annotation
+     */
+    status: 'suggested' | 'approved';
+    /**
+     * The DM ID of the CdfImage360 to which this annotation is associated
+     */
+    connectedImageId: DMInstanceRef;
+};
+export type Image360AnnotationViewReferenceAndProperties = [
+    {
+        source: typeof CORE_DM_IMAGE_360_ANNOTATION_VIEW_REFERENCE;
+        properties: CoreDmImage360AnnotationProperties;
+    },
+    {
+        source: typeof CORE_DM_IMAGE_360_VIEW_REFERENCE;
+        properties: CoreDmImage360Properties;
+    },
+    {
+        source: typeof COGNITE_ASSET_VIEW_REFERENCE;
+        properties: AssetSimpleProperties;
+    }
+];

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/datamodels/cdm/Cdf360CdmDescriptorProvider.d.ts

@@ -4,11 +4,12 @@
 import { CogniteClient } from '@cognite/sdk';
 import { Historical360ImageSet, Image360DescriptorProvider } from '../../../../types';
 import { Image360DataModelIdentifier } from '../system-space/Cdf360DataModelsDescriptorProvider';
-export declare class Cdf360CdmDescriptorProvider implements Image360DescriptorProvider<Image360DataModelIdentifier> {
+import { DMDataSourceType } from '../../../../DataSourceType';
+export declare class Cdf360CdmDescriptorProvider implements Image360DescriptorProvider<DMDataSourceType> {
     private readonly _dmsSdk;
     private readonly _cogniteSdk;
     constructor(sdk: CogniteClient);
-    get360ImageDescriptors(collectionIdentifier: Image360DataModelIdentifier, _: boolean): Promise<Historical360ImageSet[]>;
+    get360ImageDescriptors(collectionIdentifier: Image360DataModelIdentifier, _: boolean): Promise<Historical360ImageSet<DMDataSourceType>[]>;
     private queryCollection;
     private getFileDescriptors;
     private getHistorical360ImageSet;

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider.d.ts

@@ -3,19 +3,41 @@
  */
 import { CogniteClient } from '@cognite/sdk';
 import { Historical360ImageSet, Image360DescriptorProvider } from '../../../../types';
+import { DataModelsSdk } from '../../../../DataModelsSdk';
+import { ClassicDataSourceType } from '../../../../DataSourceType';
 /**
- * An identifier uniquely determining an instance of a Cognite Data Model
+ * An identifier uniquely determining a datamodel-based instance of a Cognite 360 image collection
  */
-export type Image360DataModelIdentifier = {
+export type Image360DataModelIdentifier = Image360BaseIdentifier & {
+    /**
+     * Source Type for the model - 'dm' for legacy FDM 360 images, 'cdm' for CoreDM-based ones
+     */
     source?: 'dm' | 'cdm';
+};
+/**
+ * An Identifier uniquely determining a legacy datamodel-based instance of a Cognite 360 image collection
+ */
+export type Image360LegacyDataModelIdentifier = {
+    source: 'dm';
+} & Image360BaseIdentifier;
+/**
+ * An Identifier uniquely determining a CoreDM-based instance of a Cognite 360 image collection
+ */
+export type Image360CoreDataModelIdentifier = {
+    source: 'cdm';
+} & Image360BaseIdentifier;
+/**
+ * Common properties for the Image360 Datamodel identifiers
+ */
+export type Image360BaseIdentifier = {
     space: string;
     image360CollectionExternalId: string;
 };
-export declare class Cdf360DataModelsDescriptorProvider implements Image360DescriptorProvider<Image360DataModelIdentifier> {
-    private readonly _dmsSdk;
+export declare class Cdf360DataModelsDescriptorProvider implements Image360DescriptorProvider<ClassicDataSourceType> {
+    readonly _dmsSdk: DataModelsSdk;
     private readonly _cogniteSdk;
     constructor(sdk: CogniteClient);
-    get360ImageDescriptors(collectionIdentifier: Image360DataModelIdentifier, _: boolean): Promise<Historical360ImageSet[]>;
+    get360ImageDescriptors(collectionIdentifier: Image360DataModelIdentifier, _: boolean): Promise<Historical360ImageSet<ClassicDataSourceType>[]>;
     private queryCollection;
     private getFileDescriptors;
     private getHistorical360ImageSet;

package/dist/packages/data-providers/src/image-360-data-providers/descriptor-providers/events/Cdf360EventDescriptorProvider.d.ts

@@ -3,10 +3,11 @@
  */
 import { CogniteClient, Metadata } from '@cognite/sdk';
 import { Historical360ImageSet, Image360DescriptorProvider } from '../../../types';
-export declare class Cdf360EventDescriptorProvider implements Image360DescriptorProvider<Metadata> {
+import { ClassicDataSourceType } from '../../../DataSourceType';
+export declare class Cdf360EventDescriptorProvider implements Image360DescriptorProvider<ClassicDataSourceType> {
     private readonly _client;
     constructor(client: CogniteClient);
-    get360ImageDescriptors(metadataFilter: Metadata, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+    get360ImageDescriptors(metadataFilter: Metadata, preMultipliedRotation: boolean): Promise<Historical360ImageSet<ClassicDataSourceType>[]>;
     private mergeDescriptors;
     private listEvents;
     private listFiles;

package/dist/packages/data-providers/src/image-360-data-providers/shared.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { Image360RevisionId, ImageAssetLinkAnnotationInfo } from '../types';
+import { DataSourceType } from '../DataSourceType';
+import { AnnotationModel, Metadata } from '@cognite/sdk';
+import { Image360DataModelIdentifier, Image360LegacyDataModelIdentifier } from './descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
+export declare function isClassicMetadata360Identifier(id: DataSourceType['image360Identifier']): id is Metadata & {
+    site_id: string;
+};
+export declare function isClassic360Identifier(id: DataSourceType['image360Identifier']): id is (Metadata & {
+    site_id: string;
+}) | Image360DataModelIdentifier;
+export declare function isLegacyDM360Identifier(id: DataSourceType['image360Identifier']): id is Image360LegacyDataModelIdentifier;
+export declare function isCoreDmImage360Identifier(id: DataSourceType['image360Identifier']): id is Image360DataModelIdentifier;
+export declare function isFdm360ImageCollectionIdentifier(id: DataSourceType['image360Identifier']): id is Image360DataModelIdentifier;
+export declare function isSameImage360RevisionId<T extends DataSourceType>(id0: Image360RevisionId<T>, id1: Image360RevisionId<T>): boolean;
+export declare function isImageAssetLinkAnnotation(annotation: AnnotationModel): annotation is ImageAssetLinkAnnotationInfo;

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

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2024 Cognite AS
  */
-import { DMInstanceRef } from '../types';
+import { DMInstanceRef } from '../../../../utilities';
 declare const getDMPointCloudVolumeQuery: (revisionRef: DMInstanceRef) => {
     readonly with: {
         readonly pointCloudVolumes: {

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

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2024 Cognite AS
  */
-import { DMInstanceRef } from '../types';
+import { DMInstanceRef } from '../../../../utilities';
 export type AssetProperties = {
     object3D: DMInstanceRef;
     name: string;

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

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

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

@@ -2,15 +2,10 @@
  * Copyright 2022 Cognite AS
  */
 import { StylableObject } from './StylableObject';
-import { IShape } from '../../../utilities';
+import { DMInstanceRef, IShape } from '../../../utilities';
 import { Box3 } from 'three';
-import { AnnotationsAssetRef, DirectRelationReference } from '@cognite/sdk';
+import { AnnotationsAssetRef } from '@cognite/sdk';
 import { ClassicDataSourceType, DataSourceType } from '../DataSourceType';
-/**
- * @public
- * CDF Data model instance reference
- */
-export type DMInstanceRef = DirectRelationReference;
 type VolumeAnnotation = {
     annotationId: number;
     asset?: AnnotationsAssetRef;

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

@@ -1,21 +1,44 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { AnnotationModel, AnnotationsCogniteAnnotationTypesImagesAssetLink, CogniteInternalId, IdEither } from '@cognite/sdk';
+import { AnnotationModel, AnnotationsCogniteAnnotationTypesImagesAssetLink, IdEither } from '@cognite/sdk';
 import * as THREE from 'three';
-export type Image360AnnotationFilterDelegate = (annotation: AnnotationModel) => boolean;
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
+import { AssetAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../360-images';
+import { DMInstanceRef } from '../../utilities';
+export type Image360AnnotationFilterDelegate<T extends DataSourceType> = (annotation: T['image360AnnotationType']) => boolean;
 export interface JsonFileProvider {
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;
 }
 export interface BinaryFileProvider {
     getBinaryFile(baseUrl: string, fileName: string, abortSignal?: AbortSignal): Promise<ArrayBuffer>;
 }
-export interface Image360AnnotationProvider {
-    get360ImageAnnotations(descriptors: Image360FileDescriptor[]): Promise<AnnotationModel[]>;
-    getFilesByAssetRef(assetId: IdEither): Promise<CogniteInternalId[]>;
+/**
+ * An ID identifiying a single Image360 entity within a collection
+ */
+export type Image360Id<T extends DataSourceType> = Image360RevisionId<T>;
+/**
+ * An ID identifiying a single Image360 revision within a collection
+ */
+export type Image360RevisionId<T extends DataSourceType> = T extends DMDataSourceType ? DMInstanceRef : string;
+export type Image360AnnotationSpecifier<T extends DataSourceType> = {
+    revisionId: Image360RevisionId<T>;
+    fileDescriptors: Image360FileDescriptor[];
+};
+/**
+ * Filter for finding linked annotations in either a classic 360 collection or a new one
+ */
+export type InstanceReference<T extends DataSourceType> = T extends ClassicDataSourceType ? IdEither : DMInstanceRef;
+export interface Image360AnnotationProvider<T extends DataSourceType> {
+    getRelevant360ImageAnnotations(annotationSpecifier: Image360AnnotationSpecifier<T>): Promise<T['image360AnnotationType'][]>;
+    findImageAnnotationsForInstance(instanceFilter: InstanceReference<T>, collection: DefaultImage360Collection<T>): Promise<Image360AnnotationAssetQueryResult<T>[]>;
+    getAllImage360AnnotationInfos(source: 'assets', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'cdm', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DMDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'assets' | 'cdm' | 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[] | AssetAnnotationImage360Info<DMDataSourceType>[] | AssetAnnotationImage360Info<DataSourceType>[]>;
 }
-export interface Image360DescriptorProvider<T> {
-    get360ImageDescriptors(metadataFilter: T, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+export interface Image360DescriptorProvider<T extends DataSourceType> {
+    get360ImageDescriptors(metadataFilter: T['image360Identifier'], preMultipliedRotation: boolean): Promise<Historical360ImageSet<T>[]>;
 }
 export interface Image360FileProvider {
     get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
@@ -30,18 +53,16 @@ export type ImageAssetLinkAnnotationInfo = Omit<AnnotationModel, 'data'> & {
      */
     data: AnnotationsCogniteAnnotationTypesImagesAssetLink;
 };
-export interface Image360AssetProvider {
-    get360ImageAssets(image360FileDescriptors: Image360FileDescriptor[], annotationFilter: Image360AnnotationFilterDelegate): Promise<ImageAssetLinkAnnotationInfo[]>;
-}
-export type Historical360ImageSet = Image360EventDescriptor & {
-    imageRevisions: Image360Descriptor[];
+export type Historical360ImageSet<T extends DataSourceType> = Image360RevisionDescriptor<T> & {
+    imageRevisions: Image360Descriptor<T>[];
 };
-export type Image360Descriptor = {
+export type Image360Descriptor<T extends DataSourceType> = {
+    id: Image360RevisionId<T>;
     timestamp?: number | string;
     faceDescriptors: Image360FileDescriptor[];
 };
-export type Image360EventDescriptor = {
-    id: string;
+export type Image360RevisionDescriptor<T extends DataSourceType> = {
+    id: Image360RevisionId<T>;
     label: string | undefined;
     collectionId: string;
     collectionLabel: string | undefined;
@@ -77,18 +98,14 @@ export interface BlobOutputMetadata {
 type InstanceType = 'node' | 'edge';
 export type Item = {
     instanceType: InstanceType;
-} & InstanceIdentifier;
+} & DMInstanceRef;
 export type Source = {
     type: 'view';
     version: string;
-} & InstanceIdentifier;
-export type InstanceIdentifier = {
-    space: string;
-    externalId: string;
-};
+} & DMInstanceRef;
 export type EdgeItem = {
-    startNode: InstanceIdentifier;
-    endNode: InstanceIdentifier;
+    startNode: DMInstanceRef;
+    endNode: DMInstanceRef;
 };
 export type Query = {
     with: Record<string, ResultSetExpression>;
@@ -138,7 +155,7 @@ type MainSourceProperties<T extends Query, K extends SelectKey<T>> = Sources<T,
 type ResultExpressionProperties<T extends Query, K extends SelectKey<T>> = {
     [V in MainSource<T, K>['space']]: {
         [Q in `${MainSource<T, K>['externalId']}/${MainSource<T, K>['version']}`]: {
-            [B in MainSourceProperties<T, K>[number]]: string | number | InstanceIdentifier;
+            [B in MainSourceProperties<T, K>[number]]: string | number | DMInstanceRef;
         };
     };
 };

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

@@ -27,3 +27,9 @@ export declare const COGNITE_3D_REVISION_SOURCE: {
     readonly version: "v1";
     readonly type: "view";
 };
+export declare const COGNITE_360_IMAGE_SOURCE: {
+    readonly externalId: "Cognite360Image";
+    readonly space: "cdf_cdm";
+    readonly version: "v1";
+    readonly type: "view";
+};

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

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2024 Cognite AS
  */
-import { DMInstanceRef } from '../../data-providers';
+import { DMInstanceRef } from '../../utilities';
 /**
  * A simple PointCloudDMVolumeCollection that consists of an explicitly provided list of data model instance.
  */

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

@@ -141,7 +141,7 @@ export declare class CognitePointCloudModel<T extends DataSourceType = ClassicDa
     get pointSize(): number;
     /**
      * Sets the size of each rendered point in the point cloud.
-     * @default `1`
+     * @default `2`
      */
     set pointSize(size: number);
     /**

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

@@ -36,6 +36,5 @@ export declare class Potree implements IPotree {
     private updateVisibility;
     private updateTreeNodeVisibility;
     private updateChildVisibility;
-    private updateBoundingBoxVisibility;
     private readonly updateVisibilityStructures;
 }

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

@@ -10,7 +10,6 @@ export interface IPointCloudTreeNodeBase {
     loaded: boolean;
     numPoints: number;
     isTreeNode: boolean;
-    boundingBoxNode?: THREE.Object3D;
     readonly children: Array<IPointCloudTreeNodeBase | null>;
     readonly isLeafNode: boolean;
     dispose(): void;

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

@@ -22,11 +22,9 @@ export declare class PointCloudOctree extends PointCloudTree {
      */
     minNodePixelSize: number;
     root: IPointCloudTreeNodeBase | undefined;
-    boundingBoxNodes: Object3D[];
     visibleNodes: IPointCloudTreeNode[];
     visibleGeometry: IPointCloudTreeGeometryNode[];
     numVisiblePoints: number;
-    showBoundingBox: boolean;
     private readonly visibleBounds;
     private picker;
     private _globalClippingPlanes;
@@ -41,7 +39,6 @@ export declare class PointCloudOctree extends PointCloudTree {
     set pointSizeType(value: PointSizeType);
     toTreeNode(geometryNode: IPointCloudTreeGeometryNode, parent?: IPointCloudTreeNode | null): IPointCloudTreeNode;
     updateVisibleBounds(): void;
-    updateBoundingBoxes(): void;
     updateMatricesForDescendants(): void;
     /**
      * Override updateMatrixWorld to not update children recursively. Child transformations

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

@@ -1,4 +1,4 @@
-import { Box3, EventDispatcher, Object3D, Points, Sphere } from 'three';
+import { Box3, EventDispatcher, Points, Sphere } from 'three';
 import { IPointCloudTreeGeometryNode } from '../geometry/IPointCloudTreeGeometryNode';
 import { IPointCloudTreeNode } from './IPointCloudTreeNode';
 import { IPointCloudTreeNodeBase } from './IPointCloudTreeNodeBase';
@@ -6,7 +6,6 @@ export declare class PointCloudOctreeNode extends EventDispatcher implements IPo
     geometryNode: IPointCloudTreeGeometryNode;
     sceneNode: Points;
     pcIndex: number | undefined;
-    boundingBoxNode?: Object3D | undefined;
     readonly children: (IPointCloudTreeNodeBase | null)[];
     readonly loaded = true;
     readonly isTreeNode: boolean;

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

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

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

@@ -53,5 +53,6 @@ export { Vector3Pool } from './src/three/Vector3Pool';
 export { isPointVisibleByPlanes } from './src/three/isPointVisibleByPlanes';
 export { CDF_TO_VIEWER_TRANSFORMATION } from './src/constants';
 export * from './src/workers/workerize-transferable';
+export * from './src/fdm';
 export * from './src/shapes';
 export * from './src/linalg';

package/dist/packages/utilities/src/fdm/index.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+export { DMInstanceRef, DMSpace, DMExternalId } from './types';
+export { isDmIdentifier } from './typeGuards';
+export { DMInstanceKey, dmInstanceRefToKey } from './toKey';

package/dist/packages/utilities/src/fdm/toKey.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { DMExternalId, DMInstanceRef, DMSpace } from './types';
+export type DMInstanceKey = `${DMSpace}/${DMExternalId}`;
+export declare function dmInstanceRefToKey(id: DMInstanceRef): DMInstanceKey;

package/dist/packages/utilities/src/fdm/typeGuards.d.ts

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { DMInstanceRef } from './types';
+export declare function isDmIdentifier(id: any): id is DMInstanceRef;

package/dist/packages/utilities/src/fdm/types.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+export type DMExternalId = string;
+export type DMSpace = string;
+/**
+ * @public
+ * CDF Data model instance reference
+ */
+export type DMInstanceRef = {
+    externalId: string;
+    space: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.22.0",
+  "version": "4.23.0-dev.20250122",
   "description": "WebGL based 3D viewer for CAD and point clouds processed in Cognite Data Fusion.",
   "homepage": "https://github.com/cognitedata/reveal/tree/master/viewer",
   "repository": {

package/dist/packages/360-images/src/annotation/ImageAnnotationData.d.ts

@@ -1,9 +0,0 @@
-/*!
- * Copyright 2023 Cognite AS
- */
-import { BufferGeometry, Matrix4, Vector2 } from 'three';
-export interface ImageAnnotationObjectData {
-    getGeometry(): BufferGeometry;
-    getOutlinePoints(): Vector2[];
-    getNormalizationMatrix(): Matrix4;
-}