@itwin/core-backend 5.0.0-dev.9 → 5.0.0-dev.92

package/lib/esm/IModelDb.js

@@ -0,0 +1,3230 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module iModels
+ */
+import * as fs from "fs";
+import { join } from "path";
+import * as touch from "touch";
+import { assert, BeEvent, BentleyStatus, ChangeSetStatus, DbChangeStage, DbConflictCause, DbConflictResolution, DbResult, Guid, Id64, IModelStatus, JsonUtils, Logger, LogLevel, OpenMode, } from "@itwin/core-bentley";
+import { BriefcaseIdValue, Code, DomainOptions, ECJsNames, ECSqlReader, EntityMetaData, FontMap, IModel, IModelError, IModelNotFoundResponse, ProfileOptions, QueryRowFormat, SchemaState, ViewStoreRpc, } from "@itwin/core-common";
+import { Range2d, Range3d } from "@itwin/core-geometry";
+import { BackendLoggerCategory } from "./BackendLoggerCategory";
+import { BriefcaseManager } from "./BriefcaseManager";
+import { ChannelControl } from "./ChannelControl";
+import { createChannelControl } from "./internal/ChannelAdmin";
+import { CheckpointManager, V2CheckpointManager } from "./CheckpointManager";
+import { ClassRegistry, EntityJsClassMap, MetaDataRegistry } from "./ClassRegistry";
+import { CloudSqlite } from "./CloudSqlite";
+import { CodeService } from "./CodeService";
+import { CodeSpecs } from "./CodeSpecs";
+import { ConcurrentQuery } from "./ConcurrentQuery";
+import { ECSqlStatement } from "./ECSqlStatement";
+import { Element } from "./Element";
+import { generateElementGraphics } from "./ElementGraphics";
+import { Entity } from "./Entity";
+import { GeoCoordConfig } from "./GeoCoordConfig";
+import { IModelHost } from "./IModelHost";
+import { IModelJsFs } from "./IModelJsFs";
+import { IpcHost } from "./IpcHost";
+import { Model } from "./Model";
+import { Relationships } from "./Relationship";
+import { SchemaSync } from "./SchemaSync";
+import { createServerBasedLocks } from "./internal/ServerBasedLocks";
+import { SqliteStatement, StatementCache } from "./SqliteStatement";
+import { TxnManager } from "./TxnManager";
+import { DrawingViewDefinition, SheetViewDefinition, ViewDefinition } from "./ViewDefinition";
+import { ViewStore } from "./ViewStore";
+import { SettingsPriority } from "./workspace/Settings";
+import { Workspace, WorkspaceSettingNames } from "./workspace/Workspace";
+import { constructWorkspace, throwWorkspaceDbLoadErrors } from "./internal/workspace/WorkspaceImpl";
+import { SettingsImpl } from "./internal/workspace/SettingsImpl";
+import { IModelNative } from "./internal/NativePlatform";
+import { createNoOpLockControl } from "./internal/NoLocks";
+import { createIModelDbFonts } from "./internal/IModelDbFontsImpl";
+import { _close, _hubAccess, _nativeDb, _releaseAllLocks } from "./internal/Symbols";
+import { SchemaContext, SchemaJsonLocater } from "@itwin/ecschema-metadata";
+import { SchemaMap } from "./Schema";
+// spell:ignore fontid fontmap
+const loggerCategory = BackendLoggerCategory.IModelDb;
+/** @internal */
+export var BriefcaseLocalValue;
+(function (BriefcaseLocalValue) {
+    BriefcaseLocalValue["StandaloneEdit"] = "StandaloneEdit";
+    BriefcaseLocalValue["NoLocking"] = "NoLocking";
+})(BriefcaseLocalValue || (BriefcaseLocalValue = {}));
+// function to open an briefcaseDb, perform an operation, and then close it.
+const withBriefcaseDb = async (briefcase, fn) => {
+    const db = await BriefcaseDb.open(briefcase);
+    try {
+        return await fn(db);
+    }
+    finally {
+        db.close();
+    }
+};
+/**
+ * Settings for an individual iModel. May only include settings priority for iModel, iTwin and organization.
+ * @note if there is more than one iModel for an iTwin or organization, they will *each* hold an independent copy of the settings for those priorities.
+ */
+class IModelSettings extends SettingsImpl {
+    verifyPriority(priority) {
+        if (priority <= SettingsPriority.application)
+            throw new Error("Use IModelHost.appSettings to access settings of priority 'application' or lower");
+    }
+    *getSettingEntries(name) {
+        yield* super.getSettingEntries(name);
+        yield* IModelHost.appWorkspace.settings.getSettingEntries(name);
+    }
+}
+/** An iModel database file. The database file can either be a briefcase or a snapshot.
+ * @see [Accessing iModels]($docs/learning/backend/AccessingIModels.md)
+ * @see [About IModelDb]($docs/learning/backend/IModelDb.md)
+ * @public
+ */
+export class IModelDb extends IModel {
+    _initialized = false;
+    /** Keep track of open imodels to support `tryFind` for RPC purposes */
+    static _openDbs = new Map();
+    static defaultLimit = 1000; // default limit for batching queries
+    static maxLimit = 10000; // maximum limit for batching queries
+    models = new IModelDb.Models(this);
+    elements = new IModelDb.Elements(this);
+    views = new IModelDb.Views(this);
+    tiles = new IModelDb.Tiles(this);
+    /** @beta */
+    channels = createChannelControl(this);
+    _relationships;
+    _statementCache = new StatementCache();
+    _sqliteStatementCache = new StatementCache();
+    _codeSpecs;
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    _classMetaDataRegistry;
+    _jsClassMap;
+    _schemaMap;
+    _schemaContext;
+    /** @deprecated in 5.0.0. Use [[fonts]]. */
+    _fontMap; // eslint-disable-line @typescript-eslint/no-deprecated
+    _fonts = createIModelDbFonts(this);
+    _workspace;
+    _snaps = new Map();
+    static _shutdownListener; // so we only register listener once
+    /** @internal */
+    _locks = createNoOpLockControl();
+    /** @internal */
+    _codeService;
+    /** @alpha */
+    get codeService() { return this._codeService; }
+    /** The [[LockControl]] that orchestrates [concurrent editing]($docs/learning/backend/ConcurrencyControl.md) of this iModel. */
+    get locks() { return this._locks; } // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    /** Provides methods for interacting with [font-related information]($docs/learning/backend/Fonts.md) stored in this iModel.
+     * @beta
+     */
+    get fonts() { return this._fonts; }
+    /**
+     * Get the [[Workspace]] for this iModel.
+     * @beta
+     */
+    get workspace() {
+        if (undefined === this._workspace)
+            this._workspace = constructWorkspace(new IModelSettings());
+        return this._workspace;
+    }
+    /** Acquire the exclusive schema lock on this iModel.
+     * @note: To acquire the schema lock, all other briefcases must first release *all* their locks. No other briefcases
+     * will be able to acquire *any* locks while the schema lock is held.
+     */
+    async acquireSchemaLock() {
+        return this.locks.acquireLocks({ exclusive: IModel.repositoryModelId });
+    }
+    /** determine whether the schema lock is currently held for this iModel. */
+    get holdsSchemaLock() {
+        return this.locks.holdsExclusiveLock(IModel.repositoryModelId);
+    }
+    /** Event called after a changeset is applied to this IModelDb. */
+    onChangesetApplied = new BeEvent();
+    /** @internal */
+    notifyChangesetApplied() {
+        this.changeset = this[_nativeDb].getCurrentChangeset();
+        this.onChangesetApplied.raiseEvent();
+    }
+    /** @internal */
+    restartDefaultTxn() {
+        this[_nativeDb].restartDefaultTxn();
+    }
+    /** @deprecated in 5.0.0. Use [[fonts]]. */
+    get fontMap() {
+        return this._fontMap ?? (this._fontMap = new FontMap(this[_nativeDb].readFontMap())); // eslint-disable-line @typescript-eslint/no-deprecated
+    }
+    /** @internal */
+    clearFontMap() {
+        this._fontMap = undefined; // eslint-disable-line @typescript-eslint/no-deprecated
+        this[_nativeDb].invalidateFontMap();
+    }
+    /** Check if this iModel has been opened read-only or not. */
+    get isReadonly() { return this.openMode === OpenMode.Readonly; }
+    /** The Guid that identifies this iModel. */
+    get iModelId() {
+        assert(undefined !== super.iModelId);
+        return super.iModelId;
+    } // GuidString | undefined for the IModel superclass, but required for all IModelDb subclasses
+    /** @internal*/
+    [_nativeDb];
+    /** Get the full path fileName of this iModelDb
+     * @note this member is only valid while the iModel is opened.
+     */
+    get pathName() { return this[_nativeDb].getFilePath(); }
+    /** Get the full path to this iModel's "watch file".
+     * A read-only briefcase opened with `watchForChanges: true` creates this file next to the briefcase file on open, if it doesn't already exist.
+     * A writable briefcase "touches" this file if it exists whenever it commits changes to the briefcase.
+     * The read-only briefcase can use a file watcher to react when the writable briefcase makes changes to the briefcase.
+     * This is more reliable than watching the sqlite WAL file.
+     * @internal
+     */
+    get watchFilePathName() { return `${this.pathName}-watch`; }
+    /** @internal */
+    constructor(args) {
+        super({ ...args, iTwinId: args.nativeDb.getITwinId(), iModelId: args.nativeDb.getIModelId() });
+        this[_nativeDb] = args.nativeDb;
+        // it is illegal to create an IModelDb unless the nativeDb has been opened. Throw otherwise.
+        if (!this.isOpen)
+            throw new Error("cannot create an IModelDb unless it has already been opened");
+        // PR https://github.com/iTwin/imodel-native/pull/558 renamed closeIModel to closeFile because it changed its behavior.
+        // Ideally, nobody outside of core-backend would be calling it, but somebody important is.
+        // Make closeIModel available so their code doesn't break.
+        this[_nativeDb].closeIModel = () => {
+            if (!this.isReadonly)
+                this.saveChanges(); // preserve old behavior of closeIModel that was removed when renamed to closeFile
+            this[_nativeDb].closeFile();
+        };
+        this[_nativeDb].setIModelDb(this);
+        this.loadIModelSettings();
+        GeoCoordConfig.loadForImodel(this.workspace.settings); // load gcs data specified by iModel's settings dictionaries, must be done before calling initializeIModelDb
+        this.initializeIModelDb();
+        IModelDb._openDbs.set(this._fileKey, this);
+        if (undefined === IModelDb._shutdownListener) { // the first time we create an IModelDb, add a listener to close any orphan files at shutdown.
+            IModelDb._shutdownListener = IModelHost.onBeforeShutdown.addListener(() => {
+                IModelDb._openDbs.forEach((db) => {
+                    try {
+                        db.abandonChanges();
+                        db.close();
+                    }
+                    catch { }
+                });
+            });
+        }
+    }
+    /**
+     * Attach an iModel file to this connection and load and register its schemas.
+     * @note There are some reserve tablespace names that cannot be used. They are 'main', 'schema_sync_db', 'ecchange' & 'temp'
+     * @param fileName IModel file name
+     * @param alias identifier for the attached file. This identifer is used to access schema from the attached file. e.g. if alias is 'abc' then schema can be accessed using 'abc.MySchema.MyClass'
+     *
+     * *Example:*
+     * ``` ts
+     *  [[include:IModelDb_attachDb.code]]
+     * ```
+     */
+    attachDb(fileName, alias) {
+        if (alias.toLowerCase() === "main" || alias.toLowerCase() === "schema_sync_db" || alias.toLowerCase() === "ecchange" || alias.toLowerCase() === "temp") {
+            throw new IModelError(DbResult.BE_SQLITE_ERROR, "Reserved tablespace name cannot be used");
+        }
+        this[_nativeDb].attachDb(fileName, alias);
+    }
+    /**
+     * Detach the attached file from this connection. The attached file is closed and its schemas are unregistered.
+     * @note There are some reserve tablespace names that cannot be used. They are 'main', 'schema_sync_db', 'ecchange' & 'temp'
+     * @param alias identifer that was used in the call to [[attachDb]]
+     *
+     * *Example:*
+     * ``` ts
+     *  [[include:IModelDb_attachDb.code]]
+     * ```
+     */
+    detachDb(alias) {
+        if (alias.toLowerCase() === "main" || alias.toLowerCase() === "schema_sync_db" || alias.toLowerCase() === "ecchange" || alias.toLowerCase() === "temp") {
+            throw new IModelError(DbResult.BE_SQLITE_ERROR, "Reserved tablespace name cannot be used");
+        }
+        this.clearCaches();
+        this[_nativeDb].detachDb(alias);
+    }
+    /** Close this IModel, if it is currently open, and save changes if it was opened in ReadWrite mode. */
+    close() {
+        if (!this.isOpen)
+            return; // don't continue if already closed
+        this.beforeClose();
+        IModelDb._openDbs.delete(this._fileKey);
+        this._workspace?.close();
+        this.locks[_close]();
+        this._locks = undefined;
+        this._codeService?.close();
+        this._codeService = undefined;
+        if (!this.isReadonly)
+            this.saveChanges();
+        this[_nativeDb].closeFile();
+    }
+    /** @internal */
+    async refreshContainerForRpc(_userAccessToken) { }
+    /** Event called when the iModel is about to be closed. */
+    onBeforeClose = new BeEvent();
+    /**
+     * Called by derived classes before closing the connection
+     * @internal
+     */
+    beforeClose() {
+        this.onBeforeClose.raiseEvent();
+        this.clearCaches();
+    }
+    /** @internal */
+    initializeIModelDb() {
+        const props = this[_nativeDb].getIModelProps();
+        super.initialize(props.rootSubject.name, props);
+        if (this._initialized)
+            return;
+        this._initialized = true;
+        const db = this.isBriefcaseDb() ? this : undefined;
+        if (!db || !IpcHost.isValid)
+            return;
+        db.onNameChanged.addListener(() => IpcHost.notifyTxns(db, "notifyIModelNameChanged", db.name));
+        db.onRootSubjectChanged.addListener(() => IpcHost.notifyTxns(db, "notifyRootSubjectChanged", db.rootSubject));
+        db.onProjectExtentsChanged.addListener(() => IpcHost.notifyTxns(db, "notifyProjectExtentsChanged", db.projectExtents.toJSON()));
+        db.onGlobalOriginChanged.addListener(() => IpcHost.notifyTxns(db, "notifyGlobalOriginChanged", db.globalOrigin.toJSON()));
+        db.onEcefLocationChanged.addListener(() => IpcHost.notifyTxns(db, "notifyEcefLocationChanged", db.ecefLocation?.toJSON()));
+        db.onGeographicCoordinateSystemChanged.addListener(() => IpcHost.notifyTxns(db, "notifyGeographicCoordinateSystemChanged", db.geographicCoordinateSystem?.toJSON()));
+    }
+    /** Returns true if this is a BriefcaseDb
+     * @see [[BriefcaseDb.open]]
+     */
+    get isBriefcase() { return false; }
+    /** Type guard for instanceof [[BriefcaseDb]] */
+    isBriefcaseDb() { return this.isBriefcase; }
+    /** Returns true if this is a SnapshotDb
+     * @see [[SnapshotDb.open]]
+     */
+    get isSnapshot() { return false; }
+    /** Type guard for instanceof [[SnapshotDb]] */
+    isSnapshotDb() { return this.isSnapshot; }
+    /** Returns true if this is a *standalone* iModel
+     * @see [[StandaloneDb.open]]
+     * @internal
+     */
+    get isStandalone() { return false; }
+    /** Type guard for instanceof [[StandaloneDb]]. */
+    isStandaloneDb() { return this.isStandalone; }
+    /** Return `true` if the underlying nativeDb is open and valid.
+     * @internal
+     */
+    get isOpen() { return this[_nativeDb].isOpen(); }
+    /** Get the briefcase Id of this iModel */
+    getBriefcaseId() { return this.isOpen ? this[_nativeDb].getBriefcaseId() : BriefcaseIdValue.Illegal; }
+    /**
+     * Use a prepared ECSQL statement, potentially from the statement cache. If the requested statement doesn't exist
+     * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved
+     * in the statement cache so it can be reused in the future. Use this method for ECSQL statements that will be
+     * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding
+     * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withStatement]].
+     * @param sql The SQLite SQL statement to execute
+     * @param callback the callback to invoke on the prepared statement
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @returns the value returned by `callback`.
+     * @see [[withStatement]]
+     * @public
+     */
+    withPreparedStatement(ecsql, callback, logErrors = true) {
+        const stmt = this._statementCache.findAndRemove(ecsql) ?? this.prepareStatement(ecsql, logErrors);
+        const release = () => this._statementCache.addOrDispose(stmt);
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /**
+     * Prepared and execute a callback on an ECSQL statement. After the callback completes the statement is disposed.
+     * Use this method for ECSQL statements are either not expected to be reused, or are not expensive to prepare.
+     * For statements that will be reused often, instead use [[withPreparedStatement]].
+     * @param sql The SQLite SQL statement to execute
+     * @param callback the callback to invoke on the prepared statement
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @returns the value returned by `callback`.
+     * @see [[withPreparedStatement]]
+     * @public
+     */
+    withStatement(ecsql, callback, logErrors = true) {
+        const stmt = this.prepareStatement(ecsql, logErrors);
+        const release = () => stmt[Symbol.dispose]();
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /** Allow to execute query and read results along with meta data. The result are streamed.
+     *
+     * See also:
+     * - [ECSQL Overview]($docs/learning/backend/ExecutingECSQL)
+     * - [Code Examples]($docs/learning/backend/ECSQLCodeExamples)
+     * - [ECSQL Row Format]($docs/learning/ECSQLRowFormat)
+     *
+     * @param params The values to bind to the parameters (if the ECSQL has any).
+     * @param config Allow to specify certain flags which control how query is executed.
+     * @returns Returns an [ECSqlReader]($common) which helps iterate over the result set and also give access to metadata.
+     * @public
+     * */
+    createQueryReader(ecsql, params, config) {
+        if (!this[_nativeDb].isOpen())
+            throw new IModelError(DbResult.BE_SQLITE_ERROR, "db not open");
+        const executor = {
+            execute: async (request) => {
+                return ConcurrentQuery.executeQueryRequest(this[_nativeDb], request);
+            },
+        };
+        return new ECSqlReader(executor, ecsql, params, config);
+    }
+    /**
+     * Use a prepared SQL statement, potentially from the statement cache. If the requested statement doesn't exist
+     * in the statement cache, a new statement is prepared. After the callback completes, the statement is reset and saved
+     * in the statement cache so it can be reused in the future. Use this method for SQL statements that will be
+     * reused often and are expensive to prepare. The statement cache holds the most recently used statements, discarding
+     * the oldest statements as it fills. For statements you don't intend to reuse, instead use [[withSqliteStatement]].
+     * @param sql The SQLite SQL statement to execute
+     * @param callback the callback to invoke on the prepared statement
+     * @param logErrors Determine if errors are logged or not
+     * @returns the value returned by `callback`.
+     * @see [[withPreparedStatement]]
+     * @public
+     */
+    withPreparedSqliteStatement(sql, callback, logErrors = true) {
+        const stmt = this._sqliteStatementCache.findAndRemove(sql) ?? this.prepareSqliteStatement(sql, logErrors);
+        const release = () => this._sqliteStatementCache.addOrDispose(stmt);
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /**
+     * Prepared and execute a callback on a SQL statement. After the callback completes the statement is disposed.
+     * Use this method for SQL statements are either not expected to be reused, or are not expensive to prepare.
+     * For statements that will be reused often, instead use [[withPreparedSqliteStatement]].
+     * @param sql The SQLite SQL statement to execute
+     * @param callback the callback to invoke on the prepared statement
+     * @param logErrors Determine if errors are logged or not
+     * @returns the value returned by `callback`.
+     * @public
+     */
+    withSqliteStatement(sql, callback, logErrors = true) {
+        const stmt = this.prepareSqliteStatement(sql, logErrors);
+        const release = () => stmt[Symbol.dispose]();
+        try {
+            const val = callback(stmt);
+            if (val instanceof Promise) {
+                val.then(release, release);
+            }
+            else {
+                release();
+            }
+            return val;
+        }
+        catch (err) {
+            release();
+            throw err;
+        }
+    }
+    /** Prepare an SQL statement.
+     * @param sql The SQL statement to prepare
+     * @throws [[IModelError]] if there is a problem preparing the statement.
+     * @internal
+     */
+    prepareSqliteStatement(sql, logErrors = true) {
+        const stmt = new SqliteStatement(sql);
+        stmt.prepare(this[_nativeDb], logErrors);
+        return stmt;
+    }
+    /**
+     * queries the BisCore.SubCategory table for entries that are children of used spatial categories and 3D elements.
+     * @returns array of SubCategoryResultRow
+     * @internal
+     */
+    async queryAllUsedSpatialSubCategories() {
+        const result = [];
+        const parentCategoriesQuery = `SELECT DISTINCT Category.Id AS id FROM BisCore.GeometricElement3d WHERE Category.Id IN (SELECT ECInstanceId FROM BisCore.SpatialCategory)`;
+        const parentCategories = [];
+        for await (const row of this.createQueryReader(parentCategoriesQuery)) {
+            parentCategories.push(row.id);
+        }
+        ;
+        const where = [...parentCategories].join(",");
+        const query = `SELECT ECInstanceId as id, Parent.Id as parentId, Properties as appearance FROM BisCore.SubCategory WHERE Parent.Id IN (${where})`;
+        try {
+            for await (const row of this.createQueryReader(query, undefined, { rowFormat: QueryRowFormat.UseJsPropertyNames })) {
+                result.push(row.toRow());
+            }
+        }
+        catch {
+            // We can ignore the error here, and just return whatever we were able to query.
+        }
+        return result;
+    }
+    /**
+     * queries the BisCore.SubCategory table for the entries that are children of the passed categoryIds.
+     * @param categoryIds categoryIds to query
+     * @returns array of SubCategoryResultRow
+     * @internal
+     */
+    async querySubCategories(categoryIds) {
+        const result = [];
+        const where = [...categoryIds].join(",");
+        const query = `SELECT ECInstanceId as id, Parent.Id as parentId, Properties as appearance FROM BisCore.SubCategory WHERE Parent.Id IN (${where})`;
+        try {
+            for await (const row of this.createQueryReader(query, undefined, { rowFormat: QueryRowFormat.UseJsPropertyNames })) {
+                result.push(row.toRow());
+            }
+        }
+        catch {
+            // We can ignore the error here, and just return whatever we were able to query.
+        }
+        return result;
+    }
+    /** Query for a set of entity ids, given an EntityQueryParams
+     * @param params The query parameters. The `limit` and `offset` members should be used to page results.
+     * @returns an Id64Set with results of query
+     * @throws [[IModelError]] if the generated statement is invalid or [IModelDb.maxLimit]($backend) exceeded when collecting ids.
+     *
+     * *Example:*
+     * ``` ts
+     * [[include:ECSQL-backend-queries.select-element-by-code-value-using-queryEntityIds]]
+     * ```
+     */
+    queryEntityIds(params) {
+        let sql = "SELECT ECInstanceId FROM ";
+        if (params.only)
+            sql += "ONLY ";
+        sql += params.from;
+        if (params.where)
+            sql += ` WHERE ${params.where}`;
+        if (params.orderBy)
+            sql += ` ORDER BY ${params.orderBy}`;
+        if (typeof params.limit === "number" && params.limit > 0)
+            sql += ` LIMIT ${params.limit}`;
+        if (typeof params.offset === "number" && params.offset > 0)
+            sql += ` OFFSET ${params.offset}`;
+        const ids = new Set();
+        this.withPreparedStatement(sql, (stmt) => {
+            if (params.bindings)
+                stmt.bindValues(params.bindings);
+            for (const row of stmt) {
+                if (row.id !== undefined) {
+                    ids.add(row.id);
+                    if (ids.size > IModelDb.maxLimit) {
+                        throw new IModelError(IModelStatus.BadRequest, "Max LIMIT exceeded in SELECT statement");
+                    }
+                }
+            }
+        });
+        return ids;
+    }
+    /** Clear all in-memory caches held in this IModelDb. */
+    clearCaches() {
+        this._statementCache.clear();
+        this._sqliteStatementCache.clear();
+        this._classMetaDataRegistry = undefined;
+        this._jsClassMap = undefined;
+        this._schemaMap = undefined;
+        this._schemaContext = undefined;
+    }
+    /** Update the project extents for this iModel.
+     * <p><em>Example:</em>
+     * ``` ts
+     * [[include:IModelDb.updateProjectExtents]]
+     * ```
+     */
+    updateProjectExtents(newExtents) {
+        this.projectExtents = newExtents;
+        this.updateIModelProps();
+    }
+    /** Compute an appropriate project extents for this iModel based on the ranges of all spatial elements.
+     * Typically, the result is simply the union of the ranges of all spatial elements. However, the algorithm also detects "outlier elements",
+     * whose placements locate them so far from the rest of the spatial geometry that they are considered statistically insignificant. The
+     * range of an outlier element does not contribute to the computed extents.
+     * @param options Specifies the level of detail desired in the return value.
+     * @returns the computed extents.
+     * @note This method does not modify the IModel's stored project extents. @see [[updateProjectExtents]].
+     */
+    computeProjectExtents(options) {
+        const wantFullExtents = true === options?.reportExtentsWithOutliers;
+        const wantOutliers = true === options?.reportOutliers;
+        const result = this[_nativeDb].computeProjectExtents(wantFullExtents, wantOutliers);
+        return {
+            extents: Range3d.fromJSON(result.extents),
+            extentsWithOutliers: result.fullExtents ? Range3d.fromJSON(result.fullExtents) : undefined,
+            outliers: result.outliers,
+        };
+    }
+    /** Update the [EcefLocation]($docs/learning/glossary#eceflocation) of this iModel.  */
+    updateEcefLocation(ecef) {
+        this.setEcefLocation(ecef);
+        this.updateIModelProps();
+    }
+    /** Update the IModelProps of this iModel in the database. */
+    updateIModelProps() {
+        this[_nativeDb].updateIModelProps(this.toJSON());
+    }
+    /** Commit unsaved changes in memory as a Txn to this iModelDb.
+     * @param description Optional description of the changes
+     * @throws [[IModelError]] if there is a problem saving changes or if there are pending, un-processed lock or code requests.
+     * @note This will not push changes to the iModelHub.
+     * @see [[IModelDb.pushChanges]] to push changes to the iModelHub.
+     */
+    saveChanges(description) {
+        if (this.openMode === OpenMode.Readonly)
+            throw new IModelError(IModelStatus.ReadOnly, "IModelDb was opened read-only");
+        const stat = this[_nativeDb].saveChanges(description);
+        if (DbResult.BE_SQLITE_OK !== stat)
+            throw new IModelError(stat, `Could not save changes (${description})`);
+    }
+    /** Abandon changes in memory that have not been saved as a Txn to this iModelDb.
+     * @note This will not delete Txns that have already been saved, even if they have not yet been pushed.
+    */
+    abandonChanges() {
+        this[_nativeDb].abandonChanges();
+    }
+    /**
+     * Save all changes and perform a [checkpoint](https://www.sqlite.org/c3ref/wal_checkpoint_v2.html) on this IModelDb.
+     * This ensures that all changes to the database since it was opened are saved to its file and the WAL file is truncated.
+     * @note Checkpoint automatically happens when IModelDbs are closed. However, the checkpoint
+     * operation itself can take some time. It may be useful to call this method prior to closing so that the checkpoint "penalty" is paid earlier.
+     * @note Another use for this function is to permit the file to be copied while it is open for write. iModel files should
+     * rarely be copied, and even less so while they're opened. But this scenario is sometimes encountered for tests.
+     */
+    performCheckpoint() {
+        if (!this.isReadonly) {
+            this.saveChanges();
+            this[_nativeDb].performCheckpoint();
+        }
+    }
+    /** @internal
+     * @deprecated in 4.8. Use `txns.reverseTxns`.
+     */
+    reverseTxns(numOperations) {
+        return this[_nativeDb].reverseTxns(numOperations);
+    }
+    /** @internal */
+    reinstateTxn() {
+        return this[_nativeDb].reinstateTxn();
+    }
+    /** @internal */
+    restartTxnSession() {
+        return this[_nativeDb].restartTxnSession();
+    }
+    /** Import an ECSchema. On success, the schema definition is stored in the iModel.
+     * This method is asynchronous (must be awaited) because, in the case where this IModelDb is a briefcase, this method first obtains the schema lock from the iModel server.
+     * You must import a schema into an iModel before you can insert instances of the classes in that schema. See [[Element]]
+     * @param schemaFileName  array of Full paths to ECSchema.xml files to be imported.
+     * @param {SchemaImportOptions} options - options during schema import.
+     * @throws [[IModelError]] if the schema lock cannot be obtained or there is a problem importing the schema.
+     * @note Changes are saved if importSchemas is successful and abandoned if not successful.
+     * - You can use NativeLoggerCategory to turn on the native logs. You can also control [what exactly is logged by the loggers](https://www.itwinjs.org/learning/common/logging/#controlling-what-is-logged).
+     * - See [Schema Versioning]($docs/bis/guide/schema-evolution/schema-versioning-and-generations.md) for more information on acceptable changes to schemas.
+     * @see querySchemaVersion
+     */
+    async importSchemas(schemaFileNames, options) {
+        if (schemaFileNames.length === 0)
+            return;
+        const maybeCustomNativeContext = options?.ecSchemaXmlContext?.nativeContext;
+        if (this[_nativeDb].schemaSyncEnabled()) {
+            await SchemaSync.withLockedAccess(this, { openMode: OpenMode.Readonly, operationName: "schema sync" }, async (syncAccess) => {
+                const schemaSyncDbUri = syncAccess.getUri();
+                this.saveChanges();
+                try {
+                    this[_nativeDb].importSchemas(schemaFileNames, { schemaLockHeld: false, ecSchemaXmlContext: maybeCustomNativeContext, schemaSyncDbUri });
+                }
+                catch (outerErr) {
+                    if (DbResult.BE_SQLITE_ERROR_DataTransformRequired === outerErr.errorNumber) {
+                        this.abandonChanges();
+                        if (this[_nativeDb].getITwinId() !== Guid.empty)
+                            await this.acquireSchemaLock();
+                        try {
+                            this[_nativeDb].importSchemas(schemaFileNames, { schemaLockHeld: true, ecSchemaXmlContext: maybeCustomNativeContext, schemaSyncDbUri });
+                        }
+                        catch (innerErr) {
+                            throw new IModelError(innerErr.errorNumber, innerErr.message);
+                        }
+                    }
+                    else {
+                        throw new IModelError(outerErr.errorNumber, outerErr.message);
+                    }
+                }
+            });
+        }
+        else {
+            const nativeImportOptions = {
+                schemaLockHeld: true,
+                ecSchemaXmlContext: maybeCustomNativeContext,
+            };
+            if (this[_nativeDb].getITwinId() !== Guid.empty) // if this iModel is associated with an iTwin, importing schema requires the schema lock
+                await this.acquireSchemaLock();
+            try {
+                this[_nativeDb].importSchemas(schemaFileNames, nativeImportOptions);
+            }
+            catch (err) {
+                throw new IModelError(err.errorNumber, err.message);
+            }
+        }
+        this.clearCaches();
+    }
+    /** Import ECSchema(s) serialized to XML. On success, the schema definition is stored in the iModel.
+     * This method is asynchronous (must be awaited) because, in the case where this IModelDb is a briefcase, this method first obtains the schema lock from the iModel server.
+     * You must import a schema into an iModel before you can insert instances of the classes in that schema. See [[Element]]
+     * @param serializedXmlSchemas  The xml string(s) created from a serialized ECSchema.
+     * @throws [[IModelError]] if the schema lock cannot be obtained or there is a problem importing the schema.
+     * @note Changes are saved if importSchemaStrings is successful and abandoned if not successful.
+     * @see querySchemaVersion
+     * @alpha
+     */
+    async importSchemaStrings(serializedXmlSchemas) {
+        if (serializedXmlSchemas.length === 0)
+            return;
+        if (this[_nativeDb].schemaSyncEnabled()) {
+            await SchemaSync.withLockedAccess(this, { openMode: OpenMode.Readonly, operationName: "schemaSync" }, async (syncAccess) => {
+                const schemaSyncDbUri = syncAccess.getUri();
+                this.saveChanges();
+                try {
+                    this[_nativeDb].importXmlSchemas(serializedXmlSchemas, { schemaLockHeld: false, schemaSyncDbUri });
+                }
+                catch (outerErr) {
+                    if (DbResult.BE_SQLITE_ERROR_DataTransformRequired === outerErr.errorNumber) {
+                        this.abandonChanges();
+                        if (this[_nativeDb].getITwinId() !== Guid.empty)
+                            await this.acquireSchemaLock();
+                        try {
+                            this[_nativeDb].importXmlSchemas(serializedXmlSchemas, { schemaLockHeld: true, schemaSyncDbUri });
+                        }
+                        catch (innerErr) {
+                            throw new IModelError(innerErr.errorNumber, innerErr.message);
+                        }
+                    }
+                    else {
+                        throw new IModelError(outerErr.errorNumber, outerErr.message);
+                    }
+                }
+            });
+        }
+        else {
+            if (this.iTwinId && this.iTwinId !== Guid.empty) // if this iModel is associated with an iTwin, importing schema requires the schema lock
+                await this.acquireSchemaLock();
+            try {
+                this[_nativeDb].importXmlSchemas(serializedXmlSchemas, { schemaLockHeld: true });
+            }
+            catch (err) {
+                throw new IModelError(err.errorNumber, err.message);
+            }
+        }
+        this.clearCaches();
+    }
+    /** Find an opened instance of any subclass of IModelDb, by filename
+     * @note this method returns an IModelDb if the filename is open for *any* subclass of IModelDb
+    */
+    static findByFilename(fileName) {
+        for (const entry of this._openDbs) {
+            // It shouldn't be possible for anything in _openDbs to not be open, but if so just skip them because `pathName` will throw an exception.
+            if (entry[1].isOpen && entry[1].pathName === fileName)
+                return entry[1];
+        }
+        return undefined;
+    }
+    /** Find an open IModelDb by its key.
+     * @note This method is mainly for use by RPC implementations.
+     * @throws [[IModelNotFoundResponse]] if an open IModelDb matching the key is not found.
+     * @see [IModel.key]($common)
+     */
+    static findByKey(key) {
+        const iModelDb = this.tryFindByKey(key);
+        if (undefined === iModelDb) {
+            // eslint-disable-next-line @typescript-eslint/only-throw-error
+            throw new IModelNotFoundResponse(); // a very specific status for the RpcManager
+        }
+        return iModelDb;
+    }
+    /** Attempt to find an open IModelDb by key.
+     * @returns The matching IModelDb or `undefined`.
+     */
+    static tryFindByKey(key) {
+        return this._openDbs.get(key);
+    }
+    /** @internal */
+    static openDgnDb(file, openMode, upgradeOptions, props) {
+        file.key = file.key ?? Guid.createValue();
+        if (this.tryFindByKey(file.key))
+            throw new IModelError(IModelStatus.AlreadyOpen, `key [${file.key}] for file [${file.path}] is already in use`);
+        const isUpgradeRequested = upgradeOptions?.domain === DomainOptions.Upgrade || upgradeOptions?.profile === ProfileOptions.Upgrade;
+        if (isUpgradeRequested && openMode !== OpenMode.ReadWrite)
+            throw new IModelError(IModelStatus.UpgradeFailed, "Cannot upgrade a Readonly Db");
+        try {
+            const nativeDb = new IModelNative.platform.DgnDb();
+            const container = props?.container;
+            if (container) {
+                // temp files for cloud-based Dbs should be in the profileDir in a subdirectory named for their container
+                const baseDir = join(IModelHost.profileDir, "CloudDbTemp", container.containerId);
+                IModelJsFs.recursiveMkDirSync(baseDir);
+                props = { ...props, tempFileBase: join(baseDir, file.path) };
+            }
+            nativeDb.openIModel(file.path, openMode, upgradeOptions, props, props?.container, props);
+            return nativeDb;
+        }
+        catch (err) {
+            throw new IModelError(err.errorNumber, `${err.message}, ${file.path}`);
+        }
+    }
+    /**
+     * Determines if the schemas in the Db must or can be upgraded by comparing them with those included in the
+     * current version of the software.
+     * @param filePath Full name of the briefcase including path
+     * @param forReadWrite Pass true if validating for read-write scenarios - note that the schema version requirements
+     * for opening the DgnDb read-write is more stringent than when opening the database read-only
+     * @throws [[IModelError]] If the Db was in an invalid state and that causes a problem with validating schemas
+     * @see [[BriefcaseDb.upgradeSchemas]] or [[StandaloneDb.upgradeSchemas]]
+     * @see ($docs/learning/backend/IModelDb.md#upgrading-schemas-in-an-imodel)
+     */
+    static validateSchemas(filePath, forReadWrite) {
+        const openMode = forReadWrite ? OpenMode.ReadWrite : OpenMode.Readonly;
+        const file = { path: filePath };
+        let result = DbResult.BE_SQLITE_OK;
+        try {
+            const upgradeOptions = {
+                domain: DomainOptions.CheckRecommendedUpgrades,
+            };
+            const nativeDb = this.openDgnDb(file, openMode, upgradeOptions);
+            nativeDb.closeFile();
+        }
+        catch (err) {
+            result = err.errorNumber;
+        }
+        let schemaState = SchemaState.UpToDate;
+        switch (result) {
+            case DbResult.BE_SQLITE_OK:
+                schemaState = SchemaState.UpToDate;
+                break;
+            case DbResult.BE_SQLITE_ERROR_ProfileTooOld:
+            case DbResult.BE_SQLITE_ERROR_ProfileTooOldForReadWrite:
+            case DbResult.BE_SQLITE_ERROR_SchemaTooOld:
+                schemaState = SchemaState.TooOld;
+                break;
+            case DbResult.BE_SQLITE_ERROR_ProfileTooNew:
+            case DbResult.BE_SQLITE_ERROR_ProfileTooNewForReadWrite:
+            case DbResult.BE_SQLITE_ERROR_SchemaTooNew:
+                schemaState = SchemaState.TooNew;
+                break;
+            case DbResult.BE_SQLITE_ERROR_SchemaUpgradeRecommended:
+                schemaState = SchemaState.UpgradeRecommended;
+                break;
+            case DbResult.BE_SQLITE_ERROR_SchemaUpgradeRequired:
+                schemaState = SchemaState.UpgradeRequired;
+                break;
+            case DbResult.BE_SQLITE_ERROR_InvalidProfileVersion:
+                throw new IModelError(DbResult.BE_SQLITE_ERROR_InvalidProfileVersion, "The profile of the Db is invalid. Cannot upgrade or open the Db.");
+            default:
+                throw new IModelError(DbResult.BE_SQLITE_ERROR, "Error validating schemas. Cannot upgrade or open the Db.");
+        }
+        return schemaState;
+    }
+    /** The registry of entity metadata for this iModel.
+     * @internal
+     * @deprecated in 5.0. Please use `schemaContext` from the `iModel` instead.
+     *
+     * @example
+     * ```typescript
+     * // Current usage:
+     * const classMetaData: EntityMetaData | undefined = iModel.classMetaDataRegistry.find("SchemaName:ClassName");
+     *
+     * // Replacement:
+     * const metaData: EntityClass | undefined = imodel.schemaContext.getSchemaItemSync("SchemaName.ClassName", EntityClass);
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    get classMetaDataRegistry() {
+        if (this._classMetaDataRegistry === undefined)
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            this._classMetaDataRegistry = new MetaDataRegistry();
+        return this._classMetaDataRegistry;
+    }
+    /**
+     * Allows registering js classes mapped to ECClasses
+     */
+    get jsClassMap() {
+        if (this._jsClassMap === undefined)
+            this._jsClassMap = new EntityJsClassMap();
+        return this._jsClassMap;
+    }
+    /**
+     * Allows locally registering a schema for this imodel, in constrast to [Schemas.registerSchema] which is a global operation
+     */
+    get schemaMap() {
+        if (this._schemaMap === undefined)
+            this._schemaMap = new SchemaMap();
+        return this._schemaMap;
+    }
+    /**
+     * Gets the context that allows accessing the metadata (ecschema-metadata package) of this iModel
+     * @beta
+     */
+    get schemaContext() {
+        if (this._schemaContext === undefined) {
+            const context = new SchemaContext();
+            // TODO: We probably need a more optimized locater for here
+            const locater = new SchemaJsonLocater((name) => this.getSchemaProps(name));
+            context.addLocater(locater);
+            this._schemaContext = context;
+        }
+        return this._schemaContext;
+    }
+    /** Get the linkTableRelationships for this IModel */
+    get relationships() {
+        return this._relationships || (this._relationships = new Relationships(this));
+    }
+    /** Get the CodeSpecs in this IModel. */
+    get codeSpecs() {
+        return (this._codeSpecs !== undefined) ? this._codeSpecs : (this._codeSpecs = new CodeSpecs(this));
+    }
+    /** Prepare an ECSQL statement.
+     * @param sql The ECSQL statement to prepare
+     * @param logErrors Determines if error will be logged if statement fail to prepare
+     * @throws [[IModelError]] if there is a problem preparing the statement.
+     */
+    prepareStatement(sql, logErrors = true) {
+        const stmt = new ECSqlStatement();
+        stmt.prepare(this[_nativeDb], sql, logErrors);
+        return stmt;
+    }
+    /** Prepare an ECSQL statement.
+     * @param sql The ECSQL statement to prepare
+     * @returns `undefined` if there is a problem preparing the statement.
+     */
+    tryPrepareStatement(sql) {
+        const statement = new ECSqlStatement();
+        const result = statement.tryPrepare(this[_nativeDb], sql);
+        return DbResult.BE_SQLITE_OK === result.status ? statement : undefined;
+    }
+    /** Construct an entity (Element or Model) from an iModel.
+     * @throws [[IModelError]] if the entity cannot be constructed.
+     */
+    constructEntity(props) {
+        const jsClass = this.getJsClass(props.classFullName);
+        return Entity.instantiate(jsClass, props, this);
+    }
+    /** Get the JavaScript class that handles a given entity class.  */
+    getJsClass(classFullName) {
+        try {
+            return ClassRegistry.getClass(classFullName, this);
+        }
+        catch (err) {
+            if (!ClassRegistry.isNotFoundError(err)) {
+                throw err;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            this.loadMetaData(classFullName);
+            return ClassRegistry.getClass(classFullName, this);
+        }
+    }
+    /** Get metadata for a class. This method will load the metadata from the iModel into the cache as a side-effect, if necessary.
+     * @throws [[IModelError]] if the metadata cannot be found nor loaded.
+     * @deprecated in 5.0. Please use `getSchemaItem` from `SchemaContext` class instead.
+     *
+     * @example
+     *  * ```typescript
+     * // Current usage:
+     * const metaData: EntityMetaData = imodel.getMetaData("SchemaName:ClassName");
+     *
+     * // Replacement:
+     * const metaData: EntityClass | undefined = imodel.schemaContext.getSchemaItemSync("SchemaName", "ClassName", EntityClass);
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    getMetaData(classFullName) {
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        let metadata = this.classMetaDataRegistry.find(classFullName);
+        if (metadata === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            this.loadMetaData(classFullName);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            metadata = this.classMetaDataRegistry.find(classFullName);
+            if (metadata === undefined)
+                throw ClassRegistry.makeMetaDataNotFoundError(classFullName); // do not log
+        }
+        return metadata;
+    }
+    /** Identical to [[getMetaData]], except it returns `undefined` instead of throwing an error if the metadata cannot be found nor loaded.
+     * @deprecated in 5.0. Please use `getSchemaItem` from `SchemaContext` class instead.
+     *
+     * @example
+     *  * ```typescript
+     * // Current usage:
+     * const metaData: EntityMetaData | undefined = imodel.tryGetMetaData("SchemaName:ClassName");
+     *
+     * // Replacement:
+     * const metaData: EntityClass | undefined = imodel.schemaContext.getSchemaItemSync("SchemaName.ClassName", EntityClass);
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    tryGetMetaData(classFullName) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            return this.getMetaData(classFullName);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Invoke a callback on each property of the specified class, optionally including superclass properties.
+     * @param iModel  The IModel that contains the schema
+     * @param classFullName The full class name to load the metadata, if necessary
+     * @param wantSuper If true, superclass properties will also be processed
+     * @param func The callback to be invoked on each property
+     * @param includeCustom If true (default), include custom-handled properties in the iteration. Otherwise, skip custom-handled properties.
+     * @note Custom-handled properties are core properties that have behavior enforced by C++ handlers.
+     * @deprecated in 5.0. Please use `forEachProperty` instead.
+     *
+     * @example
+     * ```typescript
+     * // Current usage:
+     * IModelDb.forEachMetaData(imodel, "BisCore:Element", true, (name: string, propMetaData: PropertyMetaData) => {
+     *   console.log(`Property name: ${name}, Property type: ${propMetaData.primitiveType}`);
+     * }, false);
+     *
+     * // Replacement:
+     * await IModelDb.forEachProperty(imodel, "TestDomain.TestDomainClass", true, (propName: string, property: Property) => {
+     *   console.log(`Property name: ${propName}, Property type: ${property.propertyType}`);
+     * }, false);
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    static forEachMetaData(iModel, classFullName, wantSuper, func, includeCustom = true) {
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        iModel.forEachMetaData(classFullName, wantSuper, func, includeCustom);
+    }
+    /** Invoke a callback on each property of the specified class, optionally including superclass properties.
+     * @param classFullName The full class name to load the metadata, if necessary
+     * @param wantSuper If true, superclass properties will also be processed
+     * @param func The callback to be invoked on each property
+     * @param includeCustom If true (default), include custom-handled properties in the iteration. Otherwise, skip custom-handled properties.
+     * @note Custom-handled properties are core properties that have behavior enforced by C++ handlers.
+     * @deprecated in 5.0. Use `forEachProperty` from `SchemaContext` class instead.
+     *
+     * @example
+     * ```typescript
+     * // Current usage:
+     * iModel.forEachMetaData("BisCore:Element", true, (name: string, propMetaData: PropertyMetaData) => {
+     *   console.log(`Property name: ${name}, Property type: ${propMetaData.primitiveType}`);
+     * });
+     *
+     * // Replacement:
+     * imodel.schemaContext.forEachProperty("BisCore:Element", true, (propName: string, property: Property) => {
+     *   console.log(`Property name: ${propName}, Property type: ${property.propertyType}`);
+     * });
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    forEachMetaData(classFullName, wantSuper, func, includeCustom = true) {
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        const meta = this.getMetaData(classFullName); // will load if necessary
+        for (const propName in meta.properties) { // eslint-disable-line guard-for-in
+            const propMeta = meta.properties[propName];
+            if (includeCustom || !propMeta.isCustomHandled || propMeta.isCustomHandledOrphan)
+                func(propName, propMeta);
+        }
+        if (wantSuper && meta.baseClasses && meta.baseClasses.length > 0)
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            meta.baseClasses.forEach((baseClass) => this.forEachMetaData(baseClass, true, func, includeCustom));
+    }
+    /**
+     * @internal
+     * @deprecated in 5.0. Please use `schemaContext` from `iModel` instead to get metadata.
+     */
+    loadMetaData(classFullName) {
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        if (this.classMetaDataRegistry.find(classFullName))
+            return;
+        const className = classFullName.split(":");
+        if (className.length !== 2)
+            throw new IModelError(IModelStatus.BadArg, `Invalid classFullName: ${classFullName}`);
+        const val = this[_nativeDb].getECClassMetaData(className[0], className[1]);
+        if (val.error)
+            throw new IModelError(val.error.status, `Error getting class meta data for: ${classFullName}`);
+        assert(undefined !== val.result);
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        const metaData = new EntityMetaData(JSON.parse(val.result));
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        this.classMetaDataRegistry.add(classFullName, metaData);
+        // Recursive, to make sure that base classes are cached.
+        if (metaData.baseClasses !== undefined && metaData.baseClasses.length > 0)
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            metaData.baseClasses.forEach((baseClassName) => this.loadMetaData(baseClassName));
+    }
+    /** Returns the full schema for the input name.
+     * @param name The name of the schema e.g. 'BisCore'
+     * @returns The SchemaProps for the requested schema
+     * @throws if the schema can not be found or loaded.
+     */
+    getSchemaProps(name) {
+        return this[_nativeDb].getSchemaProps(name);
+    }
+    /** Query if this iModel contains the definition of the specified class.
+     * @param classFullName The full name of the class, for example, SomeSchema:SomeClass
+     * @returns true if the iModel contains the class definition or false if not.
+     * @see querySchemaVersion
+     * @see importSchema
+     */
+    containsClass(classFullName) {
+        const classNameParts = classFullName.replace(".", ":").split(":");
+        return classNameParts.length === 2 && this[_nativeDb].getECClassMetaData(classNameParts[0], classNameParts[1]).error === undefined;
+    }
+    /** Query for a schema of the specified name in this iModel.
+     * @returns The schema version as a semver-compatible string or `undefined` if the schema has not been imported.
+     */
+    querySchemaVersion(schemaName) {
+        const sql = `SELECT VersionMajor,VersionWrite,VersionMinor FROM ECDbMeta.ECSchemaDef WHERE Name=:schemaName LIMIT 1`;
+        return this.withPreparedStatement(sql, (statement) => {
+            statement.bindString("schemaName", schemaName);
+            if (DbResult.BE_SQLITE_ROW === statement.step()) {
+                const versionMajor = statement.getValue(0).getInteger(); // ECSchemaDef.VersionMajor --> semver.major
+                const versionWrite = statement.getValue(1).getInteger(); // ECSchemaDef.VersionWrite --> semver.minor
+                const versionMinor = statement.getValue(2).getInteger(); // ECSchemaDef.VersionMinor --> semver.patch
+                return `${versionMajor}.${versionWrite}.${versionMinor}`;
+            }
+            return undefined;
+        });
+    }
+    /** Retrieve a named texture image from this iModel, as a TextureData.
+     * @param props the texture load properties which must include the name of the texture to load
+     * @returns the TextureData or undefined if the texture image is not present.
+     * @alpha
+     */
+    async queryTextureData(props) {
+        return this[_nativeDb].queryTextureData(props);
+    }
+    /** Query a "file property" from this iModel, as a string.
+     * @returns the property string or undefined if the property is not present.
+     */
+    queryFilePropertyString(prop) {
+        return this[_nativeDb].queryFileProperty(prop, true);
+    }
+    /** Query a "file property" from this iModel, as a blob.
+     * @returns the property blob or undefined if the property is not present.
+     */
+    queryFilePropertyBlob(prop) {
+        return this[_nativeDb].queryFileProperty(prop, false);
+    }
+    /** Save a "file property" to this iModel
+     * @param prop the FilePropertyProps that describes the new property
+     * @param value either a string or a blob to save as the file property
+     */
+    saveFileProperty(prop, strValue, blobVal) {
+        this[_nativeDb].saveFileProperty(prop, strValue, blobVal);
+    }
+    /** delete a "file property" from this iModel
+     * @param prop the FilePropertyProps that describes the property
+     */
+    deleteFileProperty(prop) {
+        this[_nativeDb].saveFileProperty(prop, undefined, undefined);
+    }
+    /** Query for the next available major id for a "file property" from this iModel.
+     * @param prop the FilePropertyProps that describes the property
+     * @returns the next available (that is, an unused) id for prop. If none are present, will return 0.
+     */
+    queryNextAvailableFileProperty(prop) { return this[_nativeDb].queryNextAvailableFileProperty(prop); }
+    /** @internal */
+    async requestSnap(sessionId, props) {
+        let request = this._snaps.get(sessionId);
+        if (undefined === request) {
+            request = new IModelNative.platform.SnapRequest();
+            this._snaps.set(sessionId, request);
+        }
+        else
+            request.cancelSnap();
+        try {
+            return await request.doSnap(this[_nativeDb], JsonUtils.toObject(props));
+        }
+        finally {
+            this._snaps.delete(sessionId);
+        }
+    }
+    /** Cancel a previously requested snap.
+     * @internal
+     */
+    cancelSnap(sessionId) {
+        const request = this._snaps.get(sessionId);
+        if (undefined !== request) {
+            request.cancelSnap();
+            this._snaps.delete(sessionId);
+        }
+    }
+    /** Get the clip containment status for the supplied elements. */
+    async getGeometryContainment(props) {
+        return this[_nativeDb].getGeometryContainment(JsonUtils.toObject(props));
+    }
+    /** Get the mass properties for the supplied elements. */
+    async getMassProperties(props) {
+        return this[_nativeDb].getMassProperties(JsonUtils.toObject(props));
+    }
+    /** Get the IModel coordinate corresponding to each GeoCoordinate point in the input */
+    async getIModelCoordinatesFromGeoCoordinates(props) {
+        return this[_nativeDb].getIModelCoordinatesFromGeoCoordinates(props);
+    }
+    /** Get the GeoCoordinate (longitude, latitude, elevation) corresponding to each IModel Coordinate point in the input */
+    async getGeoCoordinatesFromIModelCoordinates(props) {
+        return this[_nativeDb].getGeoCoordinatesFromIModelCoordinates(props);
+    }
+    /** Export meshes suitable for graphics APIs from arbitrary geometry in elements in this IModelDb.
+     *  * Requests can be slow when processing many elements so it is expected that this function be used on a dedicated backend,
+     *    or that shared backends export a limited number of elements at a time.
+     *  * Vertices are exported in the IModelDb's world coordinate system, which is right-handed with Z pointing up.
+     *  * The results of changing [ExportGraphicsOptions]($core-backend) during the [ExportGraphicsOptions.onGraphics]($core-backend) callback are not defined.
+     *
+     * Example that prints the mesh for element 1 to stdout in [OBJ format](https://en.wikipedia.org/wiki/Wavefront_.obj_file)
+     * ```ts
+     * const onGraphics: ExportGraphicsFunction = (info: ExportGraphicsInfo) => {
+     *   const mesh: ExportGraphicsMesh = info.mesh;
+     *   for (let i = 0; i < mesh.points.length; i += 3) {
+     *     process.stdout.write(`v ${mesh.points[i]} ${mesh.points[i + 1]} ${mesh.points[i + 2]}\n`);
+     *     process.stdout.write(`vn ${mesh.normals[i]} ${mesh.normals[i + 1]} ${mesh.normals[i + 2]}\n`);
+     *   }
+     *
+     *   for (let i = 0; i < mesh.params.length; i += 2) {
+     *     process.stdout.write(`vt ${mesh.params[i]} ${mesh.params[i + 1]}\n`);
+     *   }
+     *
+     *   for (let i = 0; i < mesh.indices.length; i += 3) {
+     *     const p1 = mesh.indices[i];
+     *     const p2 = mesh.indices[i + 1];
+     *     const p3 = mesh.indices[i + 2];
+     *     process.stdout.write(`f ${p1}/${p1}/${p1} ${p2}/${p2}/${p2} ${p3}/${p3}/${p3}\n`);
+     *   }
+     * };
+     *
+     * iModel.exportGraphics(({ onGraphics, elementIdArray: ["0x1"] }));
+     * ```
+     * @returns 0 if successful, status otherwise
+     * @public
+     */
+    exportGraphics(exportProps) {
+        return this[_nativeDb].exportGraphics(exportProps);
+    }
+    /**
+     * Exports meshes suitable for graphics APIs from a specified [GeometryPart]($core-backend)
+     * in this IModelDb.
+     * The expected use case is to call [IModelDb.exportGraphics]($core-backend) and supply the
+     * optional partInstanceArray argument, then call this function for each unique GeometryPart from
+     * that list.
+     *  * The results of changing [ExportPartGraphicsOptions]($core-backend) during the
+     *    [ExportPartGraphicsOptions.onPartGraphics]($core-backend) callback are not defined.
+     *  * See export-gltf under test-apps in the iTwin.js monorepo for a working reference.
+     * @returns 0 is successful, status otherwise
+     * @public
+     */
+    exportPartGraphics(exportProps) {
+        return this[_nativeDb].exportPartGraphics(exportProps);
+    }
+    /** Request geometry stream information from an element in binary format instead of json.
+     * @returns IModelStatus.Success if successful
+     * @beta
+     */
+    elementGeometryRequest(requestProps) {
+        return this[_nativeDb].processGeometryStream(requestProps);
+    }
+    /** Request the creation of a backend geometry cache for the specified geometric element.
+     * @returns ElementGeometryCacheResponseProps
+     * @beta
+     */
+    async updateElementGeometryCache(requestProps) {
+        return this[_nativeDb].updateElementGeometryCache(requestProps);
+    }
+    /** Request operation using the backend geometry cache populated by first calling elementGeometryRequest.
+   * @returns SUCCESS if requested operation could be applied.
+   * @beta
+   */
+    elementGeometryCacheOperation(requestProps) {
+        return this[_nativeDb].elementGeometryCacheOperation(requestProps);
+    }
+    /** Create brep geometry for inclusion in an element's geometry stream.
+     * @returns IModelStatus.Success if successful
+     * @throws [[IModelError]] to report issues with input geometry or parameters
+     * @alpha
+     */
+    createBRepGeometry(createProps) {
+        return this[_nativeDb].createBRepGeometry(createProps);
+    }
+    /** Generate graphics for an element or geometry stream.
+     * @see [readElementGraphics]($frontend) to convert the result to a [RenderGraphic]($frontend) for display.
+     */
+    async generateElementGraphics(request) {
+        return generateElementGraphics(request, this);
+    }
+    static _settingPropNamespace = "settings";
+    /** Save a `SettingDictionary` in this iModel that will be loaded into [[workspace.settings]] every time this iModel is opened in future sessions.
+     * @param name The name for the SettingDictionary. If a dictionary by that name already exists in the iModel, its value is replaced.
+     * @param dict The SettingDictionary object to stringify and save.
+     * @note All saved `SettingDictionary`s are loaded into [[workspace.settings]] every time an iModel is opened.
+     * @beta
+     */
+    saveSettingDictionary(name, dict) {
+        this.withSqliteStatement("REPLACE INTO be_Prop(id,SubId,TxnMode,Namespace,Name,strData) VALUES(0,0,0,?,?,?)", (stmt) => {
+            stmt.bindString(1, IModelDb._settingPropNamespace);
+            stmt.bindString(2, name);
+            stmt.bindString(3, JSON.stringify(dict));
+            stmt.stepForWrite();
+        });
+        this.saveChanges("add settings");
+    }
+    /** Delete a SettingDictionary, previously added with [[saveSettingDictionary]], from this iModel.
+     * @param name The name of the dictionary to delete.
+     * @beta
+     */
+    deleteSettingDictionary(name) {
+        this.withSqliteStatement("DELETE FROM be_Prop WHERE Namespace=? AND Name=?", (stmt) => {
+            stmt.bindString(1, IModelDb._settingPropNamespace);
+            stmt.bindString(2, name);
+            stmt.stepForWrite();
+        });
+        this.saveChanges("delete settings");
+    }
+    /** Load all setting dictionaries in this iModel into `this.workspace.settings` */
+    loadIModelSettings() {
+        if (!this[_nativeDb].isOpen())
+            return;
+        this.withSqliteStatement("SELECT Name,StrData FROM be_Prop WHERE Namespace=?", (stmt) => {
+            stmt.bindString(1, IModelDb._settingPropNamespace);
+            while (stmt.nextRow()) {
+                try {
+                    const settings = JSON.parse(stmt.getValueString(1));
+                    this.workspace.settings.addDictionary({ name: stmt.getValueString(0), priority: SettingsPriority.iModel }, settings);
+                }
+                catch (e) {
+                    Workspace.exceptionDiagnosticFn(e);
+                }
+            }
+        });
+    }
+    /** @internal */
+    async loadWorkspaceSettings() {
+        try {
+            const problems = [];
+            const settingProps = [];
+            // Note: we can't use `getArray` here because we only look at dictionaries in the iModel's workspace, not appWorkspace.
+            // Also, we must concatenate all entries in all of the dictionaries stored in the iModel into a single array *before*
+            // calling `loadSettingsDictionary` since that function will add new dictionaries to the workspace.
+            for (const dict of this.workspace.settings.dictionaries) {
+                try {
+                    const props = dict.getSetting(WorkspaceSettingNames.settingsWorkspaces);
+                    if (props)
+                        settingProps.push(...IModelHost.settingsSchemas.validateSetting(props, WorkspaceSettingNames.settingsWorkspaces));
+                }
+                catch (e) {
+                    problems.push(e); // something wrong with the setting stored in the iModel
+                }
+            }
+            if (settingProps.length > 0)
+                await this.workspace.loadSettingsDictionary(settingProps, problems);
+            if (problems.length > 0)
+                throwWorkspaceDbLoadErrors(`attempting to load workspace settings for iModel '${this.name}':`, problems);
+        }
+        catch (e) {
+            // we don't want to throw exceptions when attempting to load Dictionaries. Call the diagnostics function instead.
+            Workspace.exceptionDiagnosticFn(e);
+        }
+    }
+    /**
+     * Controls how [Code]($common)s are copied from this iModel into another iModel, to work around problems with iModels
+     * created by older connectors. The [imodel-transformer](https://github.com/iTwin/imodel-transformer) sets this appropriately
+     * on your behalf - you should never need to set or interrogate this property yourself.
+     * @public
+     */
+    get codeValueBehavior() {
+        return this[_nativeDb].getCodeValueBehavior();
+    }
+    set codeValueBehavior(newBehavior) {
+        this[_nativeDb].setCodeValueBehavior(newBehavior);
+    }
+    /** @internal */
+    computeRangesForText(args) {
+        const props = this[_nativeDb].computeRangesForText(args.chars, args.fontId, args.bold, args.italic, args.widthFactor, args.lineHeight);
+        return {
+            layout: Range2d.fromJSON(props.layout),
+            justification: Range2d.fromJSON(props.justification),
+        };
+    }
+    /** Writes the contents of a single ECSchema to a file on the local file system.
+     * @beta
+     */
+    exportSchema(args) {
+        processSchemaWriteStatus(this[_nativeDb].exportSchema(args.schemaName, args.outputDirectory, args.outputFileName));
+    }
+    /** Writes the contents of all ECSchemas in this iModel to files in a directory on the local file system.
+     * @beta
+     */
+    exportSchemas(outputDirectory) {
+        processSchemaWriteStatus(this[_nativeDb].exportSchemas(outputDirectory));
+    }
+    /** Attempt to simplify the geometry stream of a single [[GeometricElement]] or [[GeometryPart]] as specified by `args`.
+     * @beta
+     */
+    simplifyElementGeometry(args) {
+        return this[_nativeDb].simplifyElementGeometry(args);
+    }
+    /** Attempts to optimize all of the geometry in this iModel by identifying [[GeometryPart]]s that are referenced by exactly one
+     * element's geometry stream. Each such reference is replaced by inserting the part's geometry directly into the element's geometry stream.
+     * Then, the no-longer-used geometry part is deleted.
+     * This can improve performance when a connector inadvertently creates large numbers of parts that are each only used once.
+     * @beta
+     */
+    inlineGeometryParts() {
+        return this[_nativeDb].inlineGeometryPartReferences();
+    }
+    /** Returns a string representation of the error that most recently arose during an operation on the underlying SQLite database.
+     * If no errors have occurred, an empty string is returned.
+     * Otherwise, a string of the format `message (code)` is returned, where `message` is a human-readable diagnostic string and `code` is an integer status code.
+     * See [SQLite error codes and messages](https://www.sqlite.org/c3ref/errcode.html)
+     * @note Do not rely upon this value or its specific contents in error handling logic. It is only intended for use in debugging.
+     */
+    getLastError() {
+        return this[_nativeDb].getLastError();
+    }
+}
+function processSchemaWriteStatus(status) {
+    switch (status) {
+        case 0 /* SchemaWriteStatus.Success */: return;
+        case 1 /* SchemaWriteStatus.FailedToSaveXml */: throw new Error("Failed to save schema XML");
+        case 2 /* SchemaWriteStatus.FailedToCreateXml */: throw new Error("Failed to create schema XML");
+        case 3 /* SchemaWriteStatus.FailedToCreateJson */: throw new Error("Failed to create schema JSON");
+        case 4 /* SchemaWriteStatus.FailedToWriteFile */: throw new Error("Failed to write schema file");
+        default: throw new Error("Unknown error while exporting schema");
+    }
+}
+/** @public */
+(function (IModelDb) {
+    /** The collection of models in an [[IModelDb]].
+     * @public
+     */
+    class Models {
+        _iModel;
+        /** @internal */
+        constructor(_iModel) {
+            this._iModel = _iModel;
+        }
+        /** Get the ModelProps with the specified identifier.
+         * @param modelId The Model identifier.
+         * @throws [[IModelError]] if the model is not found or cannot be loaded.
+         * @see tryGetModelProps
+         */
+        getModelProps(id) {
+            return this.getModelJson({ id });
+        }
+        /** Get the ModelProps with the specified identifier.
+         * @param modelId The Model identifier.
+         * @returns The ModelProps or `undefined` if the model is not found.
+         * @throws [[IModelError]] if the model cannot be loaded.
+         * @note Useful for cases when a model may or may not exist and throwing an `Error` would be overkill.
+         * @see getModelProps
+         */
+        tryGetModelProps(id) {
+            return this.tryGetModelJson({ id });
+        }
+        /** Query for the last modified time for a [[Model]].
+         * @param modelId The Id of the model.
+         * @throws IModelError if `modelId` does not identify a model in the iModel.
+         */
+        queryLastModifiedTime(modelId) {
+            const sql = `SELECT LastMod FROM ${Model.classFullName} WHERE ECInstanceId=:modelId`;
+            return this._iModel.withPreparedStatement(sql, (statement) => {
+                statement.bindId("modelId", modelId);
+                if (DbResult.BE_SQLITE_ROW === statement.step()) {
+                    return statement.getValue(0).getDateTime();
+                }
+                throw new IModelError(IModelStatus.InvalidId, `Can't get lastMod time for Model ${modelId}`);
+            });
+        }
+        /** Get the Model with the specified identifier.
+         * @param modelId The Model identifier.
+         * @param modelClass Optional class to validate instance against. This parameter can accept abstract or concrete classes, but should be the same as the template (`T`) parameter.
+         * @throws [[IModelError]] if the model is not found, cannot be loaded, or fails validation when `modelClass` is specified.
+         * @see tryGetModel
+         */
+        getModel(modelId, modelClass) {
+            const model = this.tryGetModel(modelId, modelClass);
+            if (undefined === model) {
+                throw new IModelError(IModelStatus.NotFound, `Model=${modelId}`);
+            }
+            return model;
+        }
+        /** Get the Model with the specified identifier.
+         * @param modelId The Model identifier.
+         * @param modelClass Optional class to validate instance against. This parameter can accept abstract or concrete classes, but should be the same as the template (`T`) parameter.
+         * @returns The Model or `undefined` if the model is not found or fails validation when `modelClass` is specified.
+         * @throws [[IModelError]] if the model cannot be loaded.
+         * @note Useful for cases when a model may or may not exist and throwing an `Error` would be overkill.
+         * @see getModel
+         */
+        tryGetModel(modelId, modelClass) {
+            const modelProps = this.tryGetModelProps(modelId);
+            if (undefined === modelProps)
+                return undefined; // no Model with that modelId found
+            const model = this._iModel.constructEntity(modelProps);
+            if (undefined === modelClass)
+                return model; // modelClass was not specified, cannot call instanceof to validate
+            return model instanceof modelClass ? model : undefined;
+        }
+        /** Read the properties for a Model as a json string.
+         * @param modelIdArg a json string with the identity of the model to load. Must have either "id" or "code".
+         * @returns a json string with the properties of the model.
+         * @throws [[IModelError]] if the model is not found or cannot be loaded.
+         * @see tryGetModelJson
+         * @internal
+         */
+        getModelJson(modelIdArg) {
+            const modelJson = this.tryGetModelJson(modelIdArg);
+            if (undefined === modelJson) {
+                throw new IModelError(IModelStatus.NotFound, `Model=(id: ${modelIdArg.id}, code: ${modelIdArg.code})`);
+            }
+            return modelJson;
+        }
+        /** Read the properties for a Model as a json string.
+         * @param modelIdArg a json string with the identity of the model to load. Must have either "id" or "code".
+         * @returns a json string with the properties of the model or `undefined` if the model is not found.
+         * @see getModelJson
+         */
+        tryGetModelJson(modelIdArg) {
+            try {
+                return this._iModel[_nativeDb].getModel(modelIdArg);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        /** Get the sub-model of the specified Element.
+         * See [[IModelDb.Elements.queryElementIdByCode]] for more on how to find an element by Code.
+         * @param modeledElementId Identifies the modeled element.
+         * @param modelClass Optional class to validate instance against. This parameter can accept abstract or concrete classes, but should be the same as the template (`T`) parameter.
+         * @throws [[IModelError]] if the sub-model is not found, cannot be loaded, or fails validation when `modelClass` is specified.
+         * @see tryGetSubModel
+         */
+        getSubModel(modeledElementId, modelClass) {
+            const modeledElementProps = this._iModel.elements.getElementProps(modeledElementId);
+            if (undefined === modeledElementProps.id || modeledElementProps.id === IModel.rootSubjectId)
+                throw new IModelError(IModelStatus.NotFound, "Root subject does not have a sub-model");
+            return this.getModel(modeledElementProps.id, modelClass);
+        }
+        /** Get the sub-model of the specified Element.
+         * See [[IModelDb.Elements.queryElementIdByCode]] for more on how to find an element by Code.
+         * @param modeledElementId Identifies the modeled element.
+         * @param modelClass Optional class to validate instance against. This parameter can accept abstract or concrete classes, but should be the same as the template (`T`) parameter.
+         * @returns The sub-model or `undefined` if the specified element does not have a sub-model or fails validation when `modelClass` is specified.
+         * @see getSubModel
+         */
+        tryGetSubModel(modeledElementId, modelClass) {
+            const modeledElementProps = this._iModel.elements.tryGetElementProps(modeledElementId);
+            if (undefined === modeledElementProps?.id || (IModel.rootSubjectId === modeledElementProps.id))
+                return undefined;
+            return this.tryGetModel(modeledElementProps.id, modelClass);
+        }
+        /** Create a new model in memory.
+         * See the example in [[InformationPartitionElement]].
+         * @param modelProps The properties to use when creating the model.
+         * @throws [[IModelError]] if there is a problem creating the model.
+         */
+        createModel(modelProps) { return this._iModel.constructEntity(modelProps); }
+        /** Insert a new model.
+         * @param props The data for the new model.
+         * @returns The newly inserted model's Id.
+         * @throws [[IModelError]] if unable to insert the model.
+         */
+        insertModel(props) {
+            try {
+                return props.id = this._iModel[_nativeDb].insertModel(props);
+            }
+            catch (err) {
+                throw new IModelError(err.errorNumber, `Error inserting model [${err.message}], class=${props.classFullName}`);
+            }
+        }
+        /** Update an existing model.
+         * @param props the properties of the model to change
+         * @throws [[IModelError]] if unable to update the model.
+         */
+        updateModel(props) {
+            try {
+                this._iModel[_nativeDb].updateModel(props);
+            }
+            catch (err) {
+                throw new IModelError(err.errorNumber, `error updating model [${err.message}] id=${props.id}`);
+            }
+        }
+        /** Mark the geometry of [[GeometricModel]] as having changed, by recording an indirect change to its GeometryGuid property.
+         * Typically the GeometryGuid changes automatically when [[GeometricElement]]s within the model are modified, but
+         * explicitly updating it is occasionally useful after modifying definition elements like line styles or materials that indirectly affect the appearance of
+         * [[GeometricElement]]s that reference those definition elements in their geometry streams.
+         * Cached [Tile]($frontend)s are only invalidated after the geometry guid of the model changes.
+         * @note This will throw IModelError with [IModelStatus.VersionTooOld]($core-bentley) if a version of the BisCore schema older than 1.0.11 is present in the iModel.
+         * @throws IModelError if unable to update the geometry guid.
+         * @see [[TxnManager.onModelGeometryChanged]] for the event emitted in response to such a change.
+         */
+        updateGeometryGuid(modelId) {
+            const error = this._iModel[_nativeDb].updateModelGeometryGuid(modelId);
+            if (error !== IModelStatus.Success)
+                throw new IModelError(error, `updating geometry guid for model ${modelId}`);
+        }
+        /** Delete one or more existing models.
+         * @param ids The Ids of the models to be deleted
+         * @throws [[IModelError]]
+         */
+        deleteModel(ids) {
+            Id64.toIdSet(ids).forEach((id) => {
+                try {
+                    this._iModel[_nativeDb].deleteModel(id);
+                }
+                catch (err) {
+                    throw new IModelError(err.errorNumber, `error deleting model [${err.message}] id ${id}`);
+                }
+            });
+        }
+        /** For each specified [[GeometricModel]], attempts to obtain the union of the volumes of all geometric elements within that model.
+         * @param ids The Id or Ids of the [[GeometricModel]]s for which to obtain the extents.
+         * @returns An array of results, one per supplied Id, in the order in which the Ids were supplied. If the extents could not be obtained, the
+         * corresponding results entry's `extents` will be a "null" range (@see [Range3d.isNull]($geometry)) and its `status` will indicate
+         * why the extents could not be obtained (e.g., because the Id did not identify a [[GeometricModel]]).
+         * @see [[queryRange]] to obtain the union of all of the models' extents.
+         */
+        async queryExtents(ids) {
+            ids = typeof ids === "string" ? [ids] : ids;
+            if (ids.length === 0)
+                return [];
+            return this._iModel[_nativeDb].queryModelExtentsAsync(ids);
+        }
+        /** Computes the union of the volumes of all geometric elements within one or more [[GeometricModel]]s, specified by model Id.
+         * @see [[queryExtents]] to obtain discrete volumes for each model.
+         */
+        async queryRange(ids) {
+            const results = await this.queryExtents(ids);
+            const range = new Range3d();
+            for (const result of results)
+                range.union(Range3d.fromJSON(result.extents), range);
+            return range;
+        }
+    }
+    IModelDb.Models = Models;
+    /** The collection of elements in an [[IModelDb]].
+     * @public
+     */
+    class Elements {
+        _iModel;
+        /** @internal */
+        constructor(_iModel) {
+            this._iModel = _iModel;
+        }
+        getFederationGuidFromId(id) {
+            return this._iModel.withPreparedSqliteStatement(`SELECT FederationGuid FROM bis_Element WHERE Id=?`, (stmt) => {
+                stmt.bindId(1, id);
+                return stmt.nextRow() ? stmt.getValueGuid(0) : undefined;
+            });
+        }
+        getIdFromFederationGuid(guid) {
+            return guid ? this._iModel.withPreparedSqliteStatement(`SELECT Id FROM bis_Element WHERE FederationGuid=?`, (stmt) => {
+                stmt.bindGuid(1, guid);
+                return !stmt.nextRow() ? undefined : stmt.getValueId(0);
+            }) : undefined;
+        }
+        /** Read element data from the iModel as JSON
+         * @param elementIdArg a json string with the identity of the element to load. Must have one of "id", "federationGuid", or "code".
+         * @returns The JSON properties of the element.
+         * @throws [[IModelError]] if the element is not found or cannot be loaded.
+         * @see tryGetElementJson
+         * @internal
+         */
+        getElementJson(elementId) {
+            const elementProps = this.tryGetElementJson(elementId);
+            if (undefined === elementProps)
+                throw new IModelError(IModelStatus.NotFound, `reading element={id: ${elementId.id} federationGuid: ${elementId.federationGuid}, code: ${elementId.code}}`);
+            return elementProps;
+        }
+        /** Read element data from the iModel as JSON
+         * @param loadProps - a json string with the identity of the element to load. Must have one of "id", "federationGuid", or "code".
+         * @returns The JSON properties of the element or `undefined` if the element is not found.
+         * @throws [[IModelError]] if the element exists, but cannot be loaded.
+         * @see getElementJson
+         */
+        tryGetElementJson(loadProps) {
+            try {
+                return this._iModel[_nativeDb].getElement(loadProps);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        /** Get properties of an Element by Id, FederationGuid, or Code
+         * @throws [[IModelError]] if the element is not found or cannot be loaded.
+         * @see tryGetElementProps
+         */
+        getElementProps(props) {
+            if (typeof props === "string") {
+                props = Id64.isId64(props) ? { id: props } : { federationGuid: props };
+            }
+            else if (props instanceof Code) {
+                props = { code: props };
+            }
+            try {
+                return this._iModel[_nativeDb].getElement(props);
+            }
+            catch (err) {
+                throw new IModelError(err.errorNumber, err.message);
+            }
+        }
+        /** Get properties of an Element by Id, FederationGuid, or Code
+         * @returns The properties of the element or `undefined` if the element is not found.
+         * @throws [[IModelError]] if the element exists, but cannot be loaded.
+         * @note Useful for cases when an element may or may not exist and throwing an `Error` would be overkill.
+         * @see getElementProps
+         */
+        tryGetElementProps(elementId) {
+            if (typeof elementId === "string") {
+                elementId = Id64.isId64(elementId) ? { id: elementId } : { federationGuid: elementId };
+            }
+            else if (elementId instanceof Code) {
+                elementId = { code: elementId };
+            }
+            return this.tryGetElementJson(elementId);
+        }
+        /** Get an element by Id, FederationGuid, or Code
+         * @param elementId either the element's Id, Code, or FederationGuid, or an ElementLoadProps
+         * @param elementClass Optional class to validate instance against. This parameter can accept abstract or concrete classes, but should be the same as the template (`T`) parameter.
+         * @throws [[IModelError]] if the element is not found, cannot be loaded, or fails validation when `elementClass` is specified.
+         * @see tryGetElement
+         */
+        getElement(elementId, elementClass) {
+            const element = this.tryGetElement(elementId, elementClass);
+            if (undefined === element) {
+                if (typeof elementId === "string" || elementId instanceof Code)
+                    throw new IModelError(IModelStatus.NotFound, `Element=${elementId}`);
+                else
+                    throw new IModelError(IModelStatus.NotFound, `Element={id: ${elementId.id} federationGuid: ${elementId.federationGuid}, code: ${elementId.code}}`);
+            }
+            return element;
+        }
+        /** Get an element by Id, FederationGuid, or Code
+         * @param elementId either the element's Id, Code, or FederationGuid, or an ElementLoadProps
+         * @param elementClass Optional class to validate instance against. This parameter can accept abstract or concrete classes, but should be the same as the template (`T`) parameter.
+         * @returns The element or `undefined` if the element is not found or fails validation when `elementClass` is specified.
+         * @throws [[IModelError]] if the element exists, but cannot be loaded.
+         * @note Useful for cases when an element may or may not exist and throwing an `Error` would be overkill.
+         * @see getElement
+         */
+        tryGetElement(elementId, elementClass) {
+            if (typeof elementId === "string")
+                elementId = Id64.isId64(elementId) ? { id: elementId } : { federationGuid: elementId };
+            else if (elementId instanceof Code)
+                elementId = { code: elementId };
+            else
+                elementId.onlyBaseProperties = false; // we must load all properties to construct the element.
+            const elementProps = this.tryGetElementJson(elementId);
+            if (undefined === elementProps)
+                return undefined; // no Element with that elementId found
+            const element = this._iModel.constructEntity(elementProps);
+            if (undefined === elementClass)
+                return element; // elementClass was not specified, cannot call instanceof to validate
+            return element instanceof elementClass ? element : undefined;
+        }
+        /** Query for the Id of the element that has a specified code.
+         * This method is for the case where you know the element's Code.
+         * If you only know the code *value*, then in the simplest case, you can query on that
+         * and filter the results.
+         * In the simple case, call [[IModelDb.queryEntityIds]], specifying the code value in the where clause of the query params.
+         * Or, you can execute an ECSQL select statement. See
+         * [frequently used ECSQL queries]($docs/learning/backend/ECSQL-queries.md) for an example.
+         * @param code The code to look for
+         * @returns The element that uses the code or undefined if the code is not used.
+         * @throws IModelError if the code is invalid
+         */
+        queryElementIdByCode(code) {
+            if (Id64.isInvalid(code.spec))
+                throw new IModelError(IModelStatus.InvalidCodeSpec, "Invalid CodeSpec");
+            if (code.value === undefined)
+                throw new IModelError(IModelStatus.InvalidCode, "Invalid Code");
+            return this._iModel.withPreparedStatement("SELECT ECInstanceId FROM BisCore:Element WHERE CodeSpec.Id=? AND CodeScope.Id=? AND CodeValue=?", (stmt) => {
+                stmt.bindId(1, code.spec);
+                stmt.bindId(2, Id64.fromString(code.scope));
+                stmt.bindString(3, code.value);
+                if (DbResult.BE_SQLITE_ROW !== stmt.step())
+                    return undefined;
+                return stmt.getValue(0).getId();
+            });
+        }
+        /** Query for an [[Element]]'s last modified time.
+         * @param elementId The Id of the element.
+         * @throws IModelError if `elementId` does not identify an element in the iModel.
+         */
+        queryLastModifiedTime(elementId) {
+            const sql = "SELECT LastMod FROM BisCore:Element WHERE ECInstanceId=:elementId";
+            return this._iModel.withPreparedStatement(sql, (statement) => {
+                statement.bindId("elementId", elementId);
+                if (DbResult.BE_SQLITE_ROW === statement.step())
+                    return statement.getValue(0).getDateTime();
+                throw new IModelError(IModelStatus.InvalidId, `Can't get lastMod time for Element ${elementId}`);
+            });
+        }
+        /** Create a new instance of an element.
+         * @param elProps The properties of the new element.
+         * @throws [[IModelError]] if there is a problem creating the element.
+         */
+        createElement(elProps) { return this._iModel.constructEntity(elProps); }
+        /** Insert a new element into the iModel.
+         * @param elProps The properties of the new element.
+         * @returns The newly inserted element's Id.
+         * @throws [[IModelError]] if unable to insert the element.
+         * @note For convenience, the value of `elProps.id` is updated to reflect the resultant element's id.
+         * However when `elProps.federationGuid` is not present or undefined, a new Guid will be generated and stored on the resultant element. But
+         * the value of `elProps.federationGuid` is *not* updated. Generally, it is best to re-read the element after inserting (e.g. via [[getElementProps]])
+         * if you intend to continue working with it. That will ensure its values reflect the persistent state.
+         */
+        insertElement(elProps, options) {
+            try {
+                return elProps.id = this._iModel[_nativeDb].insertElement(elProps, options);
+            }
+            catch (err) {
+                err.message = `Error inserting element [${err.message}]`;
+                err.metadata = { elProps };
+                throw err;
+            }
+        }
+        /**
+         * Update some properties of an existing element.
+         * All parts of `elProps` are optional *other than* `id`. If id is missing, an exception is thrown.
+         *
+         * To support clearing a property value, every property name that is present in the `elProps` object will be updated even if the value is `undefined`.
+         * To keep an individual element property unchanged, it should either be excluded from the `elProps` parameter or set to its current value.
+         * @param elProps the properties of the element to update.
+         * @note The values of `classFullName` and `model` *may not be changed* by this method. Further, it will permute the `elProps` object by adding or
+         * overwriting their values to the correct values.
+         * @throws [[IModelError]] if unable to update the element.
+         */
+        updateElement(elProps) {
+            try {
+                this._iModel[_nativeDb].updateElement(elProps);
+            }
+            catch (err) {
+                err.message = `Error updating element [${err.message}], id: ${elProps.id}`;
+                err.metadata = { elProps };
+                throw err;
+            }
+        }
+        /** Delete one or more elements from this iModel.
+         * @param ids The set of Ids of the element(s) to be deleted
+         * @throws [[IModelError]]
+         * @see deleteDefinitionElements
+         */
+        deleteElement(ids) {
+            const iModel = this._iModel;
+            Id64.toIdSet(ids).forEach((id) => {
+                try {
+                    iModel[_nativeDb].deleteElement(id);
+                }
+                catch (err) {
+                    err.message = `Error deleting element [${err.message}], id: ${id}`;
+                    err.metadata = { elementId: id };
+                    throw err;
+                }
+            });
+        }
+        /** DefinitionElements can only be deleted if it can be determined that they are not referenced by other Elements.
+         * This *usage query* can be expensive since it may involve scanning the GeometryStreams of all GeometricElements.
+         * Since [[deleteElement]] does not perform these additional checks, it fails in order to prevent potentially referenced DefinitionElements from being deleted.
+         * This method performs those expensive checks and then calls *delete* if not referenced.
+         * @param ids The Ids of the DefinitionElements to attempt to delete. To prevent multiple passes over the same GeometricElements, it is best to pass in the entire array of
+         * DefinitionElements rather than calling this method separately for each one. Ids that are not valid DefinitionElements will be ignored.
+         * @returns An IdSet of the DefinitionElements that are used and were therefore not deleted.
+         * @see deleteElement
+         * @beta
+         */
+        deleteDefinitionElements(definitionElementIds) {
+            const usageInfo = this._iModel[_nativeDb].queryDefinitionElementUsage(definitionElementIds);
+            if (!usageInfo) {
+                throw new IModelError(IModelStatus.BadRequest, "Error querying for DefinitionElement usage");
+            }
+            const usedIdSet = usageInfo.usedIds ? Id64.toIdSet(usageInfo.usedIds) : new Set();
+            const deleteIfUnused = (ids, used) => {
+                if (ids) {
+                    ids.forEach((id) => {
+                        if (!used.has(id))
+                            this._iModel.elements.deleteElement(id);
+                    });
+                }
+            };
+            try {
+                this._iModel[_nativeDb].beginPurgeOperation();
+                deleteIfUnused(usageInfo.spatialCategoryIds, usedIdSet);
+                deleteIfUnused(usageInfo.drawingCategoryIds, usedIdSet);
+                deleteIfUnused(usageInfo.viewDefinitionIds, usedIdSet);
+                deleteIfUnused(usageInfo.geometryPartIds, usedIdSet);
+                deleteIfUnused(usageInfo.lineStyleIds, usedIdSet);
+                deleteIfUnused(usageInfo.renderMaterialIds, usedIdSet);
+                deleteIfUnused(usageInfo.subCategoryIds, usedIdSet);
+                deleteIfUnused(usageInfo.textureIds, usedIdSet);
+                deleteIfUnused(usageInfo.displayStyleIds, usedIdSet);
+                deleteIfUnused(usageInfo.categorySelectorIds, usedIdSet);
+                deleteIfUnused(usageInfo.modelSelectorIds, usedIdSet);
+                if (usageInfo.otherDefinitionElementIds) {
+                    this._iModel.elements.deleteElement(usageInfo.otherDefinitionElementIds);
+                }
+            }
+            finally {
+                this._iModel[_nativeDb].endPurgeOperation();
+            }
+            if (usageInfo.viewDefinitionIds) {
+                // take another pass in case a deleted ViewDefinition was the only usage of these view-related DefinitionElements
+                let viewRelatedIds = [];
+                if (usageInfo.displayStyleIds)
+                    viewRelatedIds = viewRelatedIds.concat(usageInfo.displayStyleIds.filter((id) => usedIdSet.has(id)));
+                if (usageInfo.categorySelectorIds)
+                    viewRelatedIds = viewRelatedIds.concat(usageInfo.categorySelectorIds.filter((id) => usedIdSet.has(id)));
+                if (usageInfo.modelSelectorIds)
+                    viewRelatedIds = viewRelatedIds.concat(usageInfo.modelSelectorIds.filter((id) => usedIdSet.has(id)));
+                if (viewRelatedIds.length > 0) {
+                    const viewRelatedUsageInfo = this._iModel[_nativeDb].queryDefinitionElementUsage(viewRelatedIds);
+                    if (viewRelatedUsageInfo) {
+                        const usedViewRelatedIdSet = viewRelatedUsageInfo.usedIds ? Id64.toIdSet(viewRelatedUsageInfo.usedIds) : new Set();
+                        try {
+                            this._iModel[_nativeDb].beginPurgeOperation();
+                            deleteIfUnused(viewRelatedUsageInfo.displayStyleIds, usedViewRelatedIdSet);
+                            deleteIfUnused(viewRelatedUsageInfo.categorySelectorIds, usedViewRelatedIdSet);
+                            deleteIfUnused(viewRelatedUsageInfo.modelSelectorIds, usedViewRelatedIdSet);
+                        }
+                        finally {
+                            this._iModel[_nativeDb].endPurgeOperation();
+                        }
+                        viewRelatedIds.forEach((id) => {
+                            if (!usedViewRelatedIdSet.has(id))
+                                usedIdSet.delete(id);
+                        });
+                    }
+                }
+            }
+            return usedIdSet;
+        }
+        /** Query for the child elements of the specified element.
+         * @returns Returns an array of child element identifiers.
+         * @throws [[IModelError]]
+         */
+        queryChildren(elementId) {
+            const sql = "SELECT ECInstanceId FROM BisCore:Element WHERE Parent.Id=:elementId";
+            return this._iModel.withPreparedStatement(sql, (statement) => {
+                statement.bindId("elementId", elementId);
+                const childIds = [];
+                while (DbResult.BE_SQLITE_ROW === statement.step()) {
+                    childIds.push(statement.getValue(0).getId());
+                }
+                return childIds;
+            });
+        }
+        /** Query for the parent of the specified element.
+         * @param elementId The element to check for a parent
+         * @returns The identifier of the element's parent or undefined if the element has no parent
+         * @throws [[IModelError]] if the element does not exist
+         */
+        queryParent(elementId) {
+            return this._iModel.withPreparedStatement(`select parent.id from ${Element.classFullName} where ecinstanceid=?`, (stmt) => {
+                stmt.bindId(1, elementId);
+                if (stmt.step() !== DbResult.BE_SQLITE_ROW)
+                    throw new IModelError(IModelStatus.NotFound, `Element=${elementId}`);
+                const value = stmt.getValue(0);
+                return value.isNull ? undefined : value.getId();
+            });
+        }
+        /** Returns true if the specified Element has a sub-model.
+         * @see [[IModelDb.Models.getSubModel]]
+         */
+        hasSubModel(elementId) {
+            if (IModel.rootSubjectId === elementId)
+                return false; // Special case since the RepositoryModel does not sub-model the root Subject
+            // A sub-model will have the same Id value as the element it is describing
+            const sql = "SELECT ECInstanceId FROM BisCore:Model WHERE ECInstanceId=:elementId";
+            return this._iModel.withPreparedStatement(sql, (statement) => {
+                statement.bindId("elementId", elementId);
+                return DbResult.BE_SQLITE_ROW === statement.step();
+            });
+        }
+        /** Get the root subject element. */
+        getRootSubject() { return this.getElement(IModel.rootSubjectId); }
+        /** Query for aspects of a particular class (polymorphically) associated with this element.
+         * @throws [[IModelError]]
+         * @note Most cases should use the [[getAspects]] wrapper rather than calling this method directly.
+         * @internal
+         */
+        _queryAspects(elementId, fromClassFullName, excludedClassFullNames) {
+            const sql = `SELECT ECInstanceId,ECClassId FROM ${fromClassFullName} WHERE Element.Id=:elementId ORDER BY ECClassId,ECInstanceId`; // ORDER BY to maximize statement reuse
+            return this._iModel.withPreparedStatement(sql, (statement) => {
+                statement.bindId("elementId", elementId);
+                const aspects = [];
+                while (DbResult.BE_SQLITE_ROW === statement.step()) {
+                    const aspectInstanceId = statement.getValue(0).getId();
+                    const aspectClassFullName = statement.getValue(1).getClassNameForClassId().replace(".", ":");
+                    if ((undefined === excludedClassFullNames) || (!excludedClassFullNames.has(aspectClassFullName))) {
+                        aspects.push(this._queryAspect(aspectInstanceId, aspectClassFullName));
+                    }
+                }
+                return aspects;
+            });
+        }
+        /** Query for aspect by ECInstanceId
+         * @throws [[IModelError]]
+         */
+        _queryAspect(aspectInstanceId, aspectClassName) {
+            const sql = `SELECT * FROM ${aspectClassName} WHERE ECInstanceId=:aspectInstanceId`;
+            const aspect = this._iModel.withPreparedStatement(sql, (statement) => {
+                statement.bindId("aspectInstanceId", aspectInstanceId);
+                if (DbResult.BE_SQLITE_ROW === statement.step()) {
+                    const aspectProps = statement.getRow(); // start with everything that SELECT * returned
+                    aspectProps.classFullName = aspectProps.className.replace(".", ":"); // add in property required by EntityProps
+                    aspectProps.className = undefined; // clear property from SELECT * that we don't want in the final instance
+                    return aspectProps;
+                }
+                return undefined;
+            });
+            if (undefined === aspect) {
+                throw new IModelError(IModelStatus.NotFound, `ElementAspect not found ${aspectInstanceId}, ${aspectClassName}`);
+            }
+            return this._iModel.constructEntity(aspect);
+        }
+        /** Get a single ElementAspect by its instance Id.
+         * @throws [[IModelError]]
+         */
+        getAspect(aspectInstanceId) {
+            const sql = "SELECT ECClassId FROM BisCore:ElementAspect WHERE ECInstanceId=:aspectInstanceId";
+            const aspectClassFullName = this._iModel.withPreparedStatement(sql, (statement) => {
+                statement.bindId("aspectInstanceId", aspectInstanceId);
+                return (DbResult.BE_SQLITE_ROW === statement.step()) ? statement.getValue(0).getClassNameForClassId().replace(".", ":") : undefined;
+            });
+            if (undefined === aspectClassFullName) {
+                throw new IModelError(IModelStatus.NotFound, `ElementAspect not found ${aspectInstanceId}`);
+            }
+            return this._queryAspect(aspectInstanceId, aspectClassFullName);
+        }
+        static classMap = new Map();
+        runInstanceQuery(sql, elementId, excludedClassFullNames) {
+            return this._iModel.withPreparedStatement(sql, (statement) => {
+                statement.bindId("elementId", elementId);
+                const aspects = [];
+                while (DbResult.BE_SQLITE_ROW === statement.step()) {
+                    const row = {};
+                    const parsedRow = JSON.parse(statement.getValue(0).getString());
+                    // eslint-disable-next-line guard-for-in
+                    for (const key in parsedRow) {
+                        const jsName = ECJsNames.toJsName(key[0].toUpperCase() + key.substring(1));
+                        Object.defineProperty(row, jsName, { enumerable: true, configurable: true, writable: true, value: parsedRow[key] });
+                    }
+                    const aspectProps = row;
+                    aspectProps.classFullName = aspectProps.className.replace(".", ":"); // add in property required by EntityProps
+                    aspectProps.className = undefined; // clear property from SELECT $ that we don't want in the final instance
+                    if ((undefined === excludedClassFullNames) || !excludedClassFullNames.has(aspectProps.classFullName))
+                        aspects.push(this._iModel.constructEntity(aspectProps));
+                }
+                return aspects;
+            });
+        }
+        /** Get the ElementAspect instances that are owned by the specified element.
+         * @param elementId Get ElementAspects associated with this Element
+         * @param aspectClassFullName Optionally filter ElementAspects polymorphically by this class name
+         * @param excludedClassFullNames Optional filter to exclude aspects from classes in the given set.
+         * @throws [[IModelError]]
+         */
+        getAspects(elementId, aspectClassFullName, excludedClassFullNames) {
+            if (aspectClassFullName === undefined) {
+                const allAspects = this.runInstanceQuery(`SELECT $ FROM (
+          SELECT ECInstanceId, ECClassId FROM Bis.ElementMultiAspect WHERE Element.Id = :elementId
+            UNION ALL
+          SELECT ECInstanceId, ECClassId FROM Bis.ElementUniqueAspect WHERE Element.Id = :elementId) OPTIONS USE_JS_PROP_NAMES DO_NOT_TRUNCATE_BLOB`, elementId, excludedClassFullNames);
+                if (allAspects.length === 0)
+                    Logger.logInfo(BackendLoggerCategory.ECDb, `No aspects found for class ${aspectClassFullName} and element ${elementId}`);
+                return allAspects;
+            }
+            // Check if class is abstract
+            const fullClassName = aspectClassFullName.replace(".", ":").split(":");
+            const val = this._iModel[_nativeDb].getECClassMetaData(fullClassName[0], fullClassName[1]);
+            if (val.result !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
+                const metaData = new EntityMetaData(JSON.parse(val.result));
+                if (metaData.modifier !== "Abstract") // Class is not abstract, use normal query to retrieve aspects
+                    return this._queryAspects(elementId, aspectClassFullName, excludedClassFullNames);
+            }
+            // If class specified is abstract, get the list of all classes derived from it
+            let classIdList = IModelDb.Elements.classMap.get(aspectClassFullName);
+            if (classIdList === undefined) {
+                const classIds = [];
+                this._iModel.withPreparedStatement(`select SourceECInstanceId from meta.ClassHasAllBaseClasses where TargetECInstanceId = (select ECInstanceId from meta.ECClassDef where Name='${fullClassName[1]}'
+        and Schema.Id = (select ECInstanceId from meta.ECSchemaDef where Name='${fullClassName[0]}')) and SourceECInstanceId != TargetECInstanceId`, (statement) => {
+                    while (statement.step() === DbResult.BE_SQLITE_ROW)
+                        classIds.push(statement.getValue(0).getId());
+                });
+                if (classIds.length > 0) {
+                    classIdList = classIds.join(",");
+                    IModelDb.Elements.classMap.set(aspectClassFullName, classIdList);
+                }
+            }
+            if (classIdList === undefined) {
+                Logger.logError(BackendLoggerCategory.ECDb, `No aspects found for the class ${aspectClassFullName}`);
+                return [];
+            }
+            // Execute an instance query to retrieve all aspects from all the derived classes
+            const aspects = this.runInstanceQuery(`SELECT $ FROM (
+        SELECT ECInstanceId, ECClassId FROM Bis.ElementMultiAspect WHERE Element.Id = :elementId AND ECClassId IN (${classIdList})
+          UNION ALL
+        SELECT ECInstanceId, ECClassId FROM Bis.ElementUniqueAspect WHERE Element.Id = :elementId AND ECClassId IN (${classIdList})
+        ) OPTIONS USE_JS_PROP_NAMES DO_NOT_TRUNCATE_BLOB`, elementId, excludedClassFullNames);
+            if (aspects.length === 0)
+                Logger.logInfo(BackendLoggerCategory.ECDb, `No aspects found for class ${aspectClassFullName} and element ${elementId}`);
+            return aspects;
+        }
+        /** Insert a new ElementAspect into the iModel.
+         * @param aspectProps The properties of the new ElementAspect.
+         * @throws [[IModelError]] if unable to insert the ElementAspect.
+         * @returns the id of the newly inserted aspect.
+         * @note Aspect Ids may collide with element Ids, so don't put both in a container like Set or Map
+         *       use [EntityReference]($common) for that instead.
+         */
+        insertAspect(aspectProps) {
+            try {
+                return this._iModel[_nativeDb].insertElementAspect(aspectProps);
+            }
+            catch (err) {
+                throw new IModelError(err.errorNumber, `Error inserting ElementAspect [${err.message}], class: ${aspectProps.classFullName}`);
+            }
+        }
+        /** Update an exist ElementAspect within the iModel.
+         * @param aspectProps The properties to use to update the ElementAspect.
+         * @throws [[IModelError]] if unable to update the ElementAspect.
+         */
+        updateAspect(aspectProps) {
+            try {
+                this._iModel[_nativeDb].updateElementAspect(aspectProps);
+            }
+            catch (err) {
+                throw new IModelError(err.errorNumber, `Error updating ElementAspect [${err.message}], id: ${aspectProps.id}`);
+            }
+        }
+        /** Delete one or more ElementAspects from this iModel.
+         * @param aspectInstanceIds The set of instance Ids of the ElementAspect(s) to be deleted
+         * @throws [[IModelError]] if unable to delete the ElementAspect.
+         */
+        deleteAspect(aspectInstanceIds) {
+            const iModel = this._iModel;
+            Id64.toIdSet(aspectInstanceIds).forEach((aspectInstanceId) => {
+                try {
+                    iModel[_nativeDb].deleteElementAspect(aspectInstanceId);
+                }
+                catch (err) {
+                    throw new IModelError(err.errorNumber, `Error deleting ElementAspect [${err.message}], id: ${aspectInstanceId}`);
+                }
+            });
+        }
+    }
+    IModelDb.Elements = Elements;
+    /** The collection of views in an [[IModelDb]].
+     * @public
+     */
+    class Views {
+        _iModel;
+        /** @internal */
+        constructor(_iModel) {
+            this._iModel = _iModel;
+        }
+        static viewStoreProperty = { namespace: "itwinjs", name: "DefaultViewStore" };
+        _viewStore;
+        get hasViewStore() { return undefined !== this._viewStore; }
+        /** @beta */
+        get viewStore() {
+            if (undefined === this._viewStore)
+                throw new IModelError(IModelStatus.BadRequest, "No ViewStore available");
+            return this._viewStore;
+        }
+        set viewStore(viewStore) {
+            this._viewStore = viewStore;
+        }
+        /** @beta */
+        async accessViewStore(args) {
+            let props = args.props;
+            if (undefined === props) {
+                const propsString = this._iModel.queryFilePropertyString(Views.viewStoreProperty);
+                if (!propsString)
+                    throw new Error("iModel does not have a default ViewStore");
+                props = JSON.parse(propsString);
+            }
+            const accessToken = await CloudSqlite.requestToken({
+                ...props,
+                accessLevel: args.accessLevel,
+            });
+            if (!this._viewStore)
+                this._viewStore = new ViewStore.CloudAccess({ ...props, accessToken, iModel: this._iModel });
+            this._viewStore.container.accessToken = accessToken;
+            return this._viewStore;
+        }
+        /** @beta */
+        saveDefaultViewStore(arg) {
+            const props = { baseUri: arg.baseUri, containerId: arg.containerId, storageType: arg.storageType }; // sanitize to only known properties
+            this._iModel.saveFileProperty(Views.viewStoreProperty, JSON.stringify(props));
+            this._iModel.saveChanges("update default ViewStore");
+        }
+        /** Query for the array of ViewDefinitionProps of the specified class and matching the specified IsPrivate setting.
+         * @param className Query for view definitions of this class.
+         * @param wantPrivate If true, include private view definitions.
+         */
+        queryViewDefinitionProps(className = "BisCore.ViewDefinition", limit = IModelDb.defaultLimit, offset = 0, wantPrivate = false) {
+            const where = (wantPrivate === false) ? "IsPrivate=FALSE" : "";
+            const ids = this._iModel.queryEntityIds({ from: className, limit, offset, where });
+            const props = [];
+            const imodel = this._iModel;
+            ids.forEach((id) => {
+                try {
+                    props.push(imodel.elements.getElementProps(id));
+                }
+                catch { }
+            });
+            return props;
+        }
+        /** Default parameters for iterating/querying ViewDefinitions. Includes all subclasses of ViewDefinition, excluding only those marked 'private'. */
+        static defaultQueryParams = { from: "BisCore.ViewDefinition", where: "IsPrivate=FALSE" };
+        /** Iterate all ViewDefinitions matching the supplied query.
+         * @param params Specifies the query by which views are selected.
+         * @param callback Function invoked for each ViewDefinition matching the query. Return false to terminate iteration, true to continue.
+         * @returns true if all views were iterated, false if iteration was terminated early due to callback returning false.
+         */
+        iterateViews(params, callback) {
+            const ids = this._iModel.queryEntityIds(params);
+            let finished = true;
+            for (const id of ids) {
+                try {
+                    const view = this._iModel.elements.getElement(id);
+                    if (undefined !== view && view instanceof ViewDefinition) {
+                        finished = callback(view);
+                        if (!finished)
+                            break;
+                    }
+                }
+                catch { }
+            }
+            return finished;
+        }
+        loadViewData(viewId, options) {
+            const iModel = this._iModel;
+            const elements = iModel.elements;
+            const loader = (() => {
+                if (ViewStoreRpc.isViewStoreId(viewId)) {
+                    const reader = this.viewStore.reader;
+                    return {
+                        loadView: () => reader.getViewDefinitionSync({ viewId }),
+                        loadCategorySelector: (id) => reader.getCategorySelectorSync({ id, bindings: options?.queryBindings?.categorySelector }),
+                        loadDisplayStyle: (id) => reader.getDisplayStyleSync({ id, opts: options?.displayStyle }),
+                        loadModelSelector: (id) => reader.getModelSelectorSync({ id, bindings: options?.queryBindings?.modelSelector }),
+                    };
+                }
+                return {
+                    loadView: () => elements.getElementProps(viewId),
+                    loadCategorySelector: (id) => elements.getElementProps(id),
+                    loadDisplayStyle: (id) => elements.getElementProps({ id, displayStyle: options?.displayStyle }),
+                    loadModelSelector: (id) => elements.getElementProps(id),
+                };
+            })();
+            const props = {};
+            props.viewDefinitionProps = loader.loadView();
+            props.categorySelectorProps = loader.loadCategorySelector(props.viewDefinitionProps.categorySelectorId);
+            props.displayStyleProps = loader.loadDisplayStyle(props.viewDefinitionProps.displayStyleId);
+            const modelSelectorId = props.viewDefinitionProps.modelSelectorId;
+            if (modelSelectorId !== undefined)
+                props.modelSelectorProps = loader.loadModelSelector(modelSelectorId);
+            const viewClass = iModel.getJsClass(props.viewDefinitionProps.classFullName);
+            const baseModelId = props.viewDefinitionProps.baseModelId;
+            if (viewClass.is(SheetViewDefinition)) {
+                props.sheetProps = elements.getElementProps(baseModelId);
+                props.sheetAttachments = Array.from(iModel.queryEntityIds({
+                    from: "BisCore.ViewAttachment",
+                    where: `Model.Id=${baseModelId}`,
+                }));
+            }
+            else if (viewClass.is(DrawingViewDefinition)) {
+                // Include information about the associated [[SectionDrawing]], if any.
+                // NB: The SectionDrawing ECClass may not exist in the iModel's version of the BisCore ECSchema.
+                const sectionDrawing = iModel.elements.tryGetElement(baseModelId);
+                if (sectionDrawing && sectionDrawing.spatialView && Id64.isValidId64(sectionDrawing.spatialView.id)) {
+                    props.sectionDrawing = {
+                        spatialView: sectionDrawing.spatialView.id,
+                        displaySpatialView: true === sectionDrawing.jsonProperties.displaySpatialView,
+                        drawingToSpatialTransform: sectionDrawing.jsonProperties.drawingToSpatialTransform,
+                    };
+                }
+            }
+            return props;
+        }
+        /** Obtain a [ViewStateProps]($common) for a [[ViewDefinition]] specified by ViewIdString. */
+        async getViewStateProps(viewDefinitionId, options) {
+            const viewStateData = this.loadViewData(viewDefinitionId, options);
+            const baseModelId = viewStateData.viewDefinitionProps.baseModelId;
+            if (baseModelId) {
+                const drawingExtents = await this._iModel.models.queryRange(baseModelId);
+                if (!drawingExtents.isNull)
+                    viewStateData.modelExtents = drawingExtents.toJSON();
+            }
+            return viewStateData;
+        }
+        getViewThumbnailArg(viewDefinitionId) {
+            if (!Id64.isValid(viewDefinitionId))
+                throw new Error("illegal thumbnail id");
+            return { namespace: "dgn_View", name: "Thumbnail", id: viewDefinitionId };
+        }
+        /** Get the thumbnail for a view.
+         * @param viewDefinitionId The Id of the view for thumbnail
+         * @returns the ThumbnailProps, or undefined if no thumbnail exists.
+         */
+        getThumbnail(viewDefinitionId) {
+            const viewArg = this.getViewThumbnailArg(viewDefinitionId);
+            const sizeProps = this._iModel[_nativeDb].queryFileProperty(viewArg, true);
+            if (undefined === sizeProps)
+                return undefined;
+            const out = JSON.parse(sizeProps);
+            out.image = this._iModel[_nativeDb].queryFileProperty(viewArg, false);
+            return out;
+        }
+        /** Save a thumbnail for a view.
+         * @param viewDefinitionId The Id of the view for thumbnail
+         * @param thumbnail The thumbnail data.
+         * @returns 0 if successful
+         */
+        saveThumbnail(viewDefinitionId, thumbnail) {
+            const viewArg = this.getViewThumbnailArg(viewDefinitionId);
+            const props = { format: thumbnail.format, height: thumbnail.height, width: thumbnail.width };
+            this._iModel[_nativeDb].saveFileProperty(viewArg, JSON.stringify(props), thumbnail.image);
+            return 0;
+        }
+        /** Set the default view property the iModel.
+         * @param viewId The Id of the ViewDefinition to use as the default
+         * @deprecated in 4.2.x. Avoid setting this property - it is not practical for one single view to serve the needs of the many applications
+         * that might wish to view the contents of the iModel.
+         */
+        setDefaultViewId(viewId) {
+            const spec = { namespace: "dgn_View", name: "DefaultView" };
+            const blob32 = new Uint32Array(2);
+            blob32[0] = Id64.getLowerUint32(viewId);
+            blob32[1] = Id64.getUpperUint32(viewId);
+            const blob8 = new Uint8Array(blob32.buffer);
+            this._iModel.saveFileProperty(spec, undefined, blob8);
+        }
+    }
+    IModelDb.Views = Views;
+    /** Represents the current state of a pollable tile content request.
+   * Note: lack of a "completed" state because polling a completed request returns the content as a Uint8Array.
+   * @internal
+   */
+    let TileContentState;
+    (function (TileContentState) {
+        TileContentState[TileContentState["New"] = 0] = "New";
+        TileContentState[TileContentState["Pending"] = 1] = "Pending";
+        TileContentState[TileContentState["Loading"] = 2] = "Loading";
+    })(TileContentState = IModelDb.TileContentState || (IModelDb.TileContentState = {}));
+    /** @internal */
+    class Tiles {
+        _iModel;
+        /** @internal */
+        constructor(_iModel) {
+            this._iModel = _iModel;
+        }
+        /** @internal */
+        async requestTileTreeProps(id) {
+            return new Promise((resolve, reject) => {
+                this._iModel[_nativeDb].getTileTree(id, (ret) => {
+                    if (undefined !== ret.error)
+                        reject(new IModelError(ret.error.status, `TreeId=${id}`));
+                    else
+                        resolve(ret.result);
+                });
+            });
+        }
+        pollTileContent(resolve, reject, treeId, tileId) {
+            let ret;
+            try {
+                ret = this._iModel[_nativeDb].pollTileContent(treeId, tileId);
+            }
+            catch (err) {
+                // Typically "imodel not open".
+                reject(err);
+                return;
+            }
+            if (ret.error) {
+                reject(new IModelError(ret.error.status, `TreeId=${treeId} TileId=${tileId}`));
+            }
+            else if (ret.result && typeof ret.result !== "number") { // if type is not a number, it's the TileContent interface
+                const res = ret.result;
+                const iModelId = this._iModel.iModelId;
+                const tileSizeThreshold = IModelHost.logTileSizeThreshold;
+                const tileSize = res.content.length;
+                if (tileSize > tileSizeThreshold) {
+                    Logger.logWarning(loggerCategory, "Tile size (in bytes) larger than specified threshold", () => ({ tileSize, tileSizeThreshold, treeId, tileId, iModelId }));
+                }
+                const loadTimeThreshold = IModelHost.logTileLoadTimeThreshold;
+                const loadTime = res.elapsedSeconds;
+                if (loadTime > loadTimeThreshold) {
+                    Logger.logWarning(loggerCategory, "Tile load time (in seconds) greater than specified threshold", () => ({ loadTime, loadTimeThreshold, treeId, tileId, iModelId }));
+                }
+                resolve(res);
+            }
+            else { // if the type is a number, it's the TileContentState enum
+                // ###TODO: Decide appropriate timeout interval. May want to switch on state (new vs loading vs pending)
+                setTimeout(() => this.pollTileContent(resolve, reject, treeId, tileId), 10);
+            }
+        }
+        /** @internal */
+        async requestTileContent(treeId, tileId) {
+            return new Promise((resolve, reject) => {
+                this.pollTileContent(resolve, reject, treeId, tileId);
+            });
+        }
+        /** @internal */
+        async getTileContent(treeId, tileId) {
+            const ret = await new Promise((resolve) => {
+                this._iModel[_nativeDb].getTileContent(treeId, tileId, resolve);
+            });
+            if (undefined !== ret.error) {
+                throw new IModelError(ret.error.status, `TreeId=${treeId} TileId=${tileId}`);
+            }
+            assert(undefined !== ret.result);
+            return ret.result;
+        }
+    }
+    IModelDb.Tiles = Tiles;
+})(IModelDb || (IModelDb = {}));
+/**
+ * A local copy of an iModel from iModelHub that can pull and potentially push changesets.
+ * BriefcaseDb raises a set of events to allow apps and subsystems to track its object life cycle, including [[onOpen]] and [[onOpened]].
+ * @public
+ */
+export class BriefcaseDb extends IModelDb {
+    /** Manages local changes to this briefcase. */
+    txns = new TxnManager(this);
+    /** override superclass method */
+    get isBriefcase() { return true; }
+    /* the BriefcaseId of the briefcase opened with this BriefcaseDb */
+    briefcaseId;
+    _skipSyncSchemasOnPullAndPush;
+    /** @internal */
+    get skipSyncSchemasOnPullAndPush() { return this._skipSyncSchemasOnPullAndPush ?? false; }
+    /**
+     * Event raised just before a BriefcaseDb is opened. Supplies the arguments that will be used to open the BriefcaseDb.
+     * Throw an exception to stop the open.
+     *
+     * **Example:**
+     * ``` ts
+     * [[include:BriefcaseDb.onOpen]]
+     * ```
+     */
+    static onOpen = new BeEvent();
+    /**
+     * Event raised just after a BriefcaseDb is opened. Supplies the newly opened BriefcaseDb and the arguments that were used to open it.
+     *
+     * **Example:**
+     * ``` ts
+     * [[include:BriefcaseDb.onOpened]]
+     * ```
+     */
+    static onOpened = new BeEvent();
+    /** Event raised after a BriefcaseDb has been closed. */
+    onClosed = new BeEvent();
+    /** @alpha */
+    static onCodeServiceCreated = new BeEvent();
+    static findByKey(key) {
+        return super.findByKey(key);
+    }
+    static tryFindByKey(key) {
+        const db = super.tryFindByKey(key);
+        return db?.isBriefcaseDb() ? db : undefined;
+    }
+    /**
+     * The Guid that identifies the *context* that owns this iModel.
+     * GuidString | undefined for the superclass, but required for BriefcaseDb
+     * */
+    get iTwinId() { return super.iTwinId; } // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    /**
+     * Determine whether this BriefcaseDb should use a lock server.
+     * All must be true:
+     * - file is open for write
+     * - has an assigned briefcaseId
+     * - the "no locking" flag is not present. This is a property of an iModel, established when the iModel is created in IModelHub.
+     */
+    get useLockServer() {
+        return !this[_nativeDb].isReadonly() && (this.briefcaseId !== BriefcaseIdValue.Unassigned) && (undefined === this[_nativeDb].queryLocalValue(BriefcaseLocalValue.NoLocking));
+    }
+    // if the iModel uses a lock server, create a ServerBasedLocks LockControl for this BriefcaseDb.
+    makeLockControl() {
+        if (this.useLockServer)
+            this._locks = createServerBasedLocks(this);
+    }
+    constructor(args) {
+        super({ ...args, changeset: args.nativeDb.getCurrentChangeset() });
+        this._openMode = args.openMode;
+        this.briefcaseId = args.briefcaseId;
+        this.makeLockControl();
+    }
+    /** Upgrades the profile or domain schemas. File must be closed before this call and is always left closed. */
+    static async doUpgrade(briefcase, upgradeOptions, description) {
+        let wasChanges = false;
+        const executeUpgrade = () => {
+            const nativeDb = this.openDgnDb({ path: briefcase.fileName }, OpenMode.ReadWrite, upgradeOptions); // performs the upgrade
+            wasChanges = nativeDb.hasPendingTxns();
+            nativeDb.closeFile();
+        };
+        const isSchemaSyncEnabled = await withBriefcaseDb(briefcase, async (db) => {
+            await SchemaSync.pull(db);
+            return db[_nativeDb].schemaSyncEnabled();
+        });
+        if (isSchemaSyncEnabled) {
+            await SchemaSync.withLockedAccess(briefcase, { openMode: OpenMode.Readonly, operationName: "schema sync" }, async (syncAccess) => {
+                const schemaSyncDbUri = syncAccess.getUri();
+                executeUpgrade();
+                await withBriefcaseDb(briefcase, async (db) => {
+                    db[_nativeDb].schemaSyncPush(schemaSyncDbUri);
+                    db.saveChanges();
+                });
+                syncAccess.synchronizeWithCloud();
+            });
+        }
+        else {
+            executeUpgrade();
+        }
+        if (wasChanges)
+            await withBriefcaseDb(briefcase, async (db) => db.pushChanges({ ...briefcase, description, retainLocks: true }));
+    }
+    /** Upgrades the schemas in the iModel based on the current version of the software. Follows a sequence of operations -
+     * * Acquires a schema lock to prevent other users from making any other changes while upgrade is happening
+     * * Updates the local briefcase with the schema changes.
+     * * Pushes the resulting changeset(s) to iModelHub.
+     * Note that the upgrade requires that the local briefcase be closed, and may result in one or two change sets depending on whether both
+     * profile and domain schemas need to get upgraded.
+     * @see ($docs/learning/backend/IModelDb.md#upgrading-schemas-in-an-imodel)
+    */
+    static async upgradeSchemas(briefcase) {
+        // upgrading schemas involves closing and reopening the file repeatedly. That's because the process of upgrading
+        // happens on a file open. We have to open-and-close the file at *each* of these steps:
+        // - acquire schema lock
+        // - upgrade profile
+        // - push changes
+        // - upgrade domain
+        // - push changes
+        // - release schema lock
+        // good thing computers are fast. Fortunately upgrading should be rare (and the push time will dominate anyway.) Don't try to optimize any of this away.
+        try {
+            await this.doUpgrade(briefcase, { profile: ProfileOptions.Upgrade }, "Upgraded profile");
+        }
+        catch (error) {
+            if (error.errorNumber === DbResult.BE_SQLITE_ERROR_DataTransformRequired) {
+                Logger.logInfo(loggerCategory, `Profile upgrade contains data transform. Retrying upgrade with a schema lock.`);
+                try {
+                    await withBriefcaseDb(briefcase, async (db) => db.acquireSchemaLock()); // may not really acquire lock if iModel uses "noLocks" mode.
+                    await this.doUpgrade(briefcase, { profile: ProfileOptions.Upgrade, schemaLockHeld: true }, "Upgraded profile");
+                    await this.doUpgrade(briefcase, { domain: DomainOptions.Upgrade, schemaLockHeld: true }, "Upgraded domain schemas");
+                }
+                finally {
+                    await withBriefcaseDb(briefcase, async (db) => db.locks[_releaseAllLocks]());
+                }
+                return;
+            }
+            throw error;
+        }
+        try {
+            await this.doUpgrade(briefcase, { domain: DomainOptions.Upgrade }, "Upgraded domain schemas");
+        }
+        catch (error) {
+            if (error.errorNumber === DbResult.BE_SQLITE_ERROR_DataTransformRequired) {
+                Logger.logInfo(loggerCategory, `Domain schema upgrade contains data transform. Retrying upgrade with a schema lock.`);
+                try {
+                    await withBriefcaseDb(briefcase, async (db) => db.acquireSchemaLock()); // may not really acquire lock if iModel uses "noLocks" mode.
+                    await this.doUpgrade(briefcase, { domain: DomainOptions.Upgrade, schemaLockHeld: true }, "Upgraded domain schemas");
+                }
+                finally {
+                    await withBriefcaseDb(briefcase, async (db) => db.locks[_releaseAllLocks]());
+                }
+                return;
+            }
+            throw error;
+        }
+    }
+    /** Open a briefcase file and return a new BriefcaseDb to interact with it.
+     * @param args parameters that specify the file name, and options for opening the briefcase file
+     */
+    static async open(args) {
+        this.onOpen.raiseEvent(args);
+        const file = { path: args.fileName, key: args.key };
+        const openMode = (args.readonly || args.watchForChanges) ? OpenMode.Readonly : OpenMode.ReadWrite;
+        const nativeDb = this.openDgnDb(file, openMode, undefined, args);
+        const briefcaseDb = new BriefcaseDb({ nativeDb, key: file.key ?? Guid.createValue(), openMode, briefcaseId: nativeDb.getBriefcaseId() });
+        // If they asked to watch for changes, set an fs.watch on the "-watch" file (only it is modified while we hold this connection.)
+        // Whenever there are changes, restart our defaultTxn. That loads the changes from the other connection and sends
+        // notifications as if they happened on this connection. Note: the watcher is called only when the backend event loop cycles.
+        if (args.watchForChanges && undefined === args.container) {
+            // Must touch the file synchronously - cannot watch a file until it exists.
+            touch.sync(briefcaseDb.watchFilePathName);
+            // Restart default txn to trigger events when watch file is changed by some other process.
+            const watcher = fs.watch(briefcaseDb.watchFilePathName, { persistent: false }, () => {
+                nativeDb.restartDefaultTxn();
+                briefcaseDb.changeset = briefcaseDb[_nativeDb].getCurrentChangeset();
+            });
+            // Stop the watcher when we close this connection.
+            briefcaseDb.onBeforeClose.addOnce(() => {
+                watcher.close();
+            });
+        }
+        // load all of the settings from workspaces
+        await briefcaseDb.loadWorkspaceSettings();
+        if (openMode === OpenMode.ReadWrite && CodeService.createForIModel) {
+            try {
+                briefcaseDb._codeService = await CodeService.createForIModel(briefcaseDb);
+                this.onCodeServiceCreated.raiseEvent(briefcaseDb);
+            }
+            catch (e) {
+                if (e.errorId !== "NoCodeIndex") { // no code index means iModel isn't enforcing codes.
+                    Logger.logWarning(loggerCategory, `The CodeService is not available for this briefcase: errorId: ${e.errorId}, errorMessage; ${e.message}. Proceeding with BriefcaseDb.open(), but all operations involving codes will fail.`);
+                    briefcaseDb._codeService = {
+                        verifyCode: (props) => {
+                            if (!Code.isEmpty(props.props.code)) {
+                                e.message = `The CodeService is not available for this briefcase: errorId: ${e.errorId}, errorMessage; ${e.message}.`;
+                                throw e;
+                            }
+                        },
+                        appParams: {
+                            author: { name: "unknown" },
+                            origin: { name: "unknown" },
+                        },
+                        close: () => { },
+                        initialize: async () => { },
+                    };
+                }
+            }
+        }
+        this.onOpened.raiseEvent(briefcaseDb, args);
+        return briefcaseDb;
+    }
+    /**  This is called by native code when applying a changeset */
+    onChangesetConflict(args) {
+        // returning undefined will result in native handler to resolve conflict
+        const category = "DgnCore";
+        const interpretConflictCause = (cause) => {
+            switch (cause) {
+                case DbConflictCause.Data:
+                    return "data";
+                case DbConflictCause.NotFound:
+                    return "not found";
+                case DbConflictCause.Conflict:
+                    return "conflict";
+                case DbConflictCause.Constraint:
+                    return "constraint";
+                case DbConflictCause.ForeignKey:
+                    return "foreign key";
+            }
+        };
+        if (args.cause === DbConflictCause.Data && !args.indirect) {
+            /*
+            * From SQLite Docs CHANGESET_DATA as the second argument
+            * when processing a DELETE or UPDATE change if a row with the required
+            * PRIMARY KEY fields is present in the database, but one or more other
+            * (non primary-key) fields modified by the update do not contain the
+            * expected "before" values.
+            *
+            * The conflicting row, in this case, is the database row with the matching
+            * primary key.
+            *
+            * Another reason this will be invoked is when SQLITE_CHANGESETAPPLY_FKNOACTION
+            * is passed ApplyChangeset(). The flag will disable CASCADE action and treat
+            * them as CASCADE NONE resulting in conflict handler been called.
+            */
+            if (!this.txns.hasPendingTxns) {
+                // This changeset is bad. However, it is already in the timeline. We must allow services such as
+                // checkpoint-creation, change history, and other apps to apply any changeset that is in the timeline.
+                Logger.logWarning(category, "UPDATE/DELETE before value do not match with one in db or CASCADE action was triggered.");
+                args.dump();
+            }
+            else {
+                if (args.tableName === "be_Prop") {
+                    if (args.getValueText(0, DbChangeStage.Old) === "ec_Db" && args.getValueText(1, DbChangeStage.Old) === "localDbInfo") {
+                        return DbConflictResolution.Replace;
+                    }
+                }
+                if (args.tableName.startsWith("ec_")) {
+                    return DbConflictResolution.Skip;
+                }
+                const msg = "UPDATE/DELETE before value do not match with one in db or CASCADE action was triggered.";
+                args.setLastError(msg);
+                Logger.logError(category, msg);
+                args.dump();
+                return DbConflictResolution.Abort;
+            }
+        }
+        // Handle some special cases
+        if (args.cause === DbConflictCause.Conflict) {
+            // From the SQLite docs: "CHANGESET_CONFLICT is passed as the second argument to the conflict handler while processing an INSERT change if the operation would result in duplicate primary key values."
+            // This is always a fatal error - it can happen only if the app started with a briefcase that is behind the tip and then uses the same primary key values (e.g., ElementIds)
+            // that have already been used by some other app using the SAME briefcase ID that recently pushed changes. That can happen only if the app makes changes without first pulling and acquiring locks.
+            if (!this.txns.hasPendingTxns) {
+                // This changeset is bad. However, it is already in the timeline. We must allow services such as
+                // checkpoint-creation, change history, and other apps to apply any changeset that is in the timeline.
+                Logger.logWarning(category, "PRIMARY KEY INSERT CONFLICT - resolved by replacing the existing row with the incoming row");
+                args.dump();
+            }
+            else {
+                if (args.tableName.startsWith("ec_")) {
+                    return DbConflictResolution.Skip;
+                }
+                const msg = "PRIMARY KEY INSERT CONFLICT - rejecting this changeset";
+                args.setLastError(msg);
+                Logger.logError(category, msg);
+                args.dump();
+                return DbConflictResolution.Abort;
+            }
+        }
+        if (args.cause === DbConflictCause.ForeignKey) {
+            // Note: No current or conflicting row information is provided if it's a FKey conflict
+            // Since we abort on FKey conflicts, always try and provide details about the error
+            const nConflicts = args.getForeignKeyConflicts();
+            // Note: There is no performance implication of follow code as it happen toward end of
+            // apply_changeset only once so we be querying value for 'DebugAllowFkViolations' only once.
+            if (this[_nativeDb].queryLocalValue("DebugAllowFkViolations")) {
+                Logger.logError(category, `Detected ${nConflicts} foreign key conflicts in changeset. Continuing merge as 'DebugAllowFkViolations' flag is set. Run 'PRAGMA foreign_key_check' to get list of violations.`);
+                return DbConflictResolution.Skip;
+            }
+            else {
+                const msg = `Detected ${nConflicts} foreign key conflicts in ChangeSet. Aborting merge.`;
+                args.setLastError(msg);
+                return DbConflictResolution.Abort;
+            }
+        }
+        if (args.cause === DbConflictCause.NotFound) {
+            /*
+             * Note: If DbConflictCause = NotFound, the primary key was not found, and returning DbConflictResolution::Replace is
+             * not an option at all - this will cause a BE_SQLITE_MISUSE error.
+             */
+            return DbConflictResolution.Skip;
+        }
+        if (args.cause === DbConflictCause.Constraint) {
+            if (Logger.isEnabled(category, LogLevel.Info)) {
+                Logger.logInfo(category, "------------------------------------------------------------------");
+                Logger.logInfo(category, `Conflict detected - Cause: ${interpretConflictCause(args.cause)}`);
+                args.dump();
+            }
+            Logger.logWarning(category, "Constraint conflict handled by rejecting incoming change. Constraint conflicts are NOT expected. These happen most often when two clients both insert elements with the same code. That indicates a bug in the client or the code server.");
+            return DbConflictResolution.Skip;
+        }
+        /*
+         * If we don't have a control, we always accept the incoming revision in cases of conflicts:
+         *
+         * + In a briefcase with no local changes, the state of a row in the Db (i.e., the final state of a previous revision)
+         *   may not exactly match the initial state of the incoming revision. This will cause a conflict.
+         *      - The final state of the incoming (later) revision will always be setup exactly right to accommodate
+         *        cases where dependency handlers won't be available (for instance on the server), and we have to rely on
+         *        the revision to correctly set the final state of the row in the Db. Therefore it's best to resolve the
+         *        conflict in favor of the incoming change.
+         * + In a briefcase with local changes, the state of relevant dependent properties (due to propagated indirect changes)
+         *   may not correspond with the initial state of these properties in an incoming revision. This will cause a conflict.
+         *      - Resolving the conflict in favor of the incoming revision may cause some dependent properties to be set
+         *        incorrectly, but the dependency handlers will run anyway and set this right. The new changes will be part of
+         *        a subsequent revision generated from that briefcase.
+         *
+         * + Note that conflicts can NEVER happen between direct changes made locally and direct changes in the incoming revision.
+         *      - Only one user can make a direct change at one time, and the next user has to pull those changes before getting a
+         *        lock to the same element
+         *
+         * + Also see comments in TxnManager::MergeDataChanges()
+         */
+        if (Logger.isEnabled(category, LogLevel.Info)) {
+            Logger.logInfo(category, `Conflict detected - Cause: ${interpretConflictCause(args.cause)}`);
+            args.dump();
+            Logger.logInfo(category, "Conflicting resolved by replacing the existing entry with the change");
+        }
+        return DbConflictResolution.Replace;
+    }
+    /** If the briefcase is read-only, reopen the native briefcase for writing.
+     * Execute the supplied function.
+     * If the briefcase was read-only, reopen the native briefcase as read-only.
+     * @note this._openMode is not changed from its initial value.
+     * @internal Exported strictly for tests
+     */
+    async executeWritable(func) {
+        const fileName = this.pathName;
+        const isReadonly = this.isReadonly;
+        let locks;
+        try {
+            if (isReadonly) {
+                this.closeAndReopen(OpenMode.ReadWrite, fileName);
+                locks = this.locks;
+                this.makeLockControl(); // create a ServerBasedLocks, if necessary
+            }
+            await func();
+        }
+        finally {
+            if (isReadonly) {
+                if (locks !== this._locks) { // did we have to create a ServerBasedLocks?
+                    this.locks[_close](); // yes, close it and reset back to previous
+                    this._locks = locks;
+                }
+                this.closeAndReopen(OpenMode.Readonly, fileName);
+            }
+        }
+    }
+    closeAndReopen(openMode, fileName) {
+        // Unclosed statements will produce BUSY error when attempting to close.
+        this.clearCaches();
+        // The following resets the native db's pointer to this JavaScript object.
+        this[_nativeDb].closeFile();
+        this[_nativeDb].openIModel(fileName, openMode);
+        // Restore the native db's pointer to this JavaScript object.
+        this[_nativeDb].setIModelDb(this);
+        // refresh cached properties that could have been changed by another process writing to the same briefcase
+        this.changeset = this[_nativeDb].getCurrentChangeset();
+        // assert what should never change
+        if (this.iModelId !== this[_nativeDb].getIModelId() || this.iTwinId !== this[_nativeDb].getITwinId())
+            throw new Error("closeAndReopen detected change in iModelId and/or iTwinId");
+    }
+    /** Pull and apply changesets from iModelHub */
+    async pullChanges(arg) {
+        await this.executeWritable(async () => {
+            await BriefcaseManager.pullAndApplyChangesets(this, arg ?? {});
+            if (!this.skipSyncSchemasOnPullAndPush)
+                await SchemaSync.pull(this);
+            this.initializeIModelDb();
+        });
+        IpcHost.notifyTxns(this, "notifyPulledChanges", this.changeset);
+        this.txns.touchWatchFile();
+    }
+    /** Revert timeline changes and then push resulting changeset */
+    async revertAndPushChanges(arg) {
+        const nativeDb = this[_nativeDb];
+        if (arg.toIndex === undefined) {
+            throw new IModelError(ChangeSetStatus.ApplyError, "Cannot revert without a toIndex");
+        }
+        if (nativeDb.hasUnsavedChanges()) {
+            throw new IModelError(ChangeSetStatus.HasUncommittedChanges, "Cannot revert with unsaved changes");
+        }
+        if (nativeDb.hasPendingTxns()) {
+            throw new IModelError(ChangeSetStatus.HasLocalChanges, "Cannot revert with pending txns");
+        }
+        const skipSchemaSyncPull = async (func) => {
+            if (nativeDb.schemaSyncEnabled()) {
+                this._skipSyncSchemasOnPullAndPush = true;
+                try {
+                    return await func();
+                }
+                finally {
+                    this._skipSyncSchemasOnPullAndPush = undefined;
+                }
+            }
+            else {
+                return func();
+            }
+        };
+        this.clearCaches();
+        await skipSchemaSyncPull(async () => this.pullChanges({ ...arg, toIndex: undefined }));
+        await this.acquireSchemaLock();
+        if (nativeDb.schemaSyncEnabled()) {
+            arg.skipSchemaChanges = true;
+        }
+        try {
+            await BriefcaseManager.revertTimelineChanges(this, arg);
+            this.saveChanges("Revert changes");
+            if (!arg.description) {
+                arg.description = `Reverted changes from ${this.changeset.index} to ${arg.toIndex}${arg.skipSchemaChanges ? " (schema changes skipped)" : ""}`;
+            }
+            const pushArgs = {
+                description: arg.description,
+                accessToken: arg.accessToken,
+                mergeRetryCount: arg.mergeRetryCount,
+                mergeRetryDelay: arg.mergeRetryDelay,
+                pushRetryCount: arg.pushRetryCount,
+                pushRetryDelay: arg.pushRetryDelay,
+                retainLocks: arg.retainLocks,
+            };
+            await skipSchemaSyncPull(async () => this.pushChanges(pushArgs));
+            this.clearCaches();
+        }
+        catch (err) {
+            if (!arg.retainLocks) {
+                await this.locks.releaseAllLocks();
+                throw err;
+            }
+        }
+        finally {
+            this.abandonChanges();
+        }
+    }
+    /** Push changes to iModelHub. */
+    async pushChanges(arg) {
+        if (this.briefcaseId === BriefcaseIdValue.Unassigned)
+            return;
+        if (this[_nativeDb].hasUnsavedChanges()) {
+            throw new IModelError(ChangeSetStatus.HasUncommittedChanges, "Cannot push with unsaved changes");
+        }
+        else if (!this[_nativeDb].hasPendingTxns()) {
+            // Nothing to push.
+            if (!arg.retainLocks) {
+                await this.locks.releaseAllLocks();
+            }
+            return;
+        }
+        // pushing changes requires a writeable briefcase
+        await this.executeWritable(async () => {
+            await BriefcaseManager.pullMergePush(this, arg);
+            this.initializeIModelDb();
+        });
+        const changeset = this.changeset;
+        IpcHost.notifyTxns(this, "notifyPushedChanges", changeset);
+        this.txns.touchWatchFile();
+    }
+    close() {
+        if (this.isBriefcase && this.isOpen && !this.isReadonly && this.txns.changeMergeManager.inProgress()) {
+            this.abandonChanges();
+        }
+        super.close();
+        this.onClosed.raiseEvent();
+    }
+}
+/** Used to reattach Daemon from a user's accessToken for V2 checkpoints.
+ * @note Reattach only happens if the previous access token either has expired or is about to expire within an application-supplied safety duration.
+ */
+class RefreshV2CheckpointSas {
+    /** the time at which the current token should be refreshed (its expiry minus safetySeconds) */
+    _timestamp = 0;
+    /** while a refresh is happening, all callers get this promise. */
+    _promise;
+    /** Time, in seconds, before the current token expires to obtain a new token. Default is 1 hour. */
+    _safetySeconds;
+    constructor(sasToken, safetySeconds) {
+        this._safetySeconds = safetySeconds ?? 60 * 60; // default to 1 hour
+        this.setTimestamp(sasToken);
+    }
+    async performRefresh(accessToken, iModel) {
+        this._timestamp = 0; // everyone needs to wait until token is valid
+        // we're going to request that the checkpoint manager use this user's accessToken to obtain a new access token for this checkpoint's storage account.
+        Logger.logInfo(BackendLoggerCategory.Authorization, "attempting to refresh sasToken for checkpoint");
+        try {
+            // this exchanges the supplied user accessToken for an expiring blob-store token to read the checkpoint.
+            const container = iModel[_nativeDb].cloudContainer;
+            if (!container)
+                throw new Error("checkpoint is not from a cloud container");
+            assert(undefined !== iModel.iTwinId);
+            const props = await IModelHost[_hubAccess].queryV2Checkpoint({ accessToken, iTwinId: iModel.iTwinId, iModelId: iModel.iModelId, changeset: iModel.changeset });
+            if (!props)
+                throw new Error("can't reset checkpoint sas token");
+            container.accessToken = props.sasToken;
+            this.setTimestamp(props.sasToken);
+            Logger.logInfo(BackendLoggerCategory.Authorization, "refreshed checkpoint sasToken successfully");
+        }
+        finally {
+            this._promise = undefined;
+        }
+    }
+    setTimestamp(sasToken) {
+        const exp = new URLSearchParams(sasToken).get("se");
+        const sasTokenExpiry = exp ? Date.parse(exp) : 0;
+        this._timestamp = sasTokenExpiry - (this._safetySeconds * 1000);
+        if (this._timestamp < Date.now())
+            Logger.logError(BackendLoggerCategory.Authorization, "attached with timestamp that expires before safety interval");
+    }
+    async refreshSas(accessToken, iModel) {
+        if (this._timestamp > Date.now())
+            return; // current token is fine
+        if (undefined === this._promise) // has reattach already begun?
+            this._promise = this.performRefresh(accessToken, iModel); // no, start it
+        return this._promise;
+    }
+}
+/** A *snapshot* iModel database file that is used for archival and data transfer purposes.
+ * @see [Snapshot iModels]($docs/learning/backend/AccessingIModels.md#snapshot-imodels)
+ * @see [About IModelDb]($docs/learning/backend/IModelDb.md)
+ * @public
+ */
+export class SnapshotDb extends IModelDb {
+    get isSnapshot() { return true; }
+    _refreshSas;
+    /** Timer used to restart the default txn on the SnapshotDb after some inactivity. This is only used for checkpoints.
+     *  Restarting the default txn lets CloudSqlite know that any blocks that may have been read may now be ejected.
+     *  Without restarting the default txn, CloudSQLite can get into a state where it can not evict any blocks to make space for more blocks.
+     */
+    _restartDefaultTxnTimer;
+    _createClassViewsOnClose;
+    static onOpen = new BeEvent();
+    static onOpened = new BeEvent();
+    constructor(nativeDb, key) {
+        super({ nativeDb, key, changeset: nativeDb.getCurrentChangeset() });
+        this._openMode = nativeDb.isReadonly() ? OpenMode.Readonly : OpenMode.ReadWrite;
+    }
+    static findByKey(key) {
+        return super.findByKey(key);
+    }
+    static tryFindByKey(key) {
+        const db = super.tryFindByKey(key);
+        return db?.isSnapshotDb() ? db : undefined;
+    }
+    /** Create an *empty* local [Snapshot]($docs/learning/backend/AccessingIModels.md#snapshot-imodels) iModel file.
+     * Snapshots are not synchronized with iModelHub, so do not have a change timeline.
+     * @note: A *snapshot* cannot be modified after [[close]] is called.
+     * @param filePath The file that will contain the new iModel *snapshot*
+     * @param options The parameters that define the new iModel *snapshot*
+     * @returns A writeable SnapshotDb
+     * @see [Snapshot iModels]($docs/learning/backend/AccessingIModels.md#snapshot-imodels)
+     */
+    static createEmpty(filePath, options) {
+        const nativeDb = new IModelNative.platform.DgnDb();
+        nativeDb.createIModel(filePath, options);
+        nativeDb.resetBriefcaseId(BriefcaseIdValue.Unassigned);
+        const snapshotDb = new SnapshotDb(nativeDb, Guid.createValue());
+        snapshotDb.channels.addAllowedChannel(ChannelControl.sharedChannelName);
+        if (options.createClassViews)
+            snapshotDb._createClassViewsOnClose = true; // save flag that will be checked when close() is called
+        return snapshotDb;
+    }
+    /** Create a local [Snapshot]($docs/learning/backend/AccessingIModels.md#snapshot-imodels) iModel file, using this iModel as a *seed* or starting point.
+     * Snapshots are not synchronized with iModelHub, so do not have a change timeline.
+     * @note: A *snapshot* cannot be modified after [[close]] is called.
+     * @param iModelDb The snapshot will be initialized from the current contents of this iModelDb
+     * @param snapshotFile The file that will contain the new iModel *snapshot*
+     * @param options Optional properties that determine how the snapshot iModel is created.
+     * @returns A writeable SnapshotDb
+     * @see [Snapshot iModels]($docs/learning/backend/AccessingIModels.md#snapshot-imodels)
+     */
+    static createFrom(iModelDb, snapshotFile, options) {
+        iModelDb.performCheckpoint();
+        IModelJsFs.copySync(iModelDb.pathName, snapshotFile);
+        const nativeDb = new IModelNative.platform.DgnDb();
+        nativeDb.openIModel(snapshotFile, OpenMode.ReadWrite, undefined);
+        nativeDb.vacuum();
+        // Replace iModelId if seedFile is a snapshot, preserve iModelId if seedFile is an iModelHub-managed briefcase
+        if (!BriefcaseManager.isValidBriefcaseId(nativeDb.getBriefcaseId()))
+            nativeDb.setIModelId(Guid.createValue());
+        nativeDb.deleteLocalValue(BriefcaseLocalValue.StandaloneEdit);
+        nativeDb.saveChanges();
+        nativeDb.deleteAllTxns();
+        nativeDb.resetBriefcaseId(BriefcaseIdValue.Unassigned);
+        const snapshotDb = new SnapshotDb(nativeDb, Guid.createValue());
+        if (options?.createClassViews)
+            snapshotDb._createClassViewsOnClose = true; // save flag that will be checked when close() is called
+        return snapshotDb;
+    }
+    /** open this SnapshotDb read/write, strictly to apply incoming changesets. Used for creating new checkpoints.
+     * @internal
+     */
+    static openForApplyChangesets(path, props) {
+        const file = { path, key: props?.key };
+        const nativeDb = this.openDgnDb(file, OpenMode.ReadWrite, undefined, props);
+        assert(undefined !== file.key);
+        return new SnapshotDb(nativeDb, file.key);
+    }
+    /** Open a read-only iModel *snapshot*.
+     * @param path the full path of the snapshot iModel file to open.
+     * @param props options for opening snapshot
+     * @see [[close]]
+     * @throws [[IModelError]] If the file is not found or is not a valid *snapshot*.
+     */
+    static openFile(path, opts) {
+        this.onOpen.raiseEvent(path, opts);
+        const file = { path, key: opts?.key };
+        const wasKeyUndefined = opts?.key === undefined;
+        const nativeDb = this.openDgnDb(file, OpenMode.Readonly, undefined, opts);
+        if (wasKeyUndefined) {
+            file.key = `${nativeDb.getIModelId()}:${nativeDb.getCurrentChangeset().id}`;
+        }
+        assert(undefined !== file.key);
+        const db = new SnapshotDb(nativeDb, file.key);
+        this.onOpened.raiseEvent(db);
+        return db;
+    }
+    static async attachAndOpenCheckpoint(checkpoint) {
+        const { dbName, container } = await V2CheckpointManager.attach(checkpoint);
+        const key = CheckpointManager.getKey(checkpoint);
+        const db = SnapshotDb.openFile(dbName, { key, container });
+        await db.loadWorkspaceSettings();
+        return db;
+    }
+    /** @internal */
+    static async openCheckpointFromRpc(checkpoint) {
+        const snapshot = await this.attachAndOpenCheckpoint(checkpoint);
+        snapshot._iTwinId = checkpoint.iTwinId;
+        try {
+            CheckpointManager.validateCheckpointGuids(checkpoint, snapshot);
+        }
+        catch (err) {
+            snapshot.close();
+            throw err;
+        }
+        // unref timer, so it doesn't prevent a process from shutting down.
+        snapshot._restartDefaultTxnTimer = setTimeout(() => {
+            snapshot.restartDefaultTxn();
+        }, (10 * 60) * 1000).unref(); // 10 minutes
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        snapshot._refreshSas = new RefreshV2CheckpointSas(snapshot[_nativeDb].cloudContainer.accessToken, checkpoint.reattachSafetySeconds);
+        return snapshot;
+    }
+    /**
+     * Open a Checkpoint directly from its cloud container.
+     * @beta
+     */
+    static async openCheckpoint(args) {
+        return this.attachAndOpenCheckpoint(await CheckpointManager.toCheckpointProps(args));
+    }
+    /** Used to refresh the container sasToken using the current user's accessToken.
+     * Also restarts the timer which causes the default txn to be restarted on db if the timer activates.
+     * @internal
+     */
+    async refreshContainerForRpc(userAccessToken) {
+        this._restartDefaultTxnTimer?.refresh();
+        return this._refreshSas?.refreshSas(userAccessToken, this);
+    }
+    /** @internal */
+    beforeClose() {
+        super.beforeClose();
+        if (this._restartDefaultTxnTimer)
+            clearTimeout(this._restartDefaultTxnTimer);
+        if (this._createClassViewsOnClose) { // check for flag set during create
+            if (BentleyStatus.SUCCESS !== this[_nativeDb].createClassViewsInDb()) {
+                throw new IModelError(IModelStatus.SQLiteError, "Error creating class views");
+            }
+            else {
+                this.saveChanges();
+            }
+        }
+    }
+}
+/**
+ * Standalone iModels are read/write files that are not associated with an iTwin or managed by iModelHub.
+ * They are relevant only for testing, or for small-scale single-user scenarios.
+ * Standalone iModels are designed such that the API for Standalone iModels and Briefcase
+ * iModels (those synchronized with iModelHub) are as similar and consistent as possible.
+ * This leads to a straightforward process where the a user starts with StandaloneDb and can
+ * optionally choose to upgrade to an iTwin.
+ *
+ * Some additional details. Standalone iModels:
+ * - always have [Guid.empty]($bentley) for their iTwinId (they are "unassociated" files)
+ * - always have BriefcaseId === [BriefcaseIdValue.Unassigned]($common)
+ * - are connected to the frontend via [BriefcaseConnection.openStandalone]($frontend)
+ * - may be opened without supplying any user credentials
+ * - may be opened read/write
+ * - cannot apply a changeset to nor generate a changesets (since there is no timeline from which to get/push changesets)
+ * @public
+ */
+export class StandaloneDb extends BriefcaseDb {
+    get isStandalone() { return true; }
+    get useLockServer() { return false; } // standalone iModels have no lock server
+    static findByKey(key) {
+        return super.findByKey(key);
+    }
+    static tryFindByKey(key) {
+        const db = super.tryFindByKey(key);
+        return db?.isStandaloneDb() ? db : undefined;
+    }
+    /** Create an *empty* standalone iModel.
+     * @param filePath The file path for the iModel
+     * @param args The parameters that define the new iModel
+     */
+    static createEmpty(filePath, args) {
+        const nativeDb = new IModelNative.platform.DgnDb();
+        nativeDb.createIModel(filePath, args);
+        nativeDb.saveLocalValue(BriefcaseLocalValue.StandaloneEdit, args.allowEdit);
+        nativeDb.setITwinId(Guid.empty);
+        nativeDb.resetBriefcaseId(BriefcaseIdValue.Unassigned);
+        nativeDb.saveChanges();
+        const db = new StandaloneDb({ nativeDb, key: Guid.createValue(), briefcaseId: BriefcaseIdValue.Unassigned, openMode: OpenMode.ReadWrite });
+        db.channels.addAllowedChannel(ChannelControl.sharedChannelName);
+        return db;
+    }
+    /**
+     * Upgrades the schemas in the standalone iModel file.
+     * Note that the upgrade requires that the file be closed, and will leave it back in the closed state.
+     * @param filePath Full path name of the standalone iModel file.
+     * @see ($docs/learning/backend/IModelDb.md#upgrading-schemas-in-an-imodel)
+     * @see [[StandaloneDb.validateSchemas]]
+     */
+    static upgradeStandaloneSchemas(filePath) {
+        let nativeDb = this.openDgnDb({ path: filePath }, OpenMode.ReadWrite, { profile: ProfileOptions.Upgrade, schemaLockHeld: true });
+        nativeDb.saveChanges();
+        nativeDb.closeFile();
+        nativeDb = this.openDgnDb({ path: filePath }, OpenMode.ReadWrite, { domain: DomainOptions.Upgrade, schemaLockHeld: true });
+        nativeDb.saveChanges();
+        nativeDb.closeFile();
+    }
+    /** Creates or updates views in the iModel to permit visualizing the EC content as ECClasses and ECProperties rather than raw database tables and columns.
+     * This can be helpful when debugging the EC data, especially when the raw tables make use of shared columns or spread data across multiple tables.
+     * @throws IModelError if view creation failed.
+     * @note The views are strictly intended for developers and debugging purposes only - they should not be used in application code.
+     * @beta
+     */
+    createClassViews() {
+        const result = this[_nativeDb].createClassViewsInDb();
+        if (BentleyStatus.SUCCESS !== result)
+            throw new IModelError(result, "Error creating class views");
+        else
+            this.saveChanges();
+    }
+    /** Open a standalone iModel file.
+     * @param filePath The path of the standalone iModel file.
+     * @param openMode Optional open mode for the standalone iModel. The default is read/write.
+     * @throws [[IModelError]] if the file is not a standalone iModel.
+     * @see [BriefcaseConnection.openStandalone]($frontend) to open a StandaloneDb from the frontend
+     */
+    static openFile(filePath, openMode = OpenMode.ReadWrite, options) {
+        const file = { path: filePath, key: options?.key };
+        const nativeDb = this.openDgnDb(file, openMode, undefined, options);
+        try {
+            const iTwinId = nativeDb.getITwinId();
+            if (iTwinId !== Guid.empty) // a "standalone" iModel means it is not associated with an iTwin
+                throw new IModelError(IModelStatus.WrongIModel, `${filePath} is not a Standalone iModel. iTwinId=${iTwinId}`);
+            assert(undefined !== file.key);
+            const db = new StandaloneDb({ nativeDb, key: file.key, openMode, briefcaseId: BriefcaseIdValue.Unassigned });
+            return db;
+        }
+        catch (error) {
+            nativeDb.closeFile();
+            throw error;
+        }
+    }
+    /** Convert an iModel stored on the local file system into a StandaloneDb, chiefly for testing purposes.
+     * The file must not be open in any application.
+     * @param iModelFileName the path to the iModel on the local file system.
+     * @beta
+     */
+    static convertToStandalone(iModelFileName) {
+        const nativeDb = new IModelNative.platform.DgnDb();
+        nativeDb.openIModel(iModelFileName, OpenMode.ReadWrite);
+        nativeDb.setITwinId(Guid.empty); // empty iTwinId means "standalone"
+        nativeDb.saveChanges(); // save change to iTwinId
+        nativeDb.deleteAllTxns(); // necessary before resetting briefcaseId
+        nativeDb.resetBriefcaseId(BriefcaseIdValue.Unassigned); // standalone iModels should always have BriefcaseId unassigned
+        nativeDb.saveLocalValue("StandaloneEdit", JSON.stringify({ txns: true }));
+        nativeDb.saveChanges(); // save change to briefcaseId
+        nativeDb.closeFile();
+    }
+}
+//# sourceMappingURL=IModelDb.js.map