@cognite/reveal 3.1.0 → 3.2.1

package/packages/cad-styling/src/NodeCollectionDeserializer.d.ts

@@ -1,26 +1,26 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { CogniteClient } from '@cognite/sdk';
-import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
-import { NodeCollection } from './NodeCollection';
-export declare type TypeName = string;
-export declare type NodeCollectionSerializationContext = {
-    client: CogniteClient;
-    model: CdfModelNodeCollectionDataProvider;
-};
-export declare type NodeCollectionDescriptor = {
-    token: TypeName;
-    state: any;
-    options?: any;
-};
-export declare class NodeCollectionDeserializer {
-    static readonly Instance: NodeCollectionDeserializer;
-    private readonly _types;
-    private constructor();
-    registerNodeCollectionType<T extends NodeCollection>(nodeCollectionType: TypeName, deserializer: (descriptor: NodeCollectionDescriptor, context: NodeCollectionSerializationContext) => Promise<T>): void;
-    deserialize(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, descriptor: NodeCollectionDescriptor): Promise<NodeCollection>;
-    private getDeserializer;
-    private registerWellKnownNodeCollectionTypes;
-}
-export declare function registerCustomNodeCollectionType<T extends NodeCollection>(nodeCollectionType: TypeName, deserializer: (descriptor: NodeCollectionDescriptor, context: NodeCollectionSerializationContext) => Promise<T>): void;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
+import { NodeCollection } from './NodeCollection';
+export declare type TypeName = string;
+export declare type NodeCollectionSerializationContext = {
+    client: CogniteClient;
+    model: CdfModelNodeCollectionDataProvider;
+};
+export declare type NodeCollectionDescriptor = {
+    token: TypeName;
+    state: any;
+    options?: any;
+};
+export declare class NodeCollectionDeserializer {
+    static readonly Instance: NodeCollectionDeserializer;
+    private readonly _types;
+    private constructor();
+    registerNodeCollectionType<T extends NodeCollection>(nodeCollectionType: TypeName, deserializer: (descriptor: NodeCollectionDescriptor, context: NodeCollectionSerializationContext) => Promise<T>): void;
+    deserialize(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, descriptor: NodeCollectionDescriptor): Promise<NodeCollection>;
+    private getDeserializer;
+    private registerWellKnownNodeCollectionTypes;
+}
+export declare function registerCustomNodeCollectionType<T extends NodeCollection>(nodeCollectionType: TypeName, deserializer: (descriptor: NodeCollectionDescriptor, context: NodeCollectionSerializationContext) => Promise<T>): void;

package/packages/cad-styling/src/PopulateIndexSetFromPagedResponseHelper.d.ts

@@ -1,30 +1,30 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { ListResponse } from '@cognite/sdk';
-import { IndexSet, NumericRange } from '../../utilities';
-import { AreaCollection } from './prioritized/AreaCollection';
-/**
- * Helper class that populates an IndexSet based on a paged results from the Cognite SDK.
- */
-export declare class PopulateIndexSetFromPagedResponseHelper<T> {
-    private readonly _itemsToTreeIndexRangesCallback;
-    private readonly _itemsToAreasCallback;
-    private readonly _notifyChangedCallback;
-    private _ongoingOperations;
-    private _interrupted;
-    private readonly _indexSet;
-    private readonly _areas;
-    constructor(itemsToTreeIndexRangesCallback: (items: T[]) => NumericRange[], itemsToAreasCallback: (items: T[]) => Promise<THREE.Box3[]>, notifySetChangedCallback: () => void);
-    interrupt(): void;
-    get isLoading(): boolean;
-    get indexSet(): IndexSet;
-    get areas(): AreaCollection;
-    /**
-     * Loops through all the pages of the provided response and populated the IndexSet provided.
-     * @param request
-     * @returns True if the operation was completed, false if it was interrupted using {@link interrupt}.
-     */
-    pageResults(request: Promise<ListResponse<T[]>>): Promise<boolean>;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { ListResponse } from '@cognite/sdk';
+import { IndexSet, NumericRange } from '../../utilities';
+import { AreaCollection } from './prioritized/AreaCollection';
+/**
+ * Helper class that populates an IndexSet based on a paged results from the Cognite SDK.
+ */
+export declare class PopulateIndexSetFromPagedResponseHelper<T> {
+    private readonly _itemsToTreeIndexRangesCallback;
+    private readonly _itemsToAreasCallback;
+    private readonly _notifyChangedCallback;
+    private _ongoingOperations;
+    private _interrupted;
+    private readonly _indexSet;
+    private readonly _areas;
+    constructor(itemsToTreeIndexRangesCallback: (items: T[]) => NumericRange[], itemsToAreasCallback: (items: T[]) => Promise<THREE.Box3[]>, notifySetChangedCallback: () => void);
+    interrupt(): void;
+    get isLoading(): boolean;
+    get indexSet(): IndexSet;
+    get areas(): AreaCollection;
+    /**
+     * Loops through all the pages of the provided response and populated the IndexSet provided.
+     * @param request
+     * @returns True if the operation was completed, false if it was interrupted using {@link interrupt}.
+     */
+    pageResults(request: Promise<ListResponse<T[]>>): Promise<boolean>;
+}

package/packages/cad-styling/src/PropertyFilterNodeCollection.d.ts

@@ -1,57 +1,57 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { CogniteClient } from '@cognite/sdk';
-import { AreaCollection } from './prioritized/AreaCollection';
-import { NodeCollection } from './NodeCollection';
-import { SerializedNodeCollection } from './SerializedNodeCollection';
-import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
-import { IndexSet } from '../../utilities';
-/**
- * Options for {@link PropertyFilterNodeCollection}.
- */
-export declare type PropertyFilterNodeCollectionOptions = {
-    /**
-     * How many partitions to split the request into. More partitions can yield better performance
-     * for queries with very large result set (in order of magnitude 100.000 plus).
-     * Defaults to 1.
-     */
-    requestPartitions?: number;
-};
-/**
- * Represents a set of nodes that has matching node properties to a provided filter. Note that
- * a node is considered to match if it or a {@link NodeCollection} ancestors match the filter.
- */
-export declare class PropertyFilterNodeCollection extends NodeCollection {
-    static readonly classToken = "PropertyFilterNodeCollection";
-    private readonly _client;
-    private _indexSet;
-    private _areas;
-    private readonly _model;
-    private readonly _options;
-    private _fetchResultHelper;
-    private _filter;
-    constructor(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, options?: PropertyFilterNodeCollectionOptions);
-    get isLoading(): boolean;
-    /**
-     * Populates the node collection with nodes matching the provided filter. This will replace
-     * the current nodes held by the filter.
-     * @param filter A filter for matching node properties.
-     * @example
-     * ```
-     * set.executeFilter({ 'PDMS': { 'Module': 'AQ550' }});
-     * ```
-     */
-    executeFilter(filter: {
-        [category: string]: {
-            [key: string]: string;
-        };
-    }): Promise<void>;
-    /**
-     * Clears the node collection and interrupts any ongoing operations.
-     */
-    clear(): void;
-    getIndexSet(): IndexSet;
-    getAreas(): AreaCollection;
-    serialize(): SerializedNodeCollection;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { CogniteClient } from '@cognite/sdk';
+import { AreaCollection } from './prioritized/AreaCollection';
+import { NodeCollection } from './NodeCollection';
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
+import { IndexSet } from '../../utilities';
+/**
+ * Options for {@link PropertyFilterNodeCollection}.
+ */
+export declare type PropertyFilterNodeCollectionOptions = {
+    /**
+     * How many partitions to split the request into. More partitions can yield better performance
+     * for queries with very large result set (in order of magnitude 100.000 plus).
+     * Defaults to 1.
+     */
+    requestPartitions?: number;
+};
+/**
+ * Represents a set of nodes that has matching node properties to a provided filter. Note that
+ * a node is considered to match if it or a {@link NodeCollection} ancestors match the filter.
+ */
+export declare class PropertyFilterNodeCollection extends NodeCollection {
+    static readonly classToken = "PropertyFilterNodeCollection";
+    private readonly _client;
+    private _indexSet;
+    private _areas;
+    private readonly _model;
+    private readonly _options;
+    private _fetchResultHelper;
+    private _filter;
+    constructor(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, options?: PropertyFilterNodeCollectionOptions);
+    get isLoading(): boolean;
+    /**
+     * Populates the node collection with nodes matching the provided filter. This will replace
+     * the current nodes held by the filter.
+     * @param filter A filter for matching node properties.
+     * @example
+     * ```
+     * set.executeFilter({ 'PDMS': { 'Module': 'AQ550' }});
+     * ```
+     */
+    executeFilter(filter: {
+        [category: string]: {
+            [key: string]: string;
+        };
+    }): Promise<void>;
+    /**
+     * Clears the node collection and interrupts any ongoing operations.
+     */
+    clear(): void;
+    getIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
+    serialize(): SerializedNodeCollection;
+}

package/packages/cad-styling/src/SerializedNodeCollection.d.ts

@@ -1,8 +1,8 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-export declare type SerializedNodeCollection = {
-    token: string;
-    state: any;
-    options?: any;
-};
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export declare type SerializedNodeCollection = {
+    token: string;
+    state: any;
+    options?: any;
+};

package/packages/cad-styling/src/SinglePropertyFilterNodeCollection.d.ts

@@ -1,53 +1,53 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { PropertyFilterNodeCollectionOptions } from './PropertyFilterNodeCollection';
-import { IndexSet } from '../../utilities';
-import { AreaCollection } from './prioritized/AreaCollection';
-import { NodeCollection } from './NodeCollection';
-import { SerializedNodeCollection } from './SerializedNodeCollection';
-import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
-import { CogniteClient } from '@cognite/sdk';
-/**
- * Node collection that filters nodes based on a node property from a list of values, similarly to how
- * `SELECT ... IN (...)` works. This is useful when looking up nodes based on a list of identifiers,
- * nodes within a set of areas or systems. The node set is optimized for matching with properties with
- * a large number of values (i.e. thousands).
- */
-export declare class SinglePropertyFilterNodeCollection extends NodeCollection {
-    static readonly classToken = "SinglePropertyNodeCollection";
-    private readonly _client;
-    private readonly _model;
-    private _indexSet;
-    private _areas;
-    private readonly _options;
-    private _fetchResultHelper;
-    private readonly _filter;
-    /**
-     * Construct a new node set.
-     * @param client   {@link CogniteClient} authenticated to the project the model is loaded from.
-     * @param model    CAD model.
-     * @param options
-     */
-    constructor(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, options?: PropertyFilterNodeCollectionOptions);
-    get isLoading(): boolean;
-    /**
-     * Execute filter asynchronously, replacing any existing filter active. When {@link propertyValues}
-     * contains more than 1000 elements, the operation will be split into multiple batches that
-     * are executed in parallel. Note that when providing a {@link PropertyFilterNodeCollectionOptions.requestPartitions}
-     * during construction of the node set, the total number of batches will be requestPartitions*numberOfBatches.
-     *
-     * @param propertyCategory Node property category, e.g. `'PDMS'`.
-     * @param propertyKey Node property key, e.g. `':FU'`.
-     * @param propertyValues Lookup values, e.g. `["AR100APG539","AP500INF534","AP400INF553", ...]`
-     */
-    executeFilter(propertyCategory: string, propertyKey: string, propertyValues: string[]): Promise<void>;
-    /**
-     * Clears the node set and interrupts any ongoing operations.
-     */
-    clear(): void;
-    getIndexSet(): IndexSet;
-    getAreas(): AreaCollection;
-    private buildUrl;
-    serialize(): SerializedNodeCollection;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { PropertyFilterNodeCollectionOptions } from './PropertyFilterNodeCollection';
+import { IndexSet } from '../../utilities';
+import { AreaCollection } from './prioritized/AreaCollection';
+import { NodeCollection } from './NodeCollection';
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+import { CdfModelNodeCollectionDataProvider } from './CdfModelNodeCollectionDataProvider';
+import { CogniteClient } from '@cognite/sdk';
+/**
+ * Node collection that filters nodes based on a node property from a list of values, similarly to how
+ * `SELECT ... IN (...)` works. This is useful when looking up nodes based on a list of identifiers,
+ * nodes within a set of areas or systems. The node set is optimized for matching with properties with
+ * a large number of values (i.e. thousands).
+ */
+export declare class SinglePropertyFilterNodeCollection extends NodeCollection {
+    static readonly classToken = "SinglePropertyNodeCollection";
+    private readonly _client;
+    private readonly _model;
+    private _indexSet;
+    private _areas;
+    private readonly _options;
+    private _fetchResultHelper;
+    private readonly _filter;
+    /**
+     * Construct a new node set.
+     * @param client   {@link CogniteClient} authenticated to the project the model is loaded from.
+     * @param model    CAD model.
+     * @param options
+     */
+    constructor(client: CogniteClient, model: CdfModelNodeCollectionDataProvider, options?: PropertyFilterNodeCollectionOptions);
+    get isLoading(): boolean;
+    /**
+     * Execute filter asynchronously, replacing any existing filter active. When {@link propertyValues}
+     * contains more than 1000 elements, the operation will be split into multiple batches that
+     * are executed in parallel. Note that when providing a {@link PropertyFilterNodeCollectionOptions.requestPartitions}
+     * during construction of the node set, the total number of batches will be requestPartitions*numberOfBatches.
+     *
+     * @param propertyCategory Node property category, e.g. `'PDMS'`.
+     * @param propertyKey Node property key, e.g. `':FU'`.
+     * @param propertyValues Lookup values, e.g. `["AR100APG539","AP500INF534","AP400INF553", ...]`
+     */
+    executeFilter(propertyCategory: string, propertyKey: string, propertyValues: string[]): Promise<void>;
+    /**
+     * Clears the node set and interrupts any ongoing operations.
+     */
+    clear(): void;
+    getIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
+    private buildUrl;
+    serialize(): SerializedNodeCollection;
+}

package/packages/cad-styling/src/TreeIndexNodeCollection.d.ts

@@ -1,40 +1,40 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { AreaCollection } from './prioritized/AreaCollection';
-import { NodeCollection } from './NodeCollection';
-import { SerializedNodeCollection } from './SerializedNodeCollection';
-import { NumericRange, IndexSet } from '../../utilities';
-/**
- * Node collection that holds a set of nodes defined by a set of tree indices.
- */
-export declare class TreeIndexNodeCollection extends NodeCollection {
-    static readonly classToken = "TreeIndexNodeCollection";
-    private _treeIndices;
-    private _areaCollection;
-    constructor(treeIndexSet?: IndexSet);
-    constructor(treeIndices?: Iterable<number>);
-    constructor(treeIndexRange?: NumericRange);
-    updateSet(treeIndices: IndexSet): void;
-    /**
-     * Sets this set to hold an empty set.
-     */
-    clear(): void;
-    getIndexSet(): IndexSet;
-    getAreas(): AreaCollection;
-    /**
-     * Add areas to this node collection's area set.
-     * Nearby areas may be clustered and merged together to keep
-     * the number of areas in the set small.
-     */
-    addAreas(areas: THREE.Box3[]): void;
-    /**
-     * Add points to this node collection's area set.
-     * This effectively adds boxes of size 1x1x1 meter with the points as their centers.
-     */
-    addAreaPoints(points: THREE.Vector3[]): void;
-    clearAreas(): void;
-    get isLoading(): boolean;
-    serialize(): SerializedNodeCollection;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { AreaCollection } from './prioritized/AreaCollection';
+import { NodeCollection } from './NodeCollection';
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+import { NumericRange, IndexSet } from '../../utilities';
+/**
+ * Node collection that holds a set of nodes defined by a set of tree indices.
+ */
+export declare class TreeIndexNodeCollection extends NodeCollection {
+    static readonly classToken = "TreeIndexNodeCollection";
+    private _treeIndices;
+    private _areaCollection;
+    constructor(treeIndexSet?: IndexSet);
+    constructor(treeIndices?: Iterable<number>);
+    constructor(treeIndexRange?: NumericRange);
+    updateSet(treeIndices: IndexSet): void;
+    /**
+     * Sets this set to hold an empty set.
+     */
+    clear(): void;
+    getIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
+    /**
+     * Add areas to this node collection's area set.
+     * Nearby areas may be clustered and merged together to keep
+     * the number of areas in the set small.
+     */
+    addAreas(areas: THREE.Box3[]): void;
+    /**
+     * Add points to this node collection's area set.
+     * This effectively adds boxes of size 1x1x1 meter with the points as their centers.
+     */
+    addAreaPoints(points: THREE.Vector3[]): void;
+    clearAreas(): void;
+    get isLoading(): boolean;
+    serialize(): SerializedNodeCollection;
+}

package/packages/cad-styling/src/UnionNodeCollection.d.ts

@@ -1,19 +1,19 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { SerializedNodeCollection } from './SerializedNodeCollection';
-import { NodeCollection } from './NodeCollection';
-import { CombineNodeCollectionBase } from './CombineNodeCollectionBase';
-import { AreaCollection } from './prioritized/AreaCollection';
-import { IndexSet } from '../../utilities';
-/**
- * Node collection that takes the set union of multiple node collections.
- */
-export declare class UnionNodeCollection extends CombineNodeCollectionBase {
-    private _cachedNodeAreas;
-    static readonly classToken = "UnionNodeCollection";
-    constructor(nodeCollections?: NodeCollection[]);
-    serialize(): SerializedNodeCollection;
-    protected createCombinedIndexSet(): IndexSet;
-    getAreas(): AreaCollection;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+import { NodeCollection } from './NodeCollection';
+import { CombineNodeCollectionBase } from './CombineNodeCollectionBase';
+import { AreaCollection } from './prioritized/AreaCollection';
+import { IndexSet } from '../../utilities';
+/**
+ * Node collection that takes the set union of multiple node collections.
+ */
+export declare class UnionNodeCollection extends CombineNodeCollectionBase {
+    private _cachedNodeAreas;
+    static readonly classToken = "UnionNodeCollection";
+    constructor(nodeCollections?: NodeCollection[]);
+    serialize(): SerializedNodeCollection;
+    protected createCombinedIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
+}

package/packages/cad-styling/src/prioritized/AreaCollection.d.ts

@@ -1,39 +1,39 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * Represents a collection of areas/axis-aligned
- * bounding boxes for use e.g. for load prioritization. Implementations
- * are not expected to store all areas inserted with `addAreas`,
- * but rather some "representative box set" covering the inserted areas.
- * Performance will be better the fewer boxes the representative set contains,
- * while the effectiveness of node prioritization will suffer if the
- * representative set covers too much area that is not part
- * of the inserted boxes
- */
-export interface AreaCollection {
-    readonly isEmpty: boolean;
-    /**
-     * Return some set of boxes that cover the boxes inserted with `addAreas`.
-     * It is required that each inserted box is completely covered by some
-     * subset of boxes in the set returned from `areas`
-     */
-    areas(): Generator<THREE.Box3>;
-    /**
-     * Return whether the input box intersects the AreaCollection.
-     */
-    intersectsBox(box: THREE.Box3): boolean;
-    /**
-     * Add areas to be covered by the representative set of this
-     * AreaCollection.
-     */
-    addAreas(boxes: Iterable<THREE.Box3>): void;
-    /**
-     * Alter the representative set to cover only the intersection between the
-     * representative set of this AreaCollection and the incoming boxes.
-     * Note that the intersection of two representative sets A' and B' that
-     * represent the original box sets A and B will cover the intersection between
-     * A and B, and will thus be a valid representative set for the intersection of A and B.
-     */
-    intersectWith(boxes: Iterable<THREE.Box3>): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Represents a collection of areas/axis-aligned
+ * bounding boxes for use e.g. for load prioritization. Implementations
+ * are not expected to store all areas inserted with `addAreas`,
+ * but rather some "representative box set" covering the inserted areas.
+ * Performance will be better the fewer boxes the representative set contains,
+ * while the effectiveness of node prioritization will suffer if the
+ * representative set covers too much area that is not part
+ * of the inserted boxes
+ */
+export interface AreaCollection {
+    readonly isEmpty: boolean;
+    /**
+     * Return some set of boxes that cover the boxes inserted with `addAreas`.
+     * It is required that each inserted box is completely covered by some
+     * subset of boxes in the set returned from `areas`
+     */
+    areas(): Generator<THREE.Box3>;
+    /**
+     * Return whether the input box intersects the AreaCollection.
+     */
+    intersectsBox(box: THREE.Box3): boolean;
+    /**
+     * Add areas to be covered by the representative set of this
+     * AreaCollection.
+     */
+    addAreas(boxes: Iterable<THREE.Box3>): void;
+    /**
+     * Alter the representative set to cover only the intersection between the
+     * representative set of this AreaCollection and the incoming boxes.
+     * Note that the intersection of two representative sets A' and B' that
+     * represent the original box sets A and B will cover the intersection between
+     * A and B, and will thus be a valid representative set for the intersection of A and B.
+     */
+    intersectWith(boxes: Iterable<THREE.Box3>): void;
+}

package/packages/cad-styling/src/prioritized/BoxClusterer.d.ts

@@ -1,29 +1,29 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { Box3 } from 'three';
-/**
- * SmartMergeBoxes - takes in batches of bounding boxes and
- * clusters them together in larger bounding boxes. The union of the larger
- * boxes contains all boxes that have been inserted
- */
-export declare class BoxClusterer {
-    private readonly resultBoxes;
-    private addedSinceSquash;
-    constructor();
-    constructor(boxes: Box3[]);
-    private mergeBoxesAtIndices;
-    private readonly _surfaceAreaVars;
-    private surfaceArea;
-    private readonly _shouldMergeBoxesVars;
-    private shouldMergeBoxes;
-    private addBox;
-    get boxCount(): number;
-    addBoxes(boxes: Iterable<Box3>): void;
-    squashBoxes(): void;
-    getBoxes(): Generator<Box3>;
-    intersectsBox(box: Box3): boolean;
-    union(boxes: Iterable<Box3>): BoxClusterer;
-    private addIntersectionIfNonempty;
-    intersection(other: Iterable<THREE.Box3>): BoxClusterer;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Box3 } from 'three';
+/**
+ * SmartMergeBoxes - takes in batches of bounding boxes and
+ * clusters them together in larger bounding boxes. The union of the larger
+ * boxes contains all boxes that have been inserted
+ */
+export declare class BoxClusterer {
+    private readonly resultBoxes;
+    private addedSinceSquash;
+    constructor();
+    constructor(boxes: Box3[]);
+    private mergeBoxesAtIndices;
+    private readonly _surfaceAreaVars;
+    private surfaceArea;
+    private readonly _shouldMergeBoxesVars;
+    private shouldMergeBoxes;
+    private addBox;
+    get boxCount(): number;
+    addBoxes(boxes: Iterable<Box3>): void;
+    squashBoxes(): void;
+    getBoxes(): Generator<Box3>;
+    intersectsBox(box: Box3): boolean;
+    union(boxes: Iterable<Box3>): BoxClusterer;
+    private addIntersectionIfNonempty;
+    intersection(other: Iterable<THREE.Box3>): BoxClusterer;
+}

package/packages/cad-styling/src/prioritized/ClusteredAreaCollection.d.ts

@@ -1,17 +1,17 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { AreaCollection } from './AreaCollection';
-/**
- * AreaCollection that stores a representative box set by merging
- * inserted boxes that are overlapping or close to each other.
- * It uses simple heuristics to determine which boxes are to be merged.
- */
-export declare class ClusteredAreaCollection implements AreaCollection {
-    private readonly _clusterer;
-    get isEmpty(): boolean;
-    areas(): Generator<THREE.Box3>;
-    intersectsBox(box: THREE.Box3): boolean;
-    addAreas(boxes: Iterable<THREE.Box3>): void;
-    intersectWith(boxes: Iterable<THREE.Box3>): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { AreaCollection } from './AreaCollection';
+/**
+ * AreaCollection that stores a representative box set by merging
+ * inserted boxes that are overlapping or close to each other.
+ * It uses simple heuristics to determine which boxes are to be merged.
+ */
+export declare class ClusteredAreaCollection implements AreaCollection {
+    private readonly _clusterer;
+    get isEmpty(): boolean;
+    areas(): Generator<THREE.Box3>;
+    intersectsBox(box: THREE.Box3): boolean;
+    addAreas(boxes: Iterable<THREE.Box3>): void;
+    intersectWith(boxes: Iterable<THREE.Box3>): void;
+}