@cognite/reveal 3.2.0 → 4.0.0-dev.20221025

package/packages/cad-parsers/src/metadata/types.d.ts

@@ -38,7 +38,6 @@ export declare type BaseSectorMetadata = {
     readonly estimatedRenderCost: number;
 };
 export declare type SectorMetadata = BaseSectorMetadata & (I3dF3dSectorMetadata | GltfSectorMetadata);
-export declare type V8SectorMetadata = BaseSectorMetadata & I3dF3dSectorMetadata;
 export declare type V9SectorMetadata = BaseSectorMetadata & GltfSectorMetadata;
 export declare type I3dF3dSectorMetadata = {
     readonly indexFile: SectorMetadataIndexFileSection;

package/packages/cad-parsers/src/utilities/computeBoundingBoxFromAttributes.d.ts

@@ -2,9 +2,13 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { ParsePrimitiveAttribute } from '@cognite/reveal-parser-worker';
+declare type ParsePrimitiveAttribute = {
+    offset: number;
+    size: number;
+};
 export declare function computeBoundingBoxFromCenterAndRadiusAttributes(attributeFloatValues: Float32Array, centerAByteOffset: number, centerBByteOffset: number, radiusAByteOffset: number, radiusBByteOffset: number, elementSize: number, elementIndex: number, out: THREE.Box3): THREE.Box3;
 export declare function computeBoundingBoxFromVertexAttributes(vertex1AttributeByteOffset: number, vertex2AttributeByteOffset: number, vertex3AttributeByteOffset: number, vertex4AttributeByteOffset: number, attributeFloatValues: Float32Array, elementSize: number, elementIndex: number, out: THREE.Box3): THREE.Box3;
 export declare function computeBoundingBoxFromInstanceMatrixAttributes(attributeFloatValues: Float32Array, byteOffset: number, elementSize: number, elementIndex: number, baseBoundingBox: THREE.Box3, out: THREE.Box3): THREE.Box3;
 export declare function computeBoundingBoxFromEllipseValues(radius1: number, radius2: number, height: number, center: THREE.Vector3, out: THREE.Box3): THREE.Box3;
 export declare function computeBoundingBoxFromEllipseAttributes(centerAttribute: ParsePrimitiveAttribute, radius1Attribute: ParsePrimitiveAttribute, radius2Attribute: ParsePrimitiveAttribute, heightAttribute: ParsePrimitiveAttribute, attributeFloatValues: Float32Array, elementSize: number, elementIndex: number, out: THREE.Box3): THREE.Box3;
+export {};

package/packages/cad-styling/index.d.ts

@@ -6,11 +6,12 @@ export { NodeCollection } from './src/NodeCollection';
 export { SerializedNodeCollection } from './src/SerializedNodeCollection';
 export { TreeIndexNodeCollection } from './src/TreeIndexNodeCollection';
 export { UnionNodeCollection } from './src/UnionNodeCollection';
+export { NodeIdNodeCollection } from './src/NodeIdNodeCollection';
 export { PropertyFilterNodeCollection } from './src/PropertyFilterNodeCollection';
 export { SinglePropertyFilterNodeCollection } from './src/SinglePropertyFilterNodeCollection';
 export { AssetNodeCollection } from './src/AssetNodeCollection';
 export { InvertedNodeCollection } from './src/InvertedNodeCollection';
-export { registerCustomNodeCollectionType, TypeName, NodeCollectionDescriptor, NodeCollectionSerializationContext, NodeCollectionDeserializer } from './src/NodeCollectionDeserializer';
+export { registerNodeCollectionType, NodeCollectionSerializationContext, NodeCollectionDeserializer } from './src/NodeCollectionDeserializer';
 export { NodeAppearance, DefaultNodeAppearance, NodeOutlineColor } from './src/NodeAppearance';
 export { NodeAppearanceProvider } from './src/NodeAppearanceProvider';
 export { CdfModelNodeCollectionDataProvider } from './src/CdfModelNodeCollectionDataProvider';

package/packages/cad-styling/src/CdfNodeCollectionBase.d.ts

@@ -0,0 +1,20 @@
+import { ListResponse, Node3D } from '@cognite/sdk';
+import { AreaCollection } from './prioritized/AreaCollection';
+import { NodeCollection } from './NodeCollection';
+import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
+import { IndexSet } from '../../utilities';
+export declare abstract class CdfNodeCollectionBase extends NodeCollection {
+    private _indexSet;
+    private _areas;
+    private readonly _boundsMapper;
+    private _fetchResultHelper;
+    constructor(classToken: string, model: CdfModelNodeCollectionDataProvider);
+    get isLoading(): boolean;
+    protected updateCollectionFromResults(requests: Promise<ListResponse<Node3D[]>>[]): Promise<void>;
+    /**
+     * Clears the node collection and interrupts any ongoing operations.
+     */
+    clear(): void;
+    getIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
+}

package/packages/cad-styling/src/NodeCollectionDeserializer.d.ts

@@ -4,23 +4,18 @@
 import { CogniteClient } from '@cognite/sdk';
 import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
 import { NodeCollection } from './NodeCollection';
-export declare type TypeName = string;
+import { SerializedNodeCollection } from './SerializedNodeCollection';
 export declare type NodeCollectionSerializationContext = {
     client: CogniteClient;
     model: CdfModelNodeCollectionDataProvider;
 };
-export declare type NodeCollectionDescriptor = {
-    token: TypeName;
-    state: any;
-    options?: any;
-};
 export declare class NodeCollectionDeserializer {
     static readonly Instance: NodeCollectionDeserializer;
     private readonly _types;
     private constructor();
-    registerNodeCollectionType<T extends NodeCollection>(nodeCollectionType: TypeName, deserializer: (descriptor: NodeCollectionDescriptor, context: NodeCollectionSerializationContext) => Promise<T>): void;
-    deserialize(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, descriptor: NodeCollectionDescriptor): Promise<NodeCollection>;
+    registerNodeCollectionType<T extends NodeCollection>(nodeCollectionTypeName: string, deserializer: (descriptor: SerializedNodeCollection, context: NodeCollectionSerializationContext) => Promise<T>): void;
+    deserialize(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, descriptor: SerializedNodeCollection): Promise<NodeCollection>;
     private getDeserializer;
     private registerWellKnownNodeCollectionTypes;
 }
-export declare function registerCustomNodeCollectionType<T extends NodeCollection>(nodeCollectionType: TypeName, deserializer: (descriptor: NodeCollectionDescriptor, context: NodeCollectionSerializationContext) => Promise<T>): void;
+export declare function registerNodeCollectionType<T extends NodeCollection>(nodeCollectionTypeName: string, deserializer: (descriptor: SerializedNodeCollection, context: NodeCollectionSerializationContext) => Promise<T>): void;

package/packages/cad-styling/src/NodeIdNodeCollection.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
+import { CdfNodeCollectionBase } from './CdfNodeCollectionBase';
+import { NodeCollectionSerializationContext } from './NodeCollectionDeserializer';
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+/**
+ * Collection that holds a set of nodes including children identified by nodeIds. Note that
+ * this involves remapping IDs to "tree indices" and subtree sized used by Reveal using
+ * the CDF API. Its often better to use one of the other node collections or {@see TreeIndexNodeCollection}
+ * whenever possible for best performance.
+ */
+export declare class NodeIdNodeCollection extends CdfNodeCollectionBase {
+    static readonly classToken = "NodeIdNodeCollection";
+    private readonly _client;
+    private readonly _model;
+    private _nodeIds;
+    constructor(client: CogniteClient, model: CdfModelNodeCollectionDataProvider);
+    /**
+     * Populates the collection with the nodes with the IDs provided. All children of
+     * the nodes are also included in the collection.
+     * @param nodeIds IDs of nodes to include in the collection.
+     * @returns Promise that resolves when the collection is populated.
+     */
+    executeFilter(nodeIds: number[]): Promise<void>;
+    serialize(): SerializedNodeCollection;
+    static deserialize(descriptor: SerializedNodeCollection, context: NodeCollectionSerializationContext): Promise<NodeIdNodeCollection>;
+}

package/packages/cad-styling/src/PropertyFilterNodeCollection.d.ts

@@ -2,11 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import { CogniteClient } from '@cognite/sdk';
-import { AreaCollection } from './prioritized/AreaCollection';
-import { NodeCollection } from './NodeCollection';
 import { SerializedNodeCollection } from './SerializedNodeCollection';
 import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
-import { IndexSet } from '../../utilities';
+import { CdfNodeCollectionBase } from './CdfNodeCollectionBase';
 /**
  * Options for {@link PropertyFilterNodeCollection}.
  */
@@ -22,17 +20,13 @@ export declare type PropertyFilterNodeCollectionOptions = {
  * Represents a set of nodes that has matching node properties to a provided filter. Note that
  * a node is considered to match if it or a {@link NodeCollection} ancestors match the filter.
  */
-export declare class PropertyFilterNodeCollection extends NodeCollection {
+export declare class PropertyFilterNodeCollection extends CdfNodeCollectionBase {
     static readonly classToken = "PropertyFilterNodeCollection";
     private readonly _client;
-    private _indexSet;
-    private _areas;
     private readonly _model;
     private readonly _options;
-    private _fetchResultHelper;
-    private _filter;
+    private readonly _filter;
     constructor(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, options?: PropertyFilterNodeCollectionOptions);
-    get isLoading(): boolean;
     /**
      * Populates the node collection with nodes matching the provided filter. This will replace
      * the current nodes held by the filter.
@@ -47,11 +41,5 @@ export declare class PropertyFilterNodeCollection extends NodeCollection {
             [key: string]: string;
         };
     }): Promise<void>;
-    /**
-     * Clears the node collection and interrupts any ongoing operations.
-     */
-    clear(): void;
-    getIndexSet(): IndexSet;
-    getAreas(): AreaCollection;
     serialize(): SerializedNodeCollection;
 }

package/packages/cad-styling/src/SinglePropertyFilterNodeCollection.d.ts

@@ -2,26 +2,21 @@
  * Copyright 2021 Cognite AS
  */
 import { PropertyFilterNodeCollectionOptions } from './PropertyFilterNodeCollection';
-import { IndexSet } from '../../utilities';
-import { AreaCollection } from './prioritized/AreaCollection';
-import { NodeCollection } from './NodeCollection';
 import { SerializedNodeCollection } from './SerializedNodeCollection';
 import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
 import { CogniteClient } from '@cognite/sdk';
+import { CdfNodeCollectionBase } from './CdfNodeCollectionBase';
 /**
  * Node collection that filters nodes based on a node property from a list of values, similarly to how
  * `SELECT ... IN (...)` works. This is useful when looking up nodes based on a list of identifiers,
  * nodes within a set of areas or systems. The node set is optimized for matching with properties with
  * a large number of values (i.e. thousands).
  */
-export declare class SinglePropertyFilterNodeCollection extends NodeCollection {
+export declare class SinglePropertyFilterNodeCollection extends CdfNodeCollectionBase {
     static readonly classToken = "SinglePropertyNodeCollection";
     private readonly _client;
     private readonly _model;
-    private _indexSet;
-    private _areas;
     private readonly _options;
-    private _fetchResultHelper;
     private readonly _filter;
     /**
      * Construct a new node set.
@@ -30,7 +25,6 @@ export declare class SinglePropertyFilterNodeCollection extends NodeCollection {
      * @param options
      */
     constructor(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, options?: PropertyFilterNodeCollectionOptions);
-    get isLoading(): boolean;
     /**
      * Execute filter asynchronously, replacing any existing filter active. When {@link propertyValues}
      * contains more than 1000 elements, the operation will be split into multiple batches that
@@ -42,12 +36,6 @@ export declare class SinglePropertyFilterNodeCollection extends NodeCollection {
      * @param propertyValues Lookup values, e.g. `["AR100APG539","AP500INF534","AP400INF553", ...]`
      */
     executeFilter(propertyCategory: string, propertyKey: string, propertyValues: string[]): Promise<void>;
-    /**
-     * Clears the node set and interrupts any ongoing operations.
-     */
-    clear(): void;
-    getIndexSet(): IndexSet;
-    getAreas(): AreaCollection;
     private buildUrl;
     serialize(): SerializedNodeCollection;
 }

package/packages/cad-styling/src/TreeIndexNodeCollection.d.ts

@@ -17,6 +17,8 @@ export declare class TreeIndexNodeCollection extends NodeCollection {
     constructor(treeIndices?: Iterable<number>);
     constructor(treeIndexRange?: NumericRange);
     updateSet(treeIndices: IndexSet): void;
+    updateSet(treeIndices: NumericRange): void;
+    updateSet(treeIndices: Iterable<number>): void;
     /**
      * Sets this set to hold an empty set.
      */

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

@@ -2,6 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 export { DefaultCameraManager } from './src/DefaultCameraManager';
+export { ProxyCameraManager } from './src/ProxyCameraManager';
+export { StationaryCameraManager } from './src/StationaryCameraManager';
 export { CameraManagerHelper } from './src/CameraManagerHelper';
 export { CameraManager } from './src/CameraManager';
 export { ComboControls } from './src/ComboControls';

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

@@ -54,13 +54,12 @@ export declare class ComboControls extends EventDispatcher {
     private _sphericalEnd;
     private readonly _deltaTarget;
     private readonly _rawCameraRotation;
-    private _keyboard;
+    private readonly _keyboard;
     private readonly _offsetVector;
     private readonly _panVector;
     private readonly _raycaster;
     private readonly _targetFPS;
     private _targetFPSOverActualFPS;
-    private _isFocused;
     constructor(camera: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
     update: (deltaTime: number, forceUpdate?: boolean) => boolean;
     getState: () => {
@@ -87,7 +86,6 @@ export declare class ComboControls extends EventDispatcher {
     private readonly onMouseWheel;
     private readonly onTouchStart;
     private readonly onFocusChanged;
-    private readonly isDescendant;
     private readonly onContextMenu;
     private readonly rotate;
     private readonly startMouseRotation;

package/packages/camera-manager/src/Keyboard.d.ts

@@ -4,9 +4,10 @@
 export default class Keyboard {
     private keys;
     private _disabled;
+    private readonly _domElement;
     get disabled(): boolean;
     set disabled(isDisabled: boolean);
-    constructor();
+    constructor(domElement: HTMLElement);
     isPressed(key: string): boolean;
     comsumePressed(key: string): boolean;
     dispose(): void;

package/packages/camera-manager/src/ProxyCameraManager.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { CameraManager } from './CameraManager';
+import { CameraChangeDelegate, CameraState } from './types';
+export declare class ProxyCameraManager implements CameraManager {
+    private readonly _cameraChangedListeners;
+    private _activeCameraManager;
+    private readonly _activeCameraEventHandler;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    get innerCameraManager(): CameraManager;
+    constructor(initialActiveCamera: CameraManager);
+    setActiveCameraManager(cameraManager: CameraManager, preserveCameraState?: boolean): void;
+    getCamera(): THREE.PerspectiveCamera;
+    setCameraState(state: CameraState): void;
+    getCameraState(): Required<CameraState>;
+    on(_: 'cameraChange', callback: CameraChangeDelegate): void;
+    off(_: 'cameraChange', callback: CameraChangeDelegate): void;
+    fitCameraToBoundingBox(boundingBox: THREE.Box3, duration?: number | undefined, radiusFactor?: number | undefined): void;
+    update(deltaTime: number, boundingBox: THREE.Box3): void;
+    dispose(): void;
+    private onActiveCameraManagerEventFired;
+}

package/packages/camera-manager/src/StationaryCameraManager.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { CameraManager } from './CameraManager';
+import { CameraChangeDelegate, CameraState } from './types';
+export declare class StationaryCameraManager implements CameraManager {
+    private readonly _camera;
+    private readonly _cameraChangedListener;
+    private readonly _domElement;
+    private _isEnabled;
+    private _isDragging;
+    constructor(domElement: HTMLElement, camera: THREE.PerspectiveCamera);
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    getCamera(): THREE.PerspectiveCamera;
+    setCameraState(state: CameraState): void;
+    getCameraState(): Required<CameraState>;
+    on(_: 'cameraChange', callback: CameraChangeDelegate): void;
+    off(_: 'cameraChange', callback: CameraChangeDelegate): void;
+    fitCameraToBoundingBox(boundingBox: THREE.Box3, _?: number, radiusFactor?: number): void;
+    update(_: number, boundingBox: THREE.Box3): void;
+    dispose(): void;
+    private enableDragging;
+    private disableDragging;
+    private rotateCamera;
+}

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

@@ -0,0 +1,21 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+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 { LocalModelDataProvider } from './src/model-data-providers/LocalModelDataProvider';
+export { LocalModelIdentifier } from './src/model-identifiers/LocalModelIdentifier';
+export { LocalModelMetadataProvider } from './src/metadata-providers/LocalModelMetadataProvider';
+export { Local360ImageProvider } from './src/image-360-data-providers/Local360ImageProvider';
+export { ModelIdentifier } from './src/ModelIdentifier';
+export { ModelMetadataProvider } from './src/ModelMetadataProvider';
+export { ModelDataProvider } from './src/ModelDataProvider';
+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 { Image360Provider } from './src/Image360Provider';
+export { BinaryFileProvider, JsonFileProvider, File3dFormat, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face } from './src/types';

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

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { Image360DescriptorProvider, Image360FileProvider } from './types';
+export interface Image360Provider<T> extends Image360DescriptorProvider<T>, Image360FileProvider {
+}

package/packages/data-providers/src/ModelDataProvider.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { BinaryFileProvider, JsonFileProvider } from './types';
+/**
+ * Provides data for 3D models.
+ */
+export interface ModelDataProvider extends JsonFileProvider, BinaryFileProvider {
+    /**
+     * Download and parse a JSON file and return the resulting struct.
+     * @param baseUrl     Base URL of the model.
+     * @param fileName    Filename of JSON file.
+     */
+    getJsonFile(baseUrl: string, fileName: string): Promise<any>;
+    /**
+     * Downloads a binary blob.
+     * @param baseUrl     Base URL of the model.
+     * @param fileName    Filename of binary file.
+     */
+    getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
+}

package/packages/data-providers/src/PointCloudStylableObjectProvider.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { ModelIdentifier } from './ModelIdentifier';
+import { PointCloudObject } from './pointcloud-stylable-object-providers/types';
+export interface PointCloudStylableObjectProvider {
+    getPointCloudObjects(modelIdentifier: ModelIdentifier): Promise<PointCloudObject[]>;
+}

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

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { CogniteClient, Metadata } from '@cognite/sdk';
+import { Image360Descriptor, Image360Face } from '../types';
+import { Image360Provider } from '../Image360Provider';
+export declare class Cdf360ImageEventProvider implements Image360Provider<Metadata> {
+    private readonly _client;
+    constructor(client: CogniteClient);
+    get360ImageDescriptors(metadataFilter: Metadata): Promise<Image360Descriptor[]>;
+    get360ImageFiles(image360Descriptor: Image360Descriptor): Promise<Image360Face[]>;
+    private getFileInfos;
+    private getFileBuffers;
+    private parseEventMetadata;
+    get360ImageFaces(): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import { Image360Provider } from '../Image360Provider';
+import { Image360Descriptor, Image360Face } from '../types';
+export declare class Local360ImageProvider implements Image360Provider<unknown> {
+    private readonly _modelUrl;
+    constructor(modelUrl: string);
+    get360ImageDescriptors(): Promise<Image360Descriptor[]>;
+    get360ImageFiles(image360Descriptor: Image360Descriptor): Promise<Image360Face[]>;
+}

package/packages/{modeldata-api/src → data-providers/src/metadata-providers}/CdfModelMetadataProvider.d.ts

@@ -2,10 +2,10 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { BlobOutputMetadata, File3dFormat } from './types';
-import { ModelMetadataProvider } from './ModelMetadataProvider';
+import { BlobOutputMetadata, File3dFormat } from '../types';
+import { ModelMetadataProvider } from '../ModelMetadataProvider';
 import { CogniteClient } from '@cognite/sdk';
-import { ModelIdentifier } from './ModelIdentifier';
+import { ModelIdentifier } from '../ModelIdentifier';
 export declare class CdfModelMetadataProvider implements ModelMetadataProvider {
     private readonly _client;
     constructor(client: CogniteClient);

package/packages/{modeldata-api/src → data-providers/src/metadata-providers}/LocalModelMetadataProvider.d.ts

@@ -2,9 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { ModelIdentifier } from './ModelIdentifier';
-import { ModelMetadataProvider } from './ModelMetadataProvider';
-import { BlobOutputMetadata, File3dFormat } from './types';
+import { ModelIdentifier } from '../ModelIdentifier';
+import { ModelMetadataProvider } from '../ModelMetadataProvider';
+import { BlobOutputMetadata, File3dFormat } from '../types';
 export declare class LocalModelMetadataProvider implements ModelMetadataProvider {
     getModelUri(modelIdentifier: ModelIdentifier): Promise<string>;
     getModelMatrix(modelIdentifier: ModelIdentifier, format: File3dFormat): Promise<THREE.Matrix4>;

package/packages/{modeldata-api/src → data-providers/src/model-data-providers}/CdfModelDataProvider.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import { CogniteClient } from '@cognite/sdk';
-import { ModelDataProvider } from './types';
+import { ModelDataProvider } from '../ModelDataProvider';
 /**
  * Provides 3D V2 specific extensions for the standard CogniteClient used by Reveal.
  */

package/packages/{modeldata-api/src → data-providers/src/model-data-providers}/LocalModelDataProvider.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { ModelDataProvider } from './types';
+import { ModelDataProvider } from '../ModelDataProvider';
 export declare class LocalModelDataProvider implements ModelDataProvider {
     getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;

package/packages/{modeldata-api/src → data-providers/src/model-identifiers}/CdfModelIdentifier.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { ModelIdentifier } from '..';
+import { ModelIdentifier } from '../..';
 /**
  * Identifies a 3D model stored in CDF by the combination of a modelId, a revisionId
  * and a format.

package/packages/{modeldata-api/src → data-providers/src/model-identifiers}/LocalModelIdentifier.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { ModelIdentifier } from './ModelIdentifier';
+import { ModelIdentifier } from '../ModelIdentifier';
 /**
  * Identifies a 3D model by a URL. This implementation is used for testing
  * purposes.

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

@@ -0,0 +1,14 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { ModelIdentifier } from '../ModelIdentifier';
+import { PointCloudObject } from './types';
+import { PointCloudStylableObjectProvider } from '../PointCloudStylableObjectProvider';
+export declare class CdfPointCloudStylableObjectProvider implements PointCloudStylableObjectProvider {
+    private readonly _sdk;
+    constructor(sdk: CogniteClient);
+    private annotationGeometryToRevealShapes;
+    private fetchAnnotations;
+    getPointCloudObjects(modelIdentifier: ModelIdentifier): Promise<PointCloudObject[]>;
+}

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

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { ModelIdentifier } from '../../../data-providers';
+import { PointCloudStylableObjectProvider } from '../PointCloudStylableObjectProvider';
+import { PointCloudObject } from './types';
+export declare class DummyPointCloudStylableObjectProvider implements PointCloudStylableObjectProvider {
+    getPointCloudObjects(_modelIdentifier: ModelIdentifier): Promise<PointCloudObject[]>;
+}

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

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { ISerializableShape, IShape } from '../../../utilities';
+export declare type StylableObject = {
+    objectId: number;
+    shape: IShape;
+};
+export declare type SerializableStylableObject = {
+    objectId: number;
+    shape: ISerializableShape;
+};

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

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { PointCloudObject, CdfPointCloudObjectAnnotation } from './types';
+export declare function cdfAnnotationsToObjectInfo(annotations: CdfPointCloudObjectAnnotation[]): PointCloudObject[];

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

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { StylableObject } from './StylableObject';
+import { IShape } from '../../../utilities';
+import { Box3 } from 'three';
+export declare type CdfPointCloudObjectAnnotation = {
+    annotationId: number;
+    assetId?: number;
+    region: IShape[];
+};
+export declare type PointCloudObjectMetadata = {
+    annotationId: number;
+    assetId?: number;
+    boundingBox: Box3;
+};
+export declare type PointCloudObject = PointCloudObjectMetadata & {
+    stylableObject: StylableObject;
+};

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

@@ -0,0 +1,44 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+export interface JsonFileProvider {
+    getJsonFile(baseUrl: string, fileName: string): Promise<any>;
+}
+export interface BinaryFileProvider {
+    getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
+}
+export interface Image360DescriptorProvider<T> {
+    get360ImageDescriptors(metadataFilter: T): Promise<Image360Descriptor[]>;
+}
+export interface Image360FileProvider {
+    get360ImageFiles(image360Descriptor: Image360Descriptor): Promise<Image360Face[]>;
+}
+export declare type Image360Descriptor = {
+    id: string;
+    label: string;
+    collectionId: string;
+    collectionLabel: string;
+    transformations: {
+        translation: THREE.Matrix4;
+        rotation: THREE.Matrix4;
+    };
+};
+export declare type Image360Face = {
+    face: 'front' | 'back' | 'left' | 'right' | 'top' | 'bottom';
+    mimeType: 'image/jpeg' | 'image/png';
+    data: ArrayBuffer;
+};
+export declare enum File3dFormat {
+    EptPointCloud = "ept-pointcloud",
+    /**
+     * Reveal v9 and above (GLTF based output)
+     */
+    GltfCadModel = "gltf-directory",
+    AnyFormat = "all-outputs"
+}
+export interface BlobOutputMetadata {
+    blobId: number;
+    format: File3dFormat | string;
+    version: number;
+}

package/packages/{modeldata-api/src → data-providers/src/utilities}/applyDefaultModelTransformation.d.ts

@@ -2,5 +2,5 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { File3dFormat } from './types';
+import { File3dFormat } from '../types';
 export declare function applyDefaultModelTransformation(matrix: THREE.Matrix4, format: File3dFormat | string): void;

package/packages/{modeldata-api/src/utilities.d.ts → data-providers/src/utilities/fetchWithStatusCheck.d.ts}

@@ -1,7 +1,5 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { Versioned3DFile } from '@cognite/sdk';
 export declare const supportedVersions: number[];
-export declare function getNewestVersionedFile(files: Versioned3DFile[]): Versioned3DFile;
 export declare function fetchWithStatusCheck(url: string): Promise<Response>;

package/packages/data-source/src/CdfDataSource.d.ts

@@ -4,7 +4,7 @@
 import { CogniteClient } from '@cognite/sdk';
 import { DataSource } from './DataSource';
 import { NodesApiClient } from '../../nodes-api';
-import { ModelDataProvider, ModelMetadataProvider } from '../../modeldata-api';
+import { ModelDataProvider, ModelMetadataProvider } from '../../data-providers';
 /**
  * Data source for Cognite Data Fusion.
  */