@itwin/imodel-transformer 2.0.0-dev.72 → 2.0.0-dev.74

package/lib/{cjs/IModelTransformer.js → IModelTransformer.js}

@@ -1,39 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateModelCloner = exports.IModelTransformer = void 0;
 /*---------------------------------------------------------------------------------------------
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -41,73 +5,62 @@ exports.TemplateModelCloner = exports.IModelTransformer = void 0;
 /** @packageDocumentation
  * @module iModels
  */
-const path = __importStar(require("node:path"));
-const Semver = __importStar(require("semver"));
-const node_assert_1 = require("node:assert");
-const core_bentley_1 = require("@itwin/core-bentley");
-const ECSchemaMetaData = __importStar(require("@itwin/ecschema-metadata"));
-const core_geometry_1 = require("@itwin/core-geometry");
-const core_backend_1 = require("@itwin/core-backend");
-const core_common_1 = require("@itwin/core-common");
-const IModelExporter_1 = require("./IModelExporter");
-const IModelImporter_1 = require("./IModelImporter");
-const TransformerLoggerCategory_1 = require("./TransformerLoggerCategory");
-const IModelCloneContext_1 = require("./IModelCloneContext");
-const Algo_1 = require("./Algo");
-const SyncTypeResolver_1 = require("./SyncTypeResolver");
-const ProvenanceManager_1 = require("./ProvenanceManager");
-const SchemaProcessingStrategy_1 = require("./schema-processing/SchemaProcessingStrategy");
-const SchemaProcessingCoordinator_1 = require("./schema-processing/SchemaProcessingCoordinator");
-const ChangesetScanner_1 = require("./ChangesetScanner");
-const IModelTransformerError_1 = require("./IModelTransformerError");
-const loggerCategory = TransformerLoggerCategory_1.TransformerLoggerCategory.IModelTransformer;
+import * as path from "node:path";
+import * as Semver from "semver";
+import { strict as nodeAssert } from "node:assert";
+import { assert, Guid, Id64, IModelStatus, ITwinError, Logger, } from "@itwin/core-bentley";
+import * as ECSchemaMetaData from "@itwin/ecschema-metadata";
+import { Angle, AxisIndex, Matrix3d, Point3d, Transform, Vector3d, } from "@itwin/core-geometry";
+import { BriefcaseManager, ChangeSummaryManager, ChannelRootAspect, DefinitionElement, DefinitionModel, DefinitionPartition, EditTxn, 
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+Element, ElementRefersToElements, EntityReferences, ExternalSourceAspect, GeometricElement, GeometricElement3d, IModelDb, IModelHost, InformationPartitionElement, KnownLocations, RecipeDefinitionElement, Schema, Subject, } from "@itwin/core-backend";
+import { Code, ConcreteEntityTypes, ECJsNames, IModel, IModelError, Placement2d, Placement3d, QueryBinder, } from "@itwin/core-common";
+import { ChangedInstanceIds, IModelExporter, IModelExportHandler, } from "./IModelExporter.js";
+import { IModelImporter } from "./IModelImporter.js";
+import { TransformerLoggerCategory } from "./TransformerLoggerCategory.js";
+import { IModelCloneContext } from "./IModelCloneContext.js";
+import { rangesFromRangeAndSkipped } from "./Algo.js";
+import { SyncTypeResolver } from "./SyncTypeResolver.js";
+import { ProvenanceManager } from "./ProvenanceManager.js";
+import { NewerVersionSchemaImportStrategy, } from "./schema-processing/SchemaProcessingStrategy.js";
+import { SchemaProcessingCoordinator } from "./schema-processing/SchemaProcessingCoordinator.js";
+import { ChangesetScanner, } from "./ChangesetScanner.js";
+import { IModelTransformerError, IModelTransformerErrorScope, } from "./IModelTransformerError.js";
+const loggerCategory = TransformerLoggerCategory.IModelTransformer;
 /** Key of a relationship's source and target element ids. */
 function relationshipEndpointsKey(sourceId, targetId) {
     return `${sourceId}|${targetId}`;
 }
 /**
- * Apply a function to each Id64 in a supported container type of Id64s.
- * Currently only supports raw Id64String or RelatedElement-like objects containing an `id` property that is a Id64String,
- * which matches the possible containers of references in [Element.requiredReferenceKeys]($backend).
+ * Get the Id64 held by a required reference.
+ * [Element.requiredReferenceKeys]($backend) hold either a raw Id64String or a RelatedElement-like object with an `id` property.
  * @internal
  */
-function mapId64(idContainer, func) {
-    const isId64String = (arg) => {
-        const isString = typeof arg === "string";
-        (0, core_bentley_1.assert)(() => !isString || core_bentley_1.Id64.isValidId64(arg));
-        return isString;
-    };
-    const isRelatedElem = (arg) => arg && typeof arg === "object" && "id" in arg;
-    const results = [];
-    // is a string if compressed or singular id64, but check for singular just checks if it's a string so do this test first
-    if (idContainer === undefined) {
-        // nothing
-    }
-    else if (isId64String(idContainer)) {
-        results.push(func(idContainer));
-    }
-    else if (isRelatedElem(idContainer)) {
-        results.push(func(idContainer.id));
-    }
-    else {
-        core_bentley_1.ITwinError.throwError({
-            iTwinErrorId: {
-                scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                key: IModelTransformerError_1.IModelTransformerError.InvalidEntityReference,
-            },
-            message: [
-                `Id64 container '${JSON.stringify(idContainer)}' is unsupported.`,
-                "Currently only singular Id64 strings or prop-like objects containing an 'id' property are supported.",
-            ].join("\n"),
-        });
-    }
-    return results;
+function requiredReferenceId(idContainer) {
+    if (idContainer === undefined)
+        return undefined;
+    if (typeof idContainer === "string") {
+        assert(() => Id64.isValidId64(idContainer));
+        return idContainer;
+    }
+    if (idContainer && typeof idContainer === "object" && "id" in idContainer)
+        return idContainer.id;
+    ITwinError.throwError({
+        iTwinErrorId: {
+            scope: IModelTransformerErrorScope,
+            key: IModelTransformerError.InvalidEntityReference,
+        },
+        message: [
+            `Id64 container '${JSON.stringify(idContainer)}' is unsupported.`,
+            "Currently only singular Id64 strings or prop-like objects containing an 'id' property are supported.",
+        ].join("\n"),
+    });
 }
 /** Base class used to transform a source iModel into a different target iModel.
  * @see [iModel Transformation and Data Exchange]($docs/learning/transformer/index.md), [IModelExporter]($transformer), [IModelImporter]($transformer)
  * @beta
  */
-class IModelTransformer extends IModelExporter_1.IModelExportHandler {
+export class IModelTransformer extends IModelExportHandler {
     /** The IModelExporter that will export from the source iModel. */
     exporter;
     _schemaProcessingCoordinator;
@@ -176,11 +129,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     _isProvenanceInitTransform;
     /** The element classes that are considered to define provenance in the iModel */
     static get provenanceElementClasses() {
-        return ProvenanceManager_1.ProvenanceManager.provenanceElementClasses;
+        return ProvenanceManager.provenanceElementClasses;
     }
     /** The element aspect classes that are considered to define provenance in the iModel */
     static get provenanceElementAspectClasses() {
-        return ProvenanceManager_1.ProvenanceManager.provenanceElementAspectClasses;
+        return ProvenanceManager.provenanceElementAspectClasses;
     }
     /** Construct a new IModelTransformer
      * @param args The required arguments including source and target.
@@ -194,23 +147,23 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             ...options,
             // non-falsy defaults
             cloneUsingBinaryGeometry: options?.cloneUsingBinaryGeometry ?? true,
-            targetScopeElementId: options?.targetScopeElementId ?? core_common_1.IModel.rootSubjectId,
+            targetScopeElementId: options?.targetScopeElementId ?? IModel.rootSubjectId,
             danglingReferencesBehavior: options?.danglingReferencesBehavior ?? "reject",
             branchRelationshipDataBehavior: options?.branchRelationshipDataBehavior ?? "reject",
             skipPropagateChangesToRootElements: options?.skipPropagateChangesToRootElements ?? true,
             tryAlignGeolocation: options?.tryAlignGeolocation ?? false,
         };
         // check if authorization client is defined
-        if (core_backend_1.IModelHost.authorizationClient === undefined) {
-            core_bentley_1.Logger.logWarning(loggerCategory, "Authorization client is not set in IModelHost. If the transformer needs an accessToken, then it will fail.");
+        if (IModelHost.authorizationClient === undefined) {
+            Logger.logWarning(loggerCategory, "Authorization client is not set in IModelHost. If the transformer needs an accessToken, then it will fail.");
         }
         this._isProvenanceInitTransform = this._options
             .wasSourceIModelCopiedToTarget
             ? true
             : undefined;
         // initialize exporter and sourceDb
-        if (source instanceof core_backend_1.IModelDb) {
-            this.exporter = new IModelExporter_1.IModelExporter(source);
+        if (source instanceof IModelDb) {
+            this.exporter = new IModelExporter(source);
         }
         else {
             this.exporter = source;
@@ -223,11 +176,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             IModelTransformer.provenanceElementClasses.forEach((cls) => this.exporter.excludeElementClass(cls.classFullName));
             IModelTransformer.provenanceElementAspectClasses.forEach((cls) => this.exporter.excludeElementAspectClass(cls.classFullName));
         }
-        this.exporter.excludeElementAspectClass(core_backend_1.ChannelRootAspect.classFullName); // Channel boundaries within the source iModel are not relevant to the target iModel
+        this.exporter.excludeElementAspectClass(ChannelRootAspect.classFullName); // Channel boundaries within the source iModel are not relevant to the target iModel
         this.exporter.excludeElementAspectClass("BisCore:TextAnnotationData"); // This ElementAspect is auto-created by the BisCore:TextAnnotation2d/3d element handlers
         // initialize importer and targetDb
-        if (target instanceof core_backend_1.EditTxn) {
-            this.importer = new IModelImporter_1.IModelImporter(target, {
+        if (target instanceof EditTxn) {
+            this.importer = new IModelImporter(target, {
                 preserveElementIdsForFiltering: this._options.preserveElementIdsForFiltering,
                 skipPropagateChangesToRootElements: this._options.skipPropagateChangesToRootElements,
             });
@@ -239,7 +192,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         this.targetDb = this.importer.targetDb;
         this._targetEditTxn = this.importer.editTxn;
         this._sourceEditTxn = options?.sourceEditTxn;
-        this._schemaProcessingCoordinator = new SchemaProcessingCoordinator_1.SchemaProcessingCoordinator({
+        this._schemaProcessingCoordinator = new SchemaProcessingCoordinator({
             exporter: this.exporter,
             targetDb: this.targetDb,
             getSchemaExportDirectory: () => this._schemaExportDir,
@@ -248,24 +201,24 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         });
         this.exporter.elementAspectExportCoordinator.setPreparation(async (excludedClasses, elementIds) => this.prepareElementAspects(excludedClasses, elementIds));
         // create the IModelCloneContext, it must be initialized later
-        this._cloneContext = new IModelCloneContext_1.IModelCloneContext(this.sourceDb, this.targetDb);
+        this._cloneContext = new IModelCloneContext(this.sourceDb, this.targetDb);
         this.importer.registerEntityExistenceCache(this._cloneContext.existenceCache);
         this.setCodeValueBehavior("exact");
-        this._syncTypeResolver = new SyncTypeResolver_1.SyncTypeResolver(this.sourceDb, this.targetDb, this._options.targetScopeElementId, !!this._isProvenanceInitTransform, !!this._options.argsForProcessChanges);
-        this._provenanceManager = new ProvenanceManager_1.ProvenanceManager(this._options.targetScopeElementId, this._options, this._cloneContext, this._syncTypeResolver, this._targetEditTxn, this._sourceEditTxn);
+        this._syncTypeResolver = new SyncTypeResolver(this.sourceDb, this.targetDb, this._options.targetScopeElementId, !!this._isProvenanceInitTransform, !!this._options.argsForProcessChanges);
+        this._provenanceManager = new ProvenanceManager(this._options.targetScopeElementId, this._options, this._cloneContext, this._syncTypeResolver, this._targetEditTxn, this._sourceEditTxn);
         if (this._options.tryAlignGeolocation) {
             if (this.sourceDb.geographicCoordinateSystem ||
                 this.targetDb.geographicCoordinateSystem) {
-                core_bentley_1.Logger.logTrace(loggerCategory, "Aligning Additional transforms between imodels due to imodels containing GeographicCoordinateSystem data");
+                Logger.logTrace(loggerCategory, "Aligning Additional transforms between imodels due to imodels containing GeographicCoordinateSystem data");
                 this._linearSpatialTransform =
                     this.calculateTransformFromHelmertTransforms();
             }
             else if (this.sourceDb.ecefLocation && this.targetDb.ecefLocation) {
-                core_bentley_1.Logger.logTrace(loggerCategory, "Aligning ECEF Location's between imodels due to imodels not containing GeographicCoordinateSystem data");
+                Logger.logTrace(loggerCategory, "Aligning ECEF Location's between imodels due to imodels not containing GeographicCoordinateSystem data");
                 this._linearSpatialTransform = this.calculateEcefTransform();
             }
             else
-                core_bentley_1.Logger.logTrace(loggerCategory, "No Geolcation data to align, both GCS and ECEF are undefined");
+                Logger.logTrace(loggerCategory, "No Geolcation data to align, both GCS and ECEF are undefined");
         }
     }
     /** validates that the importer set on the transformer has the same values for its shared options as the transformer.
@@ -274,20 +227,20 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     validateSharedOptionsMatch() {
         if (Boolean(this._options.preserveElementIdsForFiltering) !==
             this.importer.options.preserveElementIdsForFiltering) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.ImporterOptionMismatch,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.ImporterOptionMismatch,
                 },
                 message: "A custom importer was passed as a target but its 'preserveElementIdsForFiltering' option is out of sync with the transformer's option.",
             });
         }
         if (Boolean(this._options.skipPropagateChangesToRootElements) !==
             this.importer.options.skipPropagateChangesToRootElements) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.ImporterOptionMismatch,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.ImporterOptionMismatch,
                 },
                 message: "A custom importer was passed as a target but its 'skipPropagateChangesToRootElements' option is out of sync with the transformer's option.",
             });
@@ -295,25 +248,25 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     }
     /** Dispose any native resources associated with this IModelTransformer. */
     dispose() {
-        core_bentley_1.Logger.logTrace(loggerCategory, "dispose()");
+        Logger.logTrace(loggerCategory, "dispose()");
         this.importer.unregisterEntityExistenceCache(this._cloneContext.existenceCache);
         this._cloneContext.existenceCache.clear();
         this._cloneContext[Symbol.dispose]();
     }
     /** Log current settings that affect IModelTransformer's behavior. */
     logSettings() {
-        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelExporter, `this.exporter.visitElements=${this.exporter.visitElements}`);
-        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelExporter, `this.exporter.visitRelationships=${this.exporter.visitRelationships}`);
-        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelExporter, `this.exporter.wantGeometry=${this.exporter.wantGeometry}`);
-        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelExporter, `this.exporter.wantSystemSchemas=${this.exporter.wantSystemSchemas}`);
-        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelExporter, `this.exporter.wantTemplateModels=${this.exporter.wantTemplateModels}`);
-        core_bentley_1.Logger.logInfo(loggerCategory, `this.targetScopeElementId=${this.targetScopeElementId}`);
-        core_bentley_1.Logger.logInfo(loggerCategory, `this._noProvenance=${this._options.noProvenance}`);
-        core_bentley_1.Logger.logInfo(loggerCategory, `this._includeSourceProvenance=${this._options.includeSourceProvenance}`);
-        core_bentley_1.Logger.logInfo(loggerCategory, `this._cloneUsingBinaryGeometry=${this._options.cloneUsingBinaryGeometry}`);
-        core_bentley_1.Logger.logInfo(loggerCategory, `this._wasSourceIModelCopiedToTarget=${this._options.wasSourceIModelCopiedToTarget}`);
-        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelImporter, `this.importer.autoExtendProjectExtents=${JSON.stringify(this.importer.options.autoExtendProjectExtents)}`);
-        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelImporter, `this.importer.simplifyElementGeometry=${this.importer.options.simplifyElementGeometry}`);
+        Logger.logInfo(TransformerLoggerCategory.IModelExporter, `this.exporter.visitElements=${this.exporter.visitElements}`);
+        Logger.logInfo(TransformerLoggerCategory.IModelExporter, `this.exporter.visitRelationships=${this.exporter.visitRelationships}`);
+        Logger.logInfo(TransformerLoggerCategory.IModelExporter, `this.exporter.wantGeometry=${this.exporter.wantGeometry}`);
+        Logger.logInfo(TransformerLoggerCategory.IModelExporter, `this.exporter.wantSystemSchemas=${this.exporter.wantSystemSchemas}`);
+        Logger.logInfo(TransformerLoggerCategory.IModelExporter, `this.exporter.wantTemplateModels=${this.exporter.wantTemplateModels}`);
+        Logger.logInfo(loggerCategory, `this.targetScopeElementId=${this.targetScopeElementId}`);
+        Logger.logInfo(loggerCategory, `this._noProvenance=${this._options.noProvenance}`);
+        Logger.logInfo(loggerCategory, `this._includeSourceProvenance=${this._options.includeSourceProvenance}`);
+        Logger.logInfo(loggerCategory, `this._cloneUsingBinaryGeometry=${this._options.cloneUsingBinaryGeometry}`);
+        Logger.logInfo(loggerCategory, `this._wasSourceIModelCopiedToTarget=${this._options.wasSourceIModelCopiedToTarget}`);
+        Logger.logInfo(TransformerLoggerCategory.IModelImporter, `this.importer.autoExtendProjectExtents=${JSON.stringify(this.importer.options.autoExtendProjectExtents)}`);
+        Logger.logInfo(TransformerLoggerCategory.IModelImporter, `this.importer.simplifyElementGeometry=${this.importer.options.simplifyElementGeometry}`);
     }
     /**
      * Previously the transformer would insert provenance always pointing to the "target" relationship.
@@ -394,34 +347,34 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @note This can be called more than once for an element in arbitrary order, so it should not have side-effects.
      */
     async onTransformElement(sourceElement) {
-        core_bentley_1.Logger.logTrace(loggerCategory, `onTransformElement(${sourceElement.id}) "${sourceElement.getDisplayLabel()}"`);
+        Logger.logTrace(loggerCategory, `onTransformElement(${sourceElement.id}) "${sourceElement.getDisplayLabel()}"`);
         const targetElementProps = await this._cloneContext.cloneElement(sourceElement, {
             binaryGeometry: this._options.cloneUsingBinaryGeometry,
         });
         // Special case: source element is the root subject
-        if (sourceElement.id === core_common_1.IModel.rootSubjectId) {
+        if (sourceElement.id === IModel.rootSubjectId) {
             const targetElementId = this.context.findTargetElementId(sourceElement.id);
             // When remapping rootSubject from source to non root subject in target, the code.scope gets remapped incorrectly.
             // This is because the rootSubject has no parent and its code.scope is unique in that it is the id of itself.
             // For all other subjects which do have parents the code.scope and its parent should be in agreement.
-            if (targetElementId !== core_bentley_1.Id64.invalid &&
-                targetElementId !== core_common_1.IModel.rootSubjectId) {
+            if (targetElementId !== Id64.invalid &&
+                targetElementId !== IModel.rootSubjectId) {
                 const targetElement = this.targetDb.elements.getElement(targetElementId);
                 targetElementProps.parent =
                     targetElement.parent ?? targetElementProps.parent;
                 targetElementProps.code.scope = targetElement.code.scope;
             }
         }
-        if (sourceElement instanceof core_backend_1.Subject) {
+        if (sourceElement instanceof Subject) {
             if (targetElementProps.jsonProperties?.Subject?.Job) {
                 // don't propagate source channels into target (legacy bridge case)
                 targetElementProps.jsonProperties.Subject.Job = undefined;
             }
         }
         if (this._linearSpatialTransform !== undefined &&
-            sourceElement instanceof core_backend_1.GeometricElement3d) {
+            sourceElement instanceof GeometricElement3d) {
             // can check the sourceElement since this IModelTransformer does not remap classes
-            const placement = core_common_1.Placement3d.fromJSON(targetElementProps.placement);
+            const placement = Placement3d.fromJSON(targetElementProps.placement);
             if (placement.isValid) {
                 placement.multiplyTransform(this._linearSpatialTransform);
                 targetElementProps.placement = placement;
@@ -440,25 +393,25 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const srcEcefLoc = this.sourceDb.ecefLocation;
         const targetEcefLoc = this.targetDb.ecefLocation;
         if (srcEcefLoc === undefined || targetEcefLoc === undefined) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.GeolocationUnavailable,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.GeolocationUnavailable,
                 },
                 message: "Both source and target ECEF locations must be defined to calculate the transform.",
             });
         }
         if (srcEcefLoc.getTransform().isAlmostEqual(targetEcefLoc.getTransform())) {
-            core_bentley_1.Logger.logTrace(loggerCategory, "ECEF data is already aligned. No spatial transforms needed.");
+            Logger.logTrace(loggerCategory, "ECEF data is already aligned. No spatial transforms needed.");
             return undefined;
         }
         const srcSpatialToECEF = srcEcefLoc.getTransform(); // converts relative to ECEF in relation to source
         const targetECEFToSpatial = targetEcefLoc.getTransform().inverse(); // converts ECEF to relative in relation to target
         if (!targetECEFToSpatial) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.GeolocationUnavailable,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.GeolocationUnavailable,
                 },
                 message: "Failed to invert target ECEF transform.",
             });
@@ -468,48 +421,48 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     }
     static convertHelmertToTransform(helmert) {
         if (!helmert) {
-            return core_geometry_1.Transform.createIdentity();
+            return Transform.createIdentity();
         }
-        const rotationXY = core_geometry_1.Matrix3d.createRotationAroundAxisIndex(core_geometry_1.AxisIndex.Z, core_geometry_1.Angle.createDegrees(helmert?.rotDeg));
+        const rotationXY = Matrix3d.createRotationAroundAxisIndex(AxisIndex.Z, Angle.createDegrees(helmert?.rotDeg));
         rotationXY.scaleColumnsInPlace(helmert.scale, helmert.scale, 1.0);
-        const translation = core_geometry_1.Vector3d.create(helmert.translationX, helmert.translationY, helmert.translationZ);
-        const helmertTransform = core_geometry_1.Transform.createRefs(translation, rotationXY);
+        const translation = Vector3d.create(helmert.translationX, helmert.translationY, helmert.translationZ);
+        const helmertTransform = Transform.createRefs(translation, rotationXY);
         return helmertTransform;
     }
     calculateTransformFromHelmertTransforms() {
         if (this.sourceDb.geographicCoordinateSystem?.horizontalCRS === undefined ||
             this.sourceDb.geographicCoordinateSystem?.verticalCRS === undefined) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.GeographicCoordinateSystemUnavailable,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.GeographicCoordinateSystemUnavailable,
                 },
                 message: "Source iModel does not have a geographic coordinate system defined.",
             });
         }
         if (this.targetDb.geographicCoordinateSystem?.horizontalCRS === undefined ||
             this.targetDb.geographicCoordinateSystem.verticalCRS === undefined) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.GeographicCoordinateSystemUnavailable,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.GeographicCoordinateSystemUnavailable,
                 },
                 message: "Target iModel does not have a geographic coordinate system defined.",
             });
         }
         if (!this.sourceDb.geographicCoordinateSystem.horizontalCRS.equals(this.targetDb.geographicCoordinateSystem.horizontalCRS) ||
             !this.sourceDb.geographicCoordinateSystem.verticalCRS.equals(this.targetDb.geographicCoordinateSystem.verticalCRS)) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.GeographicCoordinateSystemMismatch,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.GeographicCoordinateSystemMismatch,
                 },
                 message: "Source and target geographic coordinate systems must match to calculate the spatial transform.",
             });
         }
         if (this.sourceDb.geographicCoordinateSystem.additionalTransform ===
             this.targetDb.geographicCoordinateSystem.additionalTransform) {
-            core_bentley_1.Logger.logTrace(loggerCategory, "Geolocation data is already aligned. No spatial transforms needed.");
+            Logger.logTrace(loggerCategory, "Geolocation data is already aligned. No spatial transforms needed.");
             return undefined;
         }
         const srcScale = this.sourceDb.geographicCoordinateSystem.additionalTransform
@@ -517,10 +470,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const targetScale = this.targetDb.geographicCoordinateSystem.additionalTransform
             ?.helmert2DWithZOffset?.scale ?? 1;
         if (srcScale !== targetScale) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.GeographicCoordinateSystemMismatch,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.GeographicCoordinateSystemMismatch,
                 },
                 message: "Spatial transform is non rigid. Source and target Helmert transforms must have the same scale to calculate a rigid spatial transform.",
             });
@@ -530,10 +483,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const targetTransformInv = IModelTransformer.convertHelmertToTransform(this.targetDb.geographicCoordinateSystem.additionalTransform
             ?.helmert2DWithZOffset).inverse(); // negates target helmert transform that is applied at render time
         if (!targetTransformInv) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.GeolocationUnavailable,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.GeolocationUnavailable,
                 },
                 message: "Failed to invert target Helmert transform.",
             });
@@ -549,6 +502,26 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * A source relationship deleted and recreated with the same endpoints maps to the same target relationship, which must not be deleted.
      */
     _reimportedTargetRelationshipIds = new Set();
+    /** Same-iModel only: whether elements of an ECClassId are non-recipe DefinitionElements that are reused in place. */
+    _sameIModelReusableDefinitionClasses = new Map();
+    isSameIModelReusableDefinition(elementId) {
+        // Reading ECClassId through a cached SQLite statement avoids loading the whole referenced element.
+        // bis_Element holds every element, and the primary connection sees uncommitted inserts.
+        const classId = this.sourceDb.withPreparedSqliteStatement("SELECT ECClassId FROM bis_Element WHERE Id=?", (stmt) => {
+            stmt.bindId(1, elementId);
+            return stmt.nextRow() ? stmt.getValueId(0) : undefined;
+        });
+        if (classId === undefined)
+            return false;
+        let isReusable = this._sameIModelReusableDefinitionClasses.get(classId);
+        if (isReusable === undefined) {
+            // Class inheritance needs EC metadata, so classify each class once in ECSQL.
+            isReusable = this.sourceDb.withQueryReader(`SELECT 1 FROM ${DefinitionElement.classFullName}
+         WHERE ECInstanceId=? AND ECClassId IS NOT (${RecipeDefinitionElement.classFullName})`, (reader) => reader.step(), QueryBinder.from([elementId]));
+            this._sameIModelReusableDefinitionClasses.set(classId, isReusable);
+        }
+        return isReusable;
+    }
     /** Returns true if a change within sourceElement is detected.
      * @param sourceElement The Element from the source iModel
      * @note A subclass can override this method to provide custom change detection behavior.
@@ -570,7 +543,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 wantBRepData: this.exporter.wantGeometry,
             });
             const targetId = this.context.findTargetElementId(sourceElementId);
-            if (core_bentley_1.Id64.isInvalid(targetId)) {
+            if (Id64.isInvalid(targetId)) {
                 throw new Error(`source-target element mapping not found for element "${sourceElementId}" when completing partially committed elements. This is a bug.`);
             }
             const targetProps = await this.onTransformElement(sourceElement);
@@ -581,7 +554,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         for (const sourceAspectId of this._partiallyCommittedAspectIds) {
             const sourceAspect = this.sourceDb.elements.getAspect(sourceAspectId);
             const targetAspectId = this.context.findTargetAspectId(sourceAspectId);
-            if (core_bentley_1.Id64.isInvalid(targetAspectId)) {
+            if (Id64.isInvalid(targetAspectId)) {
                 throw new Error(`source-target aspect mapping not found for aspect "${sourceAspectId}" when completing partially committed aspects. This is a bug.`);
             }
             const targetAspectProps = await this.onTransformElementAspect(sourceAspect);
@@ -597,20 +570,20 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     markSourceEntityExists(entity) {
         if (this._options.danglingReferencesBehavior !== "reject")
             return;
-        this._cloneContext.existenceCache.markExists(this.sourceDb, core_backend_1.EntityReferences.from(entity));
+        this._cloneContext.existenceCache.markExists(this.sourceDb, EntityReferences.from(entity));
     }
     async doAllReferencesExistInTarget(entity) {
         let allReferencesExist = true;
         const checkedReferences = [];
         for (const referenceId of entity.getReferenceIds()) {
-            const referencedEntityId = core_backend_1.EntityReferences.toId64(referenceId);
-            if (referencedEntityId === core_common_1.IModel.repositoryModelId ||
-                referencedEntityId === core_common_1.IModel.dictionaryId ||
+            const referencedEntityId = EntityReferences.toId64(referenceId);
+            if (referencedEntityId === IModel.repositoryModelId ||
+                referencedEntityId === IModel.dictionaryId ||
                 referencedEntityId === "0xe") {
                 continue;
             }
             if (allReferencesExist &&
-                !core_backend_1.EntityReferences.isValid(await this.context.findTargetEntityId(referenceId))) {
+                !EntityReferences.isValid(await this.context.findTargetEntityId(referenceId))) {
                 // if we care about references existing then we cannot return early and must check all other references.
                 if (this._options.danglingReferencesBehavior === "ignore") {
                     return false;
@@ -633,10 +606,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const found = await this._cloneContext.existenceCache.existsAll(this.sourceDb, referenceIds);
         for (const referenceId of referenceIds) {
             if (!found.has(referenceId)) {
-                core_bentley_1.ITwinError.throwError({
+                ITwinError.throwError({
                     iTwinErrorId: {
-                        scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                        key: IModelTransformerError_1.IModelTransformerError.DanglingReference,
+                        scope: IModelTransformerErrorScope,
+                        key: IModelTransformerError.DanglingReference,
                     },
                     message: [
                         `Found a reference to an element "${referenceId}" that doesn't exist while looking for references of "${entity.id}".`,
@@ -655,11 +628,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      */
     async processElement(sourceElementId) {
         await this.initialize();
-        if (sourceElementId === core_common_1.IModel.rootSubjectId) {
-            core_bentley_1.ITwinError.throwError({
+        if (sourceElementId === IModel.rootSubjectId) {
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.RootSubjectNotProcessable,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.RootSubjectNotProcessable,
                 },
                 message: "The root Subject should not be directly imported",
             });
@@ -690,49 +663,38 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      */
     async preExportElement(sourceElement) {
         if (!this.hasElementChanged(sourceElement)) {
-            core_bentley_1.Logger.logTrace(loggerCategory, `Skipping unchanged element (${sourceElement.id}, ${sourceElement.getDisplayLabel()}).`);
+            Logger.logTrace(loggerCategory, `Skipping unchanged element (${sourceElement.id}, ${sourceElement.getDisplayLabel()}).`);
             return;
         }
         const elemClass = sourceElement.constructor;
-        const unresolvedReferences = elemClass.requiredReferenceKeys
-            .map((referenceKey) => {
-            const idContainer = sourceElement.asAny[referenceKey];
-            const referenceType = elemClass.requiredReferenceKeyTypeMap[referenceKey];
+        const unresolvedReferences = [];
+        for (const referenceKey of elemClass.requiredReferenceKeys) {
             // For now we just consider all required references to be elements (as they are in biscore), and do not support
             // entities that refuse to be inserted without a different kind of entity (e.g. aspect or relationship) first being inserted
-            (0, core_bentley_1.assert)(referenceType === core_common_1.ConcreteEntityTypes.Element ||
-                referenceType === core_common_1.ConcreteEntityTypes.Model);
-            return mapId64(idContainer, (id) => {
-                if (id === core_bentley_1.Id64.invalid || id === core_common_1.IModel.rootSubjectId)
-                    return undefined; // not allowed to directly export the root subject
-                if (!this.context.isBetweenIModels) {
-                    // Within the same iModel, can use existing DefinitionElements without remapping
-                    // This is relied upon by the TemplateModelCloner
-                    // TODO: extract this out to only be in the TemplateModelCloner
-                    const asDefinitionElem = this.sourceDb.elements.tryGetElement(id, core_backend_1.DefinitionElement);
-                    if (asDefinitionElem &&
-                        !(asDefinitionElem instanceof core_backend_1.RecipeDefinitionElement)) {
-                        this.context.remapElement(id, id);
-                    }
-                }
-                return id;
-            }).filter((sourceReferenceId) => {
-                if (sourceReferenceId === undefined)
-                    return false;
-                const referenceInTargetId = this.context.findTargetElementId(sourceReferenceId);
-                const isInTarget = core_bentley_1.Id64.isValid(referenceInTargetId);
-                return !isInTarget;
-            });
-        })
-            .flat();
-        if (unresolvedReferences.length > 0) {
-            for (const reference of unresolvedReferences) {
-                const processState = await this.getElemTransformState(reference);
-                if (processState.needsElemImport)
-                    await this.resolveRequiredElement(sourceElement.id, reference);
-                if (processState.needsModelImport)
-                    await this.exporter.exportModel(reference);
-            }
+            const referenceType = elemClass.requiredReferenceKeyTypeMap[referenceKey];
+            assert(referenceType === ConcreteEntityTypes.Element ||
+                referenceType === ConcreteEntityTypes.Model);
+            const referenceId = requiredReferenceId(sourceElement.asAny[referenceKey]);
+            if (referenceId === undefined ||
+                referenceId === Id64.invalid ||
+                referenceId === IModel.rootSubjectId // not allowed to directly export the root subject
+            )
+                continue;
+            // Within the same iModel, reuse existing DefinitionElements instead of copying them.
+            // Same-iModel transformations, including TemplateModelCloner, rely on this.
+            // This also replaces any existing mapping for the definition with an identity mapping.
+            if (!this.context.isBetweenIModels &&
+                this.isSameIModelReusableDefinition(referenceId))
+                this.context.remapElement(referenceId, referenceId);
+            if (!Id64.isValid(this.context.findTargetElementId(referenceId)))
+                unresolvedReferences.push(referenceId);
+        }
+        for (const reference of unresolvedReferences) {
+            const processState = await this.getElemTransformState(reference);
+            if (processState.needsElemImport)
+                await this.resolveRequiredElement(sourceElement.id, reference);
+            if (processState.needsModelImport)
+                await this.exporter.exportModel(reference);
         }
     }
     /** Makes sure an element that a changed element requires is mapped in the target before the changed element is imported.
@@ -761,7 +723,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             if (accepted)
                 await this.findExistingTargetElement(reference, await this.onTransformElement(reference));
         }
-        if (core_bentley_1.Id64.isValid(this.context.findTargetElementId(referenceId)))
+        if (Id64.isValid(this.context.findTargetElementId(referenceId)))
             return;
         let message;
         if (referenceChanged)
@@ -770,10 +732,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             message = `Element ${elementId} requires unchanged element ${referenceId}, which is not in the target iModel. Change processing does not insert unchanged elements; to insert element ${referenceId}, add it in addCustomChanges.`;
         else
             message = `Element ${elementId} requires element ${referenceId}, which the export filter rejects. Accept element ${referenceId}, or reject element ${elementId} and every element that requires it.`;
-        core_bentley_1.ITwinError.throwError({
+        ITwinError.throwError({
             iTwinErrorId: {
-                scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                key: IModelTransformerError_1.IModelTransformerError.DependencyMappingMissing,
+                scope: IModelTransformerErrorScope,
+                key: IModelTransformerError.DependencyMappingMissing,
             },
             message,
         });
@@ -786,27 +748,27 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         if (this.context.isBetweenIModels &&
             sourceElement.federationGuid !== undefined) {
             const targetElementId = this.targetDb.elements.getIdFromFederationGuid(sourceElement.federationGuid);
-            if (targetElementId !== undefined && core_bentley_1.Id64.isValid(targetElementId)) {
+            if (targetElementId !== undefined && Id64.isValid(targetElementId)) {
                 this.context.remapElement(sourceElement.id, targetElementId); // record that the targetElement was found
                 return targetElementId;
             }
         }
         // check by Code as long as the CodeScope is valid (invalid means a missing reference so not worth checking)
-        if (!core_bentley_1.Id64.isValidId64(targetElementProps.code.scope))
-            return core_bentley_1.Id64.invalid;
+        if (!Id64.isValidId64(targetElementProps.code.scope))
+            return Id64.invalid;
         // respond the same way to undefined code value as the @see Code class, but don't use that class because it trims
         // whitespace from the value, and there are iModels out there with untrimmed whitespace that we ought not to trim
         targetElementProps.code.value = targetElementProps.code.value ?? "";
         // empty code values are stored as NULL and are never unique, so they cannot identify an existing target element
-        if (core_common_1.Code.isEmpty(targetElementProps.code))
-            return core_bentley_1.Id64.invalid;
+        if (Code.isEmpty(targetElementProps.code))
+            return Id64.invalid;
         const maybeTargetElementId = this.queryElementIdByCode(this.targetDb, targetElementProps.code);
         if (maybeTargetElementId === undefined)
-            return core_bentley_1.Id64.invalid;
+            return Id64.invalid;
         const maybeTargetElem = this.targetDb.elements.getElement(maybeTargetElementId);
         if (maybeTargetElem.classFullName !== targetElementProps.classFullName) {
-            targetElementProps.code = core_common_1.Code.createEmpty(); // clear out invalid code
-            return core_bentley_1.Id64.invalid;
+            targetElementProps.code = Code.createEmpty(); // clear out invalid code
+            return Id64.invalid;
         }
         // ensure code remapping doesn't change the target class
         this.context.remapElement(sourceElement.id, maybeTargetElementId); // record that the targetElement was found by Code
@@ -815,12 +777,12 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     }
     async getElemTransformState(elementId) {
         const dbHasModel = async (db, id) => {
-            const maybeModelId = core_backend_1.EntityReferences.fromEntityType(id, core_common_1.ConcreteEntityTypes.Model);
+            const maybeModelId = EntityReferences.fromEntityType(id, ConcreteEntityTypes.Model);
             return this._cloneContext.existenceCache.exists(db, maybeModelId);
         };
         const isSubModeled = await dbHasModel(this.sourceDb, elementId);
         const idOfElemInTarget = this.context.findTargetElementId(elementId);
-        const isElemInTarget = core_bentley_1.Id64.invalid !== idOfElemInTarget;
+        const isElemInTarget = Id64.invalid !== idOfElemInTarget;
         const needsModelImport = isSubModeled &&
             (!isElemInTarget || !(await dbHasModel(this.targetDb, idOfElemInTarget)));
         return { needsElemImport: !isElemInTarget, needsModelImport };
@@ -833,25 +795,25 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     // and the cached ECSQL API (withPreparedStatement) is deprecated. Results match the ECSQL query because CodeValue
     // is COLLATE NOCASE, ix_bis_Element_Code is unique, and the primary connection sees uncommitted target inserts.
     queryElementIdByCode(iModel, code) {
-        if (core_bentley_1.Id64.isInvalid(code.spec))
-            core_bentley_1.ITwinError.throwError({
+        if (Id64.isInvalid(code.spec))
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.InvalidCode,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.InvalidCode,
                 },
                 message: "Invalid CodeSpec",
             });
         if (code.value === undefined)
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.InvalidCode,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.InvalidCode,
                 },
                 message: "Invalid Code",
             });
         return iModel.withPreparedSqliteStatement("SELECT Id FROM bis_Element WHERE CodeSpecId=? AND CodeScopeId=? AND CodeValue=?", (stmt) => {
             stmt.bindId(1, code.spec);
-            stmt.bindId(2, core_bentley_1.Id64.fromString(code.scope));
+            stmt.bindId(2, Id64.fromString(code.scope));
             stmt.bindString(3, code.value);
             return stmt.nextRow() ? stmt.getValueId(0) : undefined;
         });
@@ -861,7 +823,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      */
     async onExportElement(sourceElement) {
         this.markSourceEntityExists(sourceElement);
-        let targetElementId = core_bentley_1.Id64.invalid;
+        let targetElementId = Id64.invalid;
         let targetElementProps;
         if (this._options.wasSourceIModelCopiedToTarget) {
             targetElementId = sourceElement.id;
@@ -873,27 +835,27 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             targetElementProps = await this.onTransformElement(sourceElement);
         }
         // if an existing remapping was not yet found, check by FederationGuid and then by Code
-        if (!core_bentley_1.Id64.isValid(targetElementId))
+        if (!Id64.isValid(targetElementId))
             targetElementId = await this.findExistingTargetElement(sourceElement, targetElementProps);
         if (!this.hasElementChanged(sourceElement)) {
-            core_bentley_1.Logger.logTrace(loggerCategory, `Skipping unchanged element (${sourceElement.id}, ${sourceElement.getDisplayLabel()}).`);
+            Logger.logTrace(loggerCategory, `Skipping unchanged element (${sourceElement.id}, ${sourceElement.getDisplayLabel()}).`);
             return;
         }
         if (!(await this.doAllReferencesExistInTarget(sourceElement))) {
             this._partiallyCommittedElementIds.add(sourceElement.id);
         }
         // targetElementId will be valid (indicating update) or undefined (indicating insert)
-        targetElementProps.id = core_bentley_1.Id64.isValid(targetElementId)
+        targetElementProps.id = Id64.isValid(targetElementId)
             ? targetElementId
             : undefined;
         if (this._options.preserveElementIdsForFiltering) {
-            const isValid = core_bentley_1.Id64.isValid(targetElementId);
+            const isValid = Id64.isValid(targetElementId);
             if (isValid && targetElementId !== sourceElement.id) {
                 // Element found with different id
-                core_bentley_1.ITwinError.throwError({
+                ITwinError.throwError({
                     iTwinErrorId: {
-                        scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                        key: IModelTransformerError_1.IModelTransformerError.ElementIdNotPreservable,
+                        scope: IModelTransformerErrorScope,
+                        key: IModelTransformerError.ElementIdNotPreservable,
                     },
                     message: `Element id(${sourceElement.id}) cannot be preserved. Found a different mapping(${targetElementId}) from source element`,
                 });
@@ -907,10 +869,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 // if we don't find mapping for source element in target(invalid) but another element with source id exists in target
                 if (sourceInTargetElemProps) {
                     // Element id is already taken by another element
-                    core_bentley_1.ITwinError.throwError({
+                    ITwinError.throwError({
                         iTwinErrorId: {
-                            scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                            key: IModelTransformerError_1.IModelTransformerError.ElementIdNotPreservable,
+                            scope: IModelTransformerErrorScope,
+                            key: IModelTransformerError.ElementIdNotPreservable,
                         },
                         message: `Element id(${sourceElement.id}) cannot be preserved. An unrelated element in the target already uses id: ${sourceElement.id}`,
                     });
@@ -929,7 +891,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         }
         this.context.remapElement(sourceElement.id, targetElementProps.id);
         if (this.sourceDb === this.targetDb) {
-            this._cloneContext.existenceCache.markExists(this.targetDb, core_backend_1.EntityReferences.fromEntityType(targetElementProps.id, core_common_1.ConcreteEntityTypes.Element));
+            this._cloneContext.existenceCache.markExists(this.targetDb, EntityReferences.fromEntityType(targetElementProps.id, ConcreteEntityTypes.Element));
         }
         // the transformer does not currently 'split' or 'join' any elements, therefore, it does not
         // insert external source aspects because federation guids are sufficient for this.
@@ -947,7 +909,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 : sourceElement.federationGuid;
             if (!provenance) {
                 const aspectProps = await this.initElementProvenance(sourceElement.id, targetElementProps.id);
-                const foundEsaProps = await ProvenanceManager_1.ProvenanceManager.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
+                const foundEsaProps = await ProvenanceManager.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
                 if (foundEsaProps === undefined)
                     aspectProps.id = provenanceEditTxn.insertAspect(aspectProps);
                 else {
@@ -963,7 +925,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const targetElementIds = new Set();
         for (const sourceElementId of sourceElementIds) {
             const targetElementId = this.context.findTargetElementId(sourceElementId);
-            if (core_bentley_1.Id64.isValidId64(targetElementId) &&
+            if (Id64.isValidId64(targetElementId) &&
                 !this._targetElementIdsRemappedByCode.has(targetElementId)) {
                 targetElementIds.add(targetElementId);
             }
@@ -976,11 +938,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     async onExportModel(sourceModel) {
         this.markSourceEntityExists(sourceModel);
         if (this._options.skipPropagateChangesToRootElements &&
-            core_common_1.IModel.repositoryModelId === sourceModel.id)
+            IModel.repositoryModelId === sourceModel.id)
             return; // The RepositoryModel should not be directly imported
         const targetModeledElementId = this.context.findTargetElementId(sourceModel.id);
         // there can only be one repositoryModel per database, so ignore the repo model on remapped subjects
-        const isRemappedRootSubject = sourceModel.id === core_common_1.IModel.repositoryModelId &&
+        const isRemappedRootSubject = sourceModel.id === IModel.repositoryModelId &&
             targetModeledElementId !== sourceModel.id;
         if (isRemappedRootSubject)
             return;
@@ -989,7 +951,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         if (targetModelProps.id === undefined) {
             throw new Error("targetModelProps.id should be assigned by now");
         }
-        this._cloneContext.existenceCache.markExists(this.targetDb, core_backend_1.EntityReferences.fromEntityType(targetModelProps.id, core_common_1.ConcreteEntityTypes.Model));
+        this._cloneContext.existenceCache.markExists(this.targetDb, EntityReferences.fromEntityType(targetModelProps.id, ConcreteEntityTypes.Model));
         this._targetModelsImportedInCurrentTransform.add(targetModelProps.id);
     }
     /** Override of [IModelExportHandler.onDeleteModel]($transformer) that is called when [IModelExporter]($transformer) detects that a [Model]($backend) has been deleted from the source iModel. */
@@ -998,13 +960,13 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         // - If only the model is deleted, [[initFromExternalSourceAspects]] will have already remapped the underlying element since it still exists.
         // - If both were deleted, [[remapDeletedSourceEntities]] will find and remap the deleted element making this operation valid
         const targetModelId = this.context.findTargetElementId(sourceModelId);
-        if (!core_bentley_1.Id64.isValidId64(targetModelId))
+        if (!Id64.isValidId64(targetModelId))
             return;
         // This handles cases where model with a partition element was remapped to
         //  new element by code value after recreation.
         if (this._targetElementIdsRemappedByCode.has(targetModelId) &&
             this._targetModelsImportedInCurrentTransform.has(targetModelId)) {
-            core_bentley_1.Logger.logTrace(loggerCategory, `Skipping delete operation for model (source id: ${sourceModelId}) because the target model (id: ${targetModelId}) was remapped by Code and re-imported during this transformation pass.`);
+            Logger.logTrace(loggerCategory, `Skipping delete operation for model (source id: ${sourceModelId}) because the target model (id: ${targetModelId}) was remapped by Code and re-imported during this transformation pass.`);
             return;
         }
         const sql = `
@@ -1017,7 +979,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
       WHERE ECInstanceId=:targetModelId
     `;
         if (this.exporter.sourceDbChanges?.element.deleteIds.has(sourceModelId)) {
-            const params = new core_common_1.QueryBinder().bindId("targetModelId", targetModelId);
+            const params = new QueryBinder().bindId("targetModelId", targetModelId);
             const reader = this.targetDb.createQueryReader(sql, params, {
                 usePrimaryConn: true,
             });
@@ -1033,9 +995,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             await this.importer.deleteModel(targetModelId);
         }
         catch (error) {
-            const isDeletionProhibitedErr = error instanceof core_common_1.IModelError &&
-                (error.errorNumber === core_bentley_1.IModelStatus.DeletionProhibited ||
-                    error.errorNumber === core_bentley_1.IModelStatus.ForeignKeyConstraint);
+            const isDeletionProhibitedErr = error instanceof IModelError &&
+                (error.errorNumber === IModelStatus.DeletionProhibited ||
+                    error.errorNumber === IModelStatus.ForeignKeyConstraint);
             if (!isDeletionProhibitedErr)
                 throw error;
             // Models are processed before elements, but a definition model cannot be deleted while it contains elements.
@@ -1067,7 +1029,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @note This method is called from [[process]], so it only needs to be called directly when processing a subset of an iModel.
      * @note After composing subset processing calls, call [[IModelImporter.finalize]] before saving target changes.
      */
-    async processModelContents(sourceModelId, targetModelId, elementClassFullName = core_backend_1.Element.classFullName) {
+    async processModelContents(sourceModelId, targetModelId, elementClassFullName = Element.classFullName) {
         await this.initialize();
         this.targetDb.models.getModel(targetModelId); // throws if Model does not exist
         this.context.remapElement(sourceModelId, targetModelId); // set remapping in case importModelContents is called directly
@@ -1077,22 +1039,22 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     async processSubjectSubModels(sourceSubjectId) {
         await this.initialize();
         // import DefinitionModels first
-        const childDefinitionPartitionSql = `SELECT ECInstanceId FROM ${core_backend_1.DefinitionPartition.classFullName} WHERE Parent.Id=:subjectId`;
-        const params = new core_common_1.QueryBinder().bindId("subjectId", sourceSubjectId);
+        const childDefinitionPartitionSql = `SELECT ECInstanceId FROM ${DefinitionPartition.classFullName} WHERE Parent.Id=:subjectId`;
+        const params = new QueryBinder().bindId("subjectId", sourceSubjectId);
         for await (const row of this.sourceDb.createQueryReader(childDefinitionPartitionSql, params, { usePrimaryConn: true })) {
             await this.processModel(row.id);
         }
         // import other partitions next
-        const childPartitionSql = `SELECT ECInstanceId FROM ${core_backend_1.InformationPartitionElement.classFullName} WHERE Parent.Id=:subjectId`;
+        const childPartitionSql = `SELECT ECInstanceId FROM ${InformationPartitionElement.classFullName} WHERE Parent.Id=:subjectId`;
         for await (const row of this.sourceDb.createQueryReader(childPartitionSql, params, { usePrimaryConn: true })) {
             const modelId = row.id;
             const model = this.sourceDb.models.getModel(modelId);
-            if (!(model instanceof core_backend_1.DefinitionModel)) {
+            if (!(model instanceof DefinitionModel)) {
                 await this.processModel(modelId);
             }
         }
         // recurse into child Subjects
-        const childSubjectSql = `SELECT ECInstanceId FROM ${core_backend_1.Subject.classFullName} WHERE Parent.Id=:subjectId`;
+        const childSubjectSql = `SELECT ECInstanceId FROM ${Subject.classFullName} WHERE Parent.Id=:subjectId`;
         for await (const row of this.sourceDb.createQueryReader(childSubjectSql, params, { usePrimaryConn: true })) {
             await this.processSubjectSubModels(row.id);
         }
@@ -1112,10 +1074,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         };
         targetModelProps.id = targetModeledElementId;
         if (targetModelProps.parentModel === undefined) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.ParentModelRequired,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.ParentModelRequired,
                 },
                 message: "targetElementProps must have a defined parentModel",
             });
@@ -1132,8 +1094,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         });
         // TODO: ignore if we remove change cache usage
         if (!this._options.noDetachChangeCache) {
-            if (core_backend_1.ChangeSummaryManager.isChangeCacheAttached(this.sourceDb))
-                core_backend_1.ChangeSummaryManager.detachChangeCache(this.sourceDb);
+            if (ChangeSummaryManager.isChangeCacheAttached(this.sourceDb))
+                ChangeSummaryManager.detachChangeCache(this.sourceDb);
         }
         this.setCodeValueBehavior("trim-unicode-whitespace");
     }
@@ -1165,7 +1127,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const targetRelationshipProps = this.onTransformRelationship(sourceRelationship);
         const targetRelationshipInstanceId = await this.importer.importRelationship(targetRelationshipProps);
         if (this._pendingRelationshipDeleteTargets.size > 0 &&
-            core_bentley_1.Id64.isValid(targetRelationshipInstanceId) &&
+            Id64.isValid(targetRelationshipInstanceId) &&
             (this._pendingRelationshipDeleteTargets.has(targetRelationshipInstanceId) ||
                 this._pendingRelationshipDeleteTargets.has(relationshipEndpointsKey(targetRelationshipProps.sourceId, targetRelationshipProps.targetId)))) {
             this._reimportedTargetRelationshipIds.add(targetRelationshipInstanceId);
@@ -1173,7 +1135,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const provenanceDb = await this.getProvenanceDb();
         const provenanceEditTxn = await this._provenanceManager.getProvenanceEditTxn();
         if (!this._options.noProvenance &&
-            core_bentley_1.Id64.isValid(targetRelationshipInstanceId)) {
+            Id64.isValid(targetRelationshipInstanceId)) {
             const needsEsaProvenance = this._options.forceExternalSourceAspectProvenance ||
                 !this.relationshipEndpointsHaveFedGuids(sourceRelationship, endpointFedGuids);
             if (needsEsaProvenance) {
@@ -1181,7 +1143,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     sourceRelSourceElementId: sourceRelationship.sourceId,
                     targetRelSourceElementId: targetRelationshipProps.sourceId,
                 });
-                const foundEsaProps = await ProvenanceManager_1.ProvenanceManager.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
+                const foundEsaProps = await ProvenanceManager.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
                 // onExportRelationship doesn't need to call updateAspect if esaProps were found, because relationship provenance doesn't have the same concept of a version as element provenance (which uses last mod time on the elements).
                 if (undefined === foundEsaProps) {
                     aspectProps.id = provenanceEditTxn.insertAspect(aspectProps);
@@ -1201,11 +1163,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * This override propagates the delete to the target iModel via [IModelImporter.deleteRelationship]($transformer).
      */
     async onDeleteRelationship(sourceRelInstanceId) {
-        (0, node_assert_1.strict)(this._deletedSourceRelationshipData, "should be defined at initialization by now");
+        nodeAssert(this._deletedSourceRelationshipData, "should be defined at initialization by now");
         const deletedRelData = this._deletedSourceRelationshipData.get(sourceRelInstanceId);
         if (!deletedRelData) {
             // this can occur if both the source and target deleted it
-            core_bentley_1.Logger.logWarning(loggerCategory, "tried to delete a relationship that wasn't in change data");
+            Logger.logWarning(loggerCategory, "tried to delete a relationship that wasn't in change data");
             return;
         }
         const id = deletedRelData.relId ??
@@ -1215,7 +1177,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             })?.id;
         if (id && this._reimportedTargetRelationshipIds.has(id)) {
             // The source relationship was recreated with the same endpoints and already imported into this target relationship.
-            core_bentley_1.Logger.logTrace(loggerCategory, `Skipping delete of target relationship ${id} because source relationship ${sourceRelInstanceId} was recreated`);
+            Logger.logTrace(loggerCategory, `Skipping delete of target relationship ${id} because source relationship ${sourceRelInstanceId} was recreated`);
         }
         else if (id) {
             await this.importer.deleteRelationship({
@@ -1229,7 +1191,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             }
             catch (error) {
                 // This aspect may no longer exist if it was deleted at some other point during the transformation. This is fine.
-                if (error.errorNumber === core_bentley_1.IModelStatus.NotFound)
+                if (error.errorNumber === IModelStatus.NotFound)
                     return;
                 throw error;
             }
@@ -1246,12 +1208,12 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         targetRelationshipProps.targetId = this.context.findTargetElementId(sourceRelationship.targetId);
         // TODO: move to cloneRelationship in IModelCloneContext
         const relationshipClass = sourceRelationship.iModel.schemaContext.getSchemaItemSync(sourceRelationship.schemaItemKey, ECSchemaMetaData.RelationshipClass);
-        (0, core_bentley_1.assert)(relationshipClass !== undefined, `Cannot get metadata for ${sourceRelationship.classFullName}.`);
+        assert(relationshipClass !== undefined, `Cannot get metadata for ${sourceRelationship.classFullName}.`);
         for (const property of relationshipClass.getPropertiesSync()) {
             const propertyName = property.name;
             if (property.isPrimitive() && "Id" === property.extendedTypeName) {
-                targetRelationshipProps[core_common_1.ECJsNames.toJsName(propertyName)] =
-                    this.context.findTargetElementId(sourceRelationship.asAny[core_common_1.ECJsNames.toJsName(propertyName)]);
+                targetRelationshipProps[ECJsNames.toJsName(propertyName)] =
+                    this.context.findTargetElementId(sourceRelationship.asAny[ECJsNames.toJsName(propertyName)]);
             }
         }
         return targetRelationshipProps;
@@ -1259,7 +1221,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     async shouldExportElementAspect(aspect) {
         // An aspect cannot be exported when its owner has no source-to-target
         // mapping.
-        return this.context.findTargetElementId(aspect.element.id) !== core_bentley_1.Id64.invalid;
+        return this.context.findTargetElementId(aspect.element.id) !== Id64.invalid;
     }
     async prepareElementAspects(excludedElementAspectClassFullNames, elementIds) {
         if (!this.exporter.visitElements)
@@ -1269,7 +1231,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const targetElementIds = new Set();
         for (const sourceElementId of elementIds) {
             const targetElementId = this.context.findTargetElementId(sourceElementId);
-            if (core_bentley_1.Id64.isValid(targetElementId)) {
+            if (Id64.isValid(targetElementId)) {
                 targetElementIds.add(targetElementId);
             }
         }
@@ -1299,7 +1261,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             }
         }
         const targetIds = await this.importer.importElementMultiAspects(await Promise.all(targetAspectPropsArray), (a) => {
-            const isExternalSourceAspectFromTransformer = a instanceof core_backend_1.ExternalSourceAspect &&
+            const isExternalSourceAspectFromTransformer = a instanceof ExternalSourceAspect &&
                 a.scope?.id === this.targetScopeElementId;
             return (!this._options.includeSourceProvenance ||
                 !isExternalSourceAspectFromTransformer);
@@ -1318,7 +1280,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         return targetElementAspectProps;
     }
     /** The directory where schemas will be exported, a random temporary directory */
-    _schemaExportDir = path.join(core_backend_1.KnownLocations.tmpdir, core_bentley_1.Guid.createValue());
+    _schemaExportDir = path.join(KnownLocations.tmpdir, Guid.createValue());
     /** Override of [IModelExportHandler.shouldExportSchema]($transformer) that is called to determine if a schema should be exported
      * @note the default behavior doesn't import schemas older than those already in the target
      */
@@ -1326,7 +1288,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const versionInTarget = this.targetDb.querySchemaVersion(schemaKey.name);
         if (versionInTarget === undefined)
             return true;
-        return Semver.gt(`${schemaKey.version.read}.${schemaKey.version.write}.${schemaKey.version.minor}`, core_backend_1.Schema.toSemverString(versionInTarget));
+        return Semver.gt(`${schemaKey.version.read}.${schemaKey.version.write}.${schemaKey.version.minor}`, Schema.toSemverString(versionInTarget));
     }
     /** Serialize a source schema to the temporary directory used by [[processSchemas]].
      * @returns A path to the serialized schema file.
@@ -1342,7 +1304,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * It is more efficient to process *data* changes after the schema changes have been saved.
      */
     async processSchemas(options) {
-        return this._schemaProcessingCoordinator.process(options?.strategy ?? new SchemaProcessingStrategy_1.NewerVersionSchemaImportStrategy());
+        return this._schemaProcessingCoordinator.process(options?.strategy ?? new NewerVersionSchemaImportStrategy());
     }
     /** Cause all fonts to be exported from the source iModel and imported into the target iModel.
      * @note This method is called from [[process]], so it only needs to be called directly when processing a subset of an iModel.
@@ -1385,8 +1347,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      */
     async processSubject(sourceSubjectId, targetSubjectId) {
         await this.initialize();
-        this.sourceDb.elements.getElement(sourceSubjectId, core_backend_1.Subject); // throws if sourceSubjectId is not a Subject
-        this.targetDb.elements.getElement(targetSubjectId, core_backend_1.Subject); // throws if targetSubjectId is not a Subject
+        this.sourceDb.elements.getElement(sourceSubjectId, Subject); // throws if sourceSubjectId is not a Subject
+        this.targetDb.elements.getElement(targetSubjectId, Subject); // throws if targetSubjectId is not a Subject
         this.context.remapElement(sourceSubjectId, targetSubjectId);
         await this.processScopedElementExport(async () => {
             await this.processChildElements(sourceSubjectId);
@@ -1429,7 +1391,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     : undefined);
             if (changedInstanceIds !== undefined) {
                 // The caller supplied changed IDs, so only deletion metadata is read.
-                this._deletionBatches = await ChangesetScanner_1.ChangesetScanner.scan(this.sourceDb, await ChangesetScanner_1.ChangesetScanner.download(this.sourceDb, ranges), {});
+                this._deletionBatches = await ChangesetScanner.scan(this.sourceDb, await ChangesetScanner.download(this.sourceDb, ranges), {});
             }
             else {
                 const scanResult = await this.collectChanges(ranges);
@@ -1466,8 +1428,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * the changesets to find deletion records.
      * @beta
      */
-    async collectChanges(ranges, changedInstanceIds = new IModelExporter_1.ChangedInstanceIds(this.sourceDb)) {
-        const deletionBatches = await ChangesetScanner_1.ChangesetScanner.scan(this.sourceDb, await ChangesetScanner_1.ChangesetScanner.download(this.sourceDb, ranges), { changedInstanceIds });
+    async collectChanges(ranges, changedInstanceIds = new ChangedInstanceIds(this.sourceDb)) {
+        const deletionBatches = await ChangesetScanner.scan(this.sourceDb, await ChangesetScanner.download(this.sourceDb, ranges), { changedInstanceIds });
         return { changedInstanceIds, deletionBatches };
     }
     /**
@@ -1497,12 +1459,12 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const alreadyImportedModelInserts = new Set();
         this.exporter.sourceDbChanges?.element.insertIds.forEach((insertedSourceElementId) => {
             const targetElementId = this.context.findTargetElementId(insertedSourceElementId);
-            if (core_bentley_1.Id64.isValid(targetElementId))
+            if (Id64.isValid(targetElementId))
                 alreadyImportedElementInserts.add(targetElementId);
         });
         this.exporter.sourceDbChanges?.model.insertIds.forEach((insertedSourceModelId) => {
             const targetModelId = this.context.findTargetElementId(insertedSourceModelId);
-            if (core_bentley_1.Id64.isValid(targetModelId))
+            if (Id64.isValid(targetModelId))
                 alreadyImportedModelInserts.add(targetModelId);
         });
         this._deletedSourceRelationshipData = new Map();
@@ -1514,7 +1476,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             const deletedScopeEsaByElementId = new Map();
             for (const aspect of batch.externalSourceAspects) {
                 if (aspect.scopeId === this.targetScopeElementId &&
-                    aspect.kind === core_backend_1.ExternalSourceAspect.Kind.Element)
+                    aspect.kind === ExternalSourceAspect.Kind.Element)
                     deletedScopeEsaByElementId.set(aspect.elementId, aspect);
             }
             const deletedFederationGuidByElementId = new Map();
@@ -1554,9 +1516,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         if (this.sourceDb === (await this.getProvenanceDb())) {
             let identifierValue;
             // TODO: clarify what happens if there are multiple (e.g. elements were merged)
-            for await (const row of this.sourceDb.createQueryReader("SELECT esa.Identifier FROM bis.ExternalSourceAspect esa WHERE Scope.Id=:scopeId AND Kind=:kind AND Element.Id=:relatedElementId LIMIT 1", core_common_1.QueryBinder.from([
+            for await (const row of this.sourceDb.createQueryReader("SELECT esa.Identifier FROM bis.ExternalSourceAspect esa WHERE Scope.Id=:scopeId AND Kind=:kind AND Element.Id=:relatedElementId LIMIT 1", QueryBinder.from([
                 this.targetScopeElementId,
-                core_backend_1.ExternalSourceAspect.Kind.Element,
+                ExternalSourceAspect.Kind.Element,
                 sourceId,
             ]), { usePrimaryConn: true })) {
                 identifierValue = row.Identifier;
@@ -1629,7 +1591,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         if (targetId === undefined &&
             this.sourceDb === (await this._provenanceManager.getProvenanceSourceDb())) {
             const contextTargetId = this.context.findTargetElementId(sourceId);
-            if (core_bentley_1.Id64.isValidId64(contextTargetId))
+            if (Id64.isValidId64(contextTargetId))
                 targetId = contextTargetId;
         }
         // Entities inserted and deleted since the last synchronization were never synced and can be safely ignored.
@@ -1666,7 +1628,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const endChangesetId = this.sourceDb.changeset.id;
         const [startChangesetIndex, endChangesetIndex] = await Promise.all([startChangesetIndexOrId, endChangesetId].map(async (indexOrId) => typeof indexOrId === "number"
             ? indexOrId
-            : core_backend_1.BriefcaseManager.queryChangeset({
+            : BriefcaseManager.queryChangeset({
                 iModelId: this.sourceDb.iModelId,
                 changeset: { id: indexOrId },
             }).then((changeset) => changeset.index)));
@@ -1675,10 +1637,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             ?.ignoreMissingChangesetsInSynchronizations &&
             startChangesetIndex !== syncVersion.index + 1 &&
             syncVersion.index !== -1) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.SynchronizationRangeInvalid,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.SynchronizationRangeInvalid,
                 },
                 message: `synchronization is ${missingChangesets ? "missing changesets" : ""},` +
                     " startChangesetId should be" +
@@ -1690,9 +1652,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             });
         }
         const changesetsToSkip = await this._provenanceManager.getChangesetsToSkip();
-        core_bentley_1.Logger.logTrace(loggerCategory, `changesets to skip: ${changesetsToSkip}`);
-        this._changesetRanges = (0, Algo_1.rangesFromRangeAndSkipped)(startChangesetIndex, endChangesetIndex, changesetsToSkip);
-        core_bentley_1.Logger.logTrace(loggerCategory, `ranges: ${this._changesetRanges}`);
+        Logger.logTrace(loggerCategory, `changesets to skip: ${changesetsToSkip}`);
+        this._changesetRanges = rangesFromRangeAndSkipped(startChangesetIndex, endChangesetIndex, changesetsToSkip);
+        Logger.logTrace(loggerCategory, `ranges: ${this._changesetRanges}`);
         /** Skipping indices found in the pendingSync and pendingReverseSync arrays can leave no ranges to process. */
         this._sourceChangeDataState =
             this._changesetRanges.length === 0 ? "no-changes" : "has-changes";
@@ -1700,19 +1662,19 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     /** Asserts that the EditTxn is active before any write operations. */
     assertEditTxnActive() {
         if (!this._targetEditTxn.isActive) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.EditTxnNotActive,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.EditTxnNotActive,
                 },
                 message: "The target EditTxn must be started before calling process(). Call targetEditTxn.start() before invoking the transformer.",
             });
         }
         if (this._sourceEditTxn && !this._sourceEditTxn.isActive) {
-            core_bentley_1.ITwinError.throwError({
+            ITwinError.throwError({
                 iTwinErrorId: {
-                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                    key: IModelTransformerError_1.IModelTransformerError.EditTxnNotActive,
+                    scope: IModelTransformerErrorScope,
+                    key: IModelTransformerError.EditTxnNotActive,
                 },
                 message: "The source EditTxn was provided but is not active. Call sourceEditTxn.start() before invoking the transformer.",
             });
@@ -1761,20 +1723,20 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         await this.exporter.elementAspectExportCoordinator.run(async () => {
             if (this._options.skipPropagateChangesToRootElements) {
                 // The RepositoryModel and root Subject of the target iModel should not be transformed.
-                await this.exporter.exportChildElements(core_common_1.IModel.rootSubjectId); // start below the root Subject
-                await this.exporter.exportModelContents(core_common_1.IModel.repositoryModelId, core_backend_1.Element.classFullName, true); // after the Subject hierarchy, process the other elements of the RepositoryModel
-                await this.exporter.exportSubModels(core_common_1.IModel.repositoryModelId); // start below the RepositoryModel
+                await this.exporter.exportChildElements(IModel.rootSubjectId); // start below the root Subject
+                await this.exporter.exportModelContents(IModel.repositoryModelId, Element.classFullName, true); // after the Subject hierarchy, process the other elements of the RepositoryModel
+                await this.exporter.exportSubModels(IModel.repositoryModelId); // start below the RepositoryModel
             }
             else {
-                await this.exporter.exportModel(core_common_1.IModel.repositoryModelId);
+                await this.exporter.exportModel(IModel.repositoryModelId);
             }
             await this.completePartiallyCommittedElements();
         });
         await this.completePartiallyCommittedAspects();
-        await this.exporter.exportRelationships(core_backend_1.ElementRefersToElements.classFullName);
+        await this.exporter.exportRelationships(ElementRefersToElements.classFullName);
         if (this._options.forceExternalSourceAspectProvenance &&
             (await this.shouldDetectDeletes())) {
-            core_bentley_1.Logger.logWarning(loggerCategory, "This workflows was deprecated in v1 and is no longer supported");
+            Logger.logWarning(loggerCategory, "This workflows was deprecated in v1 and is no longer supported");
         }
         if (this._options.optimizeGeometry)
             this.importer.optimizeGeometry(this._options.optimizeGeometry);
@@ -1844,11 +1806,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         }
     }
 }
-exports.IModelTransformer = IModelTransformer;
 /** IModelTransformer that clones the contents of a template model.
  * @beta
  */
-class TemplateModelCloner extends IModelTransformer {
+export class TemplateModelCloner extends IModelTransformer {
     /** The Placement to apply to the template. */
     _transform3d;
     /** Accumulates the mapping of sourceElementIds to targetElementIds from the elements in the template model that were cloned. */
@@ -1858,7 +1819,7 @@ class TemplateModelCloner extends IModelTransformer {
      * @note The expectation is that the template definitions are within the same iModel where instances will be placed.
      */
     constructor(editTxn) {
-        const target = new IModelImporter_1.IModelImporter(editTxn, {
+        const target = new IModelImporter(editTxn, {
             autoExtendProjectExtents: false, // autoExtendProjectExtents is intended for transformation service use cases, not template --> instance cloning
         });
         super({ source: editTxn.iModel, target }, { noProvenance: true }); // WIP: need to decide the proper way to handle provenance
@@ -1873,7 +1834,7 @@ class TemplateModelCloner extends IModelTransformer {
     async placeTemplate3d(sourceTemplateModelId, targetModelId, placement) {
         await this.initialize();
         this.context.remapElement(sourceTemplateModelId, targetModelId);
-        this._transform3d = core_geometry_1.Transform.createOriginAndMatrix(placement.origin, placement.angles.toMatrix3d());
+        this._transform3d = Transform.createOriginAndMatrix(placement.origin, placement.angles.toMatrix3d());
         this._sourceIdToTargetIdMap = new Map();
         await this.exporter.exportModelContents(sourceTemplateModelId);
         // Note: the source --> target mapping was needed during the template model cloning phase (remapping parent/child, for example), but needs to be reset afterwards
@@ -1894,7 +1855,7 @@ class TemplateModelCloner extends IModelTransformer {
     async placeTemplate2d(sourceTemplateModelId, targetModelId, placement) {
         await this.initialize();
         this.context.remapElement(sourceTemplateModelId, targetModelId);
-        this._transform3d = core_geometry_1.Transform.createOriginAndMatrix(core_geometry_1.Point3d.createFrom(placement.origin), placement.rotation);
+        this._transform3d = Transform.createOriginAndMatrix(Point3d.createFrom(placement.origin), placement.rotation);
         this._sourceIdToTargetIdMap = new Map();
         await this.exporter.exportModelContents(sourceTemplateModelId);
         // Note: the source --> target mapping was needed during the template model cloning phase (remapping parent/child, for example), but needs to be reset afterwards
@@ -1910,27 +1871,27 @@ class TemplateModelCloner extends IModelTransformer {
         const referenceIds = sourceElement.getReferenceIds();
         for (const referenceId of referenceIds) {
             // TODO: consider going through all definition elements at once and remapping them to themselves
-            if (!core_backend_1.EntityReferences.isValid(await this.context.findTargetEntityId(referenceId))) {
+            if (!EntityReferences.isValid(await this.context.findTargetEntityId(referenceId))) {
                 if (this.context.isBetweenIModels) {
-                    core_bentley_1.ITwinError.throwError({
+                    ITwinError.throwError({
                         iTwinErrorId: {
-                            scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                            key: IModelTransformerError_1.IModelTransformerError.DependencyMappingMissing,
+                            scope: IModelTransformerErrorScope,
+                            key: IModelTransformerError.DependencyMappingMissing,
                         },
                         message: `Remapping for source dependency ${referenceId} not found for target iModel`,
                     });
                 }
                 else {
-                    const definitionElement = this.sourceDb.elements.tryGetElement(referenceId, core_backend_1.DefinitionElement);
+                    const definitionElement = this.sourceDb.elements.tryGetElement(referenceId, DefinitionElement);
                     if (definitionElement &&
-                        !(definitionElement instanceof core_backend_1.RecipeDefinitionElement)) {
+                        !(definitionElement instanceof RecipeDefinitionElement)) {
                         this.context.remapElement(referenceId, referenceId); // when in the same iModel, can use existing DefinitionElements without remapping
                     }
                     else {
-                        core_bentley_1.ITwinError.throwError({
+                        ITwinError.throwError({
                             iTwinErrorId: {
-                                scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                                key: IModelTransformerError_1.IModelTransformerError.DependencyMappingMissing,
+                                scope: IModelTransformerErrorScope,
+                                key: IModelTransformerError.DependencyMappingMissing,
                             },
                             message: `Remapping for dependency ${referenceId} not found`,
                         });
@@ -1939,21 +1900,20 @@ class TemplateModelCloner extends IModelTransformer {
             }
         }
         const targetElementProps = await super.onTransformElement(sourceElement);
-        targetElementProps.federationGuid = core_bentley_1.Guid.createValue(); // clone from template should create a new federationGuid
-        targetElementProps.code = core_common_1.Code.createEmpty(); // clone from template should not maintain codes
-        if (sourceElement instanceof core_backend_1.GeometricElement) {
-            const is3d = sourceElement instanceof core_backend_1.GeometricElement3d;
-            const placementClass = is3d ? core_common_1.Placement3d : core_common_1.Placement2d;
+        targetElementProps.federationGuid = Guid.createValue(); // clone from template should create a new federationGuid
+        targetElementProps.code = Code.createEmpty(); // clone from template should not maintain codes
+        if (sourceElement instanceof GeometricElement) {
+            const is3d = sourceElement instanceof GeometricElement3d;
+            const placementClass = is3d ? Placement3d : Placement2d;
             const placement = placementClass.fromJSON(targetElementProps.placement);
             if (placement.isValid) {
-                (0, node_assert_1.strict)(this._transform3d);
+                nodeAssert(this._transform3d);
                 placement.multiplyTransform(this._transform3d);
                 targetElementProps.placement = placement;
             }
         }
-        this._sourceIdToTargetIdMap?.set(sourceElement.id, core_bentley_1.Id64.invalid); // keep track of (source) elementIds from the template model, but the target hasn't been inserted yet
+        this._sourceIdToTargetIdMap?.set(sourceElement.id, Id64.invalid); // keep track of (source) elementIds from the template model, but the target hasn't been inserted yet
         return targetElementProps;
     }
 }
-exports.TemplateModelCloner = TemplateModelCloner;
 //# sourceMappingURL=IModelTransformer.js.map