@cognite/reveal 2.2.2 → 2.3.0

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

@@ -1,107 +1,107 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { CadModelMetadata, WantedSector } from '../../../../cad-parsers';
-import { OccludingGeometryProvider } from './OccludingGeometryProvider';
-/**
- * Options for OrderSectorsByVisibleCoverage.
- */
-export interface OrderSectorsByVisibleCoverageOptions {
-    /**
-     * Renderer used to render coverage.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * Initializes a render target with already loaded geometry for pre-load
-     * occlusion.
-     */
-    occludingGeometryProvider: OccludingGeometryProvider;
-}
-export declare type PrioritizedSectorIdentifier = {
-    /**
-     * The CAD model that holds the sector.
-     */
-    model: CadModelMetadata;
-    /**
-     * Sector ID contained in the model provided.
-     */
-    sectorId: number;
-    /**
-     * A number between 0 and 1 indicating how 'important' the sector is.
-     */
-    priority: number;
-};
-/**
- * Interface for classes that estimates how visible a sector will be on screen.
- */
-export interface OrderSectorsByVisibilityCoverage {
-    /**
-     * Dispose any resources that cannot be garbage collected.
-     */
-    dispose(): void;
-    /**
-     * Specifies what CAD models to estimate sector visibility for.
-     * @param models Models to estimate sector visibility for.
-     */
-    setModels(models: CadModelMetadata[]): void;
-    /**
-     * Specify clipping planes.
-     * @param planes            A list of clip planes or null to disable clipping.
-     */
-    setClipping(planes: THREE.Plane[] | null): void;
-    /**
-     * Cull a set of sectors potentially being loaded towards already loaded geometry to determine if
-     * the sector is visible or occluded.
-     */
-    cullOccludedSectors(camera: THREE.PerspectiveCamera, sectors: WantedSector[]): WantedSector[];
-    /**
-     * Estimates how visible the different sectors for the models added are and returns
-     * a prioritized list.
-     * @param camera The current viewpoint.
-     */
-    orderSectorsByVisibility(camera: THREE.Camera): PrioritizedSectorIdentifier[];
-}
-/**
- * Estimates sector visibility by rendering their bounds with a pattern confirming to how
- * much of the geometry covers of the bounding box.
- */
-export declare class GpuOrderSectorsByVisibilityCoverage implements OrderSectorsByVisibilityCoverage {
-    /**
-     * Factor of how big render target we use for determining visibility of sectors
-     * compared to the full render size.
-     */
-    private static readonly CoverageRenderTargetScalingFactor;
-    private sectorIdOffset;
-    private readonly scene;
-    private readonly _renderer;
-    private readonly _alreadyLoadedProvider;
-    private _debugImageElement?;
-    private readonly renderTarget;
-    private readonly containers;
-    private readonly buffers;
-    private readonly coverageMaterial;
-    constructor(options: OrderSectorsByVisibleCoverageOptions);
-    dispose(): void;
-    get renderer(): THREE.WebGLRenderer;
-    createDebugCanvas(options?: {
-        width: number;
-        height: number;
-    }): HTMLElement;
-    setModels(models: CadModelMetadata[]): void;
-    setClipping(planes: THREE.Plane[] | null): void;
-    cullOccludedSectors(camera: THREE.PerspectiveCamera, sectors: WantedSector[]): WantedSector[];
-    orderSectorsByVisibility(camera: THREE.PerspectiveCamera): PrioritizedSectorIdentifier[];
-    private readonly _ensureBuffersCorrectSizeVars;
-    private ensureBuffersCorrectSize;
-    private renderSectors;
-    private setAllSectorsVisible;
-    private setSectorsVisibility;
-    private removeModel;
-    private deleteSectorsFromBuffers;
-    private addModel;
-    private updateModel;
-    private findSectorContainer;
-    private unpackSectorVisibility;
-    private createSectorTreeGeometry;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { CadModelMetadata, WantedSector } from '../../../../cad-parsers';
+import { OccludingGeometryProvider } from './OccludingGeometryProvider';
+/**
+ * Options for OrderSectorsByVisibleCoverage.
+ */
+export interface OrderSectorsByVisibleCoverageOptions {
+    /**
+     * Renderer used to render coverage.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * Initializes a render target with already loaded geometry for pre-load
+     * occlusion.
+     */
+    occludingGeometryProvider: OccludingGeometryProvider;
+}
+export declare type PrioritizedSectorIdentifier = {
+    /**
+     * The CAD model that holds the sector.
+     */
+    model: CadModelMetadata;
+    /**
+     * Sector ID contained in the model provided.
+     */
+    sectorId: number;
+    /**
+     * A number between 0 and 1 indicating how 'important' the sector is.
+     */
+    priority: number;
+};
+/**
+ * Interface for classes that estimates how visible a sector will be on screen.
+ */
+export interface OrderSectorsByVisibilityCoverage {
+    /**
+     * Dispose any resources that cannot be garbage collected.
+     */
+    dispose(): void;
+    /**
+     * Specifies what CAD models to estimate sector visibility for.
+     * @param models Models to estimate sector visibility for.
+     */
+    setModels(models: CadModelMetadata[]): void;
+    /**
+     * Specify clipping planes.
+     * @param planes            A list of clip planes or null to disable clipping.
+     */
+    setClipping(planes: THREE.Plane[] | null): void;
+    /**
+     * Cull a set of sectors potentially being loaded towards already loaded geometry to determine if
+     * the sector is visible or occluded.
+     */
+    cullOccludedSectors(camera: THREE.PerspectiveCamera, sectors: WantedSector[]): WantedSector[];
+    /**
+     * Estimates how visible the different sectors for the models added are and returns
+     * a prioritized list.
+     * @param camera The current viewpoint.
+     */
+    orderSectorsByVisibility(camera: THREE.Camera): PrioritizedSectorIdentifier[];
+}
+/**
+ * Estimates sector visibility by rendering their bounds with a pattern confirming to how
+ * much of the geometry covers of the bounding box.
+ */
+export declare class GpuOrderSectorsByVisibilityCoverage implements OrderSectorsByVisibilityCoverage {
+    /**
+     * Factor of how big render target we use for determining visibility of sectors
+     * compared to the full render size.
+     */
+    private static readonly CoverageRenderTargetScalingFactor;
+    private sectorIdOffset;
+    private readonly scene;
+    private readonly _renderer;
+    private readonly _alreadyLoadedProvider;
+    private _debugImageElement?;
+    private readonly renderTarget;
+    private readonly containers;
+    private readonly buffers;
+    private readonly coverageMaterial;
+    constructor(options: OrderSectorsByVisibleCoverageOptions);
+    dispose(): void;
+    get renderer(): THREE.WebGLRenderer;
+    createDebugCanvas(options?: {
+        width: number;
+        height: number;
+    }): HTMLElement;
+    setModels(models: CadModelMetadata[]): void;
+    setClipping(planes: THREE.Plane[] | null): void;
+    cullOccludedSectors(camera: THREE.PerspectiveCamera, sectors: WantedSector[]): WantedSector[];
+    orderSectorsByVisibility(camera: THREE.PerspectiveCamera): PrioritizedSectorIdentifier[];
+    private readonly _ensureBuffersCorrectSizeVars;
+    private ensureBuffersCorrectSize;
+    private renderSectors;
+    private setAllSectorsVisible;
+    private setSectorsVisibility;
+    private removeModel;
+    private deleteSectorsFromBuffers;
+    private addModel;
+    private updateModel;
+    private findSectorContainer;
+    private unpackSectorVisibility;
+    private createSectorTreeGeometry;
+}

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/TakenSectorTree.d.ts

@@ -1,24 +1,24 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { SectorMetadata } from '../../../../cad-parsers';
-import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from './types';
-export declare class TakenSectorTree {
-    get totalCost(): SectorCost;
-    private readonly sectors;
-    private readonly determineSectorCost;
-    private readonly _totalCost;
-    constructor(sectorRoot: SectorMetadata, determineSectorCost: DetermineSectorCostDelegate);
-    determineWantedSectorCount(): number;
-    toWantedSectors(modelIdentifier: string, modelBaseUrl: string, geometryClipBox: THREE.Box3 | null): PrioritizedWantedSector[];
-    markSectorDetailed(sectorId: number, priority: number): void;
-    /**
-     * Replaces a Simple sector by marking all its non-detailed children as Simple and
-     * marking the sector itself Detailed.
-     */
-    private replaceSimpleWithDetailed;
-    private markAllDiscardedChildrenAsSimple;
-    private setSectorLod;
-    private setSectorPriority;
-    private getSectorLod;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SectorMetadata } from '../../../../cad-parsers';
+import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from './types';
+export declare class TakenSectorTree {
+    get totalCost(): SectorCost;
+    private readonly sectors;
+    private readonly determineSectorCost;
+    private readonly _totalCost;
+    constructor(sectorRoot: SectorMetadata, determineSectorCost: DetermineSectorCostDelegate);
+    determineWantedSectorCount(): number;
+    toWantedSectors(modelIdentifier: string, modelBaseUrl: string, geometryClipBox: THREE.Box3 | null): PrioritizedWantedSector[];
+    markSectorDetailed(sectorId: number, priority: number): void;
+    /**
+     * Replaces a Simple sector by marking all its non-detailed children as Simple and
+     * marking the sector itself Detailed.
+     */
+    private replaceSimpleWithDetailed;
+    private markAllDiscardedChildrenAsSimple;
+    private setSectorLod;
+    private setSectorPriority;
+    private getSectorLod;
+}

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

@@ -1,71 +1,71 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { SectorMetadata, CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
-import { CadLoadingHints } from '../../CadLoadingHints';
-import { CadModelSectorBudget } from '../../CadModelSectorBudget';
-export interface DetermineSectorsInput {
-    camera: THREE.PerspectiveCamera;
-    clippingPlanes: THREE.Plane[];
-    cadModelsMetadata: CadModelMetadata[];
-    loadingHints: CadLoadingHints;
-    cameraInMotion: boolean;
-    budget: CadModelSectorBudget;
-}
-/**
- * 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 = (sector: SectorMetadata, levelOfDetail: LevelOfDetail) => SectorCost;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorMetadata, CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
+import { CadLoadingHints } from '../../CadLoadingHints';
+import { CadModelSectorBudget } from '../../CadModelSectorBudget';
+export interface DetermineSectorsInput {
+    camera: THREE.PerspectiveCamera;
+    clippingPlanes: THREE.Plane[];
+    cadModelsMetadata: CadModelMetadata[];
+    loadingHints: CadLoadingHints;
+    cameraInMotion: boolean;
+    budget: CadModelSectorBudget;
+}
+/**
+ * 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 = (sector: SectorMetadata, 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 { DetermineSectorsInput } from './culling/types';
-export declare function loadingEnabled({ cadModelsMetadata, loadingHints }: DetermineSectorsInput): boolean;
-export interface ModelState {
-    [id: number]: LevelOfDetail;
-}
-export interface SceneModelState {
-    [modelIdentifier: string]: ModelState;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { LevelOfDetail } from '../../../cad-parsers';
+import { DetermineSectorsInput } from './culling/types';
+export declare function loadingEnabled({ cadModelsMetadata, loadingHints }: DetermineSectorsInput): boolean;
+export interface ModelState {
+    [id: number]: LevelOfDetail;
+}
+export interface SceneModelState {
+    [modelIdentifier: string]: ModelState;
+}

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

@@ -1,20 +1,20 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { SectorQuads } from '@cognite/reveal-parser-worker';
-import { AutoDisposeGroup } from '../../../utilities';
-import { SectorMetadata, SectorGeometry, WantedSector, ConsumedSector, InstancedMeshFile } from '../../../cad-parsers';
-import { Observable, OperatorFunction, MonoTypeOperatorFunction } from 'rxjs';
-import { Materials } from '../../../rendering';
-export declare function consumeSectorSimple(sector: SectorQuads, sectorBounds: THREE.Box3, materials: Materials, geometryClipBox: THREE.Box3 | null): {
-    sectorMeshes: AutoDisposeGroup;
-    instancedMeshes: InstancedMeshFile[];
-};
-export declare function consumeSectorDetailed(sector: SectorGeometry, metadata: SectorMetadata, materials: Materials, geometryClipBox: THREE.Box3 | null): {
-    sectorMeshes: AutoDisposeGroup;
-    instancedMeshes: InstancedMeshFile[];
-};
-export declare function distinctUntilLevelOfDetailChanged(): MonoTypeOperatorFunction<ConsumedSector>;
-export declare function filterCurrentWantedSectors(wantedObservable: Observable<WantedSector[]>): OperatorFunction<ConsumedSector, ConsumedSector>;
-export declare function findSectorMetadata(root: SectorMetadata, sectorId: number): SectorMetadata;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorQuads } from '@cognite/reveal-parser-worker';
+import { AutoDisposeGroup } from '../../../utilities';
+import { SectorMetadata, SectorGeometry, WantedSector, ConsumedSector, InstancedMeshFile } from '../../../cad-parsers';
+import { Observable, OperatorFunction, MonoTypeOperatorFunction } from 'rxjs';
+import { Materials } from '../../../rendering';
+export declare function consumeSectorSimple(sector: SectorQuads, sectorBounds: THREE.Box3, materials: Materials, geometryClipBox: THREE.Box3 | null): {
+    sectorMeshes: AutoDisposeGroup;
+    instancedMeshes: InstancedMeshFile[];
+};
+export declare function consumeSectorDetailed(sector: SectorGeometry, metadata: SectorMetadata, materials: Materials, geometryClipBox: THREE.Box3 | null): {
+    sectorMeshes: AutoDisposeGroup;
+    instancedMeshes: InstancedMeshFile[];
+};
+export declare function distinctUntilLevelOfDetailChanged(): MonoTypeOperatorFunction<ConsumedSector>;
+export declare function filterCurrentWantedSectors(wantedObservable: Observable<WantedSector[]>): OperatorFunction<ConsumedSector, ConsumedSector>;
+export declare function findSectorMetadata(root: SectorMetadata, sectorId: number): SectorMetadata;

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

@@ -1,18 +1,18 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * 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, or one of the promises provided rejects. 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<T>;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * 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, or one of the promises provided rejects. 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<T>;
+}

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

@@ -1,5 +1,5 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare function createOffsets(array: Float64Array): Float64Array;
-export declare function createOffsetsArray(array: number[]): number[];
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare function createOffsets(array: Float64Array): Float64Array;
+export declare function createOffsetsArray(array: number[]): number[];

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

@@ -1,8 +1,8 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare function groupMeshesByNumber(id: Float64Array): Generator<{
-    id: number;
-    meshIndices: number[];
-}>;
-export declare function lastIndexOf<T>(sortedArray: T[], value: number, firstSearchIndex: number, elementValueOf: (element: T) => number): number;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare function groupMeshesByNumber(id: Float64Array): Generator<{
+    id: number;
+    meshIndices: number[];
+}>;
+export declare function lastIndexOf<T>(sortedArray: T[], value: number, firstSearchIndex: number, elementValueOf: (element: T) => number): number;

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

@@ -1,6 +1,6 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { Observable, OperatorFunction } from 'rxjs';
-export declare function emissionLastMillis(millis: number): OperatorFunction<unknown, boolean>;
-export declare function delayedSwitch(millis: number): Observable<boolean>;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Observable, OperatorFunction } from 'rxjs';
+export declare function emissionLastMillis(millis: number): OperatorFunction<unknown, boolean>;
+export declare function delayedSwitch(millis: number): Observable<boolean>;