@cognite/reveal 3.0.0-alpha.2 → 3.0.0

package/{core/src/public/migration → packages/cad-model/src}/Cognite3DModel.d.ts

@@ -1,340 +1,337 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { CogniteInternalId } from '@cognite/sdk';
-import { CameraConfiguration } from './types';
-import { CogniteModelBase } from './CogniteModelBase';
-import { SupportedModelTypes } from '../types';
-import { WellKnownUnit } from './types';
-import { NumericRange } from '../../../../packages/utilities';
-import { NodeCollectionBase, NodeAppearance } from '../../../../packages/cad-styling';
-/**
- * Represents a single 3D CAD model loaded from CDF.
- * @noInheritDoc
- * @module @cognite/reveal
- */
-export declare class Cognite3DModel extends THREE.Object3D implements CogniteModelBase {
-    readonly type: SupportedModelTypes;
-    /**
-     * Returns the unit the coordinates for the model is stored. Returns an empty string
-     * if no unit has been stored.
-     * Note that coordinates in Reveal always are converted to meters using {@see modelUnitToMetersFactor}.
-     */
-    get modelUnit(): WellKnownUnit | '';
-    /**
-     * Returns the conversion factor that converts from model coordinates to meters. Note that this can
-     * return undefined if the model has been stored in an unsupported unit.
-     */
-    get modelUnitToMetersFactor(): number | undefined;
-    /**
-     * The CDF model ID of the model.
-     */
-    readonly modelId: number;
-    /**
-     * The CDF revision ID of the model.
-     */
-    readonly revisionId: number;
-    private readonly cadModel;
-    private readonly nodesApiClient;
-    private readonly nodeIdAndTreeIndexMaps;
-    private readonly _styledNodeCollections;
-    /**
-     * Sets the default appearance for nodes that are not styled using
-     * {@link assignStyledNodeCollection}. Updating the default style can be an
-     * expensive operation, so use with care.
-     *
-     * @param appearance  Default node appearance.
-     */
-    setDefaultNodeAppearance(appearance: NodeAppearance): void;
-    /**
-     * Gets the default appearance for nodes that are not styled using
-     * {@link assignStyledNodeCollection}.
-     */
-    getDefaultNodeAppearance(): NodeAppearance;
-    /**
-     * Returns all currently registered node collections and associated appearance.
-     */
-    get styledNodeCollections(): {
-        nodeCollection: NodeCollectionBase;
-        appearance: NodeAppearance;
-    }[];
-    /**
-     * Customizes rendering style for a set of nodes, e.g. to highlight, hide
-     * or color code a set of 3D objects. This allows for custom look and feel
-     * of the 3D model which is useful to highlight certain parts or to
-     * color code the 3D model based on information (e.g. coloring the 3D model
-     * by construction status).
-     *
-     * The {@link NodeCollectionBase} can be updated dynamically and the rendered nodes will be
-     * updated automatically as the styling changes. The appearance of the style nodes
-     * cannot be changed.
-     *
-     * When nodes are in several styled sets, the style is combined in the order
-     * the sets were added, i.e. styled sets added late can overwrite styled sets added
-     * early.
-     *
-     * If the `nodeCollection` provided already has an assigned style, this style will
-     * be replaced with style provided.
-     *
-     * @param nodeCollection Dynamic set of nodes to apply the provided appearance to.
-     * @param appearance Appearance to style the provided set with.
-     * @example
-     * ```js
-     * model.setDefaultNodeAppearance({ rendererGhosted: true });
-     * const visibleNodes = new TreeIndexNodeCollection(someTreeIndices);
-     * model.assignStyledNodeCollection(visibleSet, { rendererGhosted: false });
-     * ```
-     * @throws Error if node collection already has been assigned to the model.
-     */
-    assignStyledNodeCollection(nodeCollection: NodeCollectionBase, appearance: NodeAppearance): void;
-    /**
-     * Removes styling for previously added styled collection, resetting the style to the default (or
-     * the style imposed by other styled collections).
-     * @param nodeCollection   Node collection previously added using {@link assignStyledNodeCollection}.
-     * @throws Error if node collection isn't assigned to the model.
-     */
-    unassignStyledNodeCollection(nodeCollection: NodeCollectionBase): void;
-    /**
-     * Removes all styled collections, resetting the appearance of all nodes to the
-     * default appearance.
-     */
-    removeAllStyledNodeCollections(): void;
-    /**
-     * Apply a transformation matrix to the tree indices given, changing
-     * rotation, scale and/or position.
-     *
-     * Note that setting multiple transformations for the same
-     * node isn't supported and might lead to undefined results.
-     * @param treeIndices       Tree indices of nodes to apply the transformation to.
-     * @param transformMatrix   Transformation to apply.
-     */
-    setNodeTransform(treeIndices: NumericRange, transformMatrix: THREE.Matrix4): void;
-    /**
-     * Resets the transformation for the nodes given.
-     * @param treeIndices Tree indices of the nodes to reset transforms for.
-     */
-    resetNodeTransform(treeIndices: NumericRange): void;
-    /**
-     * Maps a position retrieved from the CDF API (e.g. 3D node information) to
-     * coordinates in "ThreeJS model space". This is necessary because CDF has a right-handed
-     * Z-up coordinate system while ThreeJS uses a right-hand Y-up coordinate system.
-     * @param p     The CDF coordinate to transform.
-     * @param out   Optional preallocated buffer for storing the result. May be `p`.
-     * @returns Transformed position.
-     */
-    mapFromCdfToModelCoordinates(p: THREE.Vector3, out?: THREE.Vector3): THREE.Vector3;
-    /**
-     * Maps from a 3D position in "ThreeJS model space" (e.g. a ray intersection coordinate)
-     * to coordinates in "CDF space". This is necessary because CDF has a right-handed
-     * Z-up coordinate system while ThreeJS uses a right-hand Y-up coordinate system.
-     * This function also accounts for transformation applied to the model.
-     * @param p       The ThreeJS coordinate to transform.
-     * @param out     Optional preallocated buffer for storing the result. May be `p`.
-     * @returns Transformed position.
-     */
-    mapPositionFromModelToCdfCoordinates(p: THREE.Vector3, out?: THREE.Vector3): THREE.Vector3;
-    /**
-     * Maps from a 3D position in "ThreeJS model space" to coordinates in "CDF space".
-     * This is necessary because CDF has a right-handed Z-up coordinate system while ThreeJS
-     * uses a right-hand Y-up coordinate system. This function also accounts for transformation
-     * applied to the model.
-     * @param box     The box in ThreeJS/model coordinates.
-     * @param out     Optional preallocated buffer for storing the result. May be same input as `box`.
-     * @returns       Transformed box.
-     */
-    mapBoxFromModelToCdfCoordinates(box: THREE.Box3, out?: THREE.Box3): THREE.Box3;
-    /**
-     * Maps from a 3D position in "CDF space" to coordinates in "ThreeJS model space".
-     * This is necessary because CDF has a right-handed Z-up coordinate system while ThreeJS
-     * uses a right-hand Y-up coordinate system. This function also accounts for transformation
-     * applied to the model.
-     * @param box     The box in CDF model coordinates.
-     * @param out     Optional preallocated buffer for storing the result. May be same input as `box`.
-     * @returns       Transformed box.
-     */
-    mapBoxFromCdfToModelCoordinates(box: THREE.Box3, out?: THREE.Box3): THREE.Box3;
-    /**
-     * Cleans up used resources.
-     */
-    dispose(): void;
-    /**
-     * Determines the range of tree indices for a given subtree.
-     * @param treeIndex Index of the root of the subtree to get the index range for.
-     */
-    getSubtreeTreeIndices(treeIndex: number): Promise<NumericRange>;
-    /**
-     * Determines the tree index range of a subtree of an ancestor of the provided
-     * node defined by a tree index.
-     *
-     * @param treeIndex     Tree index of node to find ancestor tree index range for.
-     * @param generation    What "generation" to find. 0 is the node itself,
-     * 1 means parent, 2 means grandparent etc. If the node doesn't have as many
-     * ancestors, the root of the model is returned. This can be determined by checking
-     * that the range returned includes 0.
-     * @returns Tree index range of the subtree spanned by the ancestor at the
-     * "generation" specified, or the root.
-     */
-    getAncestorTreeIndices(treeIndex: number, generation: number): Promise<NumericRange>;
-    /**
-     * Determines the full bounding box of the model.
-     * @param outBbox Optional. Used to write result to.
-     * @param restrictToMostGeometry Optional. When true, returned bounds are restricted to
-     * where most of the geometry is located. This is useful for models that have junk geometry
-     * located far from the "main" model. Added in version 1.3.0.
-     * @returns Model bounding box.
-     *
-     * @example
-     * ```js
-     * const box = new THREE.Box3()
-     * model.getModelBoundingBox(box);
-     * // box now has the bounding box
-     * ```
-     * ```js
-     * // the following code does the same
-     * const box = model.getModelBoundingBox();
-     * ```
-     */
-    getModelBoundingBox(outBbox?: THREE.Box3, restrictToMostGeometry?: boolean): THREE.Box3;
-    /**
-     * Retrieves the camera position and target stored for the model. Typically this
-     * is used to store a good starting position for a model. Returns `undefined` if there
-     * isn't any stored camera configuration for the model.
-     */
-    getCameraConfiguration(): CameraConfiguration | undefined;
-    /**
-     * Sets transformation matrix of the model. This overrides the current transformation.
-     * @param matrix Transformation matrix.
-     */
-    setModelTransformation(matrix: THREE.Matrix4): void;
-    /**
-     * Gets transformation matrix of the model.
-     * @param out Preallocated `THREE.Matrix4` (optional).
-     */
-    getModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
-    /**
-     * Fetches a bounding box from the CDF by the nodeId.
-     * @param nodeId
-     * @param box Optional. Used to write result to.
-     * @example
-     * ```js
-     * const box = new THREE.Box3()
-     * const nodeId = 100500;
-     * await model.getBoundingBoxByNodeId(nodeId, box);
-     * // box now has the bounding box
-     *```
-     * ```js
-     * // the following code does the same
-     * const box = await model.getBoundingBoxByNodeId(nodeId);
-     * ```
-     */
-    getBoundingBoxByNodeId(nodeId: number, box?: THREE.Box3): Promise<THREE.Box3>;
-    /**
-     * Determine the bounding box of the node identified by the tree index provided. Note that this
-     * function uses the CDF API to look up the bounding box.
-     * @param treeIndex Tree index of the node to find bounding box for.
-     * @param box Optional preallocated container to hold the bounding box.
-     * @example
-     * ```js
-     * const box = new THREE.Box3()
-     * const treeIndex = 42;
-     * await model.getBoundingBoxByTreeIndex(treeIndex, box);
-     * // box now has the bounding box
-     *```
-     * ```js
-     * // the following code does the same
-     * const box = await model.getBoundingBoxByTreeIndex(treeIndex);
-     * ```
-     */
-    getBoundingBoxByTreeIndex(treeIndex: number, box?: THREE.Box3): Promise<THREE.Box3>;
-    /**
-     * Iterates over all nodes in the model and applies the provided action to each node (identified by tree index).
-     * The passed action is applied incrementally to avoid main thread blocking, meaning that the changes can be partially
-     * applied until promise is resolved (iteration is done).
-     * @param action Function that will be called with a treeIndex argument.
-     * @returns Promise that is resolved once the iteration is done.
-     * @example
-     * ```js
-     * const logIndex = (treeIndex) => console.log(treeIndex);
-     * await model.iterateNodesByTreeIndex(logIndex); // 0, 1, 2, ...
-     * ```
-     */
-    iterateNodesByTreeIndex(action: (treeIndex: number) => void): Promise<void>;
-    /**
-     * Returns the number of nodes in the model.
-     */
-    get nodeCount(): number;
-    /**
-     * Iterates over all nodes in a subtree of the model and applies the provided action to each node
-     * (identified by tree index). The provided node is included in the visited set.  The passed action
-     * is applied incrementally to avoid main thread blocking, meaning that the changes can be partially
-     * applied until promise is resolved (iteration is done).
-     * @param treeIndex Tree index of the top parent of the subtree.
-     * @param action Function that will be called with a treeIndex argument.
-     * @returns Promise that is resolved once the iteration is done.
-     * @example
-     * ```js
-     * // make a subtree to be gray
-     * await model.iterateNodesByTreeIndex(treeIndex => {
-     *   model.setNodeColorByTreeIndex(treeIndex, 127, 127, 127);
-     * });
-     * ```
-     */
-    iterateSubtreeByTreeIndex(treeIndex: number, action: (treeIndex: number) => void): Promise<void>;
-    /**
-     * Set override transform of the node by tree index.
-     * @param treeIndex
-     * @param transform
-     * @param applyToChildren
-     */
-    setNodeTransformByTreeIndex(treeIndex: number, transform: THREE.Matrix4, applyToChildren?: boolean): Promise<number>;
-    /**
-     * Remove override transform of the node by tree index.
-     * @param treeIndex
-     * @param applyToChildren
-     */
-    resetNodeTransformByTreeIndex(treeIndex: number, applyToChildren?: boolean): Promise<number>;
-    /**
-     * Maps a list of Node IDs to tree indices. This function is useful when you have
-     * a list of nodes, e.g. from Asset Mappings, that you want to highlight, hide,
-     * color etc in the viewer.
-     *
-     * @param nodeIds List of node IDs to map to tree indices.
-     * @returns A list of tree indices corresponing to the elements in the input.
-     * @throws If an invalid/non-existant node ID is provided the function throws an error.
-     */
-    mapNodeIdsToTreeIndices(nodeIds: CogniteInternalId[]): Promise<number[]>;
-    /**
-     * Maps a single node ID to tree index. This is useful when you e.g. have a
-     * node ID from an asset mapping and want to highlight the given asset using
-     * {@link mapNodeIdsToTreeIndices} is recommended for better performance when
-     * mapping multiple IDs.
-     *
-     * @param nodeId A Node ID to map to a tree index.
-     * @returns TreeIndex of the provided node.
-     * @throws If an invalid/non-existant node ID is provided the function throws an error.
-     */
-    mapNodeIdToTreeIndex(nodeId: CogniteInternalId): Promise<number>;
-    /**
-     * Maps a list of tree indices to node IDs for use with the Cognite SDK.
-     * This function is useful if you have a list of tree indices, e.g. from
-     * {@link Cognite3DModel.iterateSubtreeByTreeIndex}, and want to perform
-     * some operations on these nodes using the SDK.
-     *
-     * @param treeIndices Tree indices to map to node IDs.
-     * @returns A list of node IDs corresponding to the elements of the input.
-     * @throws If an invalid tree index is provided the function throws an error.
-     */
-    mapTreeIndicesToNodeIds(treeIndices: number[]): Promise<CogniteInternalId[]>;
-    /**
-     * Maps a single tree index to node ID for use with the API. If you have multiple
-     * tree indices to map, {@link mapNodeIdsToTreeIndices} is recommended for better
-     * performance.
-     * @param treeIndex A tree index to map to a Node ID.
-     * @returns TreeIndex of the provided node.
-     * @throws If an invalid/non-existent node ID is provided the function throws an error.
-     */
-    mapTreeIndexToNodeId(treeIndex: number): Promise<CogniteInternalId>;
-    /** @private */
-    private determineTreeIndices;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { CogniteInternalId } from '@cognite/sdk';
+import { WellKnownUnit } from './WellKnownUnit';
+import { SupportedModelTypes, CogniteModelBase } from '../../model-base';
+import { NumericRange, CameraConfiguration } from '../../utilities';
+import { NodeAppearance, NodeCollection, CdfModelNodeCollectionDataProvider } from '../../cad-styling';
+/**
+ * Represents a single 3D CAD model loaded from CDF.
+ * @noInheritDoc
+ * @module @cognite/reveal
+ */
+export declare class Cognite3DModel extends THREE.Object3D implements CogniteModelBase, CdfModelNodeCollectionDataProvider {
+    readonly type: SupportedModelTypes;
+    /**
+     * Returns the unit the coordinates for the model is stored. Returns an empty string
+     * if no unit has been stored.
+     * Note that coordinates in Reveal always are converted to meters using {@see modelUnitToMetersFactor}.
+     */
+    get modelUnit(): WellKnownUnit | '';
+    /**
+     * Returns the conversion factor that converts from model coordinates to meters. Note that this can
+     * return undefined if the model has been stored in an unsupported unit.
+     */
+    get modelUnitToMetersFactor(): number | undefined;
+    /**
+     * The CDF model ID of the model.
+     */
+    readonly modelId: number;
+    /**
+     * The CDF revision ID of the model.
+     */
+    readonly revisionId: number;
+    private readonly cadModel;
+    private readonly nodesApiClient;
+    private readonly nodeIdAndTreeIndexMaps;
+    private readonly _styledNodeCollections;
+    /**
+     * Sets the default appearance for nodes that are not styled using
+     * {@link assignStyledNodeCollection}. Updating the default style can be an
+     * expensive operation, so use with care.
+     *
+     * @param appearance  Default node appearance.
+     */
+    setDefaultNodeAppearance(appearance: NodeAppearance): void;
+    /**
+     * Gets the default appearance for nodes that are not styled using
+     * {@link assignStyledNodeCollection}.
+     */
+    getDefaultNodeAppearance(): NodeAppearance;
+    /**
+     * Returns all currently registered node collections and associated appearance.
+     */
+    get styledNodeCollections(): {
+        nodeCollection: NodeCollection;
+        appearance: NodeAppearance;
+    }[];
+    /**
+     * Customizes rendering style for a set of nodes, e.g. to highlight, hide
+     * or color code a set of 3D objects. This allows for custom look and feel
+     * of the 3D model which is useful to highlight certain parts or to
+     * color code the 3D model based on information (e.g. coloring the 3D model
+     * by construction status).
+     *
+     * The {@link NodeCollection} can be updated dynamically and the rendered nodes will be
+     * updated automatically as the styling changes. The appearance of the style nodes
+     * cannot be changed.
+     *
+     * When nodes are in several styled sets, the style is combined in the order
+     * the sets were added, i.e. styled sets added late can overwrite styled sets added
+     * early.
+     *
+     * If the `nodeCollection` provided already has an assigned style, this style will
+     * be replaced with style provided.
+     *
+     * @param nodeCollection Dynamic set of nodes to apply the provided appearance to.
+     * @param appearance Appearance to style the provided set with.
+     * @example
+     * ```js
+     * model.setDefaultNodeAppearance({ rendererGhosted: true });
+     * const visibleNodes = new TreeIndexNodeCollection(someTreeIndices);
+     * model.assignStyledNodeCollection(visibleSet, { rendererGhosted: false });
+     * ```
+     */
+    assignStyledNodeCollection(nodeCollection: NodeCollection, appearance: NodeAppearance): void;
+    /**
+     * Removes styling for previously added styled collection, resetting the style to the default (or
+     * the style imposed by other styled collections).
+     * @param nodeCollection   Node collection previously added using {@link assignStyledNodeCollection}.
+     * @throws Error if node collection isn't assigned to the model.
+     */
+    unassignStyledNodeCollection(nodeCollection: NodeCollection): void;
+    /**
+     * Removes all styled collections, resetting the appearance of all nodes to the
+     * default appearance.
+     */
+    removeAllStyledNodeCollections(): void;
+    /**
+     * Apply a transformation matrix to the tree indices given, changing
+     * rotation, scale and/or position.
+     *
+     * Note that setting multiple transformations for the same
+     * node isn't supported and might lead to undefined results.
+     * @param treeIndices       Tree indices of nodes to apply the transformation to.
+     * @param transformMatrix   Transformation to apply.
+     */
+    setNodeTransform(treeIndices: NumericRange, transformMatrix: THREE.Matrix4): void;
+    /**
+     * Resets the transformation for the nodes given.
+     * @param treeIndices Tree indices of the nodes to reset transforms for.
+     */
+    resetNodeTransform(treeIndices: NumericRange): void;
+    /**
+     * Maps a position retrieved from the CDF API (e.g. 3D node information) to
+     * coordinates in "ThreeJS model space". This is necessary because CDF has a right-handed
+     * Z-up coordinate system while ThreeJS uses a right-hand Y-up coordinate system.
+     * @param p     The CDF coordinate to transform.
+     * @param out   Optional preallocated buffer for storing the result. May be `p`.
+     * @returns Transformed position.
+     */
+    mapFromCdfToModelCoordinates(p: THREE.Vector3, out?: THREE.Vector3): THREE.Vector3;
+    /**
+     * Maps from a 3D position in "ThreeJS model space" (e.g. a ray intersection coordinate)
+     * to coordinates in "CDF space". This is necessary because CDF has a right-handed
+     * Z-up coordinate system while ThreeJS uses a right-hand Y-up coordinate system.
+     * This function also accounts for transformation applied to the model.
+     * @param p       The ThreeJS coordinate to transform.
+     * @param out     Optional preallocated buffer for storing the result. May be `p`.
+     * @returns Transformed position.
+     */
+    mapPositionFromModelToCdfCoordinates(p: THREE.Vector3, out?: THREE.Vector3): THREE.Vector3;
+    /**
+     * Maps from a 3D position in "ThreeJS model space" to coordinates in "CDF space".
+     * This is necessary because CDF has a right-handed Z-up coordinate system while ThreeJS
+     * uses a right-hand Y-up coordinate system. This function also accounts for transformation
+     * applied to the model.
+     * @param box     The box in ThreeJS/model coordinates.
+     * @param out     Optional preallocated buffer for storing the result. May be same input as `box`.
+     * @returns       Transformed box.
+     */
+    mapBoxFromModelToCdfCoordinates(box: THREE.Box3, out?: THREE.Box3): THREE.Box3;
+    /**
+     * Maps from a 3D position in "CDF space" to coordinates in "ThreeJS model space".
+     * This is necessary because CDF has a right-handed Z-up coordinate system while ThreeJS
+     * uses a right-hand Y-up coordinate system. This function also accounts for transformation
+     * applied to the model.
+     * @param box     The box in CDF model coordinates.
+     * @param out     Optional preallocated buffer for storing the result. May be same input as `box`.
+     * @returns       Transformed box.
+     */
+    mapBoxFromCdfToModelCoordinates(box: THREE.Box3, out?: THREE.Box3): THREE.Box3;
+    /**
+     * Cleans up used resources.
+     */
+    dispose(): void;
+    /**
+     * Determines the range of tree indices for a given subtree.
+     * @param treeIndex Index of the root of the subtree to get the index range for.
+     */
+    getSubtreeTreeIndices(treeIndex: number): Promise<NumericRange>;
+    /**
+     * Determines the tree index range of a subtree of an ancestor of the provided
+     * node defined by a tree index.
+     *
+     * @param treeIndex     Tree index of node to find ancestor tree index range for.
+     * @param generation    What "generation" to find. 0 is the node itself,
+     * 1 means parent, 2 means grandparent etc. If the node doesn't have as many
+     * ancestors, the root of the model is returned. This can be determined by checking
+     * that the range returned includes 0.
+     * @returns Tree index range of the subtree spanned by the ancestor at the
+     * "generation" specified, or the root.
+     */
+    getAncestorTreeIndices(treeIndex: number, generation: number): Promise<NumericRange>;
+    /**
+     * Determines the full bounding box of the model.
+     * @param outBbox Optional. Used to write result to.
+     * @param restrictToMostGeometry Optional. When true, returned bounds are restricted to
+     * where most of the geometry is located. This is useful for models that have junk geometry
+     * located far from the "main" model. Added in version 1.3.0.
+     * @returns Model bounding box.
+     *
+     * @example
+     * ```js
+     * const box = new THREE.Box3()
+     * model.getModelBoundingBox(box);
+     * // box now has the bounding box
+     * ```
+     * ```js
+     * // the following code does the same
+     * const box = model.getModelBoundingBox();
+     * ```
+     */
+    getModelBoundingBox(outBbox?: THREE.Box3, restrictToMostGeometry?: boolean): THREE.Box3;
+    /**
+     * Retrieves the camera position and target stored for the model. Typically this
+     * is used to store a good starting position for a model. Returns `undefined` if there
+     * isn't any stored camera configuration for the model.
+     */
+    getCameraConfiguration(): CameraConfiguration | undefined;
+    /**
+     * Sets transformation matrix of the model. This overrides the current transformation.
+     * @param matrix Transformation matrix.
+     */
+    setModelTransformation(matrix: THREE.Matrix4): void;
+    /**
+     * Gets transformation matrix of the model.
+     * @param out Preallocated `THREE.Matrix4` (optional).
+     */
+    getModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
+    /**
+     * Fetches a bounding box from the CDF by the nodeId.
+     * @param nodeId
+     * @param box Optional. Used to write result to.
+     * @example
+     * ```js
+     * const box = new THREE.Box3()
+     * const nodeId = 100500;
+     * await model.getBoundingBoxByNodeId(nodeId, box);
+     * // box now has the bounding box
+     *```
+     * ```js
+     * // the following code does the same
+     * const box = await model.getBoundingBoxByNodeId(nodeId);
+     * ```
+     */
+    getBoundingBoxByNodeId(nodeId: number, box?: THREE.Box3): Promise<THREE.Box3>;
+    /**
+     * Determine the bounding box of the node identified by the tree index provided. Note that this
+     * function uses the CDF API to look up the bounding box.
+     * @param treeIndex Tree index of the node to find bounding box for.
+     * @param box Optional preallocated container to hold the bounding box.
+     * @example
+     * ```js
+     * const box = new THREE.Box3()
+     * const treeIndex = 42;
+     * await model.getBoundingBoxByTreeIndex(treeIndex, box);
+     * // box now has the bounding box
+     *```
+     * ```js
+     * // the following code does the same
+     * const box = await model.getBoundingBoxByTreeIndex(treeIndex);
+     * ```
+     */
+    getBoundingBoxByTreeIndex(treeIndex: number, box?: THREE.Box3): Promise<THREE.Box3>;
+    /**
+     * Iterates over all nodes in the model and applies the provided action to each node (identified by tree index).
+     * The passed action is applied incrementally to avoid main thread blocking, meaning that the changes can be partially
+     * applied until promise is resolved (iteration is done).
+     * @param action Function that will be called with a treeIndex argument.
+     * @returns Promise that is resolved once the iteration is done.
+     * @example
+     * ```js
+     * const logIndex = (treeIndex) => console.log(treeIndex);
+     * await model.iterateNodesByTreeIndex(logIndex); // 0, 1, 2, ...
+     * ```
+     */
+    iterateNodesByTreeIndex(action: (treeIndex: number) => void): Promise<void>;
+    /**
+     * Returns the number of nodes in the model.
+     */
+    get nodeCount(): number;
+    /**
+     * Iterates over all nodes in a subtree of the model and applies the provided action to each node
+     * (identified by tree index). The provided node is included in the visited set.  The passed action
+     * is applied incrementally to avoid main thread blocking, meaning that the changes can be partially
+     * applied until promise is resolved (iteration is done).
+     * @param treeIndex Tree index of the top parent of the subtree.
+     * @param action Function that will be called with a treeIndex argument.
+     * @returns Promise that is resolved once the iteration is done.
+     * @example
+     * ```js
+     * // make a subtree to be gray
+     * await model.iterateNodesByTreeIndex(treeIndex => {
+     *   model.setNodeColorByTreeIndex(treeIndex, 127, 127, 127);
+     * });
+     * ```
+     */
+    iterateSubtreeByTreeIndex(treeIndex: number, action: (treeIndex: number) => void): Promise<void>;
+    /**
+     * Set override transform of the node by tree index.
+     * @param treeIndex
+     * @param transform
+     * @param applyToChildren
+     */
+    setNodeTransformByTreeIndex(treeIndex: number, transform: THREE.Matrix4, applyToChildren?: boolean): Promise<number>;
+    /**
+     * Remove override transform of the node by tree index.
+     * @param treeIndex
+     * @param applyToChildren
+     */
+    resetNodeTransformByTreeIndex(treeIndex: number, applyToChildren?: boolean): Promise<number>;
+    /**
+     * Maps a list of Node IDs to tree indices. This function is useful when you have
+     * a list of nodes, e.g. from Asset Mappings, that you want to highlight, hide,
+     * color etc in the viewer.
+     *
+     * @param nodeIds List of node IDs to map to tree indices.
+     * @returns A list of tree indices corresponing to the elements in the input.
+     * @throws If an invalid/non-existant node ID is provided the function throws an error.
+     */
+    mapNodeIdsToTreeIndices(nodeIds: CogniteInternalId[]): Promise<number[]>;
+    /**
+     * Maps a single node ID to tree index. This is useful when you e.g. have a
+     * node ID from an asset mapping and want to highlight the given asset using
+     * {@link mapNodeIdsToTreeIndices} is recommended for better performance when
+     * mapping multiple IDs.
+     *
+     * @param nodeId A Node ID to map to a tree index.
+     * @returns TreeIndex of the provided node.
+     * @throws If an invalid/non-existant node ID is provided the function throws an error.
+     */
+    mapNodeIdToTreeIndex(nodeId: CogniteInternalId): Promise<number>;
+    /**
+     * Maps a list of tree indices to node IDs for use with the Cognite SDK.
+     * This function is useful if you have a list of tree indices, e.g. from
+     * {@link Cognite3DModel.iterateSubtreeByTreeIndex}, and want to perform
+     * some operations on these nodes using the SDK.
+     *
+     * @param treeIndices Tree indices to map to node IDs.
+     * @returns A list of node IDs corresponding to the elements of the input.
+     * @throws If an invalid tree index is provided the function throws an error.
+     */
+    mapTreeIndicesToNodeIds(treeIndices: number[]): Promise<CogniteInternalId[]>;
+    /**
+     * Maps a single tree index to node ID for use with the API. If you have multiple
+     * tree indices to map, {@link mapNodeIdsToTreeIndices} is recommended for better
+     * performance.
+     * @param treeIndex A tree index to map to a Node ID.
+     * @returns TreeIndex of the provided node.
+     * @throws If an invalid/non-existent node ID is provided the function throws an error.
+     */
+    mapTreeIndexToNodeId(treeIndex: number): Promise<CogniteInternalId>;
+    /** @private */
+    private determineTreeIndices;
+}