@itwin/core-common 3.7.0-dev.6 → 3.7.0-dev.8

package/lib/cjs/FeatureTable.d.ts

@@ -1,249 +1,249 @@
-/** @packageDocumentation
- * @module Rendering
- */
-import { Id64, Id64String, IndexedValue, IndexMap } from "@itwin/core-bentley";
-import { GeometryClass } from "./GeometryParams";
-/** Describes a discrete entity within a batched [RenderGraphic]($frontend) that can be
- * grouped with other such entities in a [[FeatureTable]].
- * Features roughly correlate to elements: a [Tile]($frontend)'s graphics combines geometry from every
- * [GeometricElement]($backend) that intersects the tile's volume, so each element produces at least one feature.
- * However, an element's geometry stream can contain geometry belonging to multiple different combinations of [SubCategory]($backend) and
- * [[GeometryClass]], so an individual element may produce more than one feature.
- * @see [[FeatureOverrides]] for customizing the appearance of individual features.
- * @public
- */
-export declare class Feature {
-    readonly elementId: Id64String;
-    readonly subCategoryId: Id64String;
-    readonly geometryClass: GeometryClass;
-    constructor(elementId?: Id64String, subCategoryId?: Id64String, geometryClass?: GeometryClass);
-    get isDefined(): boolean;
-    get isUndefined(): boolean;
-    /** Returns true if this feature is equivalent to the supplied feature. */
-    equals(other: Feature): boolean;
-    /** Performs ordinal comparison of this feature with another.
-     * @param rhs The feature to compare with.
-     * @returns zero if the features are equivalent, a negative value if this feature compares as "less than" `rhs`, or a positive value if this feature compares "greater than" `rhs`.
-     */
-    compare(rhs: Feature): number;
-}
-/** A [[Feature]] with a modelId identifying the model containing the feature.
- * Typically produced from a PackedFeature.
- * Prior to the introduction of MultiModelPackedFeatureTable, every (Packed)FeatureTable was associated with exactly one model.
- * Now, each feature in a table may be associated with a different model.
- * @internal
- */
-export interface ModelFeature {
-    modelId: Id64String;
-    elementId: Id64String;
-    subCategoryId: Id64String;
-    geometryClass: GeometryClass;
-}
-/** @internal */
-export declare namespace ModelFeature {
-    function create(): ModelFeature;
-    function isDefined(feature: ModelFeature): boolean;
-    function unpack(packed: PackedFeature, result: ModelFeature, unpackedModelId?: Id64String): ModelFeature;
-}
-/** @internal */
-export interface PackedFeature {
-    modelId: Id64.Uint32Pair;
-    elementId: Id64.Uint32Pair;
-    subCategoryId: Id64.Uint32Pair;
-    geometryClass: GeometryClass;
-    animationNodeId: number;
-}
-/** @internal */
-export interface PackedFeatureWithIndex extends PackedFeature {
-    index: number;
-}
-/** @internal */
-export declare namespace PackedFeature {
-    function create(): PackedFeature;
-    function createWithIndex(): PackedFeatureWithIndex;
-}
-/** Describes the type of a 'batch' of graphics representing multiple [[Feature]]s.
- * The most commonly-encountered batches are Tiles, which can be of either Primary or
- * Classifier type.
- * @public
- * @extensions
- */
-export declare enum BatchType {
-    /** This batch contains graphics derived from a model's visible geometry. */
-    Primary = 0,
-    /**
-     * This batch contains color volumes which are used to classify a model's visible geometry.
-     * The graphics themselves are not rendered to the screen; instead they are rendered to the stencil buffer
-     * to resymbolize the primary geometry.
-     */
-    VolumeClassifier = 1,
-    /**
-     * This batch contains planar graphics which are used to classify a model's visible geometry.
-     * The graphics themselves are not rendered to the screen; instead they are rendered to a texture buffer
-     * to resymbolize the primary geometry.
-     */
-    PlanarClassifier = 2
-}
-/** Defines a look-up table for [[Feature]]s within a batched [RenderGraphic]($frontend). Consecutive 32-bit
- * indices are assigned to each unique Feature. Primitives within the RenderGraphic can
- * use per-vertex indices to specify the distribution of Features within the primitive. The appearance of individual
- * features can be customized using [[FeatureOverrides]]. Typically a [Tile]($frontend) will contain a feature table
- * identifying the elements whose geometry appears within that tile.
- * @see [[FeatureOverrides]] for customizing the appearance of individual features.
- * @public
- */
-export declare class FeatureTable extends IndexMap<Feature> {
-    readonly modelId: Id64String;
-    readonly type: BatchType;
-    /** Construct an empty FeatureTable. */
-    constructor(maxFeatures: number, modelId?: Id64String, type?: BatchType);
-    /** Returns the maximum number of [[Feature]]s this FeatureTable can contain. */
-    get maxFeatures(): number;
-    /** @internal */
-    get anyDefined(): boolean;
-    /** Returns true if this FeatureTable contains exactly one [[Feature]]. */
-    get isUniform(): boolean;
-    /** If this FeatureTable contains exactly one [[Feature]], returns that Feature; otherwise returns undefined. */
-    get uniform(): Feature | undefined;
-    /** Returns true if this FeatureTable is associated with [[BatchType.VolumeClassifier]] geometry. */
-    get isVolumeClassifier(): boolean;
-    /** Returns true if this FeatureTable is associated with [[BatchType.PlanarClassifier]] geometry. */
-    get isPlanarClassifier(): boolean;
-    /** Returns the Feature corresponding to the specified index, or undefined if the index is not present. */
-    findFeature(index: number): Feature | undefined;
-    /** @internal */
-    insertWithIndex(feature: Feature, index: number): void;
-    /** @internal */
-    getArray(): Array<IndexedValue<Feature>>;
-}
-/** @alpha */
-export declare type ComputeNodeId = (elementId: Id64.Uint32Pair, featureIndex: number) => number;
-/** Interface common to PackedFeatureTable and MultiModelPackedFeatureTable.
- * @internal
- */
-export interface RenderFeatureTable {
-    /** The "model Id" of the tile tree containing the tile from which this feature table originated.
-     * It may be a transient Id if, for example, the tile tree represents a reality model or represents the geometry of multiple
-     * persistent models batched together.
-     */
-    readonly batchModelId: Id64String;
-    /** Split representation of batchModelId, so we're not constantly having to parse the string. */
-    readonly batchModelIdPair: Id64.Uint32Pair;
-    /** The number of features in the table; equivalently, one more than the largest feature index. */
-    readonly numFeatures: number;
-    /** Strictly for reporting memory usage. */
-    readonly byteLength: number;
-    readonly type: BatchType;
-    /** Get the feature at the specified index. Caller is responsible for validating featureIndex less than numFeatures. */
-    getFeature(featureIndex: number, result: ModelFeature): ModelFeature;
-    /** Find the specified feature. Returns undefined if featureIndex >= numFeatures. */
-    findFeature(featureIndex: number, result: ModelFeature): ModelFeature | undefined;
-    /** Find the Id of the element of the specified feature. */
-    findElementId(featureIndex: number): Id64String | undefined;
-    /** Get the Id of the element of the specified feature as a pair of 32-bit integers, asserting that feature index < numFeatures. */
-    getElementIdPair(featureIndex: number, out: Id64.Uint32Pair): Id64.Uint32Pair;
-    /** Get the feature at the specified index. Caller is responsible for validating featureIndex less than numFeatures. */
-    getPackedFeature(featureIndex: number, result: PackedFeature): PackedFeature;
-    /** Get an object that provides iteration over all features, in order. `output` is reused as the current value on each iteration. */
-    iterable(output: PackedFeatureWithIndex): Iterable<PackedFeatureWithIndex>;
-}
-/**
- * An immutable, packed representation of a [[FeatureTable]]. The features are packed into a single array of 32-bit integer values,
- * wherein each feature occupies 3 32-bit integers.
- * @internal
- */
-export declare class PackedFeatureTable implements RenderFeatureTable {
-    private readonly _data;
-    readonly batchModelId: Id64String;
-    readonly batchModelIdPair: Id64.Uint32Pair;
-    readonly numFeatures: number;
-    readonly anyDefined: boolean;
-    readonly type: BatchType;
-    private _animationNodeIds?;
-    get byteLength(): number;
-    get animationNodeIds(): Readonly<Uint8Array | Uint16Array | Uint32Array> | undefined;
-    /** Construct a PackedFeatureTable from the packed binary data.
-     * This is used internally when deserializing Tiles in iMdl format.
-     * @internal
-     */
-    constructor(data: Uint32Array, modelId: Id64String, numFeatures: number, type: BatchType, animationNodeIds?: Uint8Array | Uint16Array | Uint32Array);
-    /** Create a packed feature table from a [[FeatureTable]]. */
-    static pack(featureTable: FeatureTable): PackedFeatureTable;
-    /** Retrieve the Feature associated with the specified index. */
-    getFeature(featureIndex: number, result: ModelFeature): ModelFeature;
-    /** Returns the Feature associated with the specified index, or undefined if the index is out of range. */
-    findFeature(featureIndex: number, result: ModelFeature): ModelFeature | undefined;
-    /** @internal */
-    getElementIdPair(featureIndex: number, out?: Id64.Uint32Pair): Id64.Uint32Pair;
-    /** @internal */
-    getSubCategoryIdPair(featureIndex: number): Id64.Uint32Pair;
-    /** @internal */
-    getAnimationNodeId(featureIndex: number): number;
-    /** @internal */
-    getPackedFeature(featureIndex: number, result: PackedFeature): PackedFeature;
-    /** Returns the element ID of the Feature associated with the specified index, or undefined if the index is out of range. */
-    findElementId(featureIndex: number): Id64String | undefined;
-    /** Return true if this table contains exactly 1 feature. */
-    get isUniform(): boolean;
-    /** If this table contains exactly 1 feature, return it. */
-    getUniform(result: ModelFeature): ModelFeature | undefined;
-    get isVolumeClassifier(): boolean;
-    get isPlanarClassifier(): boolean;
-    get isClassifier(): boolean;
-    /** Unpack the features into a [[FeatureTable]]. */
-    unpack(): FeatureTable;
-    populateAnimationNodeIds(computeNodeId: ComputeNodeId, maxNodeId: number): void;
-    iterator(output: PackedFeatureWithIndex): Iterator<PackedFeatureWithIndex>;
-    iterable(output: PackedFeatureWithIndex): Iterable<PackedFeatureWithIndex>;
-    private get _subCategoriesOffset();
-    private readId;
-}
-interface PackedFeatureModelEntry {
-    lastFeatureIndex: number;
-    idLower: number;
-    idUpper: number;
-}
-/** A table of model Ids associated with a [[MultiModelPackedFeatureTable]].
- * The feature indices in the packed feature table are grouped together by model, such that the first N features belong to model 1, the next M features to model 2, and so on.
- * The model table itself consists of one entry per model, where each entry looks like:
- *  indexOfLastFeatureInModel: u32
- *  modelId: u64
- * The modelId associated with a feature can therefore be derived by finding the entry in the model table with the highest indexOfLastFeatureInModel no greater than the feature index.
- * This lookup can be optimized using binary search.
- * Moreover, while iterating the feature table in sequence, the model table can be iterated in parallel so that no per-feature lookup of model Id is required.
- * @internal
- */
-export declare class PackedFeatureModelTable {
-    private readonly _data;
-    constructor(data: Uint32Array);
-    /** The number of models in the table. */
-    get length(): number;
-    get byteLength(): number;
-    private getLastFeatureIndex;
-    getEntry(modelIndex: number, result: PackedFeatureModelEntry): PackedFeatureModelEntry;
-    /** Get the Id of the model associated with the specified feature, or an invalid Id if the feature is not associated with any model. */
-    getModelIdPair(featureIndex: number, result?: Id64.Uint32Pair): Id64.Uint32Pair;
-}
-/** A PackedFeatureTable with a PackedFeatureModelTable appended to it, capable of storing features belonging to more than one model.
- * @internal
- */
-export declare class MultiModelPackedFeatureTable implements RenderFeatureTable {
-    private readonly _features;
-    private readonly _models;
-    constructor(features: PackedFeatureTable, models: PackedFeatureModelTable);
-    static create(data: Uint32Array, batchModelId: Id64String, numFeatures: number, type: BatchType, numSubCategories: number): MultiModelPackedFeatureTable;
-    get batchModelId(): string;
-    get batchModelIdPair(): Id64.Uint32Pair;
-    get numFeatures(): number;
-    get type(): BatchType;
-    get byteLength(): number;
-    getPackedFeature(featureIndex: number, result: PackedFeature): PackedFeature;
-    getFeature(featureIndex: number, result: ModelFeature): ModelFeature;
-    findFeature(featureIndex: number, result: ModelFeature): ModelFeature | undefined;
-    getElementIdPair(featureIndex: number, out: Id64.Uint32Pair): Id64.Uint32Pair;
-    findElementId(featureIndex: number): Id64String | undefined;
-    iterator(output: PackedFeatureWithIndex): Iterator<PackedFeatureWithIndex>;
-    iterable(output: PackedFeatureWithIndex): Iterable<PackedFeatureWithIndex>;
-}
-export {};
+/** @packageDocumentation
+ * @module Rendering
+ */
+import { Id64, Id64String, IndexedValue, IndexMap } from "@itwin/core-bentley";
+import { GeometryClass } from "./GeometryParams";
+/** Describes a discrete entity within a batched [RenderGraphic]($frontend) that can be
+ * grouped with other such entities in a [[FeatureTable]].
+ * Features roughly correlate to elements: a [Tile]($frontend)'s graphics combines geometry from every
+ * [GeometricElement]($backend) that intersects the tile's volume, so each element produces at least one feature.
+ * However, an element's geometry stream can contain geometry belonging to multiple different combinations of [SubCategory]($backend) and
+ * [[GeometryClass]], so an individual element may produce more than one feature.
+ * @see [[FeatureOverrides]] for customizing the appearance of individual features.
+ * @public
+ */
+export declare class Feature {
+    readonly elementId: Id64String;
+    readonly subCategoryId: Id64String;
+    readonly geometryClass: GeometryClass;
+    constructor(elementId?: Id64String, subCategoryId?: Id64String, geometryClass?: GeometryClass);
+    get isDefined(): boolean;
+    get isUndefined(): boolean;
+    /** Returns true if this feature is equivalent to the supplied feature. */
+    equals(other: Feature): boolean;
+    /** Performs ordinal comparison of this feature with another.
+     * @param rhs The feature to compare with.
+     * @returns zero if the features are equivalent, a negative value if this feature compares as "less than" `rhs`, or a positive value if this feature compares "greater than" `rhs`.
+     */
+    compare(rhs: Feature): number;
+}
+/** A [[Feature]] with a modelId identifying the model containing the feature.
+ * Typically produced from a PackedFeature.
+ * Prior to the introduction of MultiModelPackedFeatureTable, every (Packed)FeatureTable was associated with exactly one model.
+ * Now, each feature in a table may be associated with a different model.
+ * @internal
+ */
+export interface ModelFeature {
+    modelId: Id64String;
+    elementId: Id64String;
+    subCategoryId: Id64String;
+    geometryClass: GeometryClass;
+}
+/** @internal */
+export declare namespace ModelFeature {
+    function create(): ModelFeature;
+    function isDefined(feature: ModelFeature): boolean;
+    function unpack(packed: PackedFeature, result: ModelFeature, unpackedModelId?: Id64String): ModelFeature;
+}
+/** @internal */
+export interface PackedFeature {
+    modelId: Id64.Uint32Pair;
+    elementId: Id64.Uint32Pair;
+    subCategoryId: Id64.Uint32Pair;
+    geometryClass: GeometryClass;
+    animationNodeId: number;
+}
+/** @internal */
+export interface PackedFeatureWithIndex extends PackedFeature {
+    index: number;
+}
+/** @internal */
+export declare namespace PackedFeature {
+    function create(): PackedFeature;
+    function createWithIndex(): PackedFeatureWithIndex;
+}
+/** Describes the type of a 'batch' of graphics representing multiple [[Feature]]s.
+ * The most commonly-encountered batches are Tiles, which can be of either Primary or
+ * Classifier type.
+ * @public
+ * @extensions
+ */
+export declare enum BatchType {
+    /** This batch contains graphics derived from a model's visible geometry. */
+    Primary = 0,
+    /**
+     * This batch contains color volumes which are used to classify a model's visible geometry.
+     * The graphics themselves are not rendered to the screen; instead they are rendered to the stencil buffer
+     * to resymbolize the primary geometry.
+     */
+    VolumeClassifier = 1,
+    /**
+     * This batch contains planar graphics which are used to classify a model's visible geometry.
+     * The graphics themselves are not rendered to the screen; instead they are rendered to a texture buffer
+     * to resymbolize the primary geometry.
+     */
+    PlanarClassifier = 2
+}
+/** Defines a look-up table for [[Feature]]s within a batched [RenderGraphic]($frontend). Consecutive 32-bit
+ * indices are assigned to each unique Feature. Primitives within the RenderGraphic can
+ * use per-vertex indices to specify the distribution of Features within the primitive. The appearance of individual
+ * features can be customized using [[FeatureOverrides]]. Typically a [Tile]($frontend) will contain a feature table
+ * identifying the elements whose geometry appears within that tile.
+ * @see [[FeatureOverrides]] for customizing the appearance of individual features.
+ * @public
+ */
+export declare class FeatureTable extends IndexMap<Feature> {
+    readonly modelId: Id64String;
+    readonly type: BatchType;
+    /** Construct an empty FeatureTable. */
+    constructor(maxFeatures: number, modelId?: Id64String, type?: BatchType);
+    /** Returns the maximum number of [[Feature]]s this FeatureTable can contain. */
+    get maxFeatures(): number;
+    /** @internal */
+    get anyDefined(): boolean;
+    /** Returns true if this FeatureTable contains exactly one [[Feature]]. */
+    get isUniform(): boolean;
+    /** If this FeatureTable contains exactly one [[Feature]], returns that Feature; otherwise returns undefined. */
+    get uniform(): Feature | undefined;
+    /** Returns true if this FeatureTable is associated with [[BatchType.VolumeClassifier]] geometry. */
+    get isVolumeClassifier(): boolean;
+    /** Returns true if this FeatureTable is associated with [[BatchType.PlanarClassifier]] geometry. */
+    get isPlanarClassifier(): boolean;
+    /** Returns the Feature corresponding to the specified index, or undefined if the index is not present. */
+    findFeature(index: number): Feature | undefined;
+    /** @internal */
+    insertWithIndex(feature: Feature, index: number): void;
+    /** @internal */
+    getArray(): Array<IndexedValue<Feature>>;
+}
+/** @alpha */
+export declare type ComputeNodeId = (elementId: Id64.Uint32Pair, featureIndex: number) => number;
+/** Interface common to PackedFeatureTable and MultiModelPackedFeatureTable.
+ * @internal
+ */
+export interface RenderFeatureTable {
+    /** The "model Id" of the tile tree containing the tile from which this feature table originated.
+     * It may be a transient Id if, for example, the tile tree represents a reality model or represents the geometry of multiple
+     * persistent models batched together.
+     */
+    readonly batchModelId: Id64String;
+    /** Split representation of batchModelId, so we're not constantly having to parse the string. */
+    readonly batchModelIdPair: Id64.Uint32Pair;
+    /** The number of features in the table; equivalently, one more than the largest feature index. */
+    readonly numFeatures: number;
+    /** Strictly for reporting memory usage. */
+    readonly byteLength: number;
+    readonly type: BatchType;
+    /** Get the feature at the specified index. Caller is responsible for validating featureIndex less than numFeatures. */
+    getFeature(featureIndex: number, result: ModelFeature): ModelFeature;
+    /** Find the specified feature. Returns undefined if featureIndex >= numFeatures. */
+    findFeature(featureIndex: number, result: ModelFeature): ModelFeature | undefined;
+    /** Find the Id of the element of the specified feature. */
+    findElementId(featureIndex: number): Id64String | undefined;
+    /** Get the Id of the element of the specified feature as a pair of 32-bit integers, asserting that feature index < numFeatures. */
+    getElementIdPair(featureIndex: number, out: Id64.Uint32Pair): Id64.Uint32Pair;
+    /** Get the feature at the specified index. Caller is responsible for validating featureIndex less than numFeatures. */
+    getPackedFeature(featureIndex: number, result: PackedFeature): PackedFeature;
+    /** Get an object that provides iteration over all features, in order. `output` is reused as the current value on each iteration. */
+    iterable(output: PackedFeatureWithIndex): Iterable<PackedFeatureWithIndex>;
+}
+/**
+ * An immutable, packed representation of a [[FeatureTable]]. The features are packed into a single array of 32-bit integer values,
+ * wherein each feature occupies 3 32-bit integers.
+ * @internal
+ */
+export declare class PackedFeatureTable implements RenderFeatureTable {
+    private readonly _data;
+    readonly batchModelId: Id64String;
+    readonly batchModelIdPair: Id64.Uint32Pair;
+    readonly numFeatures: number;
+    readonly anyDefined: boolean;
+    readonly type: BatchType;
+    private _animationNodeIds?;
+    get byteLength(): number;
+    get animationNodeIds(): Readonly<Uint8Array | Uint16Array | Uint32Array> | undefined;
+    /** Construct a PackedFeatureTable from the packed binary data.
+     * This is used internally when deserializing Tiles in iMdl format.
+     * @internal
+     */
+    constructor(data: Uint32Array, modelId: Id64String, numFeatures: number, type: BatchType, animationNodeIds?: Uint8Array | Uint16Array | Uint32Array);
+    /** Create a packed feature table from a [[FeatureTable]]. */
+    static pack(featureTable: FeatureTable): PackedFeatureTable;
+    /** Retrieve the Feature associated with the specified index. */
+    getFeature(featureIndex: number, result: ModelFeature): ModelFeature;
+    /** Returns the Feature associated with the specified index, or undefined if the index is out of range. */
+    findFeature(featureIndex: number, result: ModelFeature): ModelFeature | undefined;
+    /** @internal */
+    getElementIdPair(featureIndex: number, out?: Id64.Uint32Pair): Id64.Uint32Pair;
+    /** @internal */
+    getSubCategoryIdPair(featureIndex: number): Id64.Uint32Pair;
+    /** @internal */
+    getAnimationNodeId(featureIndex: number): number;
+    /** @internal */
+    getPackedFeature(featureIndex: number, result: PackedFeature): PackedFeature;
+    /** Returns the element ID of the Feature associated with the specified index, or undefined if the index is out of range. */
+    findElementId(featureIndex: number): Id64String | undefined;
+    /** Return true if this table contains exactly 1 feature. */
+    get isUniform(): boolean;
+    /** If this table contains exactly 1 feature, return it. */
+    getUniform(result: ModelFeature): ModelFeature | undefined;
+    get isVolumeClassifier(): boolean;
+    get isPlanarClassifier(): boolean;
+    get isClassifier(): boolean;
+    /** Unpack the features into a [[FeatureTable]]. */
+    unpack(): FeatureTable;
+    populateAnimationNodeIds(computeNodeId: ComputeNodeId, maxNodeId: number): void;
+    iterator(output: PackedFeatureWithIndex): Iterator<PackedFeatureWithIndex>;
+    iterable(output: PackedFeatureWithIndex): Iterable<PackedFeatureWithIndex>;
+    private get _subCategoriesOffset();
+    private readId;
+}
+interface PackedFeatureModelEntry {
+    lastFeatureIndex: number;
+    idLower: number;
+    idUpper: number;
+}
+/** A table of model Ids associated with a [[MultiModelPackedFeatureTable]].
+ * The feature indices in the packed feature table are grouped together by model, such that the first N features belong to model 1, the next M features to model 2, and so on.
+ * The model table itself consists of one entry per model, where each entry looks like:
+ *  indexOfLastFeatureInModel: u32
+ *  modelId: u64
+ * The modelId associated with a feature can therefore be derived by finding the entry in the model table with the highest indexOfLastFeatureInModel no greater than the feature index.
+ * This lookup can be optimized using binary search.
+ * Moreover, while iterating the feature table in sequence, the model table can be iterated in parallel so that no per-feature lookup of model Id is required.
+ * @internal
+ */
+export declare class PackedFeatureModelTable {
+    private readonly _data;
+    constructor(data: Uint32Array);
+    /** The number of models in the table. */
+    get length(): number;
+    get byteLength(): number;
+    private getLastFeatureIndex;
+    getEntry(modelIndex: number, result: PackedFeatureModelEntry): PackedFeatureModelEntry;
+    /** Get the Id of the model associated with the specified feature, or an invalid Id if the feature is not associated with any model. */
+    getModelIdPair(featureIndex: number, result?: Id64.Uint32Pair): Id64.Uint32Pair;
+}
+/** A PackedFeatureTable with a PackedFeatureModelTable appended to it, capable of storing features belonging to more than one model.
+ * @internal
+ */
+export declare class MultiModelPackedFeatureTable implements RenderFeatureTable {
+    private readonly _features;
+    private readonly _models;
+    constructor(features: PackedFeatureTable, models: PackedFeatureModelTable);
+    static create(data: Uint32Array, batchModelId: Id64String, numFeatures: number, type: BatchType, numSubCategories: number): MultiModelPackedFeatureTable;
+    get batchModelId(): string;
+    get batchModelIdPair(): Id64.Uint32Pair;
+    get numFeatures(): number;
+    get type(): BatchType;
+    get byteLength(): number;
+    getPackedFeature(featureIndex: number, result: PackedFeature): PackedFeature;
+    getFeature(featureIndex: number, result: ModelFeature): ModelFeature;
+    findFeature(featureIndex: number, result: ModelFeature): ModelFeature | undefined;
+    getElementIdPair(featureIndex: number, out: Id64.Uint32Pair): Id64.Uint32Pair;
+    findElementId(featureIndex: number): Id64String | undefined;
+    iterator(output: PackedFeatureWithIndex): Iterator<PackedFeatureWithIndex>;
+    iterable(output: PackedFeatureWithIndex): Iterable<PackedFeatureWithIndex>;
+}
+export {};
 //# sourceMappingURL=FeatureTable.d.ts.map