@cognite/reveal 4.7.1 → 4.9.0

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

@@ -4,6 +4,7 @@
 import * as THREE from 'three';
 import { CogniteClient, Metadata } from '@cognite/sdk';
 import { Image360Collection, Image360Entity, Image360, IconsOptions, Image360RevisionEntity, Image360AnnotationIntersection, Image360AnnotationFilterOptions } from '../../../360-images';
+import { Image360DataModelIdentifier } from '../../../data-providers';
 import { BeforeSceneRenderedDelegate, EventTrigger, InputHandler, SceneHandler } from '../../../utilities';
 import { ProxyCameraManager } from '../../../camera-manager';
 export declare class Image360ApiHelper {
@@ -22,8 +23,7 @@ export declare class Image360ApiHelper {
     constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, iconsOptions?: IconsOptions);
     get needsRedraw(): boolean;
     resetRedraw(): void;
-    private getNormalizedOffset;
-    add360ImageSet(eventFilter: Metadata, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean, annotationOptions?: Image360AnnotationFilterOptions): Promise<Image360Collection>;
+    add360ImageSet(collectionIdentifier: Metadata | Image360DataModelIdentifier, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean, annotationOptions?: Image360AnnotationFilterOptions): Promise<Image360Collection>;
     getImageCollections(): Image360Collection[];
     remove360Images(entities: Image360[]): Promise<void>;
     remove360ImageCollection(collection: Image360Collection): void;

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

@@ -9,6 +9,7 @@ import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersecti
 import { CogniteModel } from '../types';
 import { ViewerState } from '../../utilities/ViewStateHelper';
 import { CameraManager, CameraChangeDelegate, CameraStopDelegate } from '../../../../camera-manager';
+import { Image360DataModelIdentifier } from '../../../../data-providers';
 import { SupportedModelTypes } from '../../../../model-base';
 import { Image360Collection, Image360, Image360Revision, Image360AnnotationIntersection } from '../../../../360-images';
 /**
@@ -273,6 +274,12 @@ export declare class Cognite3DViewer {
      */
     addPointCloudModel(options: AddModelOptions): Promise<CognitePointCloudModel>;
     private addPointCloudModelWithSequencer;
+    /**
+     * Adds a set of 360 images to the scene from the /datamodels API in Cognite Data Fusion.
+     * @param datasource The data data source which holds the references to the 360 image sets.
+     * @param dataModelIdentifier The search parameters to apply when querying Cognite Datamodels that contains the 360 images.
+     */
+    add360ImageSet(datasource: 'datamodels', dataModelIdentifier: Image360DataModelIdentifier): Promise<Image360Collection>;
     /**
      * Adds a set of 360 images to the scene from the /events API in Cognite Data Fusion.
      * @param datasource The CDF data source which holds the references to the 360 image sets.

package/dist/packages/cad-model/src/wrappers/CogniteCadModel.d.ts

@@ -48,7 +48,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
     private readonly cadModel;
     private readonly nodesApiClient;
     private readonly nodeIdAndTreeIndexMaps;
-    private readonly _styledNodeCollections;
+    private _styledNodeCollections;
     private readonly customSectorBounds;
     /**
      * Sets the default appearance for nodes that are not styled using
@@ -90,6 +90,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
      *
      * @param nodeCollection Dynamic set of nodes to apply the provided appearance to.
      * @param appearance Appearance to style the provided set with.
+     * @param importance The importance of this style. Can be used to manually order the order of styles, this can avoid the order of adding styles affecting the outcome. Optional and defaults to 0.
      * @example
      * ```js
      * model.setDefaultNodeAppearance({ rendererGhosted: true });
@@ -97,7 +98,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
      * model.assignStyledNodeCollection(visibleSet, { rendererGhosted: false });
      * ```
      */
-    assignStyledNodeCollection(nodeCollection: NodeCollection, appearance: NodeAppearance): void;
+    assignStyledNodeCollection(nodeCollection: NodeCollection, appearance: NodeAppearance, importance?: number): void;
     /**
      * Removes styling for previously added styled collection, resetting the style to the default (or
      * the style imposed by other styled collections).

package/dist/packages/cad-styling/src/NodeAppearanceProvider.d.ts

@@ -12,7 +12,7 @@ import { IndexSet } from '../../utilities';
  */
 export type ApplyStyleDelegate = (treeIndices: IndexSet, appearance: NodeAppearance) => void;
 export declare class NodeAppearanceProvider {
-    private readonly _styledCollections;
+    private _styledCollections;
     private _lastFiredLoadingState?;
     private _cachedPrioritizedAreas?;
     private readonly _events;
@@ -21,7 +21,7 @@ export declare class NodeAppearanceProvider {
     on(event: 'prioritizedAreasChanged', listener: () => void): void;
     off(event: 'changed', listener: () => void): void;
     off(event: 'loadingStateChanged', listener: (isLoading: boolean) => void): void;
-    assignStyledNodeCollection(nodeCollection: NodeCollection, appearance: NodeAppearance): void;
+    assignStyledNodeCollection(nodeCollection: NodeCollection, appearance: NodeAppearance, importance?: number): void;
     unassignStyledNodeCollection(nodeCollection: NodeCollection): void;
     applyStyles(applyCb: ApplyStyleDelegate): void;
     getPrioritizedAreas(): PrioritizedArea[];

package/dist/packages/camera-manager/index.d.ts

@@ -6,6 +6,7 @@ export { ProxyCameraManager } from './src/ProxyCameraManager';
 export { StationaryCameraManager } from './src/StationaryCameraManager';
 export { CameraManagerHelper } from './src/CameraManagerHelper';
 export { CameraManager } from './src/CameraManager';
-export { ComboControls, ComboControlsOptions, ComboControlsEventType } from './src/ComboControls';
+export { ComboControls, ComboControlsEventType } from './src/ComboControls';
+export { ComboControlsOptions } from './src/ComboControlsOptions';
 export { DebouncedCameraStopEventTrigger } from './src/utils/DebouncedCameraStopEventTrigger';
 export * from './src/types';

package/dist/packages/camera-manager/src/ComboControls.d.ts

@@ -2,66 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import { EventDispatcher, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
-/**
- * Exposed options for Combo Controls
- */
-export type ComboControlsOptions = {
-    enableDamping: boolean;
-    dampingFactor: number;
-    dynamicTarget: boolean;
-    minDistance: number;
-    minZoomDistance: number;
-    dollyFactor: number;
-    /**
-     * Radians
-     */
-    minPolarAngle: number;
-    /**
-     * Radians
-     */
-    maxPolarAngle: number;
-    /**
-     * Radians
-     */
-    minAzimuthAngle: number;
-    /**
-     * Radians
-     */
-    maxAzimuthAngle: number;
-    panDollyMinDistanceFactor: number;
-    firstPersonRotationFactor: number;
-    /**
-     * Radians per pixel
-     */
-    pointerRotationSpeedAzimuth: number;
-    /**
-     * Radians per pixel
-     */
-    pointerRotationSpeedPolar: number;
-    enableKeyboardNavigation: boolean;
-    keyboardRotationSpeedAzimuth: number;
-    keyboardRotationSpeedPolar: number;
-    mouseFirstPersonRotationSpeed: number;
-    keyboardDollySpeed: number;
-    keyboardPanSpeed: number;
-    /**
-     * How much quicker keyboard navigation will be with 'shift' pressed
-     */
-    keyboardSpeedFactor: number;
-    pinchEpsilon: number;
-    pinchPanSpeed: number;
-    EPSILON: number;
-    minZoom: number;
-    maxZoom: number;
-    orthographicCameraDollyFactor: number;
-    lookAtViewTarget: boolean;
-    useScrollTarget: boolean;
-    zoomToCursor: boolean;
-    minDeltaRatio: number;
-    maxDeltaRatio: number;
-    minDeltaDownscaleCoefficient: number;
-    maxDeltaDownscaleCoefficient: number;
-};
+import { ComboControlsOptions } from './ComboControlsOptions';
 /**
  * The event type for events emitted by {@link ComboControls}.
  */
@@ -75,31 +16,25 @@ export type ComboControlsEventType = {
 };
 export declare class ComboControls extends EventDispatcher<ComboControlsEventType> {
     dispose: () => void;
+    private _enabled;
+    private _options;
     private _temporarilyDisableDamping;
+    private readonly _domElement;
     private readonly _camera;
-    private _firstPersonMode;
     private readonly _reusableCamera;
-    private readonly _reusableVector3;
-    private readonly _accumulatedMouseMove;
-    private readonly _domElement;
     private readonly _target;
-    private readonly _viewTarget;
-    private readonly _scrollTarget;
     private readonly _targetEnd;
     private readonly _spherical;
     private readonly _sphericalEnd;
-    private readonly _deltaTarget;
+    private readonly _scrollTarget;
+    private readonly _viewTarget;
     private readonly _rawCameraRotation;
+    private readonly _accumulatedMouseMove;
     private readonly _keyboard;
-    private readonly _offsetVector;
-    private readonly _panVector;
-    private readonly _raycaster;
-    private readonly _targetFPS;
-    private _targetFPSOverActualFPS;
     private readonly _pointEventCache;
-    private _enabled;
-    private _options;
-    private static readonly DefaultControlsOptions;
+    private readonly _reusableVector3s;
+    private readonly _raycaster;
+    constructor(camera: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
     /**
      * Gets current Combo Controls options.
      */
@@ -118,13 +53,6 @@ export declare class ComboControls extends EventDispatcher<ComboControlsEventTyp
      * Sets the enabled state of these controls.
      */
     set enabled(newEnabledValue: boolean);
-    constructor(camera: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
-    update: (deltaTimeS: number, forceUpdate?: boolean) => boolean;
-    getState: () => {
-        target: Vector3;
-        position: Vector3;
-    };
-    setState: (position: Vector3, target: Vector3) => void;
     /**
      * Camera rotation to be used by the camera instead of target-based rotation.
      * This rotation is used only when set to non-default quaternion value (not identity rotation quaternion).
@@ -132,12 +60,25 @@ export declare class ComboControls extends EventDispatcher<ComboControlsEventTyp
      * resets to default value when `setState` method is called with no rotation value.
      */
     get cameraRawRotation(): Quaternion;
-    setViewTarget: (target: Vector3) => void;
-    setScrollTarget: (target: Vector3) => void;
     getScrollTarget: () => Vector3;
+    getState: () => {
+        target: Vector3;
+        position: Vector3;
+    };
+    setScrollTarget: (target: Vector3) => void;
+    setState: (position: Vector3, target: Vector3) => void;
+    setViewTarget: (target: Vector3) => void;
+    /**
+     * Converts deltaTimeS to a time scale based on the target frames per second (FPS).
+     *
+     * @param deltaTimeS - The elapsed time since the last frame in seconds.
+     * @returns The time scale, which is a factor representing the relationship of deltaTimeS to the target FPS.
+     */
+    private getTimeScale;
+    private getDollyDeltaDistance;
+    private newVector3;
+    update: (deltaTimeS: number, forceUpdate?: boolean) => boolean;
     triggerCameraChangeEvent: () => void;
-    private calculateShortestDeltaTheta;
-    private readonly convertPixelCoordinatesToNormalized;
     private readonly onPointerDown;
     private readonly onMouseDown;
     private readonly onPointerUp;
@@ -146,36 +87,25 @@ export declare class ComboControls extends EventDispatcher<ComboControlsEventTyp
     private readonly onTouchStart;
     private readonly onFocusChanged;
     private readonly onContextMenu;
-    private readonly rotate;
-    private readonly startMouseRotation;
-    private readonly startMousePan;
-    private readonly startTouchRotation;
-    private readonly startTouchPinch;
-    /**
-     * Converts deltaTimeS to a time scale based on the target frames per second (FPS).
-     *
-     * @param deltaTimeS - The elapsed time since the last frame in seconds.
-     * @returns The time scale, which is a factor representing the relationship of deltaTimeS to the target FPS.
-     */
-    private getTimeScale;
+    private addEventListeners;
+    private removeEventListeners;
+    private startMouseRotation;
+    private startTouchRotation;
+    private rotate;
+    private rotateFirstPersonMode;
+    private startTouchPinch;
+    private startMousePan;
+    private pan;
+    private panLeft;
+    private panUp;
+    private dolly;
+    private dollyOrthographicCamera;
+    private dollyPerspectiveCamera;
+    private dollyWithWheelScroll;
+    private calculateNewRadiusAndTargetOffsetLerp;
+    private calculateNewRadiusAndTargetOffsetScrollTarget;
     private handleRotationFromKeyboard;
     private handleDollyFromKeyboard;
     private handlePanFromKeyboard;
-    private readonly handleKeyboard;
-    private readonly rotateSpherical;
-    private readonly rotateFirstPersonMode;
-    private readonly pan;
-    private readonly dollyOrthographicCamera;
-    private readonly calculateNewRadiusAndTargetOffsetLerp;
-    private readonly clampedMap;
-    private readonly calculateNewRadiusAndTargetOffsetScrollTarget;
-    private readonly dollyWithWheelScroll;
-    private readonly dollyPerspectiveCamera;
-    private readonly dolly;
-    private readonly getDollyDeltaDistance;
-    private readonly panLeft;
-    private readonly panUp;
-    private isIdentityQuaternion;
-    private addEventListeners;
-    private removeEventListeners;
+    private handleKeyboard;
 }

package/dist/packages/camera-manager/src/ComboControlsOptions.d.ts

@@ -0,0 +1,64 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+/**
+ * Exposed options for Combo Controls
+ */
+export type ComboControlsOptions = {
+    enableDamping: boolean;
+    dampingFactor: number;
+    dynamicTarget: boolean;
+    minDistance: number;
+    minZoomDistance: number;
+    dollyFactor: number;
+    /**
+     * Radians
+     */
+    minPolarAngle: number;
+    /**
+     * Radians
+     */
+    maxPolarAngle: number;
+    /**
+     * Radians
+     */
+    minAzimuthAngle: number;
+    /**
+     * Radians
+     */
+    maxAzimuthAngle: number;
+    panDollyMinDistanceFactor: number;
+    firstPersonRotationFactor: number;
+    /**
+     * Radians per pixel
+     */
+    pointerRotationSpeedAzimuth: number;
+    /**
+     * Radians per pixel
+     */
+    pointerRotationSpeedPolar: number;
+    enableKeyboardNavigation: boolean;
+    keyboardRotationSpeedAzimuth: number;
+    keyboardRotationSpeedPolar: number;
+    mouseFirstPersonRotationSpeed: number;
+    keyboardDollySpeed: number;
+    keyboardPanSpeed: number;
+    /**
+     * How much quicker keyboard navigation will be with 'shift' pressed
+     */
+    keyboardSpeedFactor: number;
+    pinchEpsilon: number;
+    pinchPanSpeed: number;
+    EPSILON: number;
+    minZoom: number;
+    maxZoom: number;
+    orthographicCameraDollyFactor: number;
+    lookAtViewTarget: boolean;
+    useScrollTarget: boolean;
+    zoomToCursor: boolean;
+    minDeltaRatio: number;
+    maxDeltaRatio: number;
+    minDeltaDownscaleCoefficient: number;
+    maxDeltaDownscaleCoefficient: number;
+};
+export declare function CreateDefaultControlsOptions(): Readonly<Required<ComboControlsOptions>>;

package/dist/packages/camera-manager/src/DefaultCameraManager.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { ComboControlsOptions } from './ComboControls';
+import { ComboControlsOptions } from './ComboControlsOptions';
 import { CameraControlsOptions, CameraState, CameraManagerEventType, CameraEventDelegate } from './types';
 import { CameraManager } from './CameraManager';
 /**
@@ -18,12 +18,13 @@ export declare class DefaultCameraManager implements CameraManager {
     private readonly _domElement;
     private readonly _inputHandler;
     private readonly _raycaster;
-    private isDisposed;
+    private _isDisposed;
     private _nearAndFarNeedsUpdate;
-    private isEnabled;
+    private _isEnabled;
     private readonly _modelRaycastCallback;
     private _onClick;
     private _onWheel;
+    private _onDoubleClick;
     private static readonly AnimationDuration;
     private static readonly MinAnimationDuration;
     private static readonly MaxAnimationDuration;
@@ -126,11 +127,7 @@ export declare class DefaultCameraManager implements CameraManager {
      * Method for setting up camera controls listeners and values inside current controls class.
      */
     private setupControls;
-    /**
-     * Convert pixel coordinates of the cursor to [-1,1]^2 coordinates.
-     * @param pixelX
-     * @param pixelY
-     */
-    private convertPixelCoordinatesToNormalized;
+    private readonly onClick;
+    private readonly onDoubleClick;
     private calculateDefaultDuration;
 }

package/dist/packages/camera-manager/src/types.d.ts

@@ -24,6 +24,14 @@ export type CameraControlsOptions = {
      *
      */
     changeCameraTargetOnClick?: boolean;
+    /**
+     * Enables or disables change of camera position on mouse doubke click. New target is then set to the point of the model under current cursor
+     * position and the a camera position is set half way to this point
+     *
+     * Default is false.
+     *
+     */
+    changeCameraPositionOnDoubleClick?: boolean;
 };
 export type ControlsState = {
     position: THREE.Vector3;
@@ -72,6 +80,10 @@ export type CameraManagerCallbackData = {
      * Bounding box for all models on the scene
      */
     modelsBoundingBox: THREE.Box3;
+    /**
+     * Bounding box for the object (node in a model) that was picked
+     */
+    pickedBoundingBox: THREE.Box3 | undefined;
 };
 /**
  * List of supported event types (adapted from https://stackoverflow.com/questions/44480644/string-union-to-string-array)

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

@@ -4,7 +4,10 @@
 export { CdfModelDataProvider } from './src/model-data-providers/CdfModelDataProvider';
 export { CdfModelIdentifier } from './src/model-identifiers/CdfModelIdentifier';
 export { CdfModelMetadataProvider } from './src/metadata-providers/CdfModelMetadataProvider';
-export { Cdf360ImageEventProvider } from './src/image-360-data-providers/Cdf360ImageEventProvider';
+export { Cdf360ImageProvider } from './src/image-360-data-providers/Cdf360ImageProvider';
+export { Cdf360EventDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/events/Cdf360EventDescriptorProvider';
+export { Cdf360DataModelsDescriptorProvider, Image360DataModelIdentifier } from './src/image-360-data-providers/descriptor-providers/datamodels/Cdf360DataModelsDescriptorProvider';
+export { Cdf360CombinedDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/Cdf360CombinedDescriptorProvider';
 export { LocalModelDataProvider } from './src/model-data-providers/LocalModelDataProvider';
 export { LocalModelIdentifier } from './src/model-identifiers/LocalModelIdentifier';
 export { LocalModelMetadataProvider } from './src/metadata-providers/LocalModelMetadataProvider';

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

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { Query, QueryNextCursors, QueryResult } from './types';
+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>>;
+}

package/dist/packages/data-providers/src/image-360-data-providers/{Cdf360ImageEventProvider.d.ts → Cdf360ImageProvider.d.ts}

@@ -1,29 +1,25 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { AnnotationModel, CogniteClient, IdEither, Metadata, CogniteInternalId } from '@cognite/sdk';
-import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360Face, Image360FileDescriptor, ImageAssetLinkAnnotationInfo } from '../types';
+import { AnnotationModel, CogniteClient, IdEither, CogniteInternalId } from '@cognite/sdk';
+import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360DescriptorProvider, Image360Face, Image360FileDescriptor, ImageAssetLinkAnnotationInfo } from '../types';
 import { Image360Provider } from '../Image360Provider';
-export declare class Cdf360ImageEventProvider implements Image360Provider<Metadata> {
+export declare class Cdf360ImageProvider<T> implements Image360Provider<T> {
     private readonly _client;
-    constructor(client: CogniteClient);
-    get360ImageDescriptors(metadataFilter: Metadata, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+    private readonly _descriptorProvider;
+    constructor(client: CogniteClient, descriptorProvider: Image360DescriptorProvider<T>);
+    get360ImageDescriptors(metadataFilter: T, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
     get360ImageAnnotations(descriptors: Image360FileDescriptor[]): Promise<AnnotationModel[]>;
     getFilesByAssetRef(assetRef: IdEither): Promise<CogniteInternalId[]>;
     get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     getLowResolution360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     private getFileIds;
     private createFaces;
-    private mergeDescriptors;
-    private listEvents;
-    private listFiles;
-    private sortFileInfoSetByNewest;
     private getFileBuffers;
     getIconBuffers(fileIds: {
         id: number;
     }[], abortSignal?: AbortSignal): Promise<ArrayBuffer[]>;
     private getDownloadUrls;
-    private parseEventMetadata;
     get360ImageAssets(image360FileDescriptors: Image360FileDescriptor[], annotationFilter: Image360AnnotationFilterDelegate): Promise<ImageAssetLinkAnnotationInfo[]>;
     private listFileAnnotations;
 }

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

@@ -0,0 +1,14 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Metadata } from '@cognite/sdk';
+import { Historical360ImageSet, Image360DescriptorProvider } from '../../types';
+import { Cdf360DataModelsDescriptorProvider, Image360DataModelIdentifier } from './datamodels/Cdf360DataModelsDescriptorProvider';
+import { Cdf360EventDescriptorProvider } from './events/Cdf360EventDescriptorProvider';
+export declare class Cdf360CombinedDescriptorProvider implements Image360DescriptorProvider<Metadata | Image360DataModelIdentifier> {
+    private readonly _eventProvider;
+    private readonly _fdmProvider;
+    static isFdmIdentifier(metadataFilter: Metadata | Image360DataModelIdentifier): metadataFilter is Image360DataModelIdentifier;
+    constructor(fdmProvider: Cdf360DataModelsDescriptorProvider, eventProvider: Cdf360EventDescriptorProvider);
+    get360ImageDescriptors(metadataFilter: Metadata | Image360DataModelIdentifier, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+}

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

@@ -0,0 +1,23 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { Historical360ImageSet, Image360DescriptorProvider } from '../../../types';
+/**
+ * An identifier uniquely determining an instance of a Cognite Data Model
+ */
+export type Image360DataModelIdentifier = {
+    space: string;
+    image360CollectionExternalId: string;
+};
+export declare class Cdf360DataModelsDescriptorProvider implements Image360DescriptorProvider<Image360DataModelIdentifier> {
+    private readonly _dmsSdk;
+    private readonly _cogniteSdk;
+    constructor(sdk: CogniteClient);
+    get360ImageDescriptors(collectionIdentifier: Image360DataModelIdentifier, _: boolean): Promise<Historical360ImageSet[]>;
+    private queryCollection;
+    private getFileDescriptors;
+    private getHistorical360ImageSet;
+    private getImageRevision;
+    private getRevisionTransform;
+}

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

@@ -0,0 +1,103 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+declare const Image360CollectionQuery: {
+    readonly with: {
+        readonly image_collection: {
+            readonly nodes: {
+                readonly filter: {
+                    readonly and: readonly [{
+                        readonly equals: {
+                            readonly property: readonly ["node", "externalId"];
+                            readonly value: {
+                                readonly parameter: "collectionExternalId";
+                            };
+                        };
+                    }, {
+                        readonly equals: {
+                            readonly property: readonly ["node", "space"];
+                            readonly value: {
+                                readonly parameter: "collectionSpace";
+                            };
+                        };
+                    }];
+                };
+            };
+            readonly limit: 1;
+        };
+        readonly images: {
+            readonly nodes: {
+                readonly from: "image_collection";
+                readonly through: {
+                    readonly view: {
+                        readonly type: "view";
+                        readonly space: "cdf_360_image_schema";
+                        readonly externalId: "Image360";
+                        readonly version: "v1";
+                    };
+                    readonly identifier: "collection360";
+                };
+            };
+            readonly limit: 10000;
+        };
+        readonly stations: {
+            readonly nodes: {
+                readonly from: "images";
+                readonly through: {
+                    readonly view: {
+                        readonly type: "view";
+                        readonly space: "cdf_360_image_schema";
+                        readonly externalId: "Image360";
+                        readonly version: "v1";
+                    };
+                    readonly identifier: "station";
+                };
+                readonly direction: "outwards";
+            };
+            readonly limit: 10000;
+        };
+    };
+    readonly select: {
+        readonly image_collection: {
+            readonly sources: readonly [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_360_image_schema";
+                    readonly externalId: "Image360Collection";
+                    readonly version: "v1";
+                };
+                readonly properties: readonly ["label"];
+            }];
+        };
+        readonly images: {
+            readonly sources: readonly [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_360_image_schema";
+                    readonly externalId: "Image360";
+                    readonly version: "v1";
+                };
+                readonly properties: readonly ["translationX", "translationY", "translationZ", "eulerRotationX", "eulerRotationY", "eulerRotationZ", "scaleX", "scaleY", "scaleZ", "cubeMapFront", "cubeMapBack", "cubeMapLeft", "cubeMapRight", "cubeMapTop", "cubeMapBottom", "collection360", "station", "timeTaken", "label"];
+            }];
+        };
+        readonly stations: {
+            readonly sources: readonly [{
+                readonly source: {
+                    readonly type: "view";
+                    readonly space: "cdf_360_image_schema";
+                    readonly externalId: "Station360";
+                    readonly version: "v1";
+                };
+                readonly properties: readonly ["label"];
+            }];
+        };
+    };
+};
+export type Cdf360FdmQuery = typeof Image360CollectionQuery;
+export declare function get360CollectionQuery(externalId: string, space: string): Cdf360FdmQuery & {
+    parameters: {
+        collectionExternalId: string;
+        collectionSpace: string;
+    };
+};
+export {};

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

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { CogniteClient, Metadata } from '@cognite/sdk';
+import { Historical360ImageSet, Image360DescriptorProvider } from '../../../types';
+export declare class Cdf360EventDescriptorProvider implements Image360DescriptorProvider<Metadata> {
+    private readonly _client;
+    constructor(client: CogniteClient);
+    get360ImageDescriptors(metadataFilter: Metadata, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+    private mergeDescriptors;
+    private listEvents;
+    private listFiles;
+    private sortFileInfoSetByNewest;
+    private parseEventMetadata;
+}