@cognite/reveal 4.19.1 → 4.20.0-dev.20241030

package/dist/packages/360-images/index.d.ts

@@ -15,3 +15,5 @@ export { Image360AnnotationIntersection } from './src/annotation/Image360Annotat
 export { Image360Annotation } from './src/annotation/Image360Annotation';
 export { DefaultImage360Collection } from './src/collection/DefaultImage360Collection';
 export { IconsOptions } from './src/icons/IconCollection';
+export { Image360History } from './src/Image360History';
+export { Image360Action } from './src/Image360Action';

package/dist/packages/360-images/src/Image360Action.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+/**
+ * 360 image action to be used by the CogniteViewer.canDo360Action and do360Action
+ * @beta
+ */
+export declare enum Image360Action {
+    /**
+     * When inside 360 image, forwards on the history list.
+     */
+    Forward = 0,
+    /**
+     * When inside 360 image, backwards on the history list.
+     */
+    Backward = 1,
+    /**
+     * When outside 360 image, go to current in the history list (where you exit from).
+     */
+    Enter = 2,
+    /**
+     * When inside 360, exit.
+     */
+    Exit = 3
+}

package/dist/packages/360-images/src/Image360Facade.d.ts

@@ -8,24 +8,25 @@ import { DefaultImage360Collection } from './collection/DefaultImage360Collectio
 import { IconCullingScheme } from './icons/IconCollection';
 import { Image360RevisionEntity } from './entity/Image360RevisionEntity';
 import { Image360AnnotationFilterOptions } from './annotation/types';
-export declare class Image360Facade<T> {
+import { DataSourceType } from '../../data-providers';
+export declare class Image360Facade<T extends DataSourceType> {
     private readonly _entityFactory;
     private readonly _image360Collections;
     private readonly _rayCaster;
     private readonly _image360Cache;
     private readonly _loadSequencer;
-    get collections(): DefaultImage360Collection[];
+    get collections(): DefaultImage360Collection<T>[];
     set allIconsVisibility(visible: boolean);
     set allIconsSelected(visible: boolean);
-    setHoverIconVisibilityForEntity(entity: Image360Entity, visible: boolean): void;
+    setHoverIconVisibilityForEntity(entity: Image360Entity<T>, visible: boolean): void;
     hideAllHoverIcons(): boolean;
     set allIconCullingScheme(scheme: IconCullingScheme);
     constructor(_entityFactory: Image360CollectionFactory<T>);
-    create(dataProviderFilter: T, annotationFilter?: Image360AnnotationFilterOptions, postTransform?: THREE.Matrix4, preComputedRotation?: boolean): Promise<DefaultImage360Collection>;
-    removeSet(collection: DefaultImage360Collection): void;
-    delete(entity: Image360Entity): Promise<void>;
-    preload(entity: Image360Entity, revision: Image360RevisionEntity, lockDownload?: boolean): Promise<void>;
-    getCollectionContainingEntity(entity: Image360Entity): DefaultImage360Collection;
-    intersect(coords: THREE.Vector2, camera: THREE.Camera): Image360Entity | undefined;
+    create(dataProviderFilter: T['image360Identifier'], annotationFilter?: Image360AnnotationFilterOptions, postTransform?: THREE.Matrix4, preComputedRotation?: boolean): Promise<DefaultImage360Collection<T>>;
+    removeSet(collection: DefaultImage360Collection<T>): void;
+    delete(entity: Image360Entity<T>): Promise<void>;
+    preload(entity: Image360Entity<T>, revision: Image360RevisionEntity<T>, lockDownload?: boolean): Promise<void>;
+    getCollectionContainingEntity(entity: Image360Entity<T>): DefaultImage360Collection<T>;
+    intersect(coords: THREE.Vector2, camera: THREE.Camera): Image360Entity<T> | undefined;
     dispose(): void;
 }

package/dist/packages/360-images/src/Image360History.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { Image360 } from './entity/Image360';
+import { Image360Action } from './Image360Action';
+export declare class Image360History {
+    private readonly _images;
+    private _currentIndex;
+    start(image: Image360): void;
+    private current;
+    clear(): void;
+    private isLegalIndex;
+    canDoAction(action: Image360Action): boolean;
+    doAction(action: Image360Action): Image360 | undefined;
+}

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

@@ -2,15 +2,15 @@
  * Copyright 2023 Cognite AS
  */
 import { Color, Vector3 } from 'three';
-import { AnnotationModel } from '@cognite/sdk';
+import { ClassicDataSourceType, DataSourceType } from '../../../data-providers';
 /**
  * An annotation associated with a 360 image revision
  */
-export interface Image360Annotation {
+export interface Image360Annotation<T extends DataSourceType = ClassicDataSourceType> {
     /**
      * The underlying CDF annotation
      */
-    readonly annotation: AnnotationModel;
+    readonly annotation: T['image360AnnotationType'];
     /**
      * Get the individual display color of this annotation.
      */

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

@@ -2,12 +2,12 @@
  * Copyright 2023 Cognite AS
  */
 import { AnnotationModel } from '@cognite/sdk';
-import { Image360FileDescriptor } from '../../../data-providers';
+import { DataSourceType, Image360FileDescriptor } from '../../../data-providers';
 import { Color, Vector3, Object3D, Raycaster } from 'three';
 import { Image360Annotation } from './Image360Annotation';
 import { Image360AnnotationAppearance } from './types';
 type FaceType = Image360FileDescriptor['face'];
-export declare class ImageAnnotationObject implements Image360Annotation {
+export declare class ImageAnnotationObject<T extends DataSourceType> implements Image360Annotation<T> {
     private readonly _annotation;
     private readonly _mesh;
     private readonly _meshMaterial;
@@ -16,7 +16,7 @@ export declare class ImageAnnotationObject implements Image360Annotation {
     private _defaultAppearance;
     private readonly _appearance;
     get annotation(): AnnotationModel;
-    static createAnnotationObject(annotation: AnnotationModel, face: FaceType): ImageAnnotationObject | undefined;
+    static createAnnotationObject<StaticT extends DataSourceType>(annotation: AnnotationModel, face: FaceType): ImageAnnotationObject<StaticT> | undefined;
     private static createObjectData;
     private static createObjectDetectionAnnotationData;
     private static createAssetLinkAnnotationData;

package/dist/packages/360-images/src/cache/Image360LoadingCache.d.ts

@@ -3,16 +3,17 @@
  */
 import { Image360Entity } from '../entity/Image360Entity';
 import { Image360RevisionEntity } from '../entity/Image360RevisionEntity';
+import { DataSourceType } from '../../../data-providers';
 export type DownloadRequest = {
-    entity: Image360Entity;
-    revision: Image360RevisionEntity;
+    entity: Image360Entity<DataSourceType>;
+    revision: Image360RevisionEntity<DataSourceType>;
     anyCompleted: Promise<void>;
     allCompleted: Promise<void>;
     abort: () => void;
 };
 export type Loaded360Image = {
-    entity: Image360Entity;
-    revision: Image360RevisionEntity;
+    entity: Image360Entity<DataSourceType>;
+    revision: Image360RevisionEntity<DataSourceType>;
 };
 export declare class Image360LoadingCache {
     private readonly _imageCacheSize;
@@ -20,12 +21,12 @@ export declare class Image360LoadingCache {
     private readonly _loaded360Images;
     private readonly _inProgressDownloads;
     private _lockedDownload;
-    get cachedRevisions(): Image360RevisionEntity[];
+    get cachedRevisions(): Image360RevisionEntity<DataSourceType>[];
     get currentlyLoadingEntities(): DownloadRequest[];
-    getDownloadInProgress(revision: Image360RevisionEntity): DownloadRequest | undefined;
+    getDownloadInProgress(revision: Image360RevisionEntity<DataSourceType>): DownloadRequest | undefined;
     constructor(_imageCacheSize?: number, _downloadCacheSize?: number);
-    cachedPreload(entity: Image360Entity, revision: Image360RevisionEntity, lockDownload?: boolean): Promise<void>;
-    purge(entity: Image360Entity): Promise<void>;
+    cachedPreload(entity: Image360Entity<DataSourceType>, revision: Image360RevisionEntity<DataSourceType>, lockDownload?: boolean): Promise<void>;
+    purge(entity: Image360Entity<DataSourceType>): Promise<void>;
     private cacheWhenAllComplete;
     private purgeFromInProgressDownloads;
     private addRevisionToCache;

package/dist/packages/360-images/src/collection/DefaultImage360Collection.d.ts

@@ -8,18 +8,18 @@ import { Image360EnteredDelegate, Image360ExitedDelegate } from '../types';
 import { IconCollection, IconCullingScheme } from '../icons/IconCollection';
 import { Image360AnnotationAppearance } from '../annotation/types';
 import { IdEither } from '@cognite/sdk';
-import { Image360DataProvider } from '../../../data-providers';
+import { DataSourceType, Image360DataProvider } from '../../../data-providers';
 import { Image360AnnotationFilter } from '../annotation/Image360AnnotationFilter';
 import { Matrix4 } from 'three';
 /**
  * Default implementation of {@link Image360Collection}. Used for events when entering
  * and exiting 360 image mode
  */
-export declare class DefaultImage360Collection implements Image360Collection {
+export declare class DefaultImage360Collection<T extends DataSourceType> implements Image360Collection<T> {
     /**
      * A list containing all the 360 images in this set.
      */
-    readonly image360Entities: Image360Entity[];
+    readonly image360Entities: Image360Entity<T>[];
     /**
      * If defined, any subsequently entered 360 images will load the revision that are closest to the target date.
      * If undefined, the most recent revision will be loaded.
@@ -47,7 +47,7 @@ export declare class DefaultImage360Collection implements Image360Collection {
         image360Exited: EventTrigger<Image360ExitedDelegate>;
     };
     get isCollectionVisible(): boolean;
-    constructor(collectionId: string, collectionLabel: string | undefined, entities: Image360Entity[], icons: IconCollection, annotationFilter: Image360AnnotationFilter, image360DataProvider: Image360DataProvider, setNeedsRedraw: () => void);
+    constructor(collectionId: string, collectionLabel: string | undefined, entities: Image360Entity<T>[], icons: IconCollection, annotationFilter: Image360AnnotationFilter, image360DataProvider: Image360DataProvider, setNeedsRedraw: () => void);
     getModelTransformation(out?: Matrix4): Matrix4;
     setModelTransformation(matrix: Matrix4): void;
     /**
@@ -83,7 +83,7 @@ export declare class DefaultImage360Collection implements Image360Collection {
     setSelectedForAll(selected: boolean): void;
     setSelectedVisibility(visible: boolean): boolean;
     setCullingScheme(scheme: IconCullingScheme): void;
-    remove(entity: Image360Entity): void;
+    remove(entity: Image360Entity<T>): void;
     dispose(): void;
     get needsRedraw(): boolean;
     resetRedraw(): void;
@@ -91,7 +91,7 @@ export declare class DefaultImage360Collection implements Image360Collection {
     setDefaultAnnotationStyle(defaultStyle: Image360AnnotationAppearance): void;
     findImageAnnotations(filter: Image360AnnotationAssetFilter): Promise<Image360AnnotationAssetQueryResult[]>;
     getAssetIds(): Promise<IdEither[]>;
-    getAnnotationsInfo(): Promise<AssetAnnotationImage360Info[]>;
+    getAnnotationsInfo(): Promise<AssetAnnotationImage360Info<T>[]>;
     private getAllFileDescriptors;
     private createFileIdToEntityRevisionMap;
 }

package/dist/packages/360-images/src/collection/Image360Collection.d.ts

@@ -7,7 +7,7 @@ import { Image360AnnotationAppearance } from '../annotation/types';
 import { Image360Revision } from '../entity/Image360Revision';
 import { IdEither } from '@cognite/sdk';
 import { Image360Annotation } from '../annotation/Image360Annotation';
-import { ImageAssetLinkAnnotationInfo } from '../../../data-providers';
+import { ClassicDataSourceType, DataSourceType, ImageAssetLinkAnnotationInfo } from '../../../data-providers';
 import { Matrix4 } from 'three';
 /**
  * Filter for finding annotations related to an asset
@@ -21,7 +21,7 @@ export type Image360AnnotationAssetFilter = {
 /**
  * Asset search return type, including information about the image in which the asset is found
  */
-export type AssetAnnotationImage360Info = {
+export type AssetAnnotationImage360Info<T extends DataSourceType = ClassicDataSourceType> = {
     /**
      * Reference to the relevant asset
      */
@@ -29,11 +29,11 @@ export type AssetAnnotationImage360Info = {
     /**
      * The image entity in which the asset was found
      */
-    imageEntity: Image360;
+    imageEntity: Image360<T>;
     /**
      * The image revision in which the asset was found
      */
-    imageRevision: Image360Revision;
+    imageRevision: Image360Revision<T>;
 };
 /**
  * Result item from an asset annotation query
@@ -55,7 +55,7 @@ export type Image360AnnotationAssetQueryResult = {
 /**
  * A wrapper that represents a set of 360 images.
  */
-export interface Image360Collection {
+export interface Image360Collection<T extends DataSourceType = ClassicDataSourceType> {
     /**
      * The id of the collection.
      * @returns The id of the collection.
@@ -69,7 +69,7 @@ export interface Image360Collection {
     /**
      * A list containing all the 360 images in this set.
      */
-    readonly image360Entities: Image360[];
+    readonly image360Entities: Image360<T>[];
     /**
      * If defined, any subsequently entered 360 images will load the revision that are closest to the target date.
      * If undefined, the most recent revision will be loaded.
@@ -170,5 +170,5 @@ export interface Image360Collection {
      *
      * @param source What source data to pull the annotation info from
      */
-    getAnnotationsInfo(source: 'assets'): Promise<AssetAnnotationImage360Info[]>;
+    getAnnotationsInfo(source: 'assets'): Promise<AssetAnnotationImage360Info<T>[]>;
 }

package/dist/packages/360-images/src/collection/Image360CollectionFactory.d.ts

@@ -7,13 +7,14 @@ import { DefaultImage360Collection } from './DefaultImage360Collection';
 import { IconsOptions } from '../icons/IconCollection';
 import { type Matrix4 } from 'three';
 import { Image360AnnotationFilterOptions } from '../annotation/types';
-export declare class Image360CollectionFactory<T> {
+import { GenericDataSourceType } from '../../../data-providers';
+export declare class Image360CollectionFactory<T extends GenericDataSourceType> {
     private readonly _image360DataProvider;
     private readonly _sceneHandler;
     private readonly _onBeforeSceneRendered;
     private readonly _iconsOptions;
     private readonly _device;
     private readonly _setNeedsRedraw;
-    constructor(image360DataProvider: Image360Provider<T>, sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, setNeedsRedraw: () => void, device: DeviceDescriptor, iconsOptions?: IconsOptions);
-    create(dataProviderFilter: T, postTransform: Matrix4, preMultipliedRotation: boolean, annotationFilter: Image360AnnotationFilterOptions): Promise<DefaultImage360Collection>;
+    constructor(image360DataProvider: Image360Provider<T['image360Identifier']>, sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, setNeedsRedraw: () => void, device: DeviceDescriptor, iconsOptions?: IconsOptions);
+    create(dataProviderFilter: T['image360Identifier'], postTransform: Matrix4, preMultipliedRotation: boolean, annotationFilter: Image360AnnotationFilterOptions): Promise<DefaultImage360Collection<T>>;
 }

package/dist/packages/360-images/src/entity/Image360.d.ts

@@ -1,6 +1,7 @@
 /*!
  * Copyright 2022 Cognite AS
  */
+import { ClassicDataSourceType, DataSourceType } from '../../../data-providers';
 import { Image360Revision } from './Image360Revision';
 import { Image360Visualization } from './Image360Visualization';
 import { Color, type Matrix4 } from 'three';
@@ -17,7 +18,7 @@ export type Image360IconStyle = {
  * A single 360 image "station", which may consist of several revisions
  * captured in approximately the same location
  */
-export interface Image360 {
+export interface Image360<T extends DataSourceType = ClassicDataSourceType> {
     /**
      * Get a copy of the model-to-world transformation matrix
      * of the given 360 image.
@@ -43,12 +44,12 @@ export interface Image360 {
      * List all historical images for this entity.
      * @returns A list of available revisions.
      */
-    getRevisions(): Image360Revision[];
+    getRevisions(): Image360Revision<T>[];
     /**
      * Get the revision that is currently loaded for this entry.
      * @returns The active revision.
      */
-    getActiveRevision(): Image360Revision;
+    getActiveRevision(): Image360Revision<T>;
     /**
      * Get a copy of the color assigned to the icon of this entity
      *

package/dist/packages/360-images/src/entity/Image360Entity.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2022 Cognite AS
  */
 import { DeviceDescriptor, SceneHandler } from '../../../utilities';
-import { Image360DataProvider } from '../../../data-providers';
+import { DataSourceType, Image360DataProvider } from '../../../data-providers';
 import { Image360 } from './Image360';
 import { Historical360ImageSet } from '../../../data-providers/src/types';
 import { Image360RevisionEntity } from './Image360RevisionEntity';
@@ -11,7 +11,7 @@ import { ImageAnnotationObject } from '../annotation/ImageAnnotationObject';
 import { Overlay3DIcon } from '../../../3d-overlays';
 import { Image360AnnotationFilter } from '../annotation/Image360AnnotationFilter';
 import { Color, Matrix4, type Raycaster } from 'three';
-export declare class Image360Entity implements Image360 {
+export declare class Image360Entity<T extends DataSourceType> implements Image360<T> {
     private readonly _revisions;
     private readonly _imageMetadata;
     private readonly _modelTransform;
@@ -53,21 +53,21 @@ export declare class Image360Entity implements Image360 {
      * List all historical images for this entity.
      * @returns A list of available revisions.
      */
-    getRevisions(): Image360RevisionEntity[];
+    getRevisions(): Image360RevisionEntity<T>[];
     /**
      * Get the revision that is currently loaded for this entry.
      * @returns Returns the active revision.
      */
-    getActiveRevision(): Image360RevisionEntity;
-    setActiveRevision(revision: Image360RevisionEntity): void;
+    getActiveRevision(): Image360RevisionEntity<T>;
+    setActiveRevision(revision: Image360RevisionEntity<T>): void;
     applyFullResolutionTextures(): Promise<void>;
-    getMostRecentRevision(): Image360RevisionEntity;
+    getMostRecentRevision(): Image360RevisionEntity<T>;
     /**
      * Get the revision closest to the provided date.
      * If all revisions are undated the first available revison is returned.
      */
-    getRevisionClosestToDate(date: Date): Image360RevisionEntity;
-    intersectAnnotations(raycaster: Raycaster): ImageAnnotationObject | undefined;
+    getRevisionClosestToDate(date: Date): Image360RevisionEntity<T>;
+    intersectAnnotations(raycaster: Raycaster): ImageAnnotationObject<T> | undefined;
     /**
      * Drops the GPU resources for the 360 image
      */

package/dist/packages/360-images/src/entity/Image360Revision.d.ts

@@ -2,11 +2,12 @@
  * Copyright 2022 Cognite AS
  */
 import { Image360Annotation } from '../annotation/Image360Annotation';
+import { ClassicDataSourceType, DataSourceType } from '../../../data-providers';
 /**
  * Interface used to manage historical revisions of {@link Image360}.
  * One instance represents one specific image revision.
  */
-export interface Image360Revision {
+export interface Image360Revision<T extends DataSourceType = ClassicDataSourceType> {
     /**
      * The date of this revision. Undefined if the revision is undated.
      * @returns Date | undefined
@@ -15,7 +16,7 @@ export interface Image360Revision {
     /**
      * The annotations associated with this revision.
      */
-    getAnnotations(): Promise<Image360Annotation[]>;
+    getAnnotations(): Promise<Image360Annotation<T>[]>;
     /**
      * Get the thumbnail url for this revision.
      */

package/dist/packages/360-images/src/entity/Image360RevisionEntity.d.ts

@@ -1,14 +1,14 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { Image360DataProvider, Image360Descriptor } from '../../../data-providers';
+import { Image360DataProvider, Image360Descriptor, DataSourceType } from '../../../data-providers';
 import { Image360Revision } from './Image360Revision';
 import { Image360VisualizationBox } from './Image360VisualizationBox';
 import { ImageAnnotationObject } from '../annotation/ImageAnnotationObject';
 import { type Raycaster } from 'three';
 import { Image360AnnotationAppearance } from '../annotation/types';
 import { Image360AnnotationFilter } from '../annotation/Image360AnnotationFilter';
-export declare class Image360RevisionEntity implements Image360Revision {
+export declare class Image360RevisionEntity<T extends DataSourceType> implements Image360Revision<T> {
     private readonly _imageProvider;
     private readonly _image360Descriptor;
     private readonly _image360VisualizationBox;
@@ -25,8 +25,8 @@ export declare class Image360RevisionEntity implements Image360Revision {
      * @returns Date | undefined
      */
     get date(): Date | undefined;
-    getAnnotations(): Promise<ImageAnnotationObject[]>;
-    intersectAnnotations(raycaster: Raycaster): ImageAnnotationObject | undefined;
+    getAnnotations(): Promise<ImageAnnotationObject<T>[]>;
+    intersectAnnotations(raycaster: Raycaster): ImageAnnotationObject<T> | undefined;
     /**
      * Loads the textures needed for the 360 image (6 faces).
      *

package/dist/packages/360-images/src/entity/Image360VisualizationBox.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { DeviceDescriptor, SceneHandler } from '../../../utilities';
-import { Image360Face, Image360Texture } from '../../../data-providers';
+import { DataSourceType, Image360Face, Image360Texture } from '../../../data-providers';
 import { Image360Visualization } from './Image360Visualization';
 import { ImageAnnotationObject } from '../annotation/ImageAnnotationObject';
 export declare const DEFAULT_IMAGE_360_OPACITY = 1;
@@ -25,7 +25,7 @@ export declare class Image360VisualizationBox implements Image360Visualization {
     set opacity(value: number);
     set scale(value: THREE.Vector3);
     set renderOrder(value: number);
-    setAnnotations(annotations: ImageAnnotationObject[]): void;
+    setAnnotations(annotations: ImageAnnotationObject<DataSourceType>[]): void;
     constructor(worldTransform: THREE.Matrix4, sceneHandler: SceneHandler, device: DeviceDescriptor);
     setWorldTransform(matrix: THREE.Matrix4): void;
     loadImages(textures: Image360Texture[]): void;

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

@@ -4,11 +4,12 @@
 import { type Matrix4 } 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 { DataSourceType, Image360DataModelIdentifier } from '../../../data-providers';
 import { BeforeSceneRenderedDelegate, EventTrigger, InputHandler, PointerEventData, SceneHandler } from '../../../utilities';
 import { ProxyCameraManager } from '../../../camera-manager';
 import { Image360WithCollection } from '../public/types';
-export declare class Image360ApiHelper {
+import { Image360Action } from '../../../360-images/src/Image360Action';
+export declare class Image360ApiHelper<DataSourceT extends DataSourceType> {
     private readonly _image360Facade;
     private readonly _domElement;
     private _transitionInProgress;
@@ -16,36 +17,39 @@ export declare class Image360ApiHelper {
     private _needsRedraw;
     private readonly _hasEventListeners;
     private readonly _inputHandler?;
+    private readonly _history;
     private readonly _interactionState;
     private readonly _debouncePreLoad;
     private readonly _activeCameraManager;
     private readonly _stationaryCameraManager;
     private readonly _onBeforeSceneRenderedEvent;
     private _cachedCameraManager;
-    private readonly exit360ImageOnEscapeKey;
-    readonly setHoverIconEventHandler: (event: MouseEvent) => void;
-    readonly enter360ImageHandler: (event: PointerEventData) => Promise<boolean>;
+    private readonly onKeyPressed;
+    readonly onHover: (event: MouseEvent) => void;
+    readonly onClick: (event: PointerEventData) => Promise<boolean>;
     private readonly updateHoverStateOnRenderHandler;
     constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, hasEventListeners?: boolean, iconsOptions?: IconsOptions);
     get needsRedraw(): boolean;
     resetRedraw(): void;
-    add360ImageSet(collectionIdentifier: Metadata | Image360DataModelIdentifier, collectionTransform: Matrix4, preMultipliedRotation: boolean, annotationOptions?: Image360AnnotationFilterOptions): Promise<Image360Collection>;
-    getImageCollections(): Image360Collection[];
+    add360ImageSet(collectionIdentifier: Metadata | Image360DataModelIdentifier, collectionTransform: Matrix4, preMultipliedRotation: boolean, annotationOptions?: Image360AnnotationFilterOptions): Promise<Image360Collection<DataSourceT>>;
+    getImageCollections(): Image360Collection<DataSourceT>[];
     remove360Images(entities: Image360[]): Promise<void>;
-    remove360ImageCollection(collection: Image360Collection): void;
-    getCurrentlyEnteredImageInfo(): Image360WithCollection | undefined;
-    enter360Image(image360Entity: Image360Entity, revision?: Image360RevisionEntity): Promise<void>;
-    enter360ImageInternal(image360Entity: Image360Entity, revision?: Image360RevisionEntity): Promise<boolean>;
+    remove360ImageCollection(collection: Image360Collection<DataSourceT>): void;
+    getCurrentlyEnteredImageInfo(): Image360WithCollection<DataSourceT> | undefined;
+    enter360Image(image360Entity: Image360Entity<DataSourceT>, revision?: Image360RevisionEntity<DataSourceT>): Promise<void>;
+    enter360ImageInternal(image360Entity: Image360Entity<DataSourceT>, revision?: Image360RevisionEntity<DataSourceT>, updateHistory?: boolean): Promise<boolean>;
     private applyFullResolutionTextures;
     private transition;
     private tweenVisualizationAlpha;
     private tweenVisualizationZoom;
     private setStationaryCameraManager;
     exit360Image(): void;
+    canDoAction(action: Image360Action): boolean;
+    doAction(action: Image360Action): Promise<void>;
     dispose(): void;
     private findRevisionIdToEnter;
     private enter360ImageOnIntersect;
-    intersect360ImageIcons(offsetX: number, offsetY: number): Image360Entity | undefined;
+    intersect360ImageIcons(offsetX: number, offsetY: number): Image360Entity<DataSourceT> | undefined;
     intersect360ImageAnnotations(offsetX: number, offsetY: number): Image360AnnotationIntersection | undefined;
     private setHoverIconOnIntersect;
     private exit360ImageOnEscape;

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

@@ -10,7 +10,8 @@ import { CadManager, CadModelBudget } from '../../../cad-geometry-loaders';
 import { NodeAppearanceProvider } from '../../../cad-styling';
 import { RenderMode, RenderPipelineExecutor, CadMaterialManager, RenderPipelineProvider, ResizeHandler, SettableRenderTarget } from '../../../rendering';
 import { CameraManager } from '../../../camera-manager';
-import { ModelIdentifier } from '../../../data-providers';
+import { DataSourceType, InternalDataSourceType } from '../../../data-providers';
+import { AddModelOptionsWithModelRevisionId } from '../../../data-providers/src/utilities/internalAddModelOptions';
 export type AddCadModelOptions = {
     nodeAppearanceProvider?: NodeAppearanceProvider;
     geometryFilter?: GeometryFilter;
@@ -55,8 +56,8 @@ export declare class RevealManager {
     setResolutionThreshold(threshold: number): void;
     setMovingCameraResolutionFactor(factor: number): void;
     render(camera: THREE.PerspectiveCamera): void;
-    addModel(type: 'cad', modelIdentifier: ModelIdentifier, options?: AddCadModelOptions): Promise<CadNode>;
-    addModel(type: 'pointcloud', modelIdentifier: ModelIdentifier): Promise<PointCloudNode>;
+    addModel<T extends InternalDataSourceType>(type: 'cad', modelIdentifier: AddModelOptionsWithModelRevisionId<T>, options?: AddCadModelOptions): Promise<CadNode>;
+    addModel<T extends DataSourceType>(type: 'pointcloud', modelIdentifier: AddModelOptionsWithModelRevisionId<T>): Promise<PointCloudNode<T>>;
     removeModel(type: 'cad', model: CadNode): void;
     removeModel(type: 'pointcloud', model: PointCloudNode): void;
     private notifyLoadingStateChanged;