@cognite/reveal 3.1.0 → 4.0.0-dev.20221025

package/packages/cad-geometry-loaders/src/sector/culling/ByScreenSizeSectorCuller.d.ts

@@ -1,23 +1,23 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
-import { SectorCuller } from './SectorCuller';
-import { V9SectorMetadata, WantedSector } from '../../../../cad-parsers';
-export declare type ByScreenSizeSectorCullerOptions = {
-    /**
-     * Optional callback for determining the cost of a sector. The default unit of the cost
-     * function is bytes downloaded.
-     */
-    determineSectorCost?: DetermineSectorCostDelegate<V9SectorMetadata>;
-};
-export declare class ByScreenSizeSectorCuller implements SectorCuller {
-    private readonly _determineSectorCost;
-    constructor(options?: ByScreenSizeSectorCullerOptions);
-    determineSectors(input: DetermineSectorsInput): {
-        wantedSectors: WantedSector[];
-        spentBudget: SectorLoadingSpent;
-    };
-    filterSectorsToLoad(_input: DetermineSectorsInput, wantedSectorsBatch: WantedSector[]): Promise<WantedSector[]>;
-    dispose(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
+import { SectorCuller } from './SectorCuller';
+import { V9SectorMetadata, WantedSector } from '../../../../cad-parsers';
+export declare type ByScreenSizeSectorCullerOptions = {
+    /**
+     * Optional callback for determining the cost of a sector. The default unit of the cost
+     * function is bytes downloaded.
+     */
+    determineSectorCost?: DetermineSectorCostDelegate<V9SectorMetadata>;
+};
+export declare class ByScreenSizeSectorCuller implements SectorCuller {
+    private readonly _determineSectorCost;
+    constructor(options?: ByScreenSizeSectorCullerOptions);
+    determineSectors(input: DetermineSectorsInput): {
+        wantedSectors: WantedSector[];
+        spentBudget: SectorLoadingSpent;
+    };
+    filterSectorsToLoad(_input: DetermineSectorsInput, wantedSectorsBatch: WantedSector[]): Promise<WantedSector[]>;
+    dispose(): void;
+}

package/packages/cad-geometry-loaders/src/sector/culling/SectorCuller.d.ts

@@ -1,33 +1,33 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { WantedSector } from '../../../../cad-parsers';
-import { DetermineSectorsInput, SectorLoadingSpent } from './types';
-/**
- * Interface for implementations that are responsible for determining
- * what sectors should be loaded (i.e. "culls" sectors).
- */
-export interface SectorCuller {
-    /**
-     * Determine initial sector prioritization about what we think to load. This provides an initial guesstimate of
-     * what sectors we should load. Use {@link filterSectorsToLoad} to improve this estimate as new data is loaded.
-     * @param input
-     */
-    determineSectors(input: DetermineSectorsInput): {
-        wantedSectors: WantedSector[];
-        spentBudget: SectorLoadingSpent;
-    };
-    /**
-     * Evaluates if sectors provided should be loaded or not, e.g. based on geometry we have now loaded
-     * since {@link determineSectors} was called. This can be used to e.g. implement pre-load occlusion culling
-     * of sectors based on geometry that has been loaded.
-     *
-     * @param input Same input as used in {@link determineSectors}.
-     * @param wantedSectorsBatch A set of sectors from {@link determineSectors}, e.g. in batches of 5-10.
-     */
-    filterSectorsToLoad(input: DetermineSectorsInput, wantedSectorsBatch: WantedSector[]): Promise<WantedSector[]>;
-    /**
-     * Dispose all non-GCed resoures held.
-     */
-    dispose(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { WantedSector } from '../../../../cad-parsers';
+import { DetermineSectorsInput, SectorLoadingSpent } from './types';
+/**
+ * Interface for implementations that are responsible for determining
+ * what sectors should be loaded (i.e. "culls" sectors).
+ */
+export interface SectorCuller {
+    /**
+     * Determine initial sector prioritization about what we think to load. This provides an initial guesstimate of
+     * what sectors we should load. Use {@link filterSectorsToLoad} to improve this estimate as new data is loaded.
+     * @param input
+     */
+    determineSectors(input: DetermineSectorsInput): {
+        wantedSectors: WantedSector[];
+        spentBudget: SectorLoadingSpent;
+    };
+    /**
+     * Evaluates if sectors provided should be loaded or not, e.g. based on geometry we have now loaded
+     * since {@link determineSectors} was called. This can be used to e.g. implement pre-load occlusion culling
+     * of sectors based on geometry that has been loaded.
+     *
+     * @param input Same input as used in {@link determineSectors}.
+     * @param wantedSectorsBatch A set of sectors from {@link determineSectors}, e.g. in batches of 5-10.
+     */
+    filterSectorsToLoad(input: DetermineSectorsInput, wantedSectorsBatch: WantedSector[]): Promise<WantedSector[]>;
+    /**
+     * Dispose all non-GCed resoures held.
+     */
+    dispose(): void;
+}

package/packages/cad-geometry-loaders/src/sector/culling/WeightFunctionsHelper.d.ts

@@ -1,50 +1,51 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { SectorMetadata, V9SectorMetadata } from '../../../../cad-parsers';
-import { PrioritizedArea } from '../../../../cad-styling';
-export declare class WeightFunctionsHelper {
-    private readonly _camera;
-    private _minSectorDistance;
-    private _maxSectorDistance;
-    private readonly _modifiedFrustums;
-    constructor(camera: THREE.PerspectiveCamera);
-    addCandidateSectors(sectors: SectorMetadata[], modelMatrix: THREE.Matrix4): void;
-    computeTransformedSectorBounds(sectorBounds: THREE.Box3, modelMatrix: THREE.Matrix4, out: THREE.Box3): void;
-    /**
-     * Computes a weight in range [0-1], where 1 means close to camera and 0 means far away.
-     */
-    computeDistanceToCameraWeight(transformedSectorBounds: THREE.Box3): number;
-    /**
-     * Compute a weight in range [0-1] where 1 means the sector covers the entire screen
-     * and 0 means no coverage.
-     * @param transformedSectorBounds
-     * @returns
-     */
-    computeScreenAreaWeight(transformedSectorBounds: THREE.Box3): number;
-    /**
-     * Compute a weight in range [0-1] based on at what "depths"
-     * in the frustum the sector is placed.
-     * @param transformedSectorBounds
-     */
-    computeFrustumDepthWeight(transformedSectorBounds: THREE.Box3): number;
-    /**
-     * Computes a weight based on placement in sector tree (i.e. prioritize)
-     * sectors right below root sector.
-     * @param sector
-     */
-    computeSectorTreePlacementWeight(sector: V9SectorMetadata): number;
-    /**
-     * Computes a weight based on how large the biggest node within the sector
-     * will be on screen (a number in range [0-1]).
-     */
-    computeMaximumNodeScreenSizeWeight(transformedSectorBounds: THREE.Box3, maxNodeDiagonalLength: number): number;
-    /**
-     * Returns a weight that is the maximum of the extra priority in intersecting prioritized areas.
-     * @param transformedSectorBounds   Bounds of sectors in "Reveal coordinates".
-     * @param prioritizedAreas          Zero or more areas with associated priorities.
-     */
-    computePrioritizedAreaWeight(transformedSectorBounds: THREE.Box3, prioritizedAreas: PrioritizedArea[]): number;
-    private distanceToCamera;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorMetadata, V9SectorMetadata } from '../../../../cad-parsers';
+import { PrioritizedArea } from '../../../../cad-styling';
+export declare class WeightFunctionsHelper {
+    private readonly _camera;
+    private _minSectorDistance;
+    private _maxSectorDistance;
+    private readonly _modifiedFrustums;
+    constructor(camera: THREE.PerspectiveCamera);
+    reset(): void;
+    addCandidateSectors(sectors: SectorMetadata[], modelMatrix: THREE.Matrix4): void;
+    computeTransformedSectorBounds(sectorBounds: THREE.Box3, modelMatrix: THREE.Matrix4, out: THREE.Box3): void;
+    /**
+     * Computes a weight in range [0-1], where 1 means close to camera and 0 means far away.
+     */
+    computeDistanceToCameraWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Compute a weight in range [0-1] where 1 means the sector covers the entire screen
+     * and 0 means no coverage.
+     * @param transformedSectorBounds
+     * @returns
+     */
+    computeScreenAreaWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Compute a weight in range [0-1] based on at what "depths"
+     * in the frustum the sector is placed.
+     * @param transformedSectorBounds
+     */
+    computeFrustumDepthWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Computes a weight based on placement in sector tree (i.e. prioritize)
+     * sectors right below root sector.
+     * @param sector
+     */
+    computeSectorTreePlacementWeight(sector: V9SectorMetadata): number;
+    /**
+     * Computes a weight based on how large the biggest node within the sector
+     * will be on screen (a number in range [0-1]).
+     */
+    computeMaximumNodeScreenSizeWeight(transformedSectorBounds: THREE.Box3, maxNodeDiagonalLength: number): number;
+    /**
+     * Returns a weight that is the maximum of the extra priority in intersecting prioritized areas.
+     * @param transformedSectorBounds   Bounds of sectors in "Reveal coordinates".
+     * @param prioritizedAreas          Zero or more areas with associated priorities.
+     */
+    computePrioritizedAreaWeight(transformedSectorBounds: THREE.Box3, prioritizedAreas: PrioritizedArea[]): number;
+    private distanceToCamera;
+}

package/packages/cad-geometry-loaders/src/sector/culling/computeNdcAreaOfBox.d.ts

@@ -1,12 +1,12 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-/**
- * Computes area of the box after converting it to NDC space. The returned value will be a number
- * in range [0, 1].
- * @param camera
- * @param box
- * @returns
- */
-export declare function computeNdcAreaOfBox(camera: THREE.Camera, box: THREE.Box3): number;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+/**
+ * Computes area of the box after converting it to NDC space. The returned value will be a number
+ * in range [0, 1].
+ * @param camera
+ * @param box
+ * @returns
+ */
+export declare function computeNdcAreaOfBox(camera: THREE.Camera, box: THREE.Box3): number;

package/packages/cad-geometry-loaders/src/sector/culling/computeSectorCost.d.ts

@@ -1,7 +1,6 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { SectorCost } from './types';
-import { LevelOfDetail, SectorMetadata } from '../../../../cad-parsers';
-export declare function computeV9SectorCost(sectorMetadata: SectorMetadata, lod: LevelOfDetail): SectorCost;
-export declare function computeV8SectorCost(sectorMetadata: SectorMetadata, lod: LevelOfDetail): SectorCost;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SectorCost } from './types';
+import { LevelOfDetail, SectorMetadata } from '../../../../cad-parsers';
+export declare function computeV9SectorCost(sectorMetadata: SectorMetadata, lod: LevelOfDetail): SectorCost;

package/packages/cad-geometry-loaders/src/sector/culling/takensectors/TakenSectorMapBase.d.ts

@@ -1,11 +1,11 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { PrioritizedWantedSector, SectorCost, SectorLoadingSpent } from '../types';
-import { CadModelMetadata } from '../../../../../cad-parsers';
-export declare abstract class TakenSectorMapBase {
-    protected abstract get modelsMetadata(): CadModelMetadata[];
-    abstract get totalCost(): SectorCost;
-    abstract collectWantedSectors(): PrioritizedWantedSector[];
-    computeSpentBudget(): SectorLoadingSpent;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { PrioritizedWantedSector, SectorCost, SectorLoadingSpent } from '../types';
+import { CadModelMetadata } from '../../../../../cad-parsers';
+export declare abstract class TakenSectorMapBase {
+    protected abstract get modelsMetadata(): CadModelMetadata[];
+    abstract get totalCost(): SectorCost;
+    abstract collectWantedSectors(): PrioritizedWantedSector[];
+    computeSpentBudget(): SectorLoadingSpent;
+}

package/packages/cad-geometry-loaders/src/sector/culling/takensectors/TakenV9SectorMap.d.ts

@@ -1,20 +1,20 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { DetermineSectorCostDelegate, PrioritizedWantedSector, SectorCost } from '../types';
-import { CadModelBudget } from '../../../CadModelBudget';
-import { TakenSectorMapBase } from './TakenSectorMapBase';
-import { CadModelMetadata, V9SectorMetadata } from '../../../../../cad-parsers';
-export declare class TakenV9SectorMap extends TakenSectorMapBase {
-    private readonly determineSectorCost;
-    private readonly _totalCost;
-    private readonly _models;
-    get totalCost(): SectorCost;
-    get modelsMetadata(): CadModelMetadata[];
-    constructor(determineSectorCost: DetermineSectorCostDelegate<V9SectorMetadata>);
-    initializeScene(modelMetadata: CadModelMetadata): void;
-    markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
-    isWithinBudget(budget: CadModelBudget): boolean;
-    collectWantedSectors(): PrioritizedWantedSector[];
-    clear(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { DetermineSectorCostDelegate, PrioritizedWantedSector, SectorCost } from '../types';
+import { CadModelBudget } from '../../../CadModelBudget';
+import { TakenSectorMapBase } from './TakenSectorMapBase';
+import { CadModelMetadata, V9SectorMetadata } from '../../../../../cad-parsers';
+export declare class TakenV9SectorMap extends TakenSectorMapBase {
+    private readonly determineSectorCost;
+    private readonly _totalCost;
+    private readonly _models;
+    get totalCost(): SectorCost;
+    get modelsMetadata(): CadModelMetadata[];
+    constructor(determineSectorCost: DetermineSectorCostDelegate<V9SectorMetadata>);
+    initializeScene(modelMetadata: CadModelMetadata): void;
+    markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
+    isWithinBudget(budget: CadModelBudget): boolean;
+    collectWantedSectors(): PrioritizedWantedSector[];
+    clear(): void;
+}

package/packages/cad-geometry-loaders/src/sector/culling/takensectors/index.d.ts

@@ -1,5 +1,4 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export { TakenV9SectorMap } from './TakenV9SectorMap';
-export { TakenV8SectorMap } from './TakenV8SectorMap';
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { TakenV9SectorMap } from './TakenV9SectorMap';

package/packages/cad-geometry-loaders/src/sector/culling/transformBoxToNDC.d.ts

@@ -1,5 +1,5 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-export declare function transformBoxToNDC(box: THREE.Box3, camera: THREE.Camera, out?: THREE.Box3): THREE.Box3;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+export declare function transformBoxToNDC(box: THREE.Box3, camera: THREE.Camera, out?: THREE.Box3): THREE.Box3;

package/packages/cad-geometry-loaders/src/sector/culling/types.d.ts

@@ -1,83 +1,83 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { PrioritizedArea } from '../../../../cad-styling';
-import { CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
-import { CadLoadingHints } from '../../CadLoadingHints';
-import { CadModelBudget } from '../../CadModelBudget';
-import { CadNode } from '../../../../cad-model';
-export interface DetermineSectorsInput {
-    camera: THREE.PerspectiveCamera;
-    clippingPlanes: THREE.Plane[];
-    cadModelsMetadata: CadModelMetadata[];
-    loadingHints: CadLoadingHints;
-    cameraInMotion: boolean;
-    budget: CadModelBudget;
-    prioritizedAreas: PrioritizedArea[];
-}
-export declare type DetermineSectorsPayload = {
-    camera: THREE.PerspectiveCamera;
-    clippingPlanes: THREE.Plane[];
-    models: CadNode[];
-    loadingHints: CadLoadingHints;
-    cameraInMotion: boolean;
-    budget: CadModelBudget;
-    prioritizedAreas: PrioritizedArea[];
-};
-/**
- * Statistics for how much data is required to load set of sectors.
- */
-export declare type SectorLoadingSpent = {
-    /**
-     * Estimated number of bytes to download sectors.
-     */
-    readonly downloadSize: number;
-    /**
-     * Estimated number of draw calls required to draw the sectors.
-     */
-    readonly drawCalls: number;
-    /**
-     * Estimated "render cost" which can be compared to triangle count (but
-     * due to how Reveal renders primitives doesn't map directly to triangles).
-     */
-    readonly renderCost: number;
-    /**
-     * Total number of sectors to load.
-     */
-    readonly loadedSectorCount: number;
-    /**
-     * Number of 'simple' sectors to load.
-     */
-    readonly simpleSectorCount: number;
-    /**
-     * Number of 'detailed' sectors to load.
-     */
-    readonly detailedSectorCount: number;
-    /**
-     * How many sectors that was "forced prioritized".
-     */
-    readonly forcedDetailedSectorCount: number;
-    /**
-     * The total number of sectors in models we are loading.
-     */
-    readonly totalSectorCount: number;
-    /**
-     * How much of the prioritized nodes that are loaded (between 0 and 1).
-     */
-    readonly accumulatedPriority: number;
-};
-export declare type SectorCost = {
-    downloadSize: number;
-    drawCalls: number;
-    renderCost: number;
-};
-export declare function addSectorCost(sum: SectorCost, cost: SectorCost): void;
-export declare function reduceSectorCost(sum: SectorCost, cost: SectorCost): void;
-export declare type PrioritizedWantedSector = WantedSector & {
-    priority: number;
-};
-/**
- * Delegates that computes 'cost' of loading/visualizing a given sector.
- */
-export declare type DetermineSectorCostDelegate<TSectorMetadata> = (sector: TSectorMetadata, levelOfDetail: LevelOfDetail) => SectorCost;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { PrioritizedArea } from '../../../../cad-styling';
+import { CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
+import { CadLoadingHints } from '../../CadLoadingHints';
+import { CadModelBudget } from '../../CadModelBudget';
+import { CadNode } from '../../../../cad-model';
+export interface DetermineSectorsInput {
+    camera: THREE.PerspectiveCamera;
+    clippingPlanes: THREE.Plane[];
+    cadModelsMetadata: CadModelMetadata[];
+    loadingHints: CadLoadingHints;
+    cameraInMotion: boolean;
+    budget: CadModelBudget;
+    prioritizedAreas: PrioritizedArea[];
+}
+export declare type DetermineSectorsPayload = {
+    camera: THREE.PerspectiveCamera;
+    clippingPlanes: THREE.Plane[];
+    models: CadNode[];
+    loadingHints: CadLoadingHints;
+    cameraInMotion: boolean;
+    budget: CadModelBudget;
+    prioritizedAreas: PrioritizedArea[];
+};
+/**
+ * Statistics for how much data is required to load set of sectors.
+ */
+export declare type SectorLoadingSpent = {
+    /**
+     * Estimated number of bytes to download sectors.
+     */
+    readonly downloadSize: number;
+    /**
+     * Estimated number of draw calls required to draw the sectors.
+     */
+    readonly drawCalls: number;
+    /**
+     * Estimated "render cost" which can be compared to triangle count (but
+     * due to how Reveal renders primitives doesn't map directly to triangles).
+     */
+    readonly renderCost: number;
+    /**
+     * Total number of sectors to load.
+     */
+    readonly loadedSectorCount: number;
+    /**
+     * Number of 'simple' sectors to load.
+     */
+    readonly simpleSectorCount: number;
+    /**
+     * Number of 'detailed' sectors to load.
+     */
+    readonly detailedSectorCount: number;
+    /**
+     * How many sectors that was "forced prioritized".
+     */
+    readonly forcedDetailedSectorCount: number;
+    /**
+     * The total number of sectors in models we are loading.
+     */
+    readonly totalSectorCount: number;
+    /**
+     * How much of the prioritized nodes that are loaded (between 0 and 1).
+     */
+    readonly accumulatedPriority: number;
+};
+export declare type SectorCost = {
+    downloadSize: number;
+    drawCalls: number;
+    renderCost: number;
+};
+export declare function addSectorCost(sum: SectorCost, cost: SectorCost): void;
+export declare function reduceSectorCost(sum: SectorCost, cost: SectorCost): void;
+export declare type PrioritizedWantedSector = WantedSector & {
+    priority: number;
+};
+/**
+ * Delegates that computes 'cost' of loading/visualizing a given sector.
+ */
+export declare type DetermineSectorCostDelegate<TSectorMetadata> = (sector: TSectorMetadata, levelOfDetail: LevelOfDetail) => SectorCost;

package/packages/cad-geometry-loaders/src/sector/rxSectorUtilities.d.ts

@@ -1,12 +1,12 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { LevelOfDetail } from '../../../cad-parsers';
-import { DetermineSectorsPayload } from './culling/types';
-export declare function loadingEnabled({ models, loadingHints }: DetermineSectorsPayload): boolean;
-export interface ModelState {
-    [id: number]: LevelOfDetail;
-}
-export interface SceneModelState {
-    [modelIdentifier: string]: ModelState;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { LevelOfDetail } from '../../../cad-parsers';
+import { DetermineSectorsPayload } from './culling/types';
+export declare function loadingEnabled({ models, loadingHints }: DetermineSectorsPayload): boolean;
+export interface ModelState {
+    [id: number]: LevelOfDetail;
+}
+export interface SceneModelState {
+    [modelIdentifier: string]: ModelState;
+}

package/packages/cad-geometry-loaders/src/utilities/PromiseUtils.d.ts

@@ -1,28 +1,28 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * PromiseResult - Contains the result from a
- * promise together with and indicator of whether the
- * the promise resolved or rejected
- */
-declare type PromiseResult<T> = {
-    result?: T;
-    error?: any;
-};
-/**
- * Extension utilities for Promise.
- */
-export declare class PromiseUtils {
-    /**
-     * Awaits all promises in the list of promises available, returning them in an async iterator
-     * as they finish. The function completes when all promises has completed and the results have
-     * been yielded. Each result is given as a PromiseResult object. This function is similar to
-     * Promise.all(), except that it returns results as they are ready and doesn't wait for all
-     * operations to finish.
-     *
-     * @param promises A list of promises to complete.
-     */
-    static raceUntilAllCompleted<T>(promises: Promise<T>[]): AsyncIterable<PromiseResult<T>>;
-}
-export {};
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * PromiseResult - Contains the result from a
+ * promise together with and indicator of whether the
+ * the promise resolved or rejected
+ */
+declare type PromiseResult<T> = {
+    result?: T;
+    error?: any;
+};
+/**
+ * Extension utilities for Promise.
+ */
+export declare class PromiseUtils {
+    /**
+     * Awaits all promises in the list of promises available, returning them in an async iterator
+     * as they finish. The function completes when all promises has completed and the results have
+     * been yielded. Each result is given as a PromiseResult object. This function is similar to
+     * Promise.all(), except that it returns results as they are ready and doesn't wait for all
+     * operations to finish.
+     *
+     * @param promises A list of promises to complete.
+     */
+    static raceUntilAllCompleted<T>(promises: Promise<T>[]): AsyncIterable<PromiseResult<T>>;
+}
+export {};

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

@@ -1,9 +1,9 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-export { BoundingBoxClipper } from './src/utilities/BoundingBoxClipper';
-export { Cognite3DModel } from './src/wrappers/Cognite3DModel';
-export { PickingHandler } from './src/picking/PickingHandler';
-export { CadNode } from './src/wrappers/CadNode';
-export { CadModelFactory } from './src/CadModelFactory';
-export { WellKnownUnit, GeometryFilter, CadModelSectorLoadStatistics } from './src/types';
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export { BoundingBoxClipper } from './src/utilities/BoundingBoxClipper';
+export { Cognite3DModel } from './src/wrappers/Cognite3DModel';
+export { PickingHandler } from './src/picking/PickingHandler';
+export { CadNode } from './src/wrappers/CadNode';
+export { CadModelFactory } from './src/CadModelFactory';
+export { WellKnownUnit, GeometryFilter, CadModelSectorLoadStatistics } from './src/types';