@itwin/core-backend 3.4.0-dev.0 → 3.4.0-dev.3

package/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Change Log - @itwin/core-backend
 
-This log was last generated on Wed, 13 Jul 2022 15:45:52 GMT and should not be manually modified.
+This log was last generated on Mon, 01 Aug 2022 13:36:56 GMT and should not be manually modified.
+
+## 3.2.7
+Mon, 01 Aug 2022 13:36:56 GMT
+
+_Version update only_
+
+## 3.2.6
+Fri, 15 Jul 2022 19:04:43 GMT
+
+_Version update only_
 
 ## 3.2.5
 Wed, 13 Jul 2022 15:45:52 GMT

package/lib/cjs/BackendLoggerCategory.d.ts

@@ -80,9 +80,9 @@ export declare enum BackendLoggerCategory {
      */
     NativeApp = "core-backend.NativeApp",
     /** The logger category used by the following classes:
-     * - [[ViewStateHydrater]]
+     * - [[ViewStateHydrator]]
      * @internal
      */
-    ViewStateHydrater = "core-backend.ViewStateHydrater"
+    ViewStateHydrator = "core-backend.ViewStateHydrator"
 }
 //# sourceMappingURL=BackendLoggerCategory.d.ts.map

package/lib/cjs/BackendLoggerCategory.js

@@ -88,9 +88,9 @@ var BackendLoggerCategory;
      */
     BackendLoggerCategory["NativeApp"] = "core-backend.NativeApp";
     /** The logger category used by the following classes:
-     * - [[ViewStateHydrater]]
+     * - [[ViewStateHydrator]]
      * @internal
      */
-    BackendLoggerCategory["ViewStateHydrater"] = "core-backend.ViewStateHydrater";
+    BackendLoggerCategory["ViewStateHydrator"] = "core-backend.ViewStateHydrator";
 })(BackendLoggerCategory = exports.BackendLoggerCategory || (exports.BackendLoggerCategory = {}));
 //# sourceMappingURL=BackendLoggerCategory.js.map

package/lib/cjs/BackendLoggerCategory.js.map

@@ -1 +1 @@
-{"version":3,"file":"BackendLoggerCategory.js","sourceRoot":"","sources":["../../src/BackendLoggerCategory.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH;;;;GAIG;AACH,IAAY,qBA8FX;AA9FD,WAAY,qBAAqB;IAC/B,+DAA+D;IAC/D,qEAA4C,CAAA;IAE5C;;OAEG;IACH,6DAAoC,CAAA;IAEpC;;OAEG;IACH,2DAAkC,CAAA;IAElC;;;;OAIG;IACH,mDAA0B,CAAA;IAE1B;;OAEG;IACH,+DAAsC,CAAA;IAEtC;;OAEG;IACH,6EAAoD,CAAA;IAEpD;;;OAGG;IACH,2DAAkC,CAAA;IAElC;;OAEG;IACH,+DAAsC,CAAA;IAEtC;;OAEG;IACH,mFAA0D,CAAA;IAE1D;;OAEG;IACH,2EAAkD,CAAA;IAElD;;OAEG;IACH,mEAA0C,CAAA;IAE1C;;OAEG;IACH,yDAAgC,CAAA;IAEhC;;OAEG;IACH,yEAAgD,CAAA;IAChD;;OAEG;IACH,6DAAoC,CAAA;IAEpC;;;OAGG;IACH,+EAAsD,CAAA;IAEtD;;;OAGG;IACH,yDAAgC,CAAA;IAEhC;;;OAGG;IACH,6DAAoC,CAAA;IAEpC;;;OAGG;IACH,6EAAoD,CAAA;AACtD,CAAC,EA9FW,qBAAqB,GAArB,6BAAqB,KAArB,6BAAqB,QA8FhC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Logging\r\n */\r\n\r\n/** Logger categories used by this package\r\n * @note All logger categories in this package start with the `core-backend` prefix.\r\n * @see [Logger]($bentley)\r\n * @public\r\n */\r\nexport enum BackendLoggerCategory {\r\n  /** The logger category used by API related to authorization */\r\n  Authorization = \"core-backend.Authorization\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[CodeSpecs]]\r\n   */\r\n  CodeSpecs = \"core-backend.CodeSpecs\",\r\n\r\n  /** The logger category used by the [[DevTools]] class and related classes.\r\n   * @internal\r\n   */\r\n  DevTools = \"core-backend.DevTools\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[ChangeSummaryManager]]\r\n   * - [[ECDb]]\r\n   * - [[ECSqlStatement]]\r\n   */\r\n  ECDb = \"core-backend.ECDb\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[Functional]]\r\n   */\r\n  Functional = \"core-backend.Functional\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[LinearReferencing]]\r\n   */\r\n  LinearReferencing = \"core-backend.LinearReferencing\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - BriefcaseManager\r\n   * - [[IModelDb]]\r\n   */\r\n  IModelDb = \"core-backend.IModelDb\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[IModelHost]]\r\n   */\r\n  IModelHost = \"core-backend.IModelHost\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - TileRequestMemoizer\r\n   */\r\n  IModelTileRequestRpc = \"core-backend.IModelTileRequestRpc\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - IModelTileRpcImpl (Tile Uploading)\r\n   */\r\n  IModelTileUpload = \"core-backend.IModelTileUpload\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[Relationship]]\r\n   */\r\n  Relationship = \"core-backend.Relationship\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[Schemas]]\r\n   */\r\n  Schemas = \"core-backend.Schemas\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[PromiseMemoizer]]\r\n   */\r\n  PromiseMemoizer = \"core-backend.PromiseMemoizer\",\r\n  /** The logger category used by the following classes:\r\n   * - [[EventSink]]\r\n   */\r\n  EventSink = \"core-backend.EventSink\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[IModelSchemaLoader]]\r\n   * @alpha\r\n   */\r\n  IModelSchemaLoader = \"core-backend.IModelSchemaLoader\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[iModels]]\r\n   * @alpha\r\n   */\r\n  Editing = \"core-backend.Editing\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[NativeHost]], [[NativeAppStorage]]\r\n   * @internal\r\n   */\r\n  NativeApp = \"core-backend.NativeApp\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[ViewStateHydrater]]\r\n   * @internal\r\n   */\r\n  ViewStateHydrater = \"core-backend.ViewStateHydrater\",\r\n}\r\n"]}
+{"version":3,"file":"BackendLoggerCategory.js","sourceRoot":"","sources":["../../src/BackendLoggerCategory.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH;;;;GAIG;AACH,IAAY,qBA8FX;AA9FD,WAAY,qBAAqB;IAC/B,+DAA+D;IAC/D,qEAA4C,CAAA;IAE5C;;OAEG;IACH,6DAAoC,CAAA;IAEpC;;OAEG;IACH,2DAAkC,CAAA;IAElC;;;;OAIG;IACH,mDAA0B,CAAA;IAE1B;;OAEG;IACH,+DAAsC,CAAA;IAEtC;;OAEG;IACH,6EAAoD,CAAA;IAEpD;;;OAGG;IACH,2DAAkC,CAAA;IAElC;;OAEG;IACH,+DAAsC,CAAA;IAEtC;;OAEG;IACH,mFAA0D,CAAA;IAE1D;;OAEG;IACH,2EAAkD,CAAA;IAElD;;OAEG;IACH,mEAA0C,CAAA;IAE1C;;OAEG;IACH,yDAAgC,CAAA;IAEhC;;OAEG;IACH,yEAAgD,CAAA;IAChD;;OAEG;IACH,6DAAoC,CAAA;IAEpC;;;OAGG;IACH,+EAAsD,CAAA;IAEtD;;;OAGG;IACH,yDAAgC,CAAA;IAEhC;;;OAGG;IACH,6DAAoC,CAAA;IAEpC;;;OAGG;IACH,6EAAoD,CAAA;AACtD,CAAC,EA9FW,qBAAqB,GAArB,6BAAqB,KAArB,6BAAqB,QA8FhC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Logging\r\n */\r\n\r\n/** Logger categories used by this package\r\n * @note All logger categories in this package start with the `core-backend` prefix.\r\n * @see [Logger]($bentley)\r\n * @public\r\n */\r\nexport enum BackendLoggerCategory {\r\n  /** The logger category used by API related to authorization */\r\n  Authorization = \"core-backend.Authorization\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[CodeSpecs]]\r\n   */\r\n  CodeSpecs = \"core-backend.CodeSpecs\",\r\n\r\n  /** The logger category used by the [[DevTools]] class and related classes.\r\n   * @internal\r\n   */\r\n  DevTools = \"core-backend.DevTools\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[ChangeSummaryManager]]\r\n   * - [[ECDb]]\r\n   * - [[ECSqlStatement]]\r\n   */\r\n  ECDb = \"core-backend.ECDb\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[Functional]]\r\n   */\r\n  Functional = \"core-backend.Functional\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[LinearReferencing]]\r\n   */\r\n  LinearReferencing = \"core-backend.LinearReferencing\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - BriefcaseManager\r\n   * - [[IModelDb]]\r\n   */\r\n  IModelDb = \"core-backend.IModelDb\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[IModelHost]]\r\n   */\r\n  IModelHost = \"core-backend.IModelHost\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - TileRequestMemoizer\r\n   */\r\n  IModelTileRequestRpc = \"core-backend.IModelTileRequestRpc\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - IModelTileRpcImpl (Tile Uploading)\r\n   */\r\n  IModelTileUpload = \"core-backend.IModelTileUpload\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[Relationship]]\r\n   */\r\n  Relationship = \"core-backend.Relationship\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[Schemas]]\r\n   */\r\n  Schemas = \"core-backend.Schemas\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[PromiseMemoizer]]\r\n   */\r\n  PromiseMemoizer = \"core-backend.PromiseMemoizer\",\r\n  /** The logger category used by the following classes:\r\n   * - [[EventSink]]\r\n   */\r\n  EventSink = \"core-backend.EventSink\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[IModelSchemaLoader]]\r\n   * @alpha\r\n   */\r\n  IModelSchemaLoader = \"core-backend.IModelSchemaLoader\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[iModels]]\r\n   * @alpha\r\n   */\r\n  Editing = \"core-backend.Editing\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[NativeHost]], [[NativeAppStorage]]\r\n   * @internal\r\n   */\r\n  NativeApp = \"core-backend.NativeApp\",\r\n\r\n  /** The logger category used by the following classes:\r\n   * - [[ViewStateHydrator]]\r\n   * @internal\r\n   */\r\n  ViewStateHydrator = \"core-backend.ViewStateHydrator\",\r\n}\r\n"]}

package/lib/cjs/ElementTreeWalker.d.ts

@@ -0,0 +1,140 @@
+/** @packageDocumentation
+ * @module Elements
+ */
+import { Id64String } from "@itwin/core-bentley";
+import { IModelDb } from "./IModelDb";
+import { Model } from "./Model";
+/** @beta */
+export interface ElementTreeWalkerModelInfo {
+    model: Model;
+    isDefinitionModel: boolean;
+}
+/** Records the path that a tree search took to reach an element or model. This object is immutable.
+ * @beta
+ */
+export declare class ElementTreeWalkerScope {
+    readonly topElement: Id64String;
+    /** path of parent elements and enclosing models */
+    readonly path: Array<Id64String | ElementTreeWalkerModelInfo>;
+    /** cached info about the immediately enclosing model (i.e., the last model in path) */
+    readonly enclosingModelInfo: ElementTreeWalkerModelInfo;
+    constructor(topElement: Id64String, model: Model);
+    constructor(enclosingScope: ElementTreeWalkerScope, newScope: Id64String | Model);
+    get enclosingModel(): Model;
+    get inDefinitionModel(): boolean;
+    get inRepositoryModel(): boolean;
+    static createTopScope(iModel: IModelDb, topElementId: Id64String): ElementTreeWalkerScope;
+    private fmtItem;
+    toString(): string;
+}
+/** Does a depth-first search on the tree defined by an element and its sub-models and children.
+ * Sub-models are visited before their modeled elements, and children are visited before their parents.
+ *
+ * The following callbacks allow the subclass to exclude elements and sub-trees from the search:
+ *  * [[ElementTreeBottomUp.shouldExploreModel]], [[ElementTreeBottomUp.shouldExploreChildren]]
+ *  * [[ElementTreeBottomUp.shouldVisitElement]], [[ElementTreeBottomUp.shouldVisitModel]]
+ *
+ * The [[ElementTreeBottomUp.visitElement]] and [[ElementTreeBottomUp.visitModel]] callbacks allow
+ * the subclass to process the elements and models that are encountered in the search.
+ * @beta
+ */
+export declare abstract class ElementTreeBottomUp {
+    protected _iModel: IModelDb;
+    constructor(_iModel: IModelDb);
+    /** Return true if the search should recurse into this model  */
+    protected shouldExploreModel(_model: Model, _scope: ElementTreeWalkerScope): boolean;
+    /** Return true if the search should recurse into the children (if any) of this element  */
+    protected shouldExploreChildren(_parentId: Id64String, _scope: ElementTreeWalkerScope): boolean;
+    /** Return true if the search should visit this element  */
+    protected shouldVisitElement(_elementId: Id64String, _scope: ElementTreeWalkerScope): boolean;
+    /** Return true if the search should visit this model  */
+    protected shouldVisitModel(_model: Model, _scope: ElementTreeWalkerScope): boolean;
+    /** Called to visit a model */
+    protected abstract visitModel(model: Model, scope: ElementTreeWalkerScope): void;
+    /** Called to visit an element */
+    protected abstract visitElement(elementId: Id64String, scope: ElementTreeWalkerScope): void;
+    /** The main tree-walking function */
+    protected processElementTree(element: Id64String, scope: ElementTreeWalkerScope): void;
+    /** process the children of the specified parent element */
+    private _processChildren;
+    /** process the elements in the specified model */
+    private _processSubModel;
+}
+/** Deletes an entire element tree, including sub-models and child elements.
+ * Items are deleted in bottom-up order. Definitions and Subjects are deleted after normal elements.
+ * @beta
+ */
+export declare class ElementTreeDeleter extends ElementTreeBottomUp {
+    private _special;
+    private _topElement;
+    private _topScope;
+    constructor(iModel: IModelDb, topElement: Id64String, scope?: ElementTreeWalkerScope);
+    protected shouldExploreModel(_model: Model): boolean;
+    protected shouldVisitElement(_elementId: Id64String): boolean;
+    protected visitModel(model: Model, _scope: ElementTreeWalkerScope): void;
+    protected visitElement(elementId: Id64String, _scope: ElementTreeWalkerScope): void;
+    /** Delete the element tree. */
+    deleteElementTree(): void;
+}
+/** Does a breadth-first search on the tree defined by an element and its sub-models and children.
+ * Parents are visited first, then children, then sub-models.
+ * The subclass can "prune" sub-trees from the search. When a sub-tree is "pruned" the search does *not* recurse into it.
+ * If a sub-tree is not pruned, then the search does recurse into it.
+ * @beta
+ */
+declare abstract class ElementTreeTopDown {
+    protected _iModel: IModelDb;
+    constructor(_iModel: IModelDb);
+    /** Should the search *not* recurse into this sub-tree? */
+    protected shouldPrune(_elementId: Id64String, _scope: ElementTreeWalkerScope): boolean;
+    protected abstract prune(_elementId: Id64String, _scope: ElementTreeWalkerScope): void;
+    protected processElementTree(element: Id64String, scope: ElementTreeWalkerScope): void;
+    private _processChildren;
+    private _processSubModel;
+}
+/** Signature of the filter function used by ElementSubTreeDeleter.
+ * @param elementId The sub-tree parent element.
+ * @param scope The path followed by the top-down search to the element
+ * @return true if the element and its children and sub-models should be deleted.
+ * @beta
+ */
+export declare type ElementSubTreeDeleteFilter = (elementId: Id64String, scope: ElementTreeWalkerScope) => boolean;
+/** Deletes the element sub-trees that are chosen by a supplied filter function.
+ * This class uses ElementTreeTopDown to visit element sub-trees in top-down order.
+ * When the filter function chooses a sub-tree, this class uses ElementTreeDeleter to delete it.
+ * Note that when a sub-tree is selected and deleted, its children and sub-models are not visited.
+ * @beta
+ */
+export declare class ElementSubTreeDeleter extends ElementTreeTopDown {
+    private _special;
+    private _topElement;
+    private _topScope;
+    private _shouldPruneCb;
+    /** Construct an ElementSubTreeDeleter. @see pruneElementTree.
+     * @param iModel The iModel
+     * @param topElement Where to start the search.
+     * @param shouldPruneCb Callback that selects sub-trees that should be deleted.
+     */
+    constructor(iModel: IModelDb, topElement: Id64String, shouldPruneCb: ElementSubTreeDeleteFilter, scope?: ElementTreeWalkerScope);
+    protected shouldPrune(elementId: Id64String, scope: ElementTreeWalkerScope): boolean;
+    protected prune(elementId: Id64String, scope: ElementTreeWalkerScope): void;
+    /** Traverses the tree of elements, beginning with the top element, and deletes all selected sub-trees. */
+    pruneElementTree(): void;
+}
+/** Deletes an element tree starting with the specified top element. The top element is also deleted. Uses ElementTreeDeleter.
+ * @param iModel The iModel
+ * @param topElement The parent of the sub-tree
+ * @beta
+ */
+export declare function deleteElementTree(iModel: IModelDb, topElement: Id64String): void;
+/** Deletes all element sub-trees that are selected by the supplied filter. Uses ElementSubTreeDeleter.
+ * If the filter selects the top element itself, then the entire tree (including the top element) is deleted.
+ * That has the same effect as calling [[deleteElementTree]] on the top element.
+ * @param iModel The iModel
+ * @param topElement Where to start the search.
+ * @param filter Callback that selects sub-trees that should be deleted.
+ * @beta
+ */
+export declare function deleteElementSubTrees(iModel: IModelDb, topElement: Id64String, filter: ElementSubTreeDeleteFilter): void;
+export {};
+//# sourceMappingURL=ElementTreeWalker.d.ts.map

package/lib/cjs/ElementTreeWalker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementTreeWalker.d.ts","sourceRoot":"","sources":["../../src/ElementTreeWalker.ts"],"names":[],"mappings":"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"}

package/lib/cjs/ElementTreeWalker.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteElementSubTrees = exports.deleteElementTree = exports.ElementSubTreeDeleter = exports.ElementTreeDeleter = exports.ElementTreeBottomUp = exports.ElementTreeWalkerScope = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Elements
+ */
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_common_1 = require("@itwin/core-common");
+const BackendLoggerCategory_1 = require("./BackendLoggerCategory");
+const Category_1 = require("./Category");
+const Element_1 = require("./Element");
+const IModelDb_1 = require("./IModelDb");
+const Model_1 = require("./Model");
+const loggerCategory = `${BackendLoggerCategory_1.BackendLoggerCategory.IModelDb}.ElementTreeWalker`;
+function isModelEmpty(iModel, modelId) {
+    return iModel.withPreparedStatement(`select count(*) from ${Element_1.Element.classFullName} where Model.Id = ?`, (stmt) => {
+        stmt.bindId(1, modelId);
+        stmt.step();
+        return stmt.getValue(0).getInteger() === 0;
+    });
+}
+function isDefinitionModel(model) {
+    return (model.id !== core_common_1.IModel.repositoryModelId) && (model instanceof Model_1.DefinitionModel);
+}
+var ElementPruningClassification;
+(function (ElementPruningClassification) {
+    ElementPruningClassification[ElementPruningClassification["PRUNING_CLASS_Normal"] = 0] = "PRUNING_CLASS_Normal";
+    ElementPruningClassification[ElementPruningClassification["PRUNING_CLASS_Subject"] = 1] = "PRUNING_CLASS_Subject";
+    ElementPruningClassification[ElementPruningClassification["PRUNING_CLASS_Definition"] = 2] = "PRUNING_CLASS_Definition";
+    ElementPruningClassification[ElementPruningClassification["PRUNING_CLASS_DefinitionPartition"] = 3] = "PRUNING_CLASS_DefinitionPartition";
+})(ElementPruningClassification || (ElementPruningClassification = {}));
+function classifyElementForPruning(iModel, elementId) {
+    const el = iModel.elements.getElement(elementId);
+    return (el instanceof Element_1.Subject) ? ElementPruningClassification.PRUNING_CLASS_Subject :
+        (el instanceof Element_1.DefinitionElement) ? ElementPruningClassification.PRUNING_CLASS_Definition :
+            (el instanceof Element_1.DefinitionPartition) ? ElementPruningClassification.PRUNING_CLASS_DefinitionPartition :
+                ElementPruningClassification.PRUNING_CLASS_Normal;
+}
+/** Records the path that a tree search took to reach an element or model. This object is immutable.
+ * @beta
+ */
+class ElementTreeWalkerScope {
+    constructor(arg1, arg2) {
+        this.topElement = "";
+        /** path of parent elements and enclosing models */
+        this.path = [];
+        if (typeof arg1 === "string") {
+            // normal constructor
+            (0, core_bentley_1.assert)(arg2 instanceof Model_1.Model);
+            this.topElement = arg1;
+            this.path.push(this.enclosingModelInfo = { model: arg2, isDefinitionModel: isDefinitionModel(arg2) });
+        }
+        else if (arg1 instanceof ElementTreeWalkerScope) {
+            // copy-like constructor
+            this.topElement = arg1.topElement;
+            this.path = [...arg1.path];
+            if (typeof arg2 === "string") {
+                // with new parent
+                this.path.push(arg2);
+                this.enclosingModelInfo = arg1.enclosingModelInfo;
+            }
+            else {
+                // with new enclosing model
+                this.path.push(this.enclosingModelInfo = { model: arg2, isDefinitionModel: isDefinitionModel(arg2) });
+            }
+        }
+        else {
+            throw new Error("invalid constructor signature");
+        }
+    }
+    get enclosingModel() { return this.enclosingModelInfo.model; }
+    get inDefinitionModel() { return this.enclosingModelInfo.isDefinitionModel; } // NB: this will return false for the RepositoryModel!
+    get inRepositoryModel() { return this.enclosingModelInfo.model.id === IModelDb_1.IModelDb.repositoryModelId; }
+    static createTopScope(iModel, topElementId) {
+        const topElement = iModel.elements.getElement(topElementId);
+        const topElementModel = iModel.models.getModel(topElement.model);
+        return new ElementTreeWalkerScope(topElementId, topElementModel);
+    }
+    fmtItem(v) {
+        if (typeof v === "string")
+            return `element ${v}`;
+        return `model ${v.model.id} ${v.isDefinitionModel ? "(DEFN)" : ""}`;
+    }
+    toString() {
+        return `[ ${this.path.map((v) => this.fmtItem(v)).join(" / ")} ]`;
+    }
+}
+exports.ElementTreeWalkerScope = ElementTreeWalkerScope;
+function fmtElement(iModel, elementId) {
+    const el = iModel.elements.getElement(elementId);
+    return `${el.id} ${el.classFullName} ${el.code.value} ${el.getDisplayLabel()}`;
+}
+function fmtModel(model) {
+    return `${model.id} ${model.classFullName} ${model.name}`;
+}
+let isTraceEnabledChecked = -1;
+function isTraceEnabled() {
+    if (isTraceEnabledChecked === -1)
+        isTraceEnabledChecked = core_bentley_1.Logger.isEnabled(loggerCategory, core_bentley_1.LogLevel.Trace) ? 1 : 0;
+    return isTraceEnabledChecked === 1;
+}
+function logElement(op, iModel, elementId, scope) {
+    if (isTraceEnabled())
+        core_bentley_1.Logger.logTrace(loggerCategory, `${op} ${fmtElement(iModel, elementId)} ${scope === null || scope === void 0 ? void 0 : scope.toString()}`);
+}
+function logModel(op, iModel, modelId, scope) {
+    if (!isTraceEnabled())
+        return;
+    const model = iModel.models.getModel(modelId);
+    core_bentley_1.Logger.logTrace(loggerCategory, `${op} ${fmtModel(model)} ${scope === null || scope === void 0 ? void 0 : scope.toString()}`);
+}
+/** Does a depth-first search on the tree defined by an element and its sub-models and children.
+ * Sub-models are visited before their modeled elements, and children are visited before their parents.
+ *
+ * The following callbacks allow the subclass to exclude elements and sub-trees from the search:
+ *  * [[ElementTreeBottomUp.shouldExploreModel]], [[ElementTreeBottomUp.shouldExploreChildren]]
+ *  * [[ElementTreeBottomUp.shouldVisitElement]], [[ElementTreeBottomUp.shouldVisitModel]]
+ *
+ * The [[ElementTreeBottomUp.visitElement]] and [[ElementTreeBottomUp.visitModel]] callbacks allow
+ * the subclass to process the elements and models that are encountered in the search.
+ * @beta
+ */
+class ElementTreeBottomUp {
+    constructor(_iModel) {
+        this._iModel = _iModel;
+    }
+    /** Return true if the search should recurse into this model  */
+    shouldExploreModel(_model, _scope) { return true; }
+    /** Return true if the search should recurse into the children (if any) of this element  */
+    shouldExploreChildren(_parentId, _scope) { return true; }
+    /** Return true if the search should visit this element  */
+    shouldVisitElement(_elementId, _scope) { return true; }
+    /** Return true if the search should visit this model  */
+    shouldVisitModel(_model, _scope) { return true; }
+    /** The main tree-walking function */
+    processElementTree(element, scope) {
+        const subModel = this._iModel.models.tryGetModel(element);
+        if (subModel !== undefined) {
+            if (this.shouldExploreModel(subModel, scope))
+                this._processSubModel(subModel, scope);
+            if (this.shouldVisitModel(subModel, scope))
+                this.visitModel(subModel, scope);
+        }
+        if (this.shouldExploreChildren(element, scope))
+            this._processChildren(element, scope);
+        if (this.shouldVisitElement(element, scope))
+            this.visitElement(element, scope);
+    }
+    /** process the children of the specified parent element */
+    _processChildren(parentElement, parentScope) {
+        const children = this._iModel.elements.queryChildren(parentElement);
+        if (children.length === 0)
+            return;
+        const childrenScope = new ElementTreeWalkerScope(parentScope, parentElement);
+        for (const childElement of children)
+            this.processElementTree(childElement, childrenScope);
+    }
+    /** process the elements in the specified model */
+    _processSubModel(model, parenScope) {
+        const scope = new ElementTreeWalkerScope(parenScope, model);
+        // Visit only the top-level parents. processElementTree will visit their children (bottom-up).
+        model.iModel.withPreparedStatement(`select ECInstanceId from bis:Element where Model.id=? and Parent.Id is null`, (stmt) => {
+            stmt.bindId(1, model.id);
+            while (stmt.step() === core_bentley_1.DbResult.BE_SQLITE_ROW) {
+                const elementId = stmt.getValue(0).getId();
+                this.processElementTree(elementId, scope);
+            }
+        });
+    }
+}
+exports.ElementTreeBottomUp = ElementTreeBottomUp;
+/** Helper class that manages the deletion of definitions and subjects */
+class SpecialElements {
+    constructor() {
+        this.definitionModels = [];
+        this.definitions = [];
+        this.subjects = [];
+    }
+    recordSpecialElement(iModel, elementId) {
+        // Defer Definitions and Subjects
+        const cls = classifyElementForPruning(iModel, elementId);
+        if (cls === ElementPruningClassification.PRUNING_CLASS_Subject) {
+            this.subjects.push(elementId);
+            return true;
+        }
+        else if (cls === ElementPruningClassification.PRUNING_CLASS_Definition) {
+            this.definitions.push(elementId);
+            return true;
+        }
+        else if (cls === ElementPruningClassification.PRUNING_CLASS_DefinitionPartition) {
+            this.definitionModels.push(elementId);
+            return true;
+        }
+        return false; // not a special element
+    }
+    // It's dangerous to pass a mixture of SubCategories and Categories to deleteDefinitionElements.
+    // That function will delete the Categories first, which automatically deletes all their child
+    // SubCategories (in native code). If a SubCategory in the list is one of those children, then
+    // deleteDefinitionElements will try and fail with an exception to delete that SubCategory in a subsequent step.
+    // To work around this, we delete the SubCategories first, then everything else.
+    _siftSpecialElements(iModel) {
+        const subCategories = [];
+        const other = [];
+        this.definitions.forEach((elementId) => {
+            if (iModel.elements.tryGetElement(elementId, Category_1.SubCategory) !== undefined)
+                subCategories.push(elementId);
+            else
+                other.push(elementId);
+        });
+        return [subCategories, other];
+    }
+    deleteSpecialElements(iModel) {
+        for (const definitions of this._siftSpecialElements(iModel)) {
+            if (isTraceEnabled())
+                definitions.forEach((e) => logElement("try delete", iModel, e));
+            iModel.elements.deleteDefinitionElements(definitions); // will not deleted definitions that are still in use.
+        }
+        for (const m of this.definitionModels) {
+            if (!isModelEmpty(iModel, m)) {
+                logModel("Model not empty - cannot delete - may contain Definitions that are still in use", iModel, m);
+            }
+            else {
+                logModel("delete", iModel, m);
+                iModel.models.deleteModel(m);
+                iModel.elements.deleteElement(m);
+            }
+        }
+        for (const e of this.subjects) {
+            if (iModel.elements.queryChildren(e).length !== 0) {
+                logElement("Subject still has children - cannot delete - may have child DefinitionModels", iModel, e);
+            }
+            else {
+                logElement("delete", iModel, e);
+                iModel.elements.deleteElement(e);
+            }
+        }
+    }
+}
+/** Deletes an entire element tree, including sub-models and child elements.
+ * Items are deleted in bottom-up order. Definitions and Subjects are deleted after normal elements.
+ * @beta
+ */
+class ElementTreeDeleter extends ElementTreeBottomUp {
+    constructor(iModel, topElement, scope) {
+        super(iModel);
+        this._special = new SpecialElements();
+        this._topElement = topElement;
+        this._topScope = scope !== null && scope !== void 0 ? scope : ElementTreeWalkerScope.createTopScope(this._iModel, this._topElement);
+    }
+    shouldExploreModel(_model) { return true; }
+    shouldVisitElement(_elementId) { return true; }
+    visitModel(model, _scope) {
+        if (isDefinitionModel(model))
+            return; // we recorded definition models in visitElement when we encountered the DefinitionPartition elements.
+        // visitElement was called first, and it deleted the elements in the model. So, now it's safe to delete the model itself.
+        // TODO: will fail if model has an element that is sub-modeled by a **DefinitionModel**. I hope that never occurs!
+        logModel("delete", this._iModel, model.id, _scope);
+        model.delete();
+    }
+    visitElement(elementId, _scope) {
+        if (!this._special.recordSpecialElement(this._iModel, elementId)) {
+            logElement("delete", this._iModel, elementId, _scope);
+            this._iModel.elements.deleteElement(elementId);
+        }
+    }
+    /** Delete the element tree. */
+    deleteElementTree() {
+        this.processElementTree(this._topElement, this._topScope); // Delete the "normal" elements and record the special elements for deferred processing
+        this._special.deleteSpecialElements(this._iModel);
+    }
+}
+exports.ElementTreeDeleter = ElementTreeDeleter;
+/** Does a breadth-first search on the tree defined by an element and its sub-models and children.
+ * Parents are visited first, then children, then sub-models.
+ * The subclass can "prune" sub-trees from the search. When a sub-tree is "pruned" the search does *not* recurse into it.
+ * If a sub-tree is not pruned, then the search does recurse into it.
+ * @beta
+ */
+class ElementTreeTopDown {
+    constructor(_iModel) {
+        this._iModel = _iModel;
+    }
+    /** Should the search *not* recurse into this sub-tree? */
+    shouldPrune(_elementId, _scope) { return false; }
+    processElementTree(element, scope) {
+        if (this.shouldPrune(element, scope)) {
+            this.prune(element, scope);
+            return;
+        }
+        this._processChildren(element, scope);
+        const subModel = this._iModel.models.tryGetModel(element);
+        if (subModel !== undefined) {
+            this._processSubModel(subModel, scope);
+        }
+    }
+    _processChildren(element, scope) {
+        let parentScope;
+        for (const childElement of this._iModel.elements.queryChildren(element)) {
+            if (parentScope === undefined)
+                parentScope = new ElementTreeWalkerScope(scope, element);
+            this.processElementTree(childElement, parentScope);
+        }
+    }
+    _processSubModel(subModel, scope) {
+        const subModelScope = new ElementTreeWalkerScope(scope, subModel);
+        // Visit only the top-level parents. processElementTree will recurse into their children.
+        this._iModel.withPreparedStatement(`select ECInstanceId from bis:Element where Model.id=? and Parent.Id is null`, (stmt) => {
+            stmt.bindId(1, subModel.id);
+            while (stmt.step() === core_bentley_1.DbResult.BE_SQLITE_ROW) {
+                const elementId = stmt.getValue(0).getId();
+                this.processElementTree(elementId, subModelScope);
+            }
+        });
+    }
+}
+/** Deletes the element sub-trees that are chosen by a supplied filter function.
+ * This class uses ElementTreeTopDown to visit element sub-trees in top-down order.
+ * When the filter function chooses a sub-tree, this class uses ElementTreeDeleter to delete it.
+ * Note that when a sub-tree is selected and deleted, its children and sub-models are not visited.
+ * @beta
+ */
+class ElementSubTreeDeleter extends ElementTreeTopDown {
+    /** Construct an ElementSubTreeDeleter. @see pruneElementTree.
+     * @param iModel The iModel
+     * @param topElement Where to start the search.
+     * @param shouldPruneCb Callback that selects sub-trees that should be deleted.
+     */
+    constructor(iModel, topElement, shouldPruneCb, scope) {
+        super(iModel);
+        this._special = new SpecialElements();
+        this._topElement = topElement;
+        this._topScope = scope !== null && scope !== void 0 ? scope : ElementTreeWalkerScope.createTopScope(this._iModel, this._topElement);
+        this._shouldPruneCb = shouldPruneCb;
+    }
+    shouldPrune(elementId, scope) { return this._shouldPruneCb(elementId, scope); }
+    prune(elementId, scope) {
+        if (!this._special.recordSpecialElement(this._iModel, elementId)) {
+            const del = new ElementTreeDeleter(this._iModel, elementId, scope);
+            del.deleteElementTree();
+        }
+    }
+    /** Traverses the tree of elements, beginning with the top element, and deletes all selected sub-trees. */
+    pruneElementTree() {
+        this.processElementTree(this._topElement, this._topScope); // deletes normal elements and their sub-trees, defers special elements
+        this._special.deleteSpecialElements(this._iModel);
+    }
+}
+exports.ElementSubTreeDeleter = ElementSubTreeDeleter;
+/** Deletes an element tree starting with the specified top element. The top element is also deleted. Uses ElementTreeDeleter.
+ * @param iModel The iModel
+ * @param topElement The parent of the sub-tree
+ * @beta
+ */
+function deleteElementTree(iModel, topElement) {
+    const del = new ElementTreeDeleter(iModel, topElement);
+    del.deleteElementTree();
+}
+exports.deleteElementTree = deleteElementTree;
+/** Deletes all element sub-trees that are selected by the supplied filter. Uses ElementSubTreeDeleter.
+ * If the filter selects the top element itself, then the entire tree (including the top element) is deleted.
+ * That has the same effect as calling [[deleteElementTree]] on the top element.
+ * @param iModel The iModel
+ * @param topElement Where to start the search.
+ * @param filter Callback that selects sub-trees that should be deleted.
+ * @beta
+ */
+function deleteElementSubTrees(iModel, topElement, filter) {
+    const del = new ElementSubTreeDeleter(iModel, topElement, filter);
+    del.pruneElementTree();
+}
+exports.deleteElementSubTrees = deleteElementSubTrees;
+//# sourceMappingURL=ElementTreeWalker.js.map