@cognite/reveal 2.0.0-beta.3 → 2.1.2

package/{tools → packages/tools/src}/HtmlOverlayTool.d.ts

@@ -1,88 +1,88 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { Cognite3DViewer } from '../public/migration/Cognite3DViewer';
-import { Cognite3DViewerToolBase } from './Cognite3DViewerToolBase';
-export declare type HtmlOverlayPositionUpdatedDelegate = (element: HTMLElement, position2D: THREE.Vector2, position3D: THREE.Vector3, distanceToCamera: number) => void;
-export declare type HtmlOverlayOptions = {
-    positionUpdatedCallback?: HtmlOverlayPositionUpdatedDelegate;
-};
-/**
- * Manages HTMLoverlays for {@see Cognite3DViewer}. Attaches HTML elements to a
- * 3D position and updates it's position/visibility as user moves the camera. This is
- * useful to create HTML overlays to highlight information about key positions in the 3D model.
- *
- * Attached elements *must* have CSS style 'position: absolute'. It's also recommended
- * in most cases to have styles 'pointerEvents: none' and 'touchAction: none' to avoid
- * interfering with 3D navigation. Consider also applying 'transform: translate(-50%, -50%)'
- * to anchor the center of the element rather than the top-left corner. In some cases the
- * `zIndex`-attribute is necessary for the element to appear on top of the viewer.
- *
- * @example
- * ```js
- * const el = document.createElement('div');
- * el.style.position = 'absolute'; // Required!
- * // Anchor to center of element
- * el.style.transform = 'translate(-50%, -50%)';
- * // Avoid being target for events
- * el.style.pointerEvents = 'none;
- * el.style.touchAction = 'none';
- * // Render in front of other elements
- * el.style.zIndex = 10;
- *
- * el.style.color = 'red';
- * el.innerHtml = '<h1>Overlay</h1>';
- *
- * const overlayTool = new HtmlOverlayTool(viewer);
- * overlayTool.add(el, new THREE.Vector3(10, 10, 10));
- * // ...
- * overlayTool.remove(el);
- * // or, to remove all attached elements
- * overlayTool.clear();
- 
- * // detach the tool from the viewer
- * overlayTool.dispose();
- * ```
- */
-export declare class HtmlOverlayTool extends Cognite3DViewerToolBase {
-    private readonly _viewer;
-    private readonly _htmlOverlays;
-    private readonly _onSceneRenderedHandler;
-    private readonly _onViewerDisposedHandler;
-    private readonly _preallocatedVariables;
-    private get viewerDomElement();
-    private get viewerCamera();
-    private get viewerRenderer();
-    constructor(viewer: Cognite3DViewer);
-    /**
-     * Removes all elements and detaches from the viewer.
-     * @override
-     */
-    dispose(): void;
-    /**
-     * Registers a HTML overlay that will be updated on rendering.
-     *
-     * @param htmlElement
-     * @param position3D
-     * @param options
-     */
-    add(htmlElement: HTMLElement, position3D: THREE.Vector3, options?: HtmlOverlayOptions): void;
-    /**
-     * Removes a overlay and removes it from the DOM.
-     * @param htmlElement
-     */
-    remove(htmlElement: HTMLElement): void;
-    /**
-     * Removes all attached HTML overlay elements.
-     */
-    clear(): void;
-    /**
-     * Updates positions of all overlays. This is automatically managed and there
-     * shouldn't be any reason to trigger this unless the attached elements are
-     * modified externally.
-     */
-    forceUpdate(): void;
-    private onSceneRendered;
-    private onViewerDisposed;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { Cognite3DViewer } from '../../../core';
+import { Cognite3DViewerToolBase } from './Cognite3DViewerToolBase';
+export declare type HtmlOverlayPositionUpdatedDelegate = (element: HTMLElement, position2D: THREE.Vector2, position3D: THREE.Vector3, distanceToCamera: number) => void;
+export declare type HtmlOverlayOptions = {
+    positionUpdatedCallback?: HtmlOverlayPositionUpdatedDelegate;
+};
+/**
+ * Manages HTMLoverlays for {@see Cognite3DViewer}. Attaches HTML elements to a
+ * 3D position and updates it's position/visibility as user moves the camera. This is
+ * useful to create HTML overlays to highlight information about key positions in the 3D model.
+ *
+ * Attached elements *must* have CSS style 'position: absolute'. It's also recommended
+ * in most cases to have styles 'pointerEvents: none' and 'touchAction: none' to avoid
+ * interfering with 3D navigation. Consider also applying 'transform: translate(-50%, -50%)'
+ * to anchor the center of the element rather than the top-left corner. In some cases the
+ * `zIndex`-attribute is necessary for the element to appear on top of the viewer.
+ *
+ * @example
+ * ```js
+ * const el = document.createElement('div');
+ * el.style.position = 'absolute'; // Required!
+ * // Anchor to center of element
+ * el.style.transform = 'translate(-50%, -50%)';
+ * // Avoid being target for events
+ * el.style.pointerEvents = 'none;
+ * el.style.touchAction = 'none';
+ * // Render in front of other elements
+ * el.style.zIndex = 10;
+ *
+ * el.style.color = 'red';
+ * el.innerHtml = '<h1>Overlay</h1>';
+ *
+ * const overlayTool = new HtmlOverlayTool(viewer);
+ * overlayTool.add(el, new THREE.Vector3(10, 10, 10));
+ * // ...
+ * overlayTool.remove(el);
+ * // or, to remove all attached elements
+ * overlayTool.clear();
+ 
+ * // detach the tool from the viewer
+ * overlayTool.dispose();
+ * ```
+ */
+export declare class HtmlOverlayTool extends Cognite3DViewerToolBase {
+    private readonly _viewer;
+    private readonly _htmlOverlays;
+    private readonly _onSceneRenderedHandler;
+    private readonly _onViewerDisposedHandler;
+    private readonly _preallocatedVariables;
+    private get viewerDomElement();
+    private get viewerCamera();
+    private get viewerRenderer();
+    constructor(viewer: Cognite3DViewer);
+    /**
+     * Removes all elements and detaches from the viewer.
+     * @override
+     */
+    dispose(): void;
+    /**
+     * Registers a HTML overlay that will be updated on rendering.
+     *
+     * @param htmlElement
+     * @param position3D
+     * @param options
+     */
+    add(htmlElement: HTMLElement, position3D: THREE.Vector3, options?: HtmlOverlayOptions): void;
+    /**
+     * Removes a overlay and removes it from the DOM.
+     * @param htmlElement
+     */
+    remove(htmlElement: HTMLElement): void;
+    /**
+     * Removes all attached HTML overlay elements.
+     */
+    clear(): void;
+    /**
+     * Updates positions of all overlays. This is automatically managed and there
+     * shouldn't be any reason to trigger this unless the attached elements are
+     * modified externally.
+     */
+    forceUpdate(): void;
+    private onSceneRendered;
+    private onViewerDisposed;
+}

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

@@ -0,0 +1,4 @@
+/*!
+ * 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 { 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 { trackError, trackLoadModel, trackCameraNavigation, trackEvent, initMetrics } from './src/metrics';
+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/{utilities → packages/utilities/src}/IndexSet.d.ts

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

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

@@ -1,21 +1,21 @@
-/*!
- * 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;
+    str(): string;
+}

package/{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/{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/{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/{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/{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/{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 _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;
+}

package/{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/{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/{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/{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/{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;
+}