@cognite/reveal 4.22.0 → 4.23.0-dev.20250122

package/dist/packages/api/src/api-helpers/Image360ApiHelper.d.ts

@@ -3,13 +3,11 @@
  */
 import { type Matrix4 } from 'three';
 import { CogniteClient, Metadata } from '@cognite/sdk';
-import { Image360Collection, Image360Entity, Image360, IconsOptions, Image360RevisionEntity, Image360AnnotationIntersection, Image360AnnotationFilterOptions } from '../../../360-images';
+import { Image360Collection, Image360Entity, Image360, IconsOptions, Image360RevisionEntity, Image360AnnotationIntersection, Image360AnnotationFilterOptions, Image360IconIntersectionData, Image360Action } from '../../../360-images';
 import { DataSourceType, Image360DataModelIdentifier } from '../../../data-providers';
 import { BeforeSceneRenderedDelegate, EventTrigger, InputHandler, PointerEventData, SceneHandler } from '../../../utilities';
 import { ProxyCameraManager } from '../../../camera-manager';
 import { Image360WithCollection } from '../public/types';
-import { Image360Action } from '../../../360-images/src/Image360Action';
-import { Image360IconIntersectionData } from '../../../360-images/src/types';
 export declare class Image360ApiHelper<DataSourceT extends DataSourceType> {
     private readonly _image360Facade;
     private readonly _domElement;
@@ -34,7 +32,7 @@ export declare class Image360ApiHelper<DataSourceT extends DataSourceType> {
     resetRedraw(): void;
     add360ImageSet(collectionIdentifier: Metadata | Image360DataModelIdentifier, collectionTransform: Matrix4, preMultipliedRotation: boolean, annotationOptions?: Image360AnnotationFilterOptions): Promise<Image360Collection<DataSourceT>>;
     getImageCollections(): Image360Collection<DataSourceT>[];
-    remove360Images(entities: Image360[]): Promise<void>;
+    remove360Images(entities: Image360<DataSourceT>[]): Promise<void>;
     remove360ImageCollection(collection: Image360Collection<DataSourceT>): void;
     getCurrentlyEnteredImageInfo(): Image360WithCollection<DataSourceT> | undefined;
     enter360Image(image360Entity: Image360Entity<DataSourceT>, revision?: Image360RevisionEntity<DataSourceT>): Promise<void>;
@@ -51,7 +49,7 @@ export declare class Image360ApiHelper<DataSourceT extends DataSourceType> {
     private findRevisionIdToEnter;
     private enter360ImageOnIntersect;
     intersect360ImageIcons(offsetX: number, offsetY: number): Image360IconIntersectionData<DataSourceT> | undefined;
-    intersect360ImageAnnotations(offsetX: number, offsetY: number): Image360AnnotationIntersection | undefined;
+    intersect360ImageAnnotations(offsetX: number, offsetY: number): Image360AnnotationIntersection<DataSourceT> | undefined;
     private setHoverIconOnIntersect;
     private exit360ImageByTween;
     private getImageOpacity;

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

@@ -705,7 +705,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @param offsetX
      * @param offsetY
      */
-    get360AnnotationIntersectionFromPixel(offsetX: number, offsetY: number): Promise<null | Image360AnnotationIntersection>;
+    get360AnnotationIntersectionFromPixel(offsetX: number, offsetY: number): Promise<null | Image360AnnotationIntersection<DataSourceT>>;
     /** @private */
     private getModels;
     /**

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

@@ -4,10 +4,14 @@
 export { CdfModelDataProvider } from './src/model-data-providers/CdfModelDataProvider';
 export { CdfModelIdentifier } from './src/model-identifiers/CdfModelIdentifier';
 export { CdfModelMetadataProvider } from './src/metadata-providers/CdfModelMetadataProvider';
-export { Cdf360ImageProvider } from './src/image-360-data-providers/Cdf360ImageProvider';
+export { Cdf360ImageAnnotationProvider } from './src/image-360-data-providers/Cdf360ImageAnnotationProvider';
 export { Cdf360EventDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/events/Cdf360EventDescriptorProvider';
-export { Cdf360DataModelsDescriptorProvider, Image360DataModelIdentifier } from './src/image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
-export { Cdf360CombinedDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/Cdf360CombinedDescriptorProvider';
+export { CoreDm360ImageAnnotationProvider } from './src/image-360-data-providers/CoreDm360ImageAnnotationProvider';
+export { Cdf360CdmDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/datamodels/cdm/Cdf360CdmDescriptorProvider';
+export { Cdf360ImageFileProvider } from './src/image-360-data-providers/Cdf360ImageFileProvider';
+export { Cdf360DataModelsDescriptorProvider, Image360DataModelIdentifier, Image360CoreDataModelIdentifier, Image360LegacyDataModelIdentifier, Image360BaseIdentifier } from './src/image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
+export { isClassic360Identifier, isCoreDmImage360Identifier, isLegacyDM360Identifier, isFdm360ImageCollectionIdentifier, isImageAssetLinkAnnotation, isClassicMetadata360Identifier } from './src/image-360-data-providers/shared';
+export { CoreDmImage360Annotation } from './src/image-360-data-providers/cdm/types';
 export { LocalModelDataProvider } from './src/model-data-providers/LocalModelDataProvider';
 export { LocalModelIdentifier } from './src/model-identifiers/LocalModelIdentifier';
 export { LocalModelMetadataProvider } from './src/metadata-providers/LocalModelMetadataProvider';
@@ -15,15 +19,16 @@ export { Local360ImageProvider } from './src/image-360-data-providers/Local360Im
 export { ModelIdentifier, createModelIdentifier } from './src/ModelIdentifier';
 export { ModelMetadataProvider } from './src/ModelMetadataProvider';
 export { ModelDataProvider } from './src/ModelDataProvider';
-export { PointCloudObjectMetadata, PointCloudObject, DMInstanceRef } from './src/pointcloud-stylable-object-providers/types';
+export { PointCloudObjectMetadata, PointCloudObject } 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 { Image360Provider, Image360ProviderMap, getImage360ProviderFromMap } from './src/Image360Provider';
+export { Image360ProviderCombiner } from './src/Image360ProviderCombiner';
+export { BinaryFileProvider, JsonFileProvider, File3dFormat, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face, Image360Texture, Image360FileDescriptor, ImageAssetLinkAnnotationInfo, InstanceReference, Image360Id, Image360RevisionId } 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';

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

@@ -7,5 +7,6 @@ export declare class DataModelsSdk {
     private readonly _sdk;
     private readonly _queryEndpoint;
     constructor(sdk: CogniteClient);
-    queryNodesAndEdges<const T extends Query>(query: T, nextCursor?: QueryNextCursors<T>): Promise<QueryResult<T>>;
+    queryNodesAndEdges<T extends Query>(query: T, nextCursor?: QueryNextCursors<T>): Promise<QueryResult<T>>;
 }
+export declare function queryNodesAndEdges<T extends Query>(dmsSdk: DataModelsSdk, query: T, nextCursor?: QueryNextCursors<T>): Promise<QueryResult<T>>;

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

@@ -3,8 +3,9 @@
  */
 import { AnnotationModel, AnnotationsAssetRef } from '@cognite/sdk';
 import { Image360DataModelIdentifier } from './image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
-import { DMInstanceRef } from './pointcloud-stylable-object-providers/types';
 import { PointCloudAnnotationVolumeCollection, PointCloudDMVolumeCollection } from '../../pointcloud-styling';
+import { CoreDmImage360Annotation } from './image-360-data-providers/cdm/types';
+import { DMInstanceRef } from '../../utilities';
 /**
  * Model identifier for classic CDF models, referenced by modelId and revisionId
  */
@@ -84,7 +85,7 @@ export type DMDataSourceType = {
     /**
      * Type of CoreDM 360 image annotations (to be defined)
      */
-    image360AnnotationType: never;
+    image360AnnotationType: CoreDmImage360Annotation;
     /**
      * Marker to make this type inconstructable
      */
@@ -97,6 +98,8 @@ export type LocalDataSourceType = {
     modelIdentifier: LocalModelIdentifierType;
     pointCloudVolumeMetadata: any;
     pointCloudCollectionType: any;
+    image360Identifier: string;
+    image360AnnotationType: string;
     _never: never;
 };
 /**
@@ -110,8 +113,8 @@ export type GenericDataSourceType = {
     modelIdentifier: any;
     pointCloudVolumeMetadata: any;
     pointCloudCollectionType: any;
-    image360Identifier: any;
-    image360AnnotationType: any;
+    image360Identifier: string;
+    image360AnnotationType: string;
     _never: never;
 };
 /**

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

@@ -1,8 +1,10 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { Image360DescriptorProvider, Image360FileProvider, Image360AnnotationProvider, Image360AssetProvider } from './types';
-export interface Image360Provider<T> extends Image360DescriptorProvider<T>, Image360DataProvider {
-}
-export interface Image360DataProvider extends Image360FileProvider, Image360AnnotationProvider, Image360AssetProvider {
+import { Image360CollectionSourceType } from '../../360-images';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
+import { Image360DescriptorProvider, Image360FileProvider, Image360AnnotationProvider } from './types';
+export type Image360ProviderMap = Map<Image360CollectionSourceType, Image360Provider<DMDataSourceType> | Image360Provider<ClassicDataSourceType>>;
+export declare function getImage360ProviderFromMap<T extends DataSourceType>(identifier: T['image360Identifier'], providerMap: Image360ProviderMap): Image360Provider<T>;
+export interface Image360Provider<T extends DataSourceType> extends Image360DescriptorProvider<T>, Image360FileProvider, Image360AnnotationProvider<T> {
 }

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

@@ -0,0 +1,21 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { Image360Provider } from './Image360Provider';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
+import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, Image360DescriptorProvider, Image360Face, Image360FileDescriptor, Image360FileProvider, InstanceReference } from './types';
+import { AssetAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../360-images';
+export declare class Image360ProviderCombiner<T extends DataSourceType> implements Image360Provider<T> {
+    private readonly _descriptorProvider;
+    private readonly _fileProvider;
+    private readonly _annotationProvider;
+    constructor(descriptorProvider: Image360DescriptorProvider<T>, fileProvider: Image360FileProvider, annotationProvider: Image360AnnotationProvider<T>);
+    get360ImageDescriptors(metadataFilter: T['image360Identifier'], preMultipliedRotation: boolean): Promise<Historical360ImageSet<T>[]>;
+    get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
+    getLowResolution360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
+    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>[]>;
+}

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

@@ -0,0 +1,20 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, InstanceReference } from '../types';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
+import { AssetAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../../360-images';
+export declare class Cdf360ImageAnnotationProvider implements Image360AnnotationProvider<ClassicDataSourceType> {
+    private readonly _client;
+    constructor(client: CogniteClient);
+    findImageAnnotationsForInstance(asset: InstanceReference<ClassicDataSourceType>, collection: DefaultImage360Collection<ClassicDataSourceType>): Promise<Image360AnnotationAssetQueryResult<ClassicDataSourceType>[]>;
+    getRelevant360ImageAnnotations(annotationSpecifier: Image360AnnotationSpecifier<ClassicDataSourceType>): Promise<ClassicDataSourceType['image360AnnotationType'][]>;
+    private getFilesByAssetRef;
+    getAllImage360AnnotationInfos(source: 'assets', collection: DefaultImage360Collection<ClassicDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<ClassicDataSourceType>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'cdm', collection: DefaultImage360Collection<ClassicDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<ClassicDataSourceType>): Promise<AssetAnnotationImage360Info<DMDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'all', collection: DefaultImage360Collection<ClassicDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<ClassicDataSourceType>): Promise<AssetAnnotationImage360Info<DataSourceType>[]>;
+    private createFileIdToEntityRevisionMap;
+    private fetchAllAnnotations;
+    private listFileAnnotations;
+}

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

@@ -0,0 +1,10 @@
+import { Image360Face, Image360FileDescriptor, Image360FileProvider } from '../types';
+import { CogniteClient, InternalId } from '@cognite/sdk/dist/src';
+export declare class Cdf360ImageFileProvider implements Image360FileProvider {
+    private readonly _imageFileProvider;
+    constructor(client: CogniteClient);
+    get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
+    getLowResolution360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
+}
+export declare function getFileIds(image360FaceDescriptors: Image360FileDescriptor[]): InternalId[];
+export declare function createFacesFromDescriptorsAndBuffers(image360FaceDescriptors: Image360FileDescriptor[], fileBuffer: ArrayBuffer[]): Image360Face[];

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

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+export declare class CdfImageFileProvider {
+    private readonly _client;
+    constructor(sdk: CogniteClient);
+    getFileBuffers(fileIds: {
+        id: number;
+    }[], abortSignal?: AbortSignal): Promise<ArrayBuffer[]>;
+    getIconBuffers(fileIds: {
+        id: number;
+    }[], abortSignal?: AbortSignal): Promise<ArrayBuffer[]>;
+    private getDownloadUrls;
+}

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

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
+import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, InstanceReference } from '../types';
+import { AssetAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../../360-images';
+import { CogniteClient } from '@cognite/sdk/dist/src';
+export declare class CoreDm360ImageAnnotationProvider implements Image360AnnotationProvider<DMDataSourceType> {
+    private readonly _client;
+    constructor(client: CogniteClient);
+    getRelevant360ImageAnnotations(annotationSpecifier: Image360AnnotationSpecifier<DMDataSourceType>): Promise<DMDataSourceType['image360AnnotationType'][]>;
+    findImageAnnotationsForInstance(instanceFilter: InstanceReference<DMDataSourceType>, collection: DefaultImage360Collection<DMDataSourceType>): Promise<Image360AnnotationAssetQueryResult<DMDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'assets', collection: DefaultImage360Collection<DMDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<DMDataSourceType>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'cdm', collection: DefaultImage360Collection<DMDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<DMDataSourceType>): Promise<AssetAnnotationImage360Info<DMDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'all', collection: DefaultImage360Collection<DMDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<DMDataSourceType>): Promise<AssetAnnotationImage360Info<DataSourceType>[]>;
+}

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

@@ -1,13 +1,18 @@
 import { Image360Provider } from '../Image360Provider';
-import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360Face, Image360FileDescriptor, ImageAssetLinkAnnotationInfo } from '../types';
-import { AnnotationModel, CogniteInternalId, IdEither } from '@cognite/sdk';
-export declare class Local360ImageProvider implements Image360Provider<unknown> {
+import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360AnnotationSpecifier, Image360Face, Image360FileDescriptor, InstanceReference } from '../types';
+import { CogniteInternalId, IdEither } from '@cognite/sdk';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
+import { AssetAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../../360-images';
+export declare class Local360ImageProvider implements Image360Provider<ClassicDataSourceType> {
     private readonly _modelUrl;
     constructor(modelUrl: string);
-    get360ImageDescriptors(): Promise<Historical360ImageSet[]>;
-    get360ImageAnnotations(_descriptors: Image360FileDescriptor[]): Promise<AnnotationModel[]>;
+    findImageAnnotationsForInstance(_filter: InstanceReference<ClassicDataSourceType>, _collection: DefaultImage360Collection<ClassicDataSourceType>): Promise<Image360AnnotationAssetQueryResult<ClassicDataSourceType>[]>;
+    get360ImageDescriptors(): Promise<Historical360ImageSet<ClassicDataSourceType>[]>;
+    getRelevant360ImageAnnotations(_annotationSpecifier: Image360AnnotationSpecifier<ClassicDataSourceType>): Promise<ClassicDataSourceType['image360AnnotationType'][]>;
     get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     getLowResolution360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     getFilesByAssetRef(_assetId: IdEither): Promise<CogniteInternalId[]>;
-    get360ImageAssets(_image360FileDescriptors: Image360FileDescriptor[], _annotationFilter: Image360AnnotationFilterDelegate): Promise<ImageAssetLinkAnnotationInfo[]>;
+    getAllImage360AnnotationInfos(source: 'assets', collection: DefaultImage360Collection<ClassicDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<ClassicDataSourceType>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'cdm', collection: DefaultImage360Collection<ClassicDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<ClassicDataSourceType>): Promise<AssetAnnotationImage360Info<DMDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'all', collection: DefaultImage360Collection<ClassicDataSourceType>, annotationFilter: Image360AnnotationFilterDelegate<ClassicDataSourceType>): Promise<AssetAnnotationImage360Info<DataSourceType>[]>;
 }

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

@@ -0,0 +1,98 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { DMInstanceRef } from '../../../../utilities';
+import { queryNodesAndEdges } from './queryNodesAndEdges';
+import { Image360AnnotationViewReferenceAndProperties } from './types';
+export type Image360AnnotationsForInstanceResult = {
+    annotationIds: DMInstanceRef[];
+    imageRevisionIds: DMInstanceRef[];
+};
+export declare function fetchAnnotationsForInstance(instance: DMInstanceRef, sdk: CogniteClient): Promise<Image360AnnotationsForInstanceResult>;
+export type GetImage360AnnotationsForInstanceResponse = Awaited<ReturnType<typeof queryNodesAndEdges<ReturnType<typeof getImage360AnnotationsForInstanceQuery>, Image360AnnotationViewReferenceAndProperties>>>;
+declare function getImage360AnnotationsForInstanceQuery(instance: DMInstanceRef): {
+    readonly with: {
+        readonly instance_object: {
+            readonly nodes: {
+                readonly filter: {
+                    readonly and: [{
+                        readonly equals: {
+                            readonly property: ["node", "externalId"];
+                            readonly value: string;
+                        };
+                    }, {
+                        readonly equals: {
+                            readonly property: ["node", "space"];
+                            readonly value: string;
+                        };
+                    }];
+                };
+            };
+            readonly limit: 1;
+        };
+        readonly object3ds: {
+            readonly nodes: {
+                readonly from: "instance_objects";
+                readonly through: {
+                    readonly view: {
+                        readonly externalId: "CogniteVisualizable";
+                        readonly space: "cdf_cdm";
+                        readonly version: "v1";
+                        readonly type: "view";
+                    };
+                    readonly identifier: "object3D";
+                };
+                readonly direction: "outwards";
+            };
+        };
+        readonly annotation_dges: {
+            readonly edges: {
+                readonly from: "object3ds";
+                readonly direction: "outwards";
+                readonly filter: {
+                    readonly hasData: [{
+                        readonly type: "view";
+                        readonly space: "cdf_cdm";
+                        readonly externalId: "Cognite360ImageAnnotation";
+                        readonly version: "v1";
+                    }];
+                };
+            };
+            readonly limit: 10000;
+        };
+        readonly image_revisions: {
+            readonly nodes: {
+                readonly from: "annotation_edges";
+                readonly chainTo: "destination";
+                readonly direction: "outwards";
+            };
+            readonly limit: 10000;
+        };
+    };
+    readonly select: {
+        readonly image_revisions: {
+            readonly sources: [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_cdm";
+                    readonly externalId: "Cognite360Image";
+                    readonly version: "v1";
+                };
+                readonly properties: ["translationX", "translationY", "translationZ", "eulerRotationX", "eulerRotationY", "eulerRotationZ", "scaleX", "scaleY", "scaleZ", "front", "back", "left", "right", "top", "bottom", "collection360", "station360", "takenAt"];
+            }];
+        };
+        readonly annotation_edges: {
+            readonly sources: [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_cdm";
+                    readonly externalId: "Cognite360ImageAnnotation";
+                    readonly version: "v1";
+                };
+                readonly properties: ["polygon", "formatVersion"];
+            }];
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,126 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk/dist/src';
+import { queryNodesAndEdges } from './queryNodesAndEdges';
+import { CoreDmImage360Annotation, Image360AnnotationViewReferenceAndProperties } from './types';
+import { DMInstanceRef } from '../../../../utilities';
+export declare function fetchCoreDm360AnnotationsForCollection(collectionIdentifier: DMInstanceRef, sdk: CogniteClient): Promise<CoreDmImage360Annotation[]>;
+export type GetImage360AnnotationsFromCollectionResponse = Awaited<ReturnType<typeof queryNodesAndEdges<ReturnType<typeof getImage360AnnotationsQuery>, Image360AnnotationViewReferenceAndProperties>>>;
+declare function getImage360AnnotationsQuery(collectionReference: DMInstanceRef): {
+    readonly with: {
+        readonly collection: {
+            readonly nodes: {
+                readonly filter: {
+                    readonly and: [{
+                        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";
+                            };
+                        }];
+                    }, import("@cognite/sdk/dist/src").TableExpressionEqualsFilterV3, import("@cognite/sdk/dist/src").TableExpressionEqualsFilterV3];
+                };
+            };
+        };
+        readonly images: {
+            readonly nodes: {
+                readonly from: "collection";
+                readonly through: {
+                    readonly view: {
+                        readonly type: "view";
+                        readonly space: "cdf_cdm";
+                        readonly externalId: "Cognite360Image";
+                        readonly version: "v1";
+                    };
+                    readonly identifier: "collection360";
+                };
+                readonly direction: "inwards";
+            };
+            readonly limit: 10000;
+        };
+        readonly annotations: {
+            readonly edges: {
+                readonly from: "images";
+                readonly direction: "inwards";
+                readonly filter: {
+                    readonly and: [{
+                        readonly hasData: [{
+                            readonly type: "view";
+                            readonly space: "cdf_cdm";
+                            readonly externalId: "Cognite360ImageAnnotation";
+                            readonly version: "v1";
+                        }];
+                    }];
+                };
+            };
+            readonly limit: 10000;
+        };
+        readonly object3d: {
+            readonly nodes: {
+                readonly from: "annotations";
+            };
+            readonly limit: 10000;
+        };
+        readonly assets: {
+            readonly nodes: {
+                readonly from: "object3d";
+                readonly through: {
+                    readonly view: {
+                        readonly type: "view";
+                        readonly externalId: "CogniteAsset";
+                        readonly space: "cdf_cdm";
+                        readonly version: "v1";
+                    };
+                    readonly identifier: "object3D";
+                };
+            };
+            readonly limit: 10000;
+        };
+    };
+    readonly select: {
+        readonly collection: {};
+        readonly images: {
+            readonly sources: [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_cdm";
+                    readonly externalId: "Cognite360Image";
+                    readonly version: "v1";
+                };
+                readonly properties: ["translationX", "translationY", "translationZ", "eulerRotationX", "eulerRotationY", "eulerRotationZ", "scaleX", "scaleY", "scaleZ", "front", "back", "left", "right", "top", "bottom", "collection360", "station360", "takenAt"];
+            }];
+        };
+        readonly annotations: {
+            readonly sources: [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_cdm";
+                    readonly externalId: "Cognite360ImageAnnotation";
+                    readonly version: "v1";
+                };
+                readonly properties: ["polygon", "formatVersion"];
+            }];
+        };
+        readonly object3d: {};
+        readonly assets: {
+            readonly sources: [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly externalId: "CogniteAsset";
+                    readonly space: "cdf_cdm";
+                    readonly version: "v1";
+                };
+                readonly properties: ["name", "description", "object3D"];
+            }];
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,103 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { queryNodesAndEdges } from './queryNodesAndEdges';
+import { CoreDmImage360Annotation, Image360AnnotationViewReferenceAndProperties } from './types';
+import { DMInstanceRef } from '../../../../utilities';
+export declare function fetchCoreDm360AnnotationsForRevision(revision: DMInstanceRef, sdk: CogniteClient): Promise<CoreDmImage360Annotation[]>;
+export type GetImage360FromRevisionResponse = Awaited<ReturnType<typeof queryNodesAndEdges<ReturnType<typeof getImage360AnnotationsByRevisionQuery>, Image360AnnotationViewReferenceAndProperties>>>;
+declare function getImage360AnnotationsByRevisionQuery(revisionReference: DMInstanceRef): {
+    readonly with: {
+        readonly images: {
+            readonly nodes: {
+                readonly filter: {
+                    readonly and: [{
+                        readonly hasData: [{
+                            readonly type: "view";
+                            readonly space: "cdf_cdm";
+                            readonly externalId: "Cognite360Image";
+                            readonly version: "v1";
+                        }];
+                    }, import("@cognite/sdk").TableExpressionEqualsFilterV3, import("@cognite/sdk").TableExpressionEqualsFilterV3];
+                };
+            };
+            readonly limit: 10000;
+        };
+        readonly annotations: {
+            readonly edges: {
+                readonly from: "images";
+                readonly direction: "inwards";
+                readonly filter: {
+                    readonly and: [{
+                        readonly hasData: [{
+                            readonly type: "view";
+                            readonly space: "cdf_cdm";
+                            readonly externalId: "Cognite360ImageAnnotation";
+                            readonly version: "v1";
+                        }];
+                    }];
+                };
+            };
+            readonly limit: 10000;
+        };
+        readonly object3d: {
+            readonly nodes: {
+                readonly from: "annotations";
+            };
+            readonly limit: 10000;
+        };
+        readonly assets: {
+            readonly nodes: {
+                readonly from: "object3d";
+                readonly through: {
+                    readonly view: {
+                        readonly type: "view";
+                        readonly externalId: "CogniteAsset";
+                        readonly space: "cdf_cdm";
+                        readonly version: "v1";
+                    };
+                    readonly identifier: "object3D";
+                };
+            };
+            readonly limit: 10000;
+        };
+    };
+    readonly select: {
+        readonly images: {
+            readonly sources: [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_cdm";
+                    readonly externalId: "Cognite360Image";
+                    readonly version: "v1";
+                };
+                readonly properties: ["translationX", "translationY", "translationZ", "eulerRotationX", "eulerRotationY", "eulerRotationZ", "scaleX", "scaleY", "scaleZ", "front", "back", "left", "right", "top", "bottom", "collection360", "station360", "takenAt"];
+            }];
+        };
+        readonly annotations: {
+            readonly sources: [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_cdm";
+                    readonly externalId: "Cognite360ImageAnnotation";
+                    readonly version: "v1";
+                };
+                readonly properties: ["polygon", "formatVersion"];
+            }];
+        };
+        readonly object3d: {};
+        readonly assets: {
+            readonly sources: [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly externalId: "CogniteAsset";
+                    readonly space: "cdf_cdm";
+                    readonly version: "v1";
+                };
+                readonly properties: ["name", "description", "object3D"];
+            }];
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { DMInstanceRef } from '../../../../utilities';
+import { GetImage360AnnotationsFromCollectionResponse } from './fetchCoreDm360AnnotationsForCollection';
+import { CoreDmImage360Properties } from './properties';
+import { GetImage360FromRevisionResponse } from './fetchCoreDm360AnnotationsForRevision';
+export declare function getImage360Map(queryResponse: GetImage360AnnotationsFromCollectionResponse | GetImage360FromRevisionResponse): Record<string, Record<string, DMInstanceRef & CoreDmImage360Properties>>;

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

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2025 Cognite AS
+ */
+import { DMInstanceRef } from '../../../../utilities';
+import { GetImage360AnnotationsFromCollectionResponse } from './fetchCoreDm360AnnotationsForCollection';
+import { GetImage360FromRevisionResponse } from './fetchCoreDm360AnnotationsForRevision';
+export declare function getObject3dAssetMap(queryResponse: GetImage360AnnotationsFromCollectionResponse | GetImage360FromRevisionResponse): Record<string, Record<string, DMInstanceRef & {
+    name: string;
+}>>;