@cognite/reveal 2.1.0 → 2.2.2

package/packages/tools/src/Timeline/TimelineTool.d.ts

@@ -0,0 +1,79 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Cognite3DModel } from '../../../../core';
+import { Cognite3DViewerToolBase } from '../Cognite3DViewerToolBase';
+import { Keyframe } from './Keyframe';
+import { TimelineDateUpdateDelegate } from './types';
+/**
+ * Tool to applying styles to nodes based on date to play them over in Timeline
+ */
+export declare class TimelineTool extends Cognite3DViewerToolBase {
+    private readonly _model;
+    private readonly _keyframes;
+    private _playback;
+    private readonly _events;
+    constructor(cadModel: Cognite3DModel);
+    /**
+     * Subscribe to the Date changed event
+     * @param event `dateChanged` event
+     * @param listener Listen to Timeline date Update during Playback
+     */
+    subscribe(event: 'dateChanged', listener: TimelineDateUpdateDelegate): void;
+    /**
+     * Unsubscribe to the Date changed event
+     * @param event `dateChanged` event
+     * @param listener Remove Listen to Timeline date Update
+     */
+    unsubscribe(event: 'dateChanged', listener: TimelineDateUpdateDelegate): void;
+    /**
+     * Create Key frame for the Timeline
+     * @param date - date value by Date.now() since January 1, 1970
+     */
+    createKeyframe(date: Date): Keyframe;
+    /**
+     * Returns the keyframe at the date given, or undefined if not found.
+     * @param date
+     * @returns
+     */
+    getKeyframeByDate(date: Date): Keyframe | undefined;
+    /**
+     * Removes the Keyframe from the timeline. Does nothing if the keyframe isn't part of the timeline.
+     * @param keyframe - Keyframe to be removed from the timeline
+     */
+    removeKeyframe(keyframe: Keyframe): void;
+    /**
+     * Removes the Keyframe from the Timeline
+     * @param date - Date of the Keyframe to be removed from the Timeline
+     */
+    removeKeyframeByDate(date: Date): void;
+    /**
+     * Starts playback of Timeline
+     * @param startDate - Keyframe date to start the Playback of Keyframes
+     * @param endDate - Keyframe date to stop the Playback of Keyframes
+     * @param totalDurationInMilliSeconds - Number of milliseconds for all Keyframe within startDate & endDate to be rendered
+     */
+    play(startDate: Date, endDate: Date, totalDurationInMilliSeconds: number): void;
+    /**
+     * Stops any ongoing playback
+     */
+    stop(): void;
+    /**
+     * Pause any ongoing playback
+     */
+    pause(): void;
+    /**
+     * Resume any paused playback
+     */
+    resume(): void;
+    /**
+     * Provides all Keyframes in the Timeline
+     * @returns All Keyframes in Timeline
+     */
+    getAllKeyframes(): Keyframe[];
+    dispose(): void;
+    /**
+     * Sort the Timeline Keyframe by their Date
+     */
+    private sortKeyframesByDates;
+}

package/packages/tools/src/Timeline/types.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Keyframe } from './Keyframe';
+/**
+ * Delegate for Timeline Date update
+ */
+export declare type TimelineDateUpdateDelegate = (event: {
+    date: Date;
+    activeKeyframe: Keyframe | undefined;
+    startDate: Date;
+    endDate: Date;
+}) => void;

package/packages/tools/src/types.d.ts

@@ -1,4 +1,4 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare type DisposedDelegate = () => void;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare type DisposedDelegate = () => void;

package/packages/utilities/index.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { traverseDepthFirst } from './src/objectTraversal';
+export { transformCameraConfiguration } from './src/transformCameraConfiguration';
+export { RandomColors } from './src/RandomColors';
+export { CameraConfiguration } from './src/CameraConfiguration';
+export { EventTrigger, clickOrTouchEventOffset } from './src/events';
+export { assertNever } from './src/assertNever';
+export { NumericRange } from './src/NumericRange';
+export { determinePowerOfTwoDimensions } from './src/determinePowerOfTwoDimensions';
+export { IndexSet } from './src/IndexSet';
+export { packFloatInto } from './src/packFloat';
+export { DynamicDefragmentedBuffer } from './src/datastructures/DynamicDefragmentedBuffer';
+export { AutoDisposeGroup } from './src/three/AutoDisposeGroup';
+export { BoundingBoxLOD } from './src/three/BoundingBoxLOD';
+export { getBox3CornerPoints } from './src/three/getBox3CornerPoints';
+export { isMobileOrTablet } from './src/isMobileOrTablet';
+export { WebGLRendererStateHelper } from './src/WebGLRendererStateHelper';
+export { WorkerPool } from './src/workers/WorkerPool';
+export { MemoryRequestCache } from './src/cache/MemoryRequestCache';
+export { MostFrequentlyUsedCache } from './src/cache/MostFrequentlyUsedCache';
+export { disposeAttributeArrayOnUpload } from './src/disposeAttributeArrayOnUpload';
+export { revealEnv } from './src/revealEnv';

package/packages/utilities/src/CameraConfiguration.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Represents a camera configuration, consisting of a camera position and target.
+ */
+export declare type CameraConfiguration = {
+    readonly position: THREE.Vector3;
+    readonly target: THREE.Vector3;
+};

package/{core/src/utilities → packages/utilities/src}/IndexSet.d.ts

@@ -1 +1 @@
-export { IndexSet } from './indexset/IndexSet';
+export { IndexSet } from './indexset/IndexSet';

package/{core/src/utilities → packages/utilities/src}/NumericRange.d.ts

@@ -1,21 +1,22 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare class NumericRange {
-    readonly from: number;
-    readonly count: number;
-    readonly toInclusive: number;
-    constructor(from: number, count: number);
-    static createFromInterval(from: number, toInclusive: number): NumericRange;
-    values(): Generator<number>;
-    toArray(): number[];
-    equal(other: NumericRange): boolean;
-    contains(value: number): boolean;
-    intersects(range: NumericRange): boolean;
-    intersectsOrCoinciding(range: NumericRange): boolean;
-    intersectionWith(range: NumericRange): NumericRange | undefined;
-    isInside(range: NumericRange): boolean;
-    union(range: NumericRange): NumericRange;
-    forEach(action: (value: number) => void): void;
-    str(): string;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare class NumericRange {
+    readonly from: number;
+    readonly count: number;
+    readonly toInclusive: number;
+    constructor(from: number, count: number);
+    static createFromInterval(from: number, toInclusive: number): NumericRange;
+    values(): Generator<number>;
+    toArray(): number[];
+    equal(other: NumericRange): boolean;
+    contains(value: number): boolean;
+    intersects(range: NumericRange): boolean;
+    intersectsOrCoinciding(range: NumericRange): boolean;
+    intersectionWith(range: NumericRange): NumericRange | undefined;
+    isInside(range: NumericRange): boolean;
+    union(range: NumericRange): NumericRange;
+    forEach(action: (value: number) => void): void;
+    toString(): string;
+    static isNumericRange(value: any): value is NumericRange;
+}

package/packages/utilities/src/RandomColors.d.ts

@@ -0,0 +1,34 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+/**
+ * Utility class for creating reasonable visible colors. Mainly meant for use
+ * in debugging.
+ */
+export declare class RandomColors {
+    private static readonly _colors;
+    /**
+     * Returns a color as a THREE.Color.
+     * @param colorIndex
+     * @returns
+     */
+    static color(colorIndex: number): THREE.Color;
+    /**
+     * Returns color as RGB components between 0 and 255.
+     * @param colorIndex Return
+     * @returns
+     */
+    static colorRGB(colorIndex: number): [number, number, number];
+    /**
+     * Returns a color string suitable for usage in CSS styles.
+     * @param colorIndex
+     * @returns
+     */
+    static colorCSS(colorIndex: number): string;
+    /**
+     * Returns a random color with reasonable lightness and saturation
+     * to make the color easily distinguishable from other colors.
+     */
+    static generateRandomColor(): THREE.Color;
+}

package/{core/src/utilities → packages/utilities/src}/WebGLRendererStateHelper.d.ts

@@ -1,15 +1,15 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-export declare class WebGLRendererStateHelper {
-    private _originalState;
-    private readonly _renderer;
-    constructor(renderer: THREE.WebGLRenderer);
-    setClearColor(color: THREE.Color | number | string, alpha?: number): void;
-    setSize(width: number, height: number): void;
-    set localClippingEnabled(enabled: boolean);
-    set autoClear(enabled: boolean);
-    setRenderTarget(renderTarget: THREE.RenderTarget | null): void;
-    resetState(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+export declare class WebGLRendererStateHelper {
+    private _originalState;
+    private readonly _renderer;
+    constructor(renderer: THREE.WebGLRenderer);
+    setClearColor(color: THREE.Color | number | string, alpha?: number): void;
+    setSize(width: number, height: number): void;
+    set localClippingEnabled(enabled: boolean);
+    set autoClear(enabled: boolean);
+    setRenderTarget(renderTarget: THREE.RenderTarget | null): void;
+    resetState(): void;
+}

package/{core/src/utilities → packages/utilities/src}/assertNever.d.ts

@@ -1,7 +1,7 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * See https://www.typescriptlang.org/docs/handbook/unions-and-intersections.html#union-exhaustiveness-checking
- */
-export declare function assertNever(x: never, message?: string): never;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * See https://www.typescriptlang.org/docs/handbook/unions-and-intersections.html#union-exhaustiveness-checking
+ */
+export declare function assertNever(x: never, message?: string): never;

package/{core/src/utilities → packages/utilities/src}/cache/MemoryRequestCache.d.ts

@@ -1,22 +1,22 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { RequestCache } from './RequestCache';
-export interface MemoryRequestCacheOptions {
-    maxElementsInCache?: number;
-}
-export declare class MemoryRequestCache<Key, Data> implements RequestCache<Key, Data> {
-    private readonly _maxElementsInCache;
-    private readonly _data;
-    private readonly _defaultCleanupCount;
-    private readonly _removeCallback;
-    constructor(maxElementsInCache?: number, removeCallback?: (value: Data) => void, defaultCleanupCount?: number);
-    has(id: Key): boolean;
-    forceInsert(id: Key, data: Data): void;
-    insert(id: Key, data: Data): void;
-    remove(id: Key): void;
-    get(id: Key): Data;
-    isFull(): boolean;
-    cleanCache(count: number): void;
-    clear(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { RequestCache } from './RequestCache';
+export interface MemoryRequestCacheOptions {
+    maxElementsInCache?: number;
+}
+export declare class MemoryRequestCache<Key, Data> implements RequestCache<Key, Data> {
+    private readonly _maxElementsInCache;
+    private readonly _data;
+    private readonly _defaultCleanupCount;
+    private readonly _removeCallback;
+    constructor(maxElementsInCache?: number, removeCallback?: (value: Data) => void, defaultCleanupCount?: number);
+    has(id: Key): boolean;
+    forceInsert(id: Key, data: Data): void;
+    insert(id: Key, data: Data): void;
+    remove(id: Key): void;
+    get(id: Key): Data;
+    isFull(): boolean;
+    cleanCache(count: number): void;
+    clear(): void;
+}

package/{core/src/utilities → packages/utilities/src/cache}/MostFrequentlyUsedCache.d.ts

@@ -1,19 +1,19 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * A cache that keeps values that is most frequently used (MFU) rather than a more common
- * least recently used (LRU) approach.
- */
-export declare class MostFrequentlyUsedCache<TKey, TValue> {
-    private readonly _capacity;
-    private readonly _cache;
-    private readonly _retrieves;
-    private readonly _disposeCallback;
-    constructor(capacity: number, disposeCallback?: (value: TValue) => void);
-    get(key: TKey): TValue | undefined;
-    set(key: TKey, value: TValue): boolean;
-    remove(key: TKey): boolean;
-    clear(): void;
-    private ensureWithinCapacity;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * A cache that keeps values that is most frequently used (MFU) rather than a more common
+ * least recently used (LRU) approach.
+ */
+export declare class MostFrequentlyUsedCache<TKey, TValue> {
+    private readonly _capacity;
+    private readonly _cache;
+    private readonly _retrieves;
+    private readonly _disposeCallback;
+    constructor(capacity: number, disposeCallback?: (value: TValue) => void);
+    get(key: TKey): TValue | undefined;
+    set(key: TKey, value: TValue): boolean;
+    remove(key: TKey): boolean;
+    clear(): void;
+    private ensureWithinCapacity;
+}

package/{core/src/utilities → packages/utilities/src}/cache/RequestCache.d.ts

@@ -1,13 +1,13 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export interface RequestCache<Key, Data> {
-    has(key: Key): boolean;
-    get(key: Key): Data;
-    insert(key: Key, data: Data): void;
-    forceInsert(key: Key, data: Data): void;
-    remove(key: Key): void;
-    isFull(): boolean;
-    cleanCache(count: number): void;
-    clear(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export interface RequestCache<Key, Data> {
+    has(key: Key): boolean;
+    get(key: Key): Data;
+    insert(key: Key, data: Data): void;
+    forceInsert(key: Key, data: Data): void;
+    remove(key: Key): void;
+    isFull(): boolean;
+    cleanCache(count: number): void;
+    clear(): void;
+}

package/{core/src/utilities → packages/utilities/src}/datastructures/DynamicDefragmentedBuffer.d.ts

@@ -1,22 +1,22 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { TypedArray } from '../types';
-export declare class DynamicDefragmentedBuffer<T extends TypedArray> {
-    get length(): number;
-    get buffer(): T;
-    private _buffer;
-    private _numFilled;
-    private _type;
-    private _batchMap;
-    private _currentTail;
-    private _batchIdCounter;
-    constructor(initialSize: number, type: new (length: number) => T);
-    add(array: T): {
-        batchId: number;
-        bufferIsReallocated: boolean;
-    };
-    remove(batchId: number): void;
-    private createBatch;
-    private allocateNewBuffer;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { TypedArray } from '../types';
+export declare class DynamicDefragmentedBuffer<T extends TypedArray> {
+    get length(): number;
+    get buffer(): T;
+    private _buffer;
+    private _numFilled;
+    private readonly _type;
+    private readonly _batchMap;
+    private _currentTail;
+    private _batchIdCounter;
+    constructor(initialSize: number, type: new (length: number) => T);
+    add(array: T): {
+        batchId: number;
+        bufferIsReallocated: boolean;
+    };
+    remove(batchId: number): void;
+    private createBatch;
+    private allocateNewBuffer;
+}

package/{core/src/utilities → packages/utilities/src}/determinePowerOfTwoDimensions.d.ts

@@ -1,11 +1,11 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * Computes minimal power-of-two width and height that holds at least the number of elements provided.
- * This is useful to compute texture sizes.
- */
-export declare function determinePowerOfTwoDimensions(elementCount: number): {
-    width: number;
-    height: number;
-};
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Computes minimal power-of-two width and height that holds at least the number of elements provided.
+ * This is useful to compute texture sizes.
+ */
+export declare function determinePowerOfTwoDimensions(elementCount: number): {
+    width: number;
+    height: number;
+};

package/{core/src/utilities → packages/utilities/src}/disposeAttributeArrayOnUpload.d.ts

@@ -1,17 +1,17 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * Handler for THREE.BufferAttribute.onUpload() that frees the underlying JS side array
- * of values after they have been uploaded to the GPU.
- *
- * @example
- * const geometry = new THREE.BufferGeometry();
- * const indices = new THREE.Uint32BufferAttribute(mesh.indices.buffer, 1).onUpload(disposeAttributeArrayOnUpload);
- * const vertices = new THREE.Float32BufferAttribute(mesh.vertices.buffer, 3).onUpload(disposeAttributeArrayOnUpload);
- * const colors = new THREE.Float32BufferAttribute(mesh.colors.buffer, 3).onUpload(disposeAttributeArrayOnUpload);
- * const treeIndices = new THREE.Float32BufferAttribute(mesh.treeIndices.buffer, 1).onUpload(disposeAttributeArrayOnUpload);
- */
-export declare function disposeAttributeArrayOnUpload(this: {
-    array: ArrayLike<number>;
-}): void;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Handler for THREE.BufferAttribute.onUpload() that frees the underlying JS side array
+ * of values after they have been uploaded to the GPU.
+ *
+ * @example
+ * const geometry = new THREE.BufferGeometry();
+ * const indices = new THREE.Uint32BufferAttribute(mesh.indices.buffer, 1).onUpload(disposeAttributeArrayOnUpload);
+ * const vertices = new THREE.Float32BufferAttribute(mesh.vertices.buffer, 3).onUpload(disposeAttributeArrayOnUpload);
+ * const colors = new THREE.Float32BufferAttribute(mesh.colors.buffer, 3).onUpload(disposeAttributeArrayOnUpload);
+ * const treeIndices = new THREE.Float32BufferAttribute(mesh.treeIndices.buffer, 1).onUpload(disposeAttributeArrayOnUpload);
+ */
+export declare function disposeAttributeArrayOnUpload(this: {
+    array: ArrayLike<number>;
+}): void;

package/{core/src/utilities → packages/utilities/src}/events/EventTrigger.d.ts

@@ -1,13 +1,13 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * Subscribable event source.
- */
-export declare class EventTrigger<TListener extends (...args: any[]) => void> {
-    private readonly _listeners;
-    subscribe(listener: TListener): void;
-    unsubscribe(listener: TListener): void;
-    unsubscribeAll(): void;
-    fire(...args: Parameters<TListener>): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Subscribable event source.
+ */
+export declare class EventTrigger<TListener extends (...args: any[]) => void> {
+    private readonly _listeners;
+    subscribe(listener: TListener): void;
+    unsubscribe(listener: TListener): void;
+    unsubscribeAll(): void;
+    fire(...args: Parameters<TListener>): void;
+}

package/packages/utilities/src/events/clickOrTouchEventOffset.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Determines clicked or touched coordinate as offset
+ * @param ev        An MouseEvent or TouchEvent.
+ * @param target    HTML element to find coordinates relative to.
+ * @returns A struct containing coordinates relative to the HTML element provided.
+ */
+export declare function clickOrTouchEventOffset(ev: MouseEvent | TouchEvent, target: HTMLElement): {
+    offsetX: number;
+    offsetY: number;
+};

package/{core/src/utilities → packages/utilities/src}/events/index.d.ts

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

package/{core/src/utilities → packages/utilities/src}/indexset/IndexSet.d.ts

@@ -1,26 +1,26 @@
-import { IntermediateIndexNode } from './IntermediateIndexNode';
-import { LeafIndexNode } from './LeafIndexNode';
-import { NumericRange } from '../NumericRange';
-export declare type IndexNode = IntermediateIndexNode | LeafIndexNode;
-export declare class IndexSet {
-    rootNode?: IndexNode;
-    constructor(values?: Iterable<number>);
-    constructor(values?: NumericRange);
-    forEachRange(visitor: (range: NumericRange) => void): void;
-    add(index: number): void;
-    addRange(range: NumericRange): void;
-    remove(index: number): void;
-    removeRange(range: NumericRange): void;
-    contains(index: number): boolean;
-    get count(): number;
-    toRangeArray(): NumericRange[];
-    toIndexArray(): number[];
-    toPlainSet(): Set<number>;
-    invertedRanges(): NumericRange[];
-    unionWith(otherSet: IndexSet): IndexSet;
-    differenceWith(otherSet: IndexSet): IndexSet;
-    hasIntersectionWith(otherSet: IndexSet | Set<number>): boolean;
-    intersectWith(otherSet: IndexSet): IndexSet;
-    clear(): void;
-    clone(): IndexSet;
-}
+import { IntermediateIndexNode } from './IntermediateIndexNode';
+import { LeafIndexNode } from './LeafIndexNode';
+import { NumericRange } from '../NumericRange';
+export declare type IndexNode = IntermediateIndexNode | LeafIndexNode;
+export declare class IndexSet {
+    rootNode?: IndexNode;
+    constructor(values?: Iterable<number>);
+    constructor(values?: NumericRange);
+    forEachRange(visitor: (range: NumericRange) => void): void;
+    add(index: number): void;
+    addRange(range: NumericRange): void;
+    remove(index: number): void;
+    removeRange(range: NumericRange): void;
+    contains(index: number): boolean;
+    get count(): number;
+    toRangeArray(): NumericRange[];
+    toIndexArray(): number[];
+    toPlainSet(): Set<number>;
+    invertedRanges(): NumericRange[];
+    unionWith(otherSet: IndexSet): IndexSet;
+    differenceWith(otherSet: IndexSet): IndexSet;
+    hasIntersectionWith(otherSet: IndexSet | Set<number>): boolean;
+    intersectWith(otherSet: IndexSet): IndexSet;
+    clear(): void;
+    clone(): IndexSet;
+}

package/{core/src/utilities → packages/utilities/src}/indexset/IntermediateIndexNode.d.ts

@@ -1,26 +1,26 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { IndexNode } from './IndexSet';
-import { NumericRange } from '../NumericRange';
-export declare class IntermediateIndexNode {
-    readonly range: NumericRange;
-    readonly maxSubtreeDepth: number;
-    readonly left: IndexNode;
-    readonly right: IndexNode;
-    readonly count: number;
-    constructor(left: IndexNode, right: IndexNode);
-    static fromIndexNodesAndBalance(r0: IndexNode, r1: IndexNode): IntermediateIndexNode;
-    traverse(visitor: (range: NumericRange) => void): void;
-    contains(index: number): boolean;
-    addRange(range: NumericRange): IndexNode;
-    removeRange(range: NumericRange): IndexNode | undefined;
-    balance(): IntermediateIndexNode;
-    clone(): IntermediateIndexNode;
-    hasIntersectionWith(node: IndexNode): boolean;
-    soak(range: NumericRange): [IndexNode | undefined, NumericRange];
-    rotateRight(): IntermediateIndexNode;
-    rotateLeft(): IntermediateIndexNode;
-    rotateSmallerLeft(): IntermediateIndexNode;
-    rotateSmallerRight(): IntermediateIndexNode;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { IndexNode } from './IndexSet';
+import { NumericRange } from '../NumericRange';
+export declare class IntermediateIndexNode {
+    readonly range: NumericRange;
+    readonly maxSubtreeDepth: number;
+    readonly left: IndexNode;
+    readonly right: IndexNode;
+    readonly count: number;
+    constructor(left: IndexNode, right: IndexNode);
+    static fromIndexNodesAndBalance(r0: IndexNode, r1: IndexNode): IntermediateIndexNode;
+    traverse(visitor: (range: NumericRange) => void): void;
+    contains(index: number): boolean;
+    addRange(range: NumericRange): IndexNode;
+    removeRange(range: NumericRange): IndexNode | undefined;
+    balance(): IntermediateIndexNode;
+    clone(): IntermediateIndexNode;
+    hasIntersectionWith(node: IndexNode): boolean;
+    soak(range: NumericRange): [IndexNode | undefined, NumericRange];
+    rotateRight(): IntermediateIndexNode;
+    rotateLeft(): IntermediateIndexNode;
+    rotateSmallerLeft(): IntermediateIndexNode;
+    rotateSmallerRight(): IntermediateIndexNode;
+}