@itwin/ecschema-metadata 5.10.0-dev.19 → 5.10.0-dev.20

package/lib/cjs/SchemaView.d.ts

@@ -0,0 +1,653 @@
+/** @packageDocumentation
+ * @module Schema
+ */
+import { type ClassData, ClassModifier, ClassType, type EnumerationData, type EnumeratorData, type KoqData, type PropCategoryData, type PropertyDef, PropertyKind, type PropertyRef, type RelConstraintData, type SchemaData, SchemaViewPrimitiveType } from "./SchemaViewInterfaces";
+import { StrengthDirection, StrengthType } from "./ECObjects";
+declare const _storage: unique symbol;
+/** Internal runtime storage attached to a SchemaView instance. Carries the immutable data
+ * tables built by SchemaViewBuilder plus two mutable caches populated lazily at runtime.
+ * @internal
+ */
+interface SchemaViewStorage extends SchemaViewData {
+    readonly transitiveBaseCache: Map<number, ReadonlySet<number>>;
+    derivedClassMap: ReadonlyMap<number, readonly number[]> | undefined;
+}
+/** A property reference paired with the index of the class that declared it. Used for
+ * property inheritance resolution - the classIdx tracks where each property originates
+ * (base class, mixin, or own) so consumers can discover the declaring class.
+ * @internal
+ */
+export interface ResolvedPropertyRef {
+    readonly ref: PropertyRef;
+    readonly classIdx: number;
+}
+/** Internal data bag passed from the builder to the context constructor.
+ * @internal
+ */
+export interface SchemaViewData {
+    readonly strings: readonly string[];
+    readonly lowerStrings: readonly string[];
+    readonly schemas: readonly SchemaData[];
+    readonly classes: readonly ClassData[];
+    readonly classMixins: readonly number[];
+    readonly propDefs: readonly PropertyDef[];
+    readonly propertyRefs: readonly PropertyRef[];
+    readonly relConstraints: readonly RelConstraintData[];
+    readonly constraintClassRefs: readonly number[];
+    readonly enumerations: readonly EnumerationData[];
+    readonly enumerators: readonly EnumeratorData[];
+    readonly koqs: readonly KoqData[];
+    readonly propCategories: readonly PropCategoryData[];
+    readonly schemaByName: ReadonlyMap<string, number>;
+    readonly schemaByAlias: ReadonlyMap<string, number>;
+    readonly classByName: ReadonlyMap<number, ReadonlyMap<string, number>>;
+    readonly enumByName: ReadonlyMap<number, ReadonlyMap<string, number>>;
+    readonly koqByName: ReadonlyMap<number, ReadonlyMap<string, number>>;
+    readonly catByName: ReadonlyMap<number, ReadonlyMap<string, number>>;
+}
+/** Read-only schema metadata view. Optimized for fast lookup and low memory usage.
+ *
+ * All data is stored in flat arrays. View objects (`SchemaView.Schema`, `SchemaView.Class`, etc.) are
+ * stateless wrappers that hold a reference to this view plus an index. They allocate nothing
+ * and cache nothing.
+ *
+ * The view is immutable after construction. Build it via `SchemaViewBuilder` or parse
+ * from a binary blob via `fromBinary`.
+ * @beta
+ */
+export declare class SchemaView {
+    /** @internal */
+    readonly [_storage]: SchemaViewStorage;
+    private _schemaToken;
+    private _outdated;
+    /** @internal */
+    constructor(data: SchemaViewData, schemaToken?: string);
+    /** SHA3-256 content hash of the ec_ schema tables at the time this view was built.
+     * Empty string if not set (e.g., when built from a builder without a token).
+     * @beta
+     */
+    get schemaToken(): string;
+    /** True if the host (`IModelDb` / `IModelConnection`) has replaced this view with a newer one.
+     * The view remains fully functional - it returns stale data rather than throwing.
+     * Consumers who stored a reference can check this flag for diagnostics.
+     * @beta
+     */
+    get isOutdated(): boolean;
+    /** Mark this view as outdated. Called by the host when a newer view replaces it.
+     * @internal
+     */
+    markOutdated(): void;
+    /** Number of schemas in the view. */
+    get schemaCount(): number;
+    /** Number of classes across all schemas. */
+    get classCount(): number;
+    /** Get a schema by name (case-insensitive). */
+    getSchema(name: string): SchemaView.Schema | undefined;
+    /** Get a schema by alias (case-insensitive). */
+    getSchemaByAlias(alias: string): SchemaView.Schema | undefined;
+    /** Iterate all schemas. */
+    getSchemas(): IterableIterator<SchemaView.Schema>;
+    /** Find a class by qualified name ("SchemaName:ClassName" or "SchemaName.ClassName").
+     * The namespace part matches schema name first, then alias. Case-insensitive.
+     */
+    findClass(qualifiedName: string): SchemaView.Class | undefined;
+    /** Find an enumeration by qualified name ("SchemaName:EnumName" or "SchemaName.EnumName").
+     * The namespace part matches schema name first, then alias. Case-insensitive.
+     */
+    findEnumeration(qualifiedName: string): SchemaView.Enumeration | undefined;
+    /** Find a KindOfQuantity by qualified name ("SchemaName:KoqName" or "SchemaName.KoqName").
+     * The namespace part matches schema name first, then alias. Case-insensitive.
+     */
+    findKindOfQuantity(qualifiedName: string): SchemaView.KindOfQuantity | undefined;
+    /** Find a PropertyCategory by qualified name ("SchemaName:CategoryName" or "SchemaName.CategoryName").
+     * The namespace part matches schema name first, then alias. Case-insensitive.
+     */
+    findPropertyCategory(qualifiedName: string): SchemaView.PropertyCategory | undefined;
+    /** Parse a binary blob into a SchemaView. Synchronous.
+     * @param blob - The binary blob from `PRAGMA schema_view`.
+     * @param schemaToken - Optional SHA3-256 content hash for cache invalidation.
+     * @beta
+     */
+    static fromBinary(blob: Uint8Array, schemaToken?: string): SchemaView;
+    /** Build from a pre-populated builder (used by the binary parser).
+     * @internal
+     */
+    static fromBuilder(builder: SchemaViewBuilder, schemaToken?: string): SchemaView;
+    /** Resolve a qualified "SchemaName:ItemName" (or dot-separated) to an index using the given
+     * per-schema name map. Returns undefined if not found. @internal */
+    private _resolveSchemaItemIdx;
+    /** @internal */
+    resolveClassIdx(qualifiedName: string): number;
+    /** @internal */
+    getTransitiveBases(classIdx: number): ReadonlySet<number>;
+    private _buildTransitiveBases;
+    /** @internal */
+    resolveAllProperties(classIdx: number): readonly ResolvedPropertyRef[];
+    private _collectProperties;
+    private _collectMixinProperties;
+    /** @internal */
+    buildDerivedClassMap(): ReadonlyMap<number, readonly number[]>;
+}
+/** @beta */
+export declare namespace SchemaView {
+    /** Lightweight view over a schema in a `SchemaView`. Holds only a view reference and
+     * an index - no data duplication, no mutable state.
+     * @beta
+     */
+    class Schema {
+        private readonly _ctx;
+        /** @internal */ readonly idx: number;
+        /** @internal */
+        constructor(_ctx: SchemaView, 
+        /** @internal */ idx: number);
+        private get _data();
+        /** Row ID from ec_Schema. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECSchemaDef WHERE ECInstanceId = ?`.
+         *
+         * This is not an array index or internal handle - it is the database row ID from the ec_Schema
+         * table, carried through the binary blob so consumers can fall back to ECSQL meta-queries for
+         * data not included in the schema view (custom attributes, schema references, etc.).
+         */
+        get ecInstanceId(): number;
+        get name(): string;
+        get alias(): string;
+        get label(): string;
+        get description(): string;
+        get readVersion(): number;
+        get writeVersion(): number;
+        get minorVersion(): number;
+        /** Reflects the `HiddenSchema` custom attribute from `CoreCustomAttributes`.
+         * Schemas marked hidden are typically excluded from UI display but remain accessible programmatically. */
+        get isHidden(): boolean;
+        /** "SchemaName.RR.WW.mm" - dot-separated, matching the EC schema versioning convention. */
+        get fullName(): string;
+        /** Find a class by name within this schema (case-insensitive). */
+        getClass(name: string): Class | undefined;
+        /** Iterate classes in this schema. Pass a `ClassType` to filter to a single kind
+         * (e.g. `getClasses(ClassType.View)`). Omit the argument to iterate every class
+         * regardless of type.
+         */
+        getClasses(filter?: ClassType): IterableIterator<Class>;
+        /** Find an enumeration by name within this schema (case-insensitive). */
+        getEnumeration(name: string): Enumeration | undefined;
+        /** Find a KindOfQuantity by name within this schema (case-insensitive). */
+        getKindOfQuantity(name: string): KindOfQuantity | undefined;
+        /** Find a PropertyCategory by name within this schema (case-insensitive). */
+        getPropertyCategory(name: string): PropertyCategory | undefined;
+        /** Iterate all enumerations in this schema. */
+        getEnumerations(): IterableIterator<Enumeration>;
+        /** Iterate all KindOfQuantity items in this schema. */
+        getKindOfQuantities(): IterableIterator<KindOfQuantity>;
+        /** Iterate all PropertyCategory items in this schema. */
+        getPropertyCategories(): IterableIterator<PropertyCategory>;
+    }
+    /** Lightweight view over a class in a `SchemaView`. For relationship-specific
+     * fields (strength, direction, source/target constraints), narrow via `isRelationship()`
+     * or `assertRelationship()` to get a `SchemaView.RelationshipClass`.
+     * @beta
+     */
+    class Class {
+        protected readonly _ctx: SchemaView;
+        /** @internal */ readonly idx: number;
+        /** @internal */
+        constructor(_ctx: SchemaView, 
+        /** @internal */ idx: number);
+        /** @internal */
+        protected get _data(): ClassData;
+        /** Row ID from ec_Class. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECClassDef WHERE ECInstanceId = ?`.
+         */
+        get ecInstanceId(): number;
+        get name(): string;
+        get label(): string;
+        get description(): string;
+        /** "SchemaName:ClassName" - colon-separated, matching the EC class full name convention.
+         * Use either ":" or "." as separator when passing to `findClass()`. */
+        get fullName(): string;
+        get schema(): Schema;
+        get type(): ClassType;
+        get modifier(): ClassModifier;
+        isEntity(): boolean;
+        /** Type predicate - narrows to `SchemaView.RelationshipClass` for access to strength, direction,
+         * source, and target constraint fields. */
+        isRelationship(): this is RelationshipClass;
+        isStruct(): boolean;
+        isMixin(): boolean;
+        isCustomAttribute(): boolean;
+        isView(): boolean;
+        /** @see isRelationship */
+        assertRelationship(): asserts this is RelationshipClass;
+        get isAbstract(): boolean;
+        get isSealed(): boolean;
+        /** Reflects the `HiddenClass` custom attribute from `CoreCustomAttributes`.
+         * Returns `true` when this class is directly hidden (via `HiddenClass(Show!=true)` or
+         * schema-level `HiddenSchema(ShowClasses!=true)`). Does NOT consider base class inheritance -
+         * use `isEffectivelyHidden` for that.
+         *
+         * Note: `false` means explicitly shown via `HiddenClass(Show=true)`. `undefined` means
+         * no `HiddenClass` CA and the schema does not hide its classes. Both are "not hidden" for
+         * this property, but `isEffectivelyHidden` distinguishes them when walking the hierarchy. */
+        get isHidden(): boolean | undefined;
+        /** Computed hidden status that walks the base class chain (not mixins).
+         *
+         * Returns `true` if this class is hidden or any ancestor in the base class chain is hidden,
+         * unless this class or an intermediate class explicitly breaks the chain with
+         * `HiddenClass(Show=true)` (i.e. `isHidden === false`).
+         *
+         * Mixins are intentionally excluded - a hidden mixin represents a hidden capability,
+         * not a hidden identity. */
+        get isEffectivelyHidden(): boolean;
+        /** Single base class. undefined for root classes. */
+        get baseClass(): Class | undefined;
+        /** Applied mixins in declaration order. Only meaningful for entity classes. */
+        get mixins(): readonly Class[];
+        /** IS-A check. Returns true if this class is, or derives from, `other` (transitively, including mixins).
+         * Accepts a `SchemaView.Class` or a qualified name string ("SchemaName:ClassName").
+         */
+        is(classOrName: Class | string): boolean;
+        /** Direct derived classes. Expensive on first call (builds reverse map across all classes). */
+        get derivedClasses(): readonly Class[];
+        /** Find a property by name (case-insensitive). Searches own + inherited.
+         *
+         * Note: this resolves the full property list and linear-scans it on every call. For workloads
+         * that hit `getProperty` repeatedly on the same class with different names, a per-class
+         * resolved-property map cache could be added on the view. Not done now - measure before
+         * optimizing. */
+        getProperty(name: string): Property | undefined;
+        /** All properties including inherited, in inheritance order (base first, then mixins, then own). */
+        getProperties(): readonly Property[];
+        /** Own properties only (not inherited), in ordinal order. */
+        getOwnProperties(): readonly Property[];
+    }
+    /** A relationship class with constraint and strength metadata. Created by `createClass()`
+     * when the underlying `ClassType` is `Relationship`. Use `cls.isRelationship()` to narrow a
+     * `SchemaView.Class` to this type.
+     * @beta
+     */
+    class RelationshipClass extends Class {
+        get strength(): StrengthType;
+        get strengthDirection(): StrengthDirection;
+        get source(): RelConstraint | undefined;
+        get target(): RelConstraint | undefined;
+    }
+    /** @internal */
+    function createClass(ctx: SchemaView, idx: number): Class;
+    /** Lightweight view over a property in a `SchemaView`. Subclasses provide
+     * type-safe access to kind-specific fields. Use `isPrimitive()`, `isStruct()`,
+     * `isArray()`, or `isNavigation()` to narrow, or the corresponding `assert*()` methods.
+     * @beta
+     */
+    abstract class Property {
+        protected readonly _ctx: SchemaView;
+        private readonly _ref;
+        /** Index of the class that declared or contributed this property through inheritance.
+         * For own properties, this is the class itself. For inherited properties, this is the
+         * base class or mixin that introduced it. -1 for view properties. */
+        private readonly _classIdx;
+        /** @internal */
+        constructor(_ctx: SchemaView, _ref: PropertyRef, 
+        /** Index of the class that declared or contributed this property through inheritance.
+         * For own properties, this is the class itself. For inherited properties, this is the
+         * base class or mixin that introduced it. -1 for view properties. */
+        _classIdx: number);
+        /** @internal */
+        protected get _def(): PropertyDef;
+        /** Row ID from ec_Property. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECPropertyDef WHERE ECInstanceId = ?`.
+         *
+         * Stored per-reference (not per-definition) because each class-property pair has a unique
+         * ec_Property row even when the structural definition is deduplicated.
+         */
+        get ecInstanceId(): number;
+        get name(): string;
+        /** Display label. Falls back to the property name if no explicit label is set.
+         * Labels are stored per-reference (not per-definition) because EC allows class overrides. */
+        get label(): string;
+        get description(): string;
+        get kind(): PropertyKind;
+        get isReadOnly(): boolean;
+        /** Reflects the `HiddenProperty` custom attribute from `CoreCustomAttributes`.
+         * Properties marked hidden are typically excluded from UI display but remain accessible programmatically. */
+        get isHidden(): boolean;
+        /** Display priority. Higher values should be displayed more prominently. 0 means default. */
+        get priority(): number;
+        /** The class that declared or contributed this property through inheritance.
+         * For own properties, returns the class itself. For inherited properties, returns the
+         * base class or mixin that introduced it. Returns `undefined` for view properties.
+         * This is the class array index, not the ec_Class.Id from the database.
+         * @beta
+         */
+        get declaringClass(): Class | undefined;
+        /** Property category, or undefined if none assigned. Available on all property kinds. */
+        get category(): PropertyCategory | undefined;
+        /** True for `SchemaView.PrimitiveProperty` and `SchemaView.PrimitiveArrayProperty`.
+         * Matches ecschema-metadata behavior where `isPrimitive()` includes primitive arrays. */
+        isPrimitive(): this is AnyPrimitiveProperty;
+        /** True for `SchemaView.StructProperty` and `SchemaView.StructArrayProperty`. */
+        isStruct(): this is AnyStructProperty;
+        /** True for `SchemaView.PrimitiveArrayProperty` and `SchemaView.StructArrayProperty`. */
+        isArray(): this is AnyArrayProperty;
+        /** True for `SchemaView.NavigationProperty`. */
+        isNavigation(): this is NavigationProperty;
+        /** True if this property is backed by an enumeration. Enumerations are a facet of primitive
+         * properties - an enum property IS a primitive property with an enum binding. Narrows to
+         * `AnyPrimitiveProperty` so you can access `enumeration`, `primitiveType`, etc. */
+        isEnumeration(): this is AnyPrimitiveProperty;
+        /** @see isPrimitive */
+        assertPrimitive(): asserts this is AnyPrimitiveProperty;
+        /** @see isStruct */
+        assertStruct(): asserts this is AnyStructProperty;
+        /** @see isArray */
+        assertArray(): asserts this is AnyArrayProperty;
+        /** @see isNavigation */
+        assertNavigation(): asserts this is NavigationProperty;
+    }
+    /** A scalar primitive property. May optionally be backed by an enumeration -
+     * check `isEnumeration()` or `enumeration`.
+     * @beta
+     */
+    class PrimitiveProperty extends Property {
+        get primitiveType(): SchemaViewPrimitiveType;
+        get extendedTypeName(): string | undefined;
+        get enumeration(): Enumeration | undefined;
+        get kindOfQuantity(): KindOfQuantity | undefined;
+    }
+    /** An array of primitive values. Same primitive/enum fields as `PrimitiveProperty`,
+     * plus array bounds.
+     * @beta
+     */
+    class PrimitiveArrayProperty extends Property {
+        get primitiveType(): SchemaViewPrimitiveType;
+        get extendedTypeName(): string | undefined;
+        get enumeration(): Enumeration | undefined;
+        get kindOfQuantity(): KindOfQuantity | undefined;
+        get arrayMinOccurs(): number | undefined;
+        get arrayMaxOccurs(): number | undefined;
+    }
+    /** A scalar struct property. `structClass` is non-nullable - the binary parser drops
+     * properties whose struct class can't be resolved (e.g. from excluded schemas).
+     * @beta
+     */
+    class StructProperty extends Property {
+        get structClass(): Class;
+    }
+    /** An array of struct values. Same struct field as `StructProperty`, plus array bounds.
+     * @beta
+     */
+    class StructArrayProperty extends Property {
+        get structClass(): Class;
+        get arrayMinOccurs(): number | undefined;
+        get arrayMaxOccurs(): number | undefined;
+    }
+    /** A navigation property. `relationshipClass` is non-nullable - the binary parser drops
+     * properties whose relationship class can't be resolved.
+     * @beta
+     */
+    class NavigationProperty extends Property {
+        get direction(): StrengthDirection;
+        get relationshipClass(): RelationshipClass;
+    }
+    /** Any primitive property (scalar or array). Useful for accessing `primitiveType`,
+     * `extendedTypeName`, `enumeration`, `kindOfQuantity` after an `isPrimitive()` check.
+     * @beta
+     */
+    type AnyPrimitiveProperty = PrimitiveProperty | PrimitiveArrayProperty;
+    /** Any struct property (scalar or array). Useful for accessing `structClass` after an `isStruct()` check.
+     * @beta
+     */
+    type AnyStructProperty = StructProperty | StructArrayProperty;
+    /** Any array property (primitive or struct). Useful for accessing `arrayMinOccurs`/`arrayMaxOccurs`
+     * after an `isArray()` check.
+     * @beta
+     */
+    type AnyArrayProperty = PrimitiveArrayProperty | StructArrayProperty;
+    /** Union of all concrete property types.
+     * @beta
+     */
+    type AnyProperty = PrimitiveProperty | PrimitiveArrayProperty | StructProperty | StructArrayProperty | NavigationProperty;
+    /** @internal */
+    function createProperty(ctx: SchemaView, ref: PropertyRef, classIdx: number): Property;
+    /** Lightweight view over an enumeration in a `SchemaView`.
+     * @beta
+     */
+    class Enumeration {
+        private readonly _ctx;
+        /** @internal */ readonly idx: number;
+        /** @internal */
+        constructor(_ctx: SchemaView, 
+        /** @internal */ idx: number);
+        private get _data();
+        /** Row ID from ec_Enumeration. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECEnumerationDef WHERE ECInstanceId = ?`.
+         */
+        get ecInstanceId(): number;
+        get name(): string;
+        get label(): string;
+        get description(): string;
+        /** "SchemaName:EnumName" - colon-separated. */
+        get fullName(): string;
+        get schema(): Schema;
+        get primitiveType(): SchemaViewPrimitiveType;
+        get isStrict(): boolean;
+        /** Iterate enumerators in declaration order. */
+        getEnumerators(): IterableIterator<Enumerator>;
+        /** Find enumerator by name (case-insensitive). */
+        getEnumeratorByName(name: string): Enumerator | undefined;
+        /** Find enumerator by value. */
+        getEnumerator(value: number | string): Enumerator | undefined;
+    }
+    /** Thin view over an enumerator.
+     * @beta
+     */
+    class Enumerator {
+        private readonly _ctx;
+        /** @internal */ readonly idx: number;
+        /** @internal */
+        constructor(_ctx: SchemaView, 
+        /** @internal */ idx: number);
+        private get _data();
+        get name(): string;
+        get label(): string;
+        get description(): string;
+        get value(): number | string;
+    }
+    /** A parsed presentation format override from a KindOfQuantity. Names are alias-qualified
+     * as stored in ECDb (e.g. `"f:DefaultRealU"`, `"u:M"`). The alias can be resolved to a
+     * full schema name via the schema's alias if needed.
+     *
+     * Format string syntax: `formatName(precision)[unitName|label][unitName|label]...`
+     * @beta
+     */
+    interface PresentationFormat {
+        /** Format name (alias-qualified), e.g. `"f:DefaultRealU"`. */
+        readonly name: string;
+        /** Precision override. `undefined` if the format string does not override precision. */
+        readonly precision?: number;
+        /** Unit overrides as `[unitName, labelOverride]` tuples. `unitName` is alias-qualified
+         * (e.g. `"u:M"`). `labelOverride` is `undefined` when no label was specified, or a
+         * string (possibly empty) when a `|` separator was present.
+         */
+        readonly unitAndLabels?: ReadonlyArray<readonly [string, string | undefined]>;
+    }
+    /** Parse a single format override string into a `PresentationFormat`.
+     * @internal
+     */
+    function parseFormatString(formatString: string): PresentationFormat;
+    /** Lightweight view over a KindOfQuantity in a `SchemaView`.
+     * @beta
+     */
+    class KindOfQuantity {
+        private readonly _ctx;
+        /** @internal */ readonly idx: number;
+        /** @internal */
+        constructor(_ctx: SchemaView, 
+        /** @internal */ idx: number);
+        private get _data();
+        /** Row ID from ec_KindOfQuantity. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECKindOfQuantityDef WHERE ECInstanceId = ?`.
+         */
+        get ecInstanceId(): number;
+        get name(): string;
+        get label(): string;
+        get description(): string;
+        /** "SchemaName:KoqName" - colon-separated. */
+        get fullName(): string;
+        get schema(): Schema;
+        get relativeError(): number;
+        /** Persistence unit as a full name string, e.g. "Units:M".
+         *
+         * On iModels still on ECDb profile `4.0.0.1` (predates the 2018 EC3.2 Units/Formats migration)
+         * this string is in legacy FUS format rather than the EC3.2 alias-qualified form.
+         * Upgrade the iModel's ECDb profile to get EC3.2 strings.
+         */
+        get persistenceUnit(): string;
+        /** Raw presentation format string as stored in ECDb (`ec_KindOfQuantity.PresentationUnits`).
+         * This is a JSON array of format override strings. Empty string if none are defined.
+         * Prefer `presentationFormats` for structured access.
+         *
+         * On iModels still on ECDb profile `4.0.0.1` (predates the 2018 EC3.2 Units/Formats migration)
+         * the strings are in legacy FUS format and will not parse via `presentationFormats`.
+         * Upgrade the iModel's ECDb profile to get EC3.2 strings.
+         */
+        get presentationFormatsRaw(): string;
+        /** Presentation formats parsed into structured overrides. Each entry has the format name
+         * (alias-qualified, e.g. `"f:DefaultRealU"`), optional precision override, and optional
+         * unit-and-label overrides. Returns an empty array if no presentation formats are defined.
+         *
+         * Example - given a raw string of `["f:DefaultRealU(4)[u:M_PER_SEC_SQ]","f:DefaultRealU(4)[u:CM_PER_SEC_SQ]"]`:
+         * ```ts
+         * // [
+         * //   { name: "f:DefaultRealU", precision: 4, unitAndLabels: [["u:M_PER_SEC_SQ", undefined]] },
+         * //   { name: "f:DefaultRealU", precision: 4, unitAndLabels: [["u:CM_PER_SEC_SQ", undefined]] },
+         * // ]
+         * ```
+         */
+        get presentationFormats(): readonly PresentationFormat[];
+    }
+    /** Lightweight view over a PropertyCategory in a `SchemaView`.
+     * @beta
+     */
+    class PropertyCategory {
+        private readonly _ctx;
+        /** @internal */ readonly idx: number;
+        /** @internal */
+        constructor(_ctx: SchemaView, 
+        /** @internal */ idx: number);
+        private get _data();
+        /** Row ID from ec_PropertyCategory. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECPropertyCategoryDef WHERE ECInstanceId = ?`.
+         */
+        get ecInstanceId(): number;
+        get name(): string;
+        get label(): string;
+        get description(): string;
+        /** "SchemaName:CategoryName" - colon-separated. */
+        get fullName(): string;
+        get schema(): Schema;
+        get priority(): number;
+    }
+    /** Lightweight view over a relationship constraint in a `SchemaView`.
+     * @beta
+     */
+    class RelConstraint {
+        private readonly _ctx;
+        private readonly _idx;
+        /** @internal */
+        constructor(_ctx: SchemaView, _idx: number);
+        private get _data();
+        get abstractConstraint(): Class | undefined;
+        get polymorphic(): boolean;
+        /** Multiplicity lower bound (0 = unbounded). */
+        get multiplicityLower(): number;
+        /** Multiplicity upper bound (0 = unbounded). */
+        get multiplicityUpper(): number;
+        /** Role label string, or empty if not set. */
+        get roleLabel(): string;
+        get constraintClasses(): readonly Class[];
+    }
+}
+/** Builder for constructing an immutable `SchemaView`.
+ *
+ * Collects data during binary blob parsing, then freezes it into a view.
+ * Handles string interning and property definition deduplication.
+ *
+ * Consumers should not use this directly - read views via `IModelDb.getSchemaView`
+ * / `IModelConnection.getSchemaView` (or `SchemaView.fromBinary` if you have a raw blob).
+ * @internal
+ */
+export declare class SchemaViewBuilder {
+    private readonly _strings;
+    private readonly _lowerStrings;
+    private readonly _stringMap;
+    private readonly _schemas;
+    private readonly _classes;
+    private readonly _classMixins;
+    private readonly _propDefs;
+    private readonly _propertyRefs;
+    private readonly _relConstraints;
+    private readonly _constraintClassRefs;
+    private readonly _enumerations;
+    private readonly _enumerators;
+    private readonly _koqs;
+    private readonly _propCategories;
+    private readonly _propDefMap;
+    /** Intern a string, returning its SID. Empty/undefined strings return 0.
+     * Interning is case-sensitive - "MyLabel" and "MYLABEL" get distinct SIDs.
+     * The `lowerStrings` array provides case-insensitive lookup without mutating display values.
+     */
+    internString(value: string | undefined): number;
+    /** Add a schema. Returns its index. */
+    addSchema(data: SchemaData): number;
+    /** Add a class. Returns its index. Must be called after the owning schema. */
+    addClass(data: ClassData): number;
+    /** Add a property definition with deduplication. Returns the def index (possibly existing). */
+    addPropertyDef(data: PropertyDef): number;
+    /** Append a property reference to the flat refs array. */
+    addPropertyRef(ref: PropertyRef): void;
+    /** Add an enumeration. Returns its index. */
+    addEnumeration(data: EnumerationData): number;
+    /** Append an enumerator to the flat enumerators array. */
+    addEnumerator(data: EnumeratorData): void;
+    /** Add a KindOfQuantity. Returns its index. */
+    addKoq(data: KoqData): number;
+    /** Add a PropertyCategory. Returns its index. */
+    addPropertyCategory(data: PropCategoryData): number;
+    /** Add a relationship constraint. Returns its index. */
+    addRelConstraint(data: RelConstraintData): number;
+    /** Append a constraint class reference to the flat array. */
+    addConstraintClassRef(classIdx: number): void;
+    /** Append a mixin class reference to the flat array. */
+    addClassMixin(classIdx: number): void;
+    /** The current count of property refs (used to set ownPropStart on ClassData). */
+    get propertyRefCount(): number;
+    /** The current count of enumerators (used to set enumeratorStart on EnumerationData). */
+    get enumeratorCount(): number;
+    /** The current count of constraint class refs (used to set classRefStart). */
+    get constraintClassRefCount(): number;
+    /** The current count of class mixins (used to set mixinStartIdx). */
+    get classMixinCount(): number;
+    /** Get a string by SID. @internal */
+    getString(sid: number): string;
+    /** Replace class data at the given index (used during deferred cross-ref resolution). @internal */
+    updateClass(classIdx: number, data: ClassData): void;
+    /** Update range fields on a schema (used after all items for a schema are collected). @internal */
+    updateSchemaRanges(schemaIdx: number, ranges: {
+        classRangeStart: number;
+        classCount: number;
+        enumRangeStart: number;
+        enumCount: number;
+        koqRangeStart: number;
+        koqCount: number;
+        catRangeStart: number;
+        catCount: number;
+    }): void;
+    /** Freeze all data and produce an immutable SchemaView. */
+    build(schemaToken?: string): SchemaView;
+    /** Produce a dedup signature for a PropertyDef. Label and priority are excluded because
+     * they are per-PropertyRef overrides, not part of the structural definition.
+     * Uses SIDs (not lowercase strings) for name/description so that case-preserving names
+     * stay distinct - matching the C++ writer's dedup behavior. */
+    private _propDefSignature;
+}
+export {};
+//# sourceMappingURL=SchemaView.d.ts.map