@itwin/imodel-transformer 0.0.1-dev.0

package/lib/cjs/IModelImporter.js

@@ -0,0 +1,591 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasEntityChanged = exports.IModelImporter = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module iModels
+ */
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_common_1 = require("@itwin/core-common");
+const TransformerLoggerCategory_1 = require("./TransformerLoggerCategory");
+const core_backend_1 = require("@itwin/core-backend");
+const assert = require("assert");
+const loggerCategory = TransformerLoggerCategory_1.TransformerLoggerCategory.IModelImporter;
+/** Base class for importing data into an iModel.
+ * @see [iModel Transformation and Data Exchange]($docs/learning/transformer/index.md)
+ * @see [IModelExporter]($transformer)
+ * @see [IModelTransformer]($transformer)
+ * @beta
+ */
+class IModelImporter {
+    /** Construct a new IModelImporter
+     * @param targetDb The target IModelDb
+     * @param options The options that specify how the import should be done.
+     */
+    constructor(targetDb, options) {
+        var _a, _b, _c;
+        /** The set of elements that should not be updated by this IModelImporter.
+         * Defaults to the elements that are always present (even in an "empty" iModel) and therefore do not need to be updated
+         * @note Adding an element to this set is typically necessary when remapping a source element to one that already exists in the target and already has the desired properties.
+         */
+        this.doNotUpdateElementIds = new Set([
+            core_common_1.IModel.rootSubjectId,
+            core_common_1.IModel.dictionaryId,
+            IModelImporter._realityDataSourceLinkPartitionStaticId,
+        ]);
+        /** The number of entity changes before incremental progress should be reported via the [[onProgress]] callback. */
+        this.progressInterval = 1000;
+        /** Tracks the current total number of entity changes. */
+        this._progressCounter = 0;
+        /** */
+        this._modelPropertiesToIgnore = new Set([
+            "geometryGuid", // cannot compare GeometricModel.GeometryGuid values across iModels
+        ]);
+        this.targetDb = targetDb;
+        this.options = {
+            autoExtendProjectExtents: (_a = options === null || options === void 0 ? void 0 : options.autoExtendProjectExtents) !== null && _a !== void 0 ? _a : true,
+            preserveElementIdsForFiltering: (_b = options === null || options === void 0 ? void 0 : options.preserveElementIdsForFiltering) !== null && _b !== void 0 ? _b : false,
+            simplifyElementGeometry: (_c = options === null || options === void 0 ? void 0 : options.simplifyElementGeometry) !== null && _c !== void 0 ? _c : false,
+        };
+    }
+    /** If `true` (the default), compute the projectExtents of the target iModel after elements are imported.
+     * The computed projectExtents will either include or exclude *outliers* depending on the `excludeOutliers` flag that defaults to `false`.
+     * @see [[IModelImportOptions.autoExtendProjectExtents]]
+     * @see [IModelImporter Options]($docs/learning/transformer/index.md#IModelImporter)
+     * @deprecated in 3.x. Use [[IModelImporter.options.autoExtendProjectExtents]] instead
+     */
+    get autoExtendProjectExtents() {
+        return this.options.autoExtendProjectExtents;
+    }
+    set autoExtendProjectExtents(val) {
+        this.options.autoExtendProjectExtents = val;
+    }
+    /**
+     * See [IModelTransformOptions.preserveElementIdsForFiltering]($transformer)
+     * @deprecated in 3.x. Use [[IModelImporter.options.preserveElementIdsForFiltering]] instead
+     */
+    get preserveElementIdsForFiltering() {
+        return this.options.preserveElementIdsForFiltering;
+    }
+    set preserveElementIdsForFiltering(val) {
+        this.options.preserveElementIdsForFiltering = val;
+    }
+    /**
+     * See [[IModelImportOptions.simplifyElementGeometry]]
+     * @deprecated in 3.x. Use [[IModelImporter.options.simplifyElementGeometry]] instead
+     */
+    get simplifyElementGeometry() {
+        return this.options.simplifyElementGeometry;
+    }
+    set simplifyElementGeometry(val) {
+        this.options.simplifyElementGeometry = val;
+    }
+    /** Import the specified ModelProps (either as an insert or an update) into the target iModel. */
+    importModel(modelProps) {
+        if ((undefined === modelProps.id) || !core_bentley_1.Id64.isValidId64(modelProps.id))
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidId, "Model Id not provided, should be the same as the ModeledElementId");
+        if (this.doNotUpdateElementIds.has(modelProps.id)) {
+            core_bentley_1.Logger.logInfo(loggerCategory, `Do not update target model ${modelProps.id}`);
+            return;
+        }
+        try {
+            const model = this.targetDb.models.getModel(modelProps.id); // throws IModelError.NotFound if model does not exist
+            if (hasEntityChanged(model, modelProps, this._modelPropertiesToIgnore)) {
+                this.onUpdateModel(modelProps);
+            }
+        }
+        catch (error) {
+            // catch NotFound error and insertModel
+            if (error instanceof core_common_1.IModelError && error.errorNumber === core_bentley_1.IModelStatus.NotFound) {
+                this.onInsertModel(modelProps);
+                return;
+            }
+            throw error;
+        }
+    }
+    /** Create a new Model from the specified ModelProps and insert it into the target iModel.
+     * @note A subclass may override this method to customize insert behavior but should call `super.onInsertModel`.
+     */
+    onInsertModel(modelProps) {
+        try {
+            const modelId = this.targetDb.models.insertModel(modelProps);
+            core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatModelForLogger(modelProps)}`);
+            this.trackProgress();
+            return modelId;
+        }
+        catch (error) {
+            if (!this.targetDb.containsClass(modelProps.classFullName)) {
+                // replace standard insert error with something more helpful
+                const errorMessage = `Model class "${modelProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`;
+                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidName, errorMessage);
+            }
+            throw error; // throw original error
+        }
+    }
+    /** Update an existing Model in the target iModel from the specified ModelProps.
+     * @note A subclass may override this method to customize update behavior but should call `super.onUpdateModel`.
+     */
+    onUpdateModel(modelProps) {
+        this.targetDb.models.updateModel(modelProps);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatModelForLogger(modelProps)}`);
+        this.trackProgress();
+    }
+    /** Format a Model for the Logger. */
+    formatModelForLogger(modelProps) {
+        return `${modelProps.classFullName} [${modelProps.id}]`;
+    }
+    /** Import the specified ElementProps (either as an insert or an update) into the target iModel. */
+    importElement(elementProps) {
+        if (undefined !== elementProps.id && this.doNotUpdateElementIds.has(elementProps.id)) {
+            core_bentley_1.Logger.logInfo(loggerCategory, `Do not update target element ${elementProps.id}`);
+            return elementProps.id;
+        }
+        if (this.options.preserveElementIdsForFiltering) {
+            if (elementProps.id === undefined) {
+                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, `elementProps.id must be defined during a preserveIds operation`);
+            }
+            // Categories are the only element that onInserted will immediately insert a new element (their default subcategory)
+            // since default subcategories always exist and always will be inserted after their categories, we treat them as an update
+            // to prevent duplicate inserts.
+            // Otherwise we always insert during a preserveElementIdsForFiltering operation
+            if (isSubCategory(elementProps) && isDefaultSubCategory(elementProps)) {
+                this.onUpdateElement(elementProps);
+            }
+            else {
+                this.onInsertElement(elementProps);
+            }
+        }
+        else {
+            if (undefined !== elementProps.id) {
+                this.onUpdateElement(elementProps);
+            }
+            else {
+                this.onInsertElement(elementProps); // targetElementProps.id assigned by insertElement
+            }
+        }
+        return elementProps.id;
+    }
+    /** Create a new Element from the specified ElementProps and insert it into the target iModel.
+     * @returns The Id of the newly inserted Element.
+     * @note A subclass may override this method to customize insert behavior but should call `super.onInsertElement`.
+     */
+    onInsertElement(elementProps) {
+        try {
+            const elementId = this.targetDb.nativeDb.insertElement(elementProps, { forceUseId: this.options.preserveElementIdsForFiltering });
+            // set the id like [IModelDb.insertElement]($backend), does, the raw nativeDb method does not
+            elementProps.id = elementId;
+            core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatElementForLogger(elementProps)}`);
+            this.trackProgress();
+            if (this.options.simplifyElementGeometry) {
+                this.targetDb.nativeDb.simplifyElementGeometry({ id: elementId, convertBReps: true });
+                core_bentley_1.Logger.logInfo(loggerCategory, `Simplified element geometry for ${this.formatElementForLogger(elementProps)}`);
+            }
+            return elementId;
+        }
+        catch (error) {
+            if (!this.targetDb.containsClass(elementProps.classFullName)) {
+                // replace standard insert error with something more helpful
+                const errorMessage = `Element class "${elementProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`;
+                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidName, errorMessage);
+            }
+            throw error; // throw original error
+        }
+    }
+    /** Update an existing Element in the target iModel from the specified ElementProps.
+     * @note A subclass may override this method to customize update behavior but should call `super.onUpdateElement`.
+     */
+    onUpdateElement(elementProps) {
+        if (!elementProps.id) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidId, "ElementId not provided");
+        }
+        this.targetDb.elements.updateElement(elementProps);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatElementForLogger(elementProps)}`);
+        this.trackProgress();
+        if (this.options.simplifyElementGeometry) {
+            this.targetDb.nativeDb.simplifyElementGeometry({ id: elementProps.id, convertBReps: true });
+            core_bentley_1.Logger.logInfo(loggerCategory, `Simplified element geometry for ${this.formatElementForLogger(elementProps)}`);
+        }
+    }
+    /** Delete the specified Element (and all its children) from the target iModel.
+     * Will delete special elements like definition elements and subjects.
+     * @note A subclass may override this method to customize delete behavior but should call `super.onDeleteElement`.
+     */
+    onDeleteElement(elementId) {
+        (0, core_backend_1.deleteElementTree)(this.targetDb, elementId);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Deleted element ${elementId} and its descendants`);
+        this.trackProgress();
+    }
+    /** Delete the specified Element from the target iModel. */
+    deleteElement(elementId) {
+        if (this.doNotUpdateElementIds.has(elementId)) {
+            core_bentley_1.Logger.logInfo(loggerCategory, `Do not delete target element ${elementId}`);
+            return;
+        }
+        this.onDeleteElement(elementId);
+    }
+    /** Delete the specified Model from the target iModel.
+     * @note A subclass may override this method to customize delete behavior but should call `super.onDeleteModel`.
+     */
+    onDeleteModel(modelId) {
+        this.targetDb.models.deleteModel(modelId);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Deleted model ${modelId}`);
+        this.trackProgress();
+    }
+    /** Delete the specified Model from the target iModel. */
+    deleteModel(modelId) {
+        this.onDeleteModel(modelId);
+    }
+    /** Format an Element for the Logger. */
+    formatElementForLogger(elementProps) {
+        const namePiece = elementProps.code.value ? `${elementProps.code.value} ` : elementProps.userLabel ? `${elementProps.userLabel} ` : "";
+        return `${elementProps.classFullName} ${namePiece}[${elementProps.id}]`;
+    }
+    /** Import an ElementUniqueAspect into the target iModel. */
+    importElementUniqueAspect(aspectProps) {
+        const aspects = this.targetDb.elements.getAspects(aspectProps.element.id, aspectProps.classFullName);
+        if (aspects.length === 0) {
+            return this.onInsertElementAspect(aspectProps);
+        }
+        else if (hasEntityChanged(aspects[0], aspectProps)) {
+            aspectProps.id = aspects[0].id;
+            this.onUpdateElementAspect(aspectProps);
+        }
+        return aspects[0].id;
+    }
+    /** Import the collection of ElementMultiAspects into the target iModel.
+     * @param aspectPropsArray The ElementMultiAspects to import
+     * @param filterFunc Optional filter func that is used to exclude target ElementMultiAspects that were added during iModel transformation from the update detection logic.
+     * @note For insert vs. update reasons, it is important to process all ElementMultiAspects owned by an Element at once since we don't have aspect-specific provenance.
+     * @returns the array of ids of the resulting ElementMultiAspects, in the same order of the aspectPropsArray parameter
+     */
+    importElementMultiAspects(aspectPropsArray, 
+    /** caller must use this to enforce any aspects added by IModelTransformer are not considered for update */
+    filterFunc = () => true) {
+        const result = new Array(aspectPropsArray.length).fill(undefined);
+        if (aspectPropsArray.length === 0) {
+            return result;
+        }
+        const elementId = aspectPropsArray[0].element.id;
+        // Determine the set of ElementMultiAspect classes to consider
+        const aspectClassFullNames = new Set();
+        aspectPropsArray.forEach((aspectsProps) => {
+            aspectClassFullNames.add(aspectsProps.classFullName);
+        });
+        // Handle ElementMultiAspects in groups by class
+        aspectClassFullNames.forEach((aspectClassFullName) => {
+            const proposedAspects = aspectPropsArray
+                .map((props, index) => ({ props, index }))
+                .filter(({ props }) => aspectClassFullName === props.classFullName);
+            const currentAspects = this.targetDb.elements
+                .getAspects(elementId, aspectClassFullName)
+                .map((props, index) => ({ props, index }))
+                .filter(({ props }) => filterFunc(props));
+            if (proposedAspects.length >= currentAspects.length) {
+                proposedAspects.forEach(({ props, index: resultIndex }, index) => {
+                    let id;
+                    if (index < currentAspects.length) {
+                        id = currentAspects[index].props.id;
+                        props.id = id;
+                        if (hasEntityChanged(currentAspects[index].props, props)) {
+                            this.onUpdateElementAspect(props);
+                        }
+                        id = props.id;
+                    }
+                    else {
+                        id = this.onInsertElementAspect(props);
+                    }
+                    result[resultIndex] = id;
+                });
+            }
+            else {
+                currentAspects.forEach(({ props, index: resultIndex }, index) => {
+                    let id;
+                    if (index < proposedAspects.length) {
+                        id = props.id;
+                        proposedAspects[index].props.id = id;
+                        if (hasEntityChanged(props, proposedAspects[index].props)) {
+                            this.onUpdateElementAspect(proposedAspects[index].props);
+                        }
+                        result[resultIndex] = id;
+                    }
+                    else {
+                        this.onDeleteElementAspect(props);
+                    }
+                });
+            }
+        });
+        assert(result.every((r) => typeof r !== undefined));
+        return result;
+    }
+    /** Insert the ElementAspect into the target iModel.
+     * @note A subclass may override this method to customize insert behavior but should call `super.onInsertElementAspect`.
+     */
+    onInsertElementAspect(aspectProps) {
+        try {
+            const id = this.targetDb.elements.insertAspect(aspectProps);
+            core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatElementAspectForLogger(aspectProps)}`);
+            this.trackProgress();
+            return id;
+        }
+        catch (error) {
+            if (!this.targetDb.containsClass(aspectProps.classFullName)) {
+                // replace standard insert error with something more helpful
+                const errorMessage = `ElementAspect class "${aspectProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`;
+                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidName, errorMessage);
+            }
+            throw error; // throw original error
+        }
+    }
+    /** Update the ElementAspect within the target iModel.
+     * @note A subclass may override this method to customize update behavior but should call `super.onUpdateElementAspect`.
+     */
+    onUpdateElementAspect(aspectProps) {
+        this.targetDb.elements.updateAspect(aspectProps);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatElementAspectForLogger(aspectProps)}`);
+        this.trackProgress();
+    }
+    /** Delete the specified ElementAspect from the target iModel.
+     * @note A subclass may override this method to customize delete behavior but should call `super.onDeleteElementAspect`.
+     */
+    onDeleteElementAspect(targetElementAspect) {
+        this.targetDb.elements.deleteAspect(targetElementAspect.id);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Deleted ${this.formatElementAspectForLogger(targetElementAspect)}`);
+        this.trackProgress();
+    }
+    /** Format an ElementAspect for the Logger. */
+    formatElementAspectForLogger(elementAspectProps) {
+        return `${elementAspectProps.classFullName} elementId=[${elementAspectProps.element.id}]`;
+    }
+    /** Import the specified RelationshipProps (either as an insert or an update) into the target iModel.
+     * @returns The instance Id of the inserted or updated Relationship.
+     */
+    importRelationship(relationshipProps) {
+        if ((undefined === relationshipProps.sourceId) || !core_bentley_1.Id64.isValidId64(relationshipProps.sourceId)) {
+            core_bentley_1.Logger.logInfo(loggerCategory, `Ignoring ${relationshipProps.classFullName} instance because of invalid RelationshipProps.sourceId`);
+            return core_bentley_1.Id64.invalid;
+        }
+        if ((undefined === relationshipProps.targetId) || !core_bentley_1.Id64.isValidId64(relationshipProps.targetId)) {
+            core_bentley_1.Logger.logInfo(loggerCategory, `Ignoring ${relationshipProps.classFullName} instance because of invalid RelationshipProps.targetId`);
+            return core_bentley_1.Id64.invalid;
+        }
+        // check for an existing relationship
+        const relSourceAndTarget = { sourceId: relationshipProps.sourceId, targetId: relationshipProps.targetId };
+        const relationship = this.targetDb.relationships.tryGetInstance(relationshipProps.classFullName, relSourceAndTarget);
+        if (undefined !== relationship) { // if relationship found, update it
+            relationshipProps.id = relationship.id;
+            if (hasEntityChanged(relationship, relationshipProps)) {
+                this.onUpdateRelationship(relationshipProps);
+            }
+            return relationshipProps.id;
+        }
+        else {
+            return this.onInsertRelationship(relationshipProps);
+        }
+    }
+    /** Create a new Relationship from the specified RelationshipProps and insert it into the target iModel.
+     * @returns The instance Id of the newly inserted relationship.
+     * @note A subclass may override this method to customize insert behavior but should call `super.onInsertRelationship`.
+     */
+    onInsertRelationship(relationshipProps) {
+        try {
+            const targetRelInstanceId = this.targetDb.relationships.insertInstance(relationshipProps);
+            core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatRelationshipForLogger(relationshipProps)}`);
+            this.trackProgress();
+            return targetRelInstanceId;
+        }
+        catch (error) {
+            if (!this.targetDb.containsClass(relationshipProps.classFullName)) {
+                // replace standard insert error with something more helpful
+                const errorMessage = `Relationship class "${relationshipProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`;
+                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidName, errorMessage);
+            }
+            throw error; // throw original error
+        }
+    }
+    /** Update an existing Relationship in the target iModel from the specified RelationshipProps.
+     * @note A subclass may override this method to customize update behavior but should call `super.onUpdateRelationship`.
+     */
+    onUpdateRelationship(relationshipProps) {
+        if (!relationshipProps.id) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidId, "Relationship instance Id not provided");
+        }
+        this.targetDb.relationships.updateInstance(relationshipProps);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatRelationshipForLogger(relationshipProps)}`);
+        this.trackProgress();
+    }
+    /** Delete the specified Relationship from the target iModel. */
+    onDeleteRelationship(relationshipProps) {
+        this.targetDb.relationships.deleteInstance(relationshipProps);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Deleted relationship ${this.formatRelationshipForLogger(relationshipProps)}`);
+        this.trackProgress();
+    }
+    /** Delete the specified Relationship from the target iModel. */
+    deleteRelationship(relationshipProps) {
+        this.onDeleteRelationship(relationshipProps);
+    }
+    /** Format a Relationship for the Logger. */
+    formatRelationshipForLogger(relProps) {
+        return `${relProps.classFullName} sourceId=[${relProps.sourceId}] targetId=[${relProps.targetId}]`;
+    }
+    /** Tracks incremental progress */
+    trackProgress() {
+        this._progressCounter++;
+        if (0 === (this._progressCounter % this.progressInterval)) {
+            this.onProgress();
+        }
+    }
+    /** This method is called when IModelImporter has made incremental progress based on the [[progressInterval]] setting.
+     * @note A subclass may override this method to report custom progress but should call `super.onProgress`.
+     */
+    onProgress() { }
+    /** Optionally compute the projectExtents for the target iModel depending on the options for this IModelImporter.
+     * @note This method is automatically called from [IModelTransformer.processChanges]($transformer) and [IModelTransformer.processAll]($transformer).
+     * @see [IModelDb.computeProjectExtents]($backend), [[autoExtendProjectExtents]]
+     */
+    computeProjectExtents() {
+        const computedProjectExtents = this.targetDb.computeProjectExtents({ reportExtentsWithOutliers: true, reportOutliers: true });
+        core_bentley_1.Logger.logInfo(loggerCategory, `Current projectExtents=${JSON.stringify(this.targetDb.projectExtents)}`);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Computed projectExtents without outliers=${JSON.stringify(computedProjectExtents.extents)}`);
+        core_bentley_1.Logger.logInfo(loggerCategory, `Computed projectExtents with outliers=${JSON.stringify(computedProjectExtents.extentsWithOutliers)}`);
+        if (this.options.autoExtendProjectExtents) {
+            const excludeOutliers = typeof this.options.autoExtendProjectExtents === "object" ? this.options.autoExtendProjectExtents.excludeOutliers : false;
+            const newProjectExtents = excludeOutliers ? computedProjectExtents.extents : computedProjectExtents.extentsWithOutliers;
+            if (!newProjectExtents.isAlmostEqual(this.targetDb.projectExtents)) {
+                this.targetDb.updateProjectExtents(newProjectExtents);
+                core_bentley_1.Logger.logInfo(loggerCategory, `Updated projectExtents=${JSON.stringify(this.targetDb.projectExtents)}`);
+            }
+            if (!excludeOutliers && computedProjectExtents.outliers && computedProjectExtents.outliers.length > 0) {
+                core_bentley_1.Logger.logInfo(loggerCategory, `${computedProjectExtents.outliers.length} outliers detected within projectExtents`);
+            }
+        }
+        else {
+            if (!this.targetDb.projectExtents.containsRange(computedProjectExtents.extents)) {
+                core_bentley_1.Logger.logWarning(loggerCategory, "Current project extents may be too small");
+            }
+            if (computedProjectExtents.outliers && computedProjectExtents.outliers.length > 0) {
+                core_bentley_1.Logger.logInfo(loggerCategory, `${computedProjectExtents.outliers.length} outliers detected within projectExtents`);
+            }
+        }
+    }
+    /** Examine the geometry streams of every [GeometricElement3d]($backend) in the target iModel and apply the specified optimizations.
+     * @note This method is automatically called from [[IModelTransformer.processChanges]] and [[IModelTransformer.processAll]] if
+     * [[IModelTransformOptions.optimizeGeometry]] is defined.
+     */
+    optimizeGeometry(options) {
+        if (options.inlineUniqueGeometryParts) {
+            const result = this.targetDb.nativeDb.inlineGeometryPartReferences();
+            core_bentley_1.Logger.logInfo(loggerCategory, `Inlined ${result.numRefsInlined} references to ${result.numCandidateParts} geometry parts and deleted ${result.numPartsDeleted} parts.`);
+        }
+    }
+    /**
+     * You may override this to store arbitrary json state in a exporter state dump, useful for some resumptions
+     * @see [[IModelTransformer.saveStateToFile]]
+     */
+    getAdditionalStateJson() {
+        return {};
+    }
+    /**
+     * You may override this to load arbitrary json state in a transformer state dump, useful for some resumptions
+     * @see [[IModelTransformer.loadStateFromFile]]
+     */
+    loadAdditionalStateJson(_additionalState) { }
+    /**
+     * Reload our state from a JSON object
+     * Intended for [[IModelTransformer.resumeTransformation]]
+     * @internal
+     * You can load custom json from the importer save state for custom importers by overriding [[IModelImporter.loadAdditionalStateJson]]
+     */
+    loadStateFromJson(state) {
+        if (state.importerClass !== this.constructor.name)
+            throw Error("resuming from a differently named importer class, it is not necessarily valid to resume with a different importer class");
+        // ignore readonly since this runs right after construction in [[IModelTransformer.resumeTransformation]]
+        this.options = state.options;
+        if (this.targetDb.iModelId !== state.targetDbId)
+            throw Error("can only load importer state when the same target is reused");
+        // TODO: fix upstream, looks like a bad case for the linter rule when casting away readonly for this generic
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        this.doNotUpdateElementIds = core_bentley_1.CompressedId64Set.decompressSet(state.doNotUpdateElementIds);
+        this.loadAdditionalStateJson(state.additionalState);
+    }
+    /**
+     * Serialize state to a JSON object
+     * Intended for [[IModelTransformer.resumeTransformation]]
+     * @internal
+     * You can add custom json to the importer save state for custom importers by overriding [[IModelImporter.getAdditionalStateJson]]
+     */
+    saveStateToJson() {
+        return {
+            importerClass: this.constructor.name,
+            options: this.options,
+            targetDbId: this.targetDb.iModelId || this.targetDb.nativeDb.getFilePath(),
+            doNotUpdateElementIds: core_bentley_1.CompressedId64Set.compressSet(this.doNotUpdateElementIds),
+            additionalState: this.getAdditionalStateJson(),
+        };
+    }
+}
+exports.IModelImporter = IModelImporter;
+IModelImporter._realityDataSourceLinkPartitionStaticId = "0xe";
+/** Returns true if a change within an Entity is detected.
+ * @param entity The current persistent Entity.
+ * @param entityProps The new EntityProps to compare against
+ * @note This method should only be called if changeset information is not available.
+ * @internal
+ */
+function hasEntityChanged(entity, entityProps, namesToIgnore) {
+    let changed = false;
+    entity.forEachProperty((propertyName, propertyMeta) => {
+        if (!changed) {
+            if (namesToIgnore && namesToIgnore.has(propertyName)) {
+                // skip
+            }
+            else if (core_common_1.PrimitiveTypeCode.Binary === propertyMeta.primitiveType) {
+                changed = hasBinaryValueChanged(entity.asAny[propertyName], entityProps[propertyName]);
+            }
+            else if (propertyMeta.isNavigation) {
+                changed = hasNavigationValueChanged(entity.asAny[propertyName], entityProps[propertyName]);
+            }
+            else {
+                changed = hasValueChanged(entity.asAny[propertyName], entityProps[propertyName]);
+            }
+        }
+    });
+    return changed;
+}
+exports.hasEntityChanged = hasEntityChanged;
+/** Returns true if the specified binary values are different. */
+function hasBinaryValueChanged(binaryProperty1, binaryProperty2) {
+    const jsonString1 = JSON.stringify(binaryProperty1, core_common_1.Base64EncodedString.replacer);
+    const jsonString2 = JSON.stringify(binaryProperty2, core_common_1.Base64EncodedString.replacer);
+    return jsonString1 !== jsonString2;
+}
+/** Returns true if the specified navigation property values are different. */
+function hasNavigationValueChanged(navigationProperty1, navigationProperty2) {
+    const relatedElement1 = core_common_1.RelatedElement.fromJSON(navigationProperty1);
+    const relatedElement2 = core_common_1.RelatedElement.fromJSON(navigationProperty2);
+    const jsonString1 = JSON.stringify(relatedElement1);
+    const jsonString2 = JSON.stringify(relatedElement2);
+    return jsonString1 !== jsonString2;
+}
+/** Returns true if the specified navigation property values are different. */
+function hasValueChanged(property1, property2) {
+    return JSON.stringify(property1) !== JSON.stringify(property2);
+}
+/** check if element props are a subcategory */
+function isSubCategory(props) {
+    return props.classFullName === core_backend_1.SubCategory.classFullName;
+}
+/** check if element props are a subcategory without loading the element */
+function isDefaultSubCategory(props) {
+    var _a;
+    if (props.id === undefined)
+        return false;
+    if (!core_bentley_1.Id64.isId64(props.id))
+        throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, `subcategory had invalid id`);
+    if (((_a = props.parent) === null || _a === void 0 ? void 0 : _a.id) === undefined)
+        throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, `subcategory with id ${props.id} had no parent`);
+    return props.id === core_backend_1.IModelDb.getDefaultSubCategoryId(props.parent.id);
+}
+//# sourceMappingURL=IModelImporter.js.map