@itwin/core-backend 5.15.0-dev.2 → 5.15.0-dev.20

package/lib/esm/test/element/DeleteDefinitionElements.test.js

@@ -4,14 +4,38 @@
 *--------------------------------------------------------------------------------------------*/
 import { assert } from "chai";
 import * as path from "path";
-import { Id64 } from "@itwin/core-bentley";
-import { Point3d } from "@itwin/core-geometry";
+import { DbResult, Id64 } from "@itwin/core-bentley";
+import { Point3d, Range3d } from "@itwin/core-geometry";
 import { Code, CodeScopeSpec, ImageSourceFormat, IModel, QueryBinder, QueryRowFormat, SubCategoryAppearance } from "@itwin/core-common";
-import { EditTxn } from "../../EditTxn";
-import { CategorySelector, ChannelControl, DefinitionContainer, DefinitionModel, DisplayStyle2d, DisplayStyle3d, DocumentListModel, Drawing, DrawingCategory, DrawingGraphic, DrawingViewDefinition, GenericGraphicalType2d, GenericPhysicalType, GeometryPart, GraphicalElement2dIsOfType, IModelJsFs, InformationPartitionElement, ModelSelector, OrthographicViewDefinition, PhysicalElementIsOfType, PhysicalModel, PhysicalPartition, RenderMaterialElement, SnapshotDb, SpatialCategory, SubCategory, Subject, Texture, } from "../../core-backend";
+import { BulkDeleteElementsStatus, BulkDeleteFailureReason, EditTxn } from "../../EditTxn";
+import { _nativeDb, CategorySelector, ChannelControl, DefinitionContainer, DefinitionModel, DisplayStyle2d, DisplayStyle3d, DocumentListModel, Drawing, DrawingCategory, DrawingGraphic, DrawingViewDefinition, GenericGraphicalType2d, GenericPhysicalType, GeometryPart, GraphicalElement2dIsOfType, IModelJsFs, InformationPartitionElement, ModelSelector, OrthographicViewDefinition, PhysicalElementIsOfType, PhysicalModel, PhysicalPartition, RenderMaterialElement, SnapshotDb, SpatialCategory, SubCategory, Subject, Texture, } from "../../core-backend";
 import { ExtensiveTestScenario, IModelTestUtils } from "../IModelTestUtils";
 import { KnownTestLocations } from "../KnownTestLocations";
 import { withEditTxn } from "../TestEditTxn";
+const success = { status: BulkDeleteElementsStatus.Success, sqlDeleteStatus: DbResult.BE_SQLITE_OK, failures: [] };
+/** Nothing is deleted; `failures` lists the direct violators (one entry per element, `ReferencedByForeignKey` wins over `DefinitionInUse`). */
+const constraintViolation = (...failures) => ({ status: BulkDeleteElementsStatus.ConstraintViolation, failures });
+/** The element is a DefinitionElement still used (e.g. via a GeometryStream) by elements outside the delete set. */
+const definitionInUse = (elementId) => ({ elementId, reason: BulkDeleteFailureReason.DefinitionInUse });
+/** The element itself is referenced from outside the delete set via its Code scope. */
+const codeScopeViolator = (elementId) => referencedByForeignKey(elementId);
+/** A row outside the delete set references the element via a hard NO ACTION foreign key. */
+const referencedByForeignKey = (elementId) => ({ elementId, reason: BulkDeleteFailureReason.ReferencedByForeignKey });
+/** A Category still assigned to a GeometricElement3d outside the delete set (hard FK, so not `DefinitionInUse`). */
+const categoryInUse3d = (elementId) => referencedByForeignKey(elementId);
+/** A Category still assigned to a GeometricElement2d outside the delete set (hard FK, so not `DefinitionInUse`). */
+const categoryInUse2d = (elementId) => referencedByForeignKey(elementId);
+/** Assert the result matches `expected` exactly, then check that each id in `deletedIds` is gone and each id in `retainedIds` is still present. */
+const assertResult = (result, expected, deletedIds, retainedIds, iModelDb) => {
+    assert.equal(result.status, expected.status, `Bulk element deletion status is ${BulkDeleteElementsStatus[result.status]}; Expected: ${BulkDeleteElementsStatus[expected.status]}. Actual failures: ${JSON.stringify(result.failures)}`);
+    assert.equal(result.sqlDeleteStatus, expected.sqlDeleteStatus ?? DbResult.BE_SQLITE_OK, `Bulk element deletion internal sql status is ${result.sqlDeleteStatus}; Expected: ${expected.sqlDeleteStatus ?? DbResult.BE_SQLITE_OK}`);
+    assert.equal(result.failures.length, expected.failures.length, `Actual failures don't match the expected. Actual: ${JSON.stringify(result.failures)}; Expected: ${JSON.stringify(expected.failures)}`);
+    assert.deepEqualInAnyOrder(result.failures.map(({ elementId, reason }) => ({ elementId, reason })), expected.failures);
+    for (const retainedId of retainedIds)
+        assert.isDefined(iModelDb.elements.tryGetElement(retainedId), `${retainedId} should have been retained`);
+    for (const deletedId of deletedIds)
+        assert.isUndefined(iModelDb.elements.tryGetElement(deletedId), `${deletedId} should have been deleted`);
+};
 describe("DeleteDefinitionElements", () => {
     const outputDir = path.join(KnownTestLocations.outputDir, "DeleteDefinitionElements");
     let seedDb;
@@ -21,6 +45,7 @@ describe("DeleteDefinitionElements", () => {
     let physicalModelId;
     let spatialCategoryId;
     let subCategoryId;
+    let filteredSubCategoryId;
     let spatialCategorySelectorId;
     let modelSelectorId;
     let displayStyle3dId;
@@ -55,6 +80,7 @@ describe("DeleteDefinitionElements", () => {
         physicalModelId = seedDb.elements.queryElementIdByCode(PhysicalPartition.createCode(seedDb, subjectId, "Physical"));
         spatialCategoryId = seedDb.elements.queryElementIdByCode(SpatialCategory.createCode(seedDb, definitionModelId, "SpatialCategory"));
         subCategoryId = seedDb.elements.queryElementIdByCode(SubCategory.createCode(seedDb, spatialCategoryId, "SubCategory"));
+        filteredSubCategoryId = seedDb.elements.queryElementIdByCode(SubCategory.createCode(seedDb, spatialCategoryId, "FilteredSubCategory"));
         spatialCategorySelectorId = seedDb.elements.queryElementIdByCode(CategorySelector.createCode(seedDb, definitionModelId, "SpatialCategories"));
         modelSelectorId = seedDb.elements.queryElementIdByCode(ModelSelector.createCode(seedDb, definitionModelId, "SpatialModels"));
         displayStyle3dId = seedDb.elements.queryElementIdByCode(DisplayStyle3d.createCode(seedDb, definitionModelId, "DisplayStyle3d"));
@@ -282,183 +308,168 @@ describe("DeleteDefinitionElements", () => {
             return txn.insertElement(props);
         };
         /**
-         * Call deleteElements, verify the returned failed-set, then check which elements survived vs. were deleted.
+         * Failures reported when the used `spatialCategoryId` is requested on its own. Validation runs once over the expanded set
+         * (no pruning between the FK pass and the definition-usage pass), so the used SpatialCategory is reported via its hard FK and
+         * its used non-default SubCategories (pulled into the set as children) are reported as `DefinitionInUse` as well.
+         */
+        const usedSpatialCategoryViolations = () => [
+            categoryInUse3d(spatialCategoryId),
+            definitionInUse(subCategoryId),
+            definitionInUse(filteredSubCategoryId),
+        ];
+        /**
+         * Call deleteElements, compare the returned result object against `expected`, then check which elements survived vs. were deleted.
          * Rolls back changes with abandonChanges afterwards.
          */
-        const executeTestCase = (txn, label, idsToDelete, expectedDeleted, expectedFailed, expectedRetained, abandonChanges = true) => {
-            const failed = txn.deleteElements(idsToDelete);
-            assert.sameMembers(Array.from(failed.failedIds), expectedFailed, `[${label}] failed set mismatch`);
-            for (const id of expectedDeleted)
-                assert.isUndefined(iModelDb.elements.tryGetElement(id), `error reading element`);
-            for (const id of expectedRetained)
-                assert.isDefined(iModelDb.elements.tryGetElement(id), `[${label}] ${id} should have been retained`);
+        const executeTestCase = (txn, _label, idsToDelete, deletedIds, expected, retainedIds, abandonChanges = true) => {
+            const result = txn.deleteElements(idsToDelete);
+            assertResult(result, expected, deletedIds, retainedIds, iModelDb);
             if (abandonChanges)
                 txn.abandonChanges();
         };
         it("should delete only if not used with deleteElements", async () => {
-            let usedDefinitionElementIds;
             const txn = new EditTxn(iModelDb, "delete definition elements");
             txn.start();
-            // make sure deleteElements only skips Elements that are being used (subjectId)
-            usedDefinitionElementIds = txn.deleteElements([physicalObjectId1, physicalObjectId2, physicalObjectId3, subjectId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 1);
-            assert.isUndefined(iModelDb.elements.tryGetElement(physicalObjectId1));
-            assert.isUndefined(iModelDb.elements.tryGetElement(physicalObjectId2));
-            assert.isUndefined(iModelDb.elements.tryGetElement(physicalObjectId3));
-            assert.isDefined(iModelDb.elements.tryGetElement(subjectId));
-            // Reset the db state
-            txn.abandonChanges();
-            // make sure deleteElements throws for invalid Ids
-            assert.throws(() => txn.deleteElements([Id64.invalid, Id64.invalid]));
-            // deleteElement/deleteElements for a used GeometryPart should fail
-            assert.throws(() => txn.deleteElement(geometryPartId));
-            usedDefinitionElementIds = txn.deleteElements([geometryPartId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(geometryPartId));
-            assert.isDefined(iModelDb.elements.tryGetElement(geometryPartId));
-            // deleteElements for an unused GeometryPart should succeed, delete should still fail
-            const unusedGeometryPartProps = {
-                classFullName: GeometryPart.classFullName,
-                model: definitionModelId,
-                code: GeometryPart.createCode(iModelDb, definitionModelId, "Unused GeometryPart"),
-                geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1)),
-            };
-            // Reset the db state
-            txn.abandonChanges();
-            const unusedGeometryPartId = txn.insertElement(unusedGeometryPartProps);
-            assert.isTrue(Id64.isValidId64(unusedGeometryPartId));
-            assert.throws(() => txn.deleteElement(unusedGeometryPartId));
-            usedDefinitionElementIds = txn.deleteElements([unusedGeometryPartId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 0);
-            assert.isUndefined(iModelDb.elements.tryGetElement(unusedGeometryPartId));
-            txn.abandonChanges();
-            // deleteElement/deleteElements for a used RenderMaterial should fail
-            assert.throws(() => txn.deleteElement(renderMaterialId));
-            usedDefinitionElementIds = txn.deleteElements([renderMaterialId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(renderMaterialId));
-            assert.isDefined(iModelDb.elements.tryGetElement(renderMaterialId));
-            txn.abandonChanges();
-            // deleteElements for an unused RenderMaterial should succeed, delete should still fail
-            const unusedRenderMaterialId = RenderMaterialElement.insert(txn, definitionModelId, "Unused RenderMaterial", { paletteName: "PaletteName" });
-            assert.isTrue(Id64.isValidId64(unusedRenderMaterialId));
-            assert.throws(() => txn.deleteElement(unusedRenderMaterialId));
-            usedDefinitionElementIds = txn.deleteElements([unusedRenderMaterialId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 0);
-            assert.isUndefined(iModelDb.elements.tryGetElement(unusedRenderMaterialId));
-            txn.abandonChanges();
-            // deleteElement/deleteElements for a used Texture should fail
-            assert.throws(() => txn.deleteElement(textureId));
-            usedDefinitionElementIds = txn.deleteElements([textureId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(textureId));
-            assert.isDefined(iModelDb.elements.tryGetElement(textureId));
-            txn.abandonChanges();
-            // deleteElements for an unused Texture should succeed, delete should still fail
-            const unusedTextureId = IModelTestUtils.insertTextureElement(txn, definitionModelId, "Unused Texture");
-            assert.isTrue(Id64.isValidId64(unusedTextureId));
-            assert.throws(() => txn.deleteElement(unusedTextureId));
-            usedDefinitionElementIds = txn.deleteElements([unusedTextureId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 0);
-            assert.isUndefined(iModelDb.elements.tryGetElement(unusedTextureId));
-            txn.abandonChanges();
-            // deleteElement/deleteElements for a used SpatialCategory should fail
-            assert.throws(() => txn.deleteElement(spatialCategoryId));
-            usedDefinitionElementIds = txn.deleteElements([spatialCategoryId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(spatialCategoryId));
-            assert.isDefined(iModelDb.elements.tryGetElement(spatialCategoryId));
-            txn.abandonChanges();
-            // deleteElement/deleteElements for a default SubCategory should fail
-            const spatialCategory = iModelDb.elements.getElement(spatialCategoryId, SpatialCategory);
-            const defaultSpatialSubCategoryId = spatialCategory.myDefaultSubCategoryId();
-            assert.throws(() => txn.deleteElement(defaultSpatialSubCategoryId));
-            usedDefinitionElementIds = txn.deleteElements([defaultSpatialSubCategoryId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(defaultSpatialSubCategoryId));
-            assert.isDefined(iModelDb.elements.tryGetElement(defaultSpatialSubCategoryId));
-            txn.abandonChanges();
-            // deleteElement/deleteElements for a used, non-default SubCategory should fail
-            assert.throws(() => txn.deleteElement(subCategoryId));
-            usedDefinitionElementIds = txn.deleteElements([subCategoryId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(subCategoryId));
-            assert.isDefined(iModelDb.elements.tryGetElement(subCategoryId));
-            txn.abandonChanges();
-            // deleteElements for an unused SubCategory should succeed, delete should still fail
-            const unusedSubCategoryId = SubCategory.insert(txn, spatialCategoryId, "Unused SubCategory", {});
-            assert.isTrue(Id64.isValidId64(unusedSubCategoryId));
-            assert.throws(() => txn.deleteElement(unusedSubCategoryId));
-            usedDefinitionElementIds = txn.deleteElements([unusedSubCategoryId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 0);
-            assert.isUndefined(iModelDb.elements.tryGetElement(unusedSubCategoryId));
-            txn.abandonChanges();
-            // deleteElements for an unused SpatialCategory should succeed, delete should still fail
-            const unusedSpatialCategoryId = SpatialCategory.insert(txn, definitionModelId, "Unused SpatialCategory", {});
-            assert.isTrue(Id64.isValidId64(unusedSpatialCategoryId));
-            const unusedSpatialCategory = iModelDb.elements.getElement(unusedSpatialCategoryId, SpatialCategory);
-            const unusedSpatialCategoryDefaultSubCategoryId = unusedSpatialCategory.myDefaultSubCategoryId();
-            assert.isTrue(Id64.isValidId64(unusedSpatialCategoryDefaultSubCategoryId));
-            assert.throws(() => txn.deleteElement(unusedSpatialCategoryId));
-            assert.throws(() => txn.deleteElement(unusedSpatialCategoryDefaultSubCategoryId));
-            usedDefinitionElementIds = txn.deleteElements([unusedSpatialCategoryId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 0);
-            assert.isUndefined(iModelDb.elements.tryGetElement(unusedSpatialCategoryId));
-            assert.isUndefined(iModelDb.elements.tryGetElement(unusedSpatialCategoryDefaultSubCategoryId));
-            txn.abandonChanges();
-            // deleteElement/deleteElements of a used DrawingCategory should fail
-            assert.throws(() => txn.deleteElement(drawingCategoryId));
-            usedDefinitionElementIds = txn.deleteElements([drawingCategoryId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(drawingCategoryId));
-            assert.isDefined(iModelDb.elements.tryGetElement(drawingCategoryId));
-            txn.abandonChanges();
-            // deleteElements for an unused DrawingCategory should succeed, delete should still fail
-            const unusedDrawingCategoryId = DrawingCategory.insert(txn, definitionModelId, "Unused DrawingCategory", {});
-            assert.isTrue(Id64.isValidId64(unusedDrawingCategoryId));
-            const unusedDrawingCategory = iModelDb.elements.getElement(unusedDrawingCategoryId, DrawingCategory);
-            const unusedDrawingSubCategoryId = unusedDrawingCategory.myDefaultSubCategoryId();
-            assert.isTrue(Id64.isValidId64(unusedDrawingSubCategoryId));
-            assert.throws(() => txn.deleteElement(unusedDrawingSubCategoryId));
-            usedDefinitionElementIds = txn.deleteElements([unusedDrawingCategoryId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 0);
-            assert.isUndefined(iModelDb.elements.tryGetElement(unusedDrawingCategoryId));
-            assert.isUndefined(iModelDb.elements.tryGetElement(unusedDrawingSubCategoryId));
-            txn.abandonChanges();
-            // deleteElement/deleteElements of DefinitionElements used by an existing SpatialViewDefinition should fail
-            assert.throws(() => txn.deleteElement(spatialCategorySelectorId));
-            assert.throws(() => txn.deleteElement(modelSelectorId));
-            assert.throws(() => txn.deleteElement(displayStyle3dId));
-            usedDefinitionElementIds = txn.deleteElements([spatialCategorySelectorId, modelSelectorId, displayStyle3dId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(spatialCategorySelectorId));
-            assert.isTrue(usedDefinitionElementIds.has(modelSelectorId));
-            assert.isTrue(usedDefinitionElementIds.has(displayStyle3dId));
-            assert.isDefined(iModelDb.elements.tryGetElement(spatialCategorySelectorId));
-            assert.isDefined(iModelDb.elements.tryGetElement(modelSelectorId));
-            assert.isDefined(iModelDb.elements.tryGetElement(displayStyle3dId));
-            assert.isDefined(iModelDb.elements.tryGetElement(viewId));
-            txn.abandonChanges();
-            // deleteElements should succeed when the list includes the SpatialViewDefinition as the only thing referencing other DefinitionElements, delete should still fail
-            assert.throws(() => txn.deleteElement(viewId));
-            usedDefinitionElementIds = txn.deleteElements([viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 0);
-            assert.isUndefined(iModelDb.elements.tryGetElement(spatialCategorySelectorId));
-            assert.isUndefined(iModelDb.elements.tryGetElement(modelSelectorId));
-            assert.isUndefined(iModelDb.elements.tryGetElement(displayStyle3dId));
-            assert.isUndefined(iModelDb.elements.tryGetElement(viewId));
-            txn.abandonChanges();
-            // deleteElement/deleteElements of DefinitionElements used by an existing DrawingViewDefinition should fail
-            assert.throws(() => txn.deleteElement(drawingCategorySelectorId));
-            assert.throws(() => txn.deleteElement(displayStyle2dId));
-            usedDefinitionElementIds = txn.deleteElements([drawingCategorySelectorId, displayStyle2dId]).failedIds;
-            assert.isTrue(usedDefinitionElementIds.has(drawingCategorySelectorId));
-            assert.isTrue(usedDefinitionElementIds.has(displayStyle2dId));
-            assert.isDefined(iModelDb.elements.tryGetElement(drawingCategorySelectorId));
-            assert.isDefined(iModelDb.elements.tryGetElement(displayStyle2dId));
-            assert.isDefined(iModelDb.elements.tryGetElement(drawingViewId));
-            txn.abandonChanges();
-            // deleteElements should succeed when the list includes the DrawingViewDefinition as the only thing referencing other DefinitionElements, delete should still fail
-            assert.throws(() => txn.deleteElement(drawingViewId));
-            usedDefinitionElementIds = txn.deleteElements([drawingViewId, drawingCategorySelectorId, displayStyle2dId]).failedIds;
-            assert.equal(usedDefinitionElementIds.size, 0);
-            assert.isUndefined(iModelDb.elements.tryGetElement(drawingCategorySelectorId));
-            assert.isUndefined(iModelDb.elements.tryGetElement(displayStyle2dId));
-            assert.isUndefined(iModelDb.elements.tryGetElement(drawingViewId));
-            txn.end("abandon");
-            iModelDb.close();
+            /** Run deleteElements and compare the returned result object against `expected`, then check deleted / retained ids. */
+            const expectDelete = (idsToDelete, expected, deletedIds, retainedIds) => assertResult(txn.deleteElements(idsToDelete), expected, deletedIds, retainedIds, iModelDb);
+            try {
+                // Deleting the Subject expands the delete set to everything beneath it (partitions, sub-models and their contents).
+                // Every element in this iModel lives under that Subject, so all usages of the categories / GeometryPart / RenderMaterial
+                // in the Definition model are *intra-set* and must not block the deletion: everything is deleted.
+                expectDelete([physicalObjectId1, physicalObjectId2, physicalObjectId3, subjectId], success, [physicalObjectId1, physicalObjectId2, physicalObjectId3, subjectId, definitionModelId, physicalModelId, spatialCategoryId, geometryPartId, renderMaterialId], []);
+                // Reset the db state
+                txn.abandonChanges();
+                // make sure deleteElements throws for invalid Ids
+                assert.throws(() => txn.deleteElements([Id64.invalid, Id64.invalid]));
+                // deleteElement/deleteElements for a used GeometryPart should fail
+                assert.throws(() => txn.deleteElement(geometryPartId));
+                expectDelete([geometryPartId], constraintViolation(definitionInUse(geometryPartId)), [], [geometryPartId]);
+                // deleteElements for an unused GeometryPart should succeed, delete should still fail
+                const unusedGeometryPartProps = {
+                    classFullName: GeometryPart.classFullName,
+                    model: definitionModelId,
+                    code: GeometryPart.createCode(iModelDb, definitionModelId, "Unused GeometryPart"),
+                    geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1)),
+                };
+                // Reset the db state
+                txn.abandonChanges();
+                const unusedGeometryPartId = txn.insertElement(unusedGeometryPartProps);
+                assert.isTrue(Id64.isValidId64(unusedGeometryPartId));
+                assert.throws(() => txn.deleteElement(unusedGeometryPartId));
+                expectDelete([unusedGeometryPartId], success, [unusedGeometryPartId], []);
+                txn.abandonChanges();
+                // deleteElement/deleteElements for a used RenderMaterial should fail
+                assert.throws(() => txn.deleteElement(renderMaterialId));
+                expectDelete([renderMaterialId], constraintViolation(definitionInUse(renderMaterialId)), [], [renderMaterialId]);
+                txn.abandonChanges();
+                // deleteElements for an unused RenderMaterial should succeed, delete should still fail
+                const unusedRenderMaterialId = RenderMaterialElement.insert(txn, definitionModelId, "Unused RenderMaterial", { paletteName: "PaletteName" });
+                assert.isTrue(Id64.isValidId64(unusedRenderMaterialId));
+                assert.throws(() => txn.deleteElement(unusedRenderMaterialId));
+                expectDelete([unusedRenderMaterialId], success, [unusedRenderMaterialId], []);
+                txn.abandonChanges();
+                // deleteElement/deleteElements for a used Texture should fail
+                assert.throws(() => txn.deleteElement(textureId));
+                expectDelete([textureId], constraintViolation(definitionInUse(textureId)), [], [textureId]);
+                txn.abandonChanges();
+                // deleteElements for an unused Texture should succeed, delete should still fail
+                const unusedTextureId = IModelTestUtils.insertTextureElement(txn, definitionModelId, "Unused Texture");
+                assert.isTrue(Id64.isValidId64(unusedTextureId));
+                assert.throws(() => txn.deleteElement(unusedTextureId));
+                expectDelete([unusedTextureId], success, [unusedTextureId], []);
+                txn.abandonChanges();
+                // deleteElement/deleteElements for a used SpatialCategory should fail (hard FK from GeometricElement3d.CategoryId, so not DefinitionInUse).
+                // Its used non-default SubCategories are pulled into the set as children and are reported as well.
+                assert.throws(() => txn.deleteElement(spatialCategoryId));
+                expectDelete([spatialCategoryId], constraintViolation(...usedSpatialCategoryViolations()), [], [spatialCategoryId, subCategoryId, filteredSubCategoryId]);
+                txn.abandonChanges();
+                // deleteElement/deleteElements for a default SubCategory should fail
+                const spatialCategory = iModelDb.elements.getElement(spatialCategoryId, SpatialCategory);
+                const defaultSpatialSubCategoryId = spatialCategory.myDefaultSubCategoryId();
+                assert.throws(() => txn.deleteElement(defaultSpatialSubCategoryId));
+                expectDelete([defaultSpatialSubCategoryId], constraintViolation(definitionInUse(defaultSpatialSubCategoryId)), [], [defaultSpatialSubCategoryId]);
+                txn.abandonChanges();
+                // deleteElement/deleteElements for a used, non-default SubCategory should fail
+                assert.throws(() => txn.deleteElement(subCategoryId));
+                expectDelete([subCategoryId], constraintViolation(definitionInUse(subCategoryId)), [], [subCategoryId]);
+                txn.abandonChanges();
+                // deleteElements for an unused SubCategory should succeed, delete should still fail
+                const unusedSubCategoryId = SubCategory.insert(txn, spatialCategoryId, "Unused SubCategory", {});
+                assert.isTrue(Id64.isValidId64(unusedSubCategoryId));
+                assert.throws(() => txn.deleteElement(unusedSubCategoryId));
+                expectDelete([unusedSubCategoryId], success, [unusedSubCategoryId], []);
+                txn.abandonChanges();
+                // deleteElements for an unused SpatialCategory should succeed, delete should still fail
+                const unusedSpatialCategoryId = SpatialCategory.insert(txn, definitionModelId, "Unused SpatialCategory", {});
+                assert.isTrue(Id64.isValidId64(unusedSpatialCategoryId));
+                const unusedSpatialCategory = iModelDb.elements.getElement(unusedSpatialCategoryId, SpatialCategory);
+                const unusedSpatialCategoryDefaultSubCategoryId = unusedSpatialCategory.myDefaultSubCategoryId();
+                assert.isTrue(Id64.isValidId64(unusedSpatialCategoryDefaultSubCategoryId));
+                assert.throws(() => txn.deleteElement(unusedSpatialCategoryId));
+                assert.throws(() => txn.deleteElement(unusedSpatialCategoryDefaultSubCategoryId));
+                expectDelete([unusedSpatialCategoryId], success, [unusedSpatialCategoryId, unusedSpatialCategoryDefaultSubCategoryId], []);
+                txn.abandonChanges();
+                // deleteElement/deleteElements of a used DrawingCategory should fail (hard FK from GeometricElement2d.CategoryId, so not DefinitionInUse)
+                assert.throws(() => txn.deleteElement(drawingCategoryId));
+                expectDelete([drawingCategoryId], constraintViolation(categoryInUse2d(drawingCategoryId)), [], [drawingCategoryId]);
+                txn.abandonChanges();
+                // deleteElements for an unused DrawingCategory should succeed, delete should still fail
+                const unusedDrawingCategoryId = DrawingCategory.insert(txn, definitionModelId, "Unused DrawingCategory", {});
+                assert.isTrue(Id64.isValidId64(unusedDrawingCategoryId));
+                const unusedDrawingCategory = iModelDb.elements.getElement(unusedDrawingCategoryId, DrawingCategory);
+                const unusedDrawingSubCategoryId = unusedDrawingCategory.myDefaultSubCategoryId();
+                assert.isTrue(Id64.isValidId64(unusedDrawingSubCategoryId));
+                assert.throws(() => txn.deleteElement(unusedDrawingSubCategoryId));
+                expectDelete([unusedDrawingCategoryId], success, [unusedDrawingCategoryId, unusedDrawingSubCategoryId], []);
+                txn.abandonChanges();
+                // deleteElement/deleteElements of DefinitionElements used by an existing SpatialViewDefinition should fail
+                assert.throws(() => txn.deleteElement(spatialCategorySelectorId));
+                assert.throws(() => txn.deleteElement(modelSelectorId));
+                assert.throws(() => txn.deleteElement(displayStyle3dId));
+                expectDelete([spatialCategorySelectorId, modelSelectorId, displayStyle3dId], constraintViolation(definitionInUse(spatialCategorySelectorId), definitionInUse(modelSelectorId), definitionInUse(displayStyle3dId)), [], [spatialCategorySelectorId, modelSelectorId, displayStyle3dId, viewId]);
+                txn.abandonChanges();
+                // deleteElements should succeed when the list includes the SpatialViewDefinition as the only thing referencing other DefinitionElements, delete should still fail
+                assert.throws(() => txn.deleteElement(viewId));
+                expectDelete([viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId], success, [viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId], []);
+                txn.abandonChanges();
+                // deleteElement/deleteElements of DefinitionElements used by an existing DrawingViewDefinition should fail
+                assert.throws(() => txn.deleteElement(drawingCategorySelectorId));
+                assert.throws(() => txn.deleteElement(displayStyle2dId));
+                expectDelete([drawingCategorySelectorId, displayStyle2dId], constraintViolation(definitionInUse(drawingCategorySelectorId), definitionInUse(displayStyle2dId)), [], [drawingCategorySelectorId, displayStyle2dId, drawingViewId]);
+                txn.abandonChanges();
+                // deleteElements should succeed when the list includes the DrawingViewDefinition as the only thing referencing other DefinitionElements, delete should still fail
+                assert.throws(() => txn.deleteElement(drawingViewId));
+                expectDelete([drawingViewId, drawingCategorySelectorId, displayStyle2dId], success, [drawingViewId, drawingCategorySelectorId, displayStyle2dId], []);
+            }
+            finally {
+                if (txn.isActive)
+                    txn.end("abandon");
+            }
+        });
+        it("deleting a Subject is rejected when a definition beneath it is used from outside its subtree", () => {
+            const txn = new EditTxn(iModelDb, "delete subject with outside user");
+            txn.start();
+            try {
+                // A PhysicalObject in a model that is NOT under the Subject uses the SpatialCategory. The category is a hard FK violator
+                // (bis_GeometricElement3d.CategoryId, so ReferencedByForeignKey rather than DefinitionInUse). Its SubCategories are only
+                // used by elements inside the Subject's subtree, so they are not reported. The whole call is rejected - the requested
+                // PhysicalObjects survive as well, even though nothing references them.
+                const outsideModelId = PhysicalModel.insert(txn, IModel.rootSubjectId, "OutsideSubject");
+                const outsideUserProps = {
+                    classFullName: "Generic:PhysicalObject",
+                    model: outsideModelId,
+                    category: spatialCategoryId,
+                    code: Code.createEmpty(),
+                    placement: { origin: Point3d.create(0, 0, 0).toJSON(), angles: {} },
+                };
+                const outsideUserId = txn.insertElement(outsideUserProps);
+                txn.saveChanges();
+                executeTestCase(txn, "subject rejected by outside user of its category", [physicalObjectId1, physicalObjectId2, physicalObjectId3, subjectId], [], constraintViolation(categoryInUse3d(spatialCategoryId)), [physicalObjectId1, physicalObjectId2, physicalObjectId3, subjectId, definitionModelId, physicalModelId, spatialCategoryId, IModel.getDefaultSubCategoryId(spatialCategoryId), outsideUserId]);
+            }
+            finally {
+                if (txn.isActive)
+                    txn.end("abandon");
+            }
         });
         describe("basic tests", () => {
             let txn;
@@ -471,28 +482,25 @@ describe("DeleteDefinitionElements", () => {
             });
             it("deletes a single unused definition element", () => {
                 const element = insertDefinitionElement(txn);
-                executeTestCase(txn, "single unused definition element", [element], [element], [], []);
+                executeTestCase(txn, "single unused definition element", [element], [element], success, []);
             });
             it("deletes multiple unused definition elements in one call", () => {
                 const element1 = insertDefinitionElement(txn);
                 const element2 = insertDefinitionElement(txn);
                 const element3 = insertDefinitionElement(txn);
-                executeTestCase(txn, "multiple unused definition elements", [element1, element2, element3], [element1, element2, element3], [], []);
+                executeTestCase(txn, "multiple unused definition elements", [element1, element2, element3], [element1, element2, element3], success, []);
             });
-            it("returns empty failed-set when given an empty array", () => {
-                const failed = txn.deleteElements([]).failedIds;
-                assert.isEmpty(Array.from(failed), "empty input should return empty failed set");
+            it("returns a Success result when given an empty array", () => {
+                executeTestCase(txn, "empty input", [], [], success, []);
             });
             it("throws for invalid ids", () => {
                 assert.throws(() => txn.deleteElements([Id64.invalid, Id64.invalid]));
             });
-            it("keeps an in-use definition element in the failed set and does not delete it", () => {
+            it("reports an in-use definition element as a failure and does not delete it", () => {
                 // geometryPartId is referenced by PhysicalObject1's geometry stream
-                const failed = txn.deleteElements([geometryPartId]);
-                assert.isTrue(failed.failedIds.has(geometryPartId), "in-use definition element must be in failed set");
-                assert.isDefined(iModelDb.elements.tryGetElement(geometryPartId), "in-use definition element must not be deleted");
+                executeTestCase(txn, "in-use GeometryPart", [geometryPartId], [], constraintViolation(definitionInUse(geometryPartId)), [geometryPartId]);
             });
-            it("returns only the in-use definition element in the failed set when mixing used and unused parts", () => {
+            it("reports only the in-use definition element as a failure when mixing used and unused parts, and deletes nothing", () => {
                 const unusedElement = insertDefinitionElement(txn);
                 const usedElement = insertDefinitionElement(txn);
                 // Reference usedElement from a physical element geometry stream
@@ -505,27 +513,23 @@ describe("DeleteDefinitionElements", () => {
                     geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1), spatialCategoryId, undefined, undefined, usedElement),
                 };
                 const physElemId = txn.insertElement(physElemProps);
-                executeTestCase(txn, "used + unused definition elements", [unusedElement, usedElement], [unusedElement], [usedElement], [usedElement, physElemId]);
+                executeTestCase(txn, "used + unused definition elements", [unusedElement, usedElement], [], constraintViolation(definitionInUse(usedElement)), [unusedElement, usedElement, physElemId]);
             });
-            it("keeps an in-use RenderMaterial in the failed set and does not delete it", () => {
-                const failed = txn.deleteElements([renderMaterialId]);
-                assert.isTrue(failed.failedIds.has(renderMaterialId), "in-use RenderMaterial must be in failed set");
-                assert.isDefined(iModelDb.elements.tryGetElement(renderMaterialId), "in-use RenderMaterial must not be deleted");
+            it("reports an in-use RenderMaterial as a failure and does not delete it", () => {
+                executeTestCase(txn, "in-use RenderMaterial", [renderMaterialId], [], constraintViolation(definitionInUse(renderMaterialId)), [renderMaterialId]);
             });
             it("deletes an unused RenderMaterial", () => {
                 const unusedRenderMaterialId = RenderMaterialElement.insert(txn, definitionModelId, "Unused RenderMaterial", { paletteName: "PaletteName" });
-                executeTestCase(txn, "unused RenderMaterial", [unusedRenderMaterialId], [unusedRenderMaterialId], [], []);
+                executeTestCase(txn, "unused RenderMaterial", [unusedRenderMaterialId], [unusedRenderMaterialId], success, []);
             });
-            it("keeps an in-use Texture in the failed set and does not delete it", () => {
-                const failed = txn.deleteElements([textureId]);
-                assert.isTrue(failed.failedIds.has(textureId), "in-use Texture must be in failed set");
-                assert.isDefined(iModelDb.elements.tryGetElement(textureId), "in-use Texture must not be deleted");
+            it("reports an in-use Texture as a failure and does not delete it", () => {
+                executeTestCase(txn, "in-use Texture", [textureId], [], constraintViolation(definitionInUse(textureId)), [textureId]);
             });
             it("deletes an unused Texture", () => {
                 const unusedTextureId = IModelTestUtils.insertTextureElement(txn, definitionModelId, "Unused Texture");
-                executeTestCase(txn, "unused Texture", [unusedTextureId], [unusedTextureId], [], []);
+                executeTestCase(txn, "unused Texture", [unusedTextureId], [unusedTextureId], success, []);
             });
-            it("returns the full input as the failed set when every element is an in-use definition element", () => {
+            it("reports every element as a failure when all are in-use definition elements", () => {
                 const usedElement1 = insertDefinitionElement(txn);
                 const usedElement2 = insertDefinitionElement(txn);
                 const usedElement3 = insertDefinitionElement(txn);
@@ -543,11 +547,33 @@ describe("DeleteDefinitionElements", () => {
                 assert.isTrue(Id64.isValid(txn.insertElement(physElemProps)));
                 physElemProps.geom = IModelTestUtils.createBox(Point3d.create(1, 1, 1), spatialCategoryId, undefined, undefined, usedElement3);
                 assert.isTrue(Id64.isValid(txn.insertElement(physElemProps)));
-                const failedToDelete = txn.deleteElements([usedElement1, usedElement2, usedElement3]);
-                assert.equal(failedToDelete.failedIds.size, 3, "all in-use definition elements should be in failed set");
-                assert.isTrue(failedToDelete.failedIds.has(usedElement1));
-                assert.isTrue(failedToDelete.failedIds.has(usedElement2));
-                assert.isTrue(failedToDelete.failedIds.has(usedElement3));
+                // Every requested element is in use - all three are reported and nothing is deleted.
+                executeTestCase(txn, "all in-use", [usedElement1, usedElement2, usedElement3], [], constraintViolation(definitionInUse(usedElement1), definitionInUse(usedElement2), definitionInUse(usedElement3)), [usedElement1, usedElement2, usedElement3]);
+            });
+            it("a definition used only by elements inside the delete set is not DefinitionInUse", () => {
+                const insertPhysicalObject = (model, category) => {
+                    const props = {
+                        classFullName: "Generic:PhysicalObject",
+                        model,
+                        category,
+                        code: Code.createEmpty(),
+                        placement: { origin: [0, 0, 0], angles: { yaw: 0, pitch: 0, roll: 0 } },
+                    };
+                    return txn.insertElement(props);
+                };
+                // Case 1: the only user of the category is requested directly.
+                const directCategory = SpatialCategory.insert(txn, definitionModelId, "DirectUserCategory", new SubCategoryAppearance());
+                const directUser = insertPhysicalObject(physicalModelId, directCategory);
+                // Case 2: the only user of the category lives in a sub-model that is reached through the partition cascade, i.e. it is in the
+                // *expanded* delete set but not in the requested ids.
+                const cascadeCategory = SpatialCategory.insert(txn, definitionModelId, "CascadeUserCategory", new SubCategoryAppearance());
+                const partitionId = PhysicalModel.insert(txn, subjectId, "CascadeUserModel");
+                const cascadeUser = insertPhysicalObject(partitionId, cascadeCategory);
+                txn.saveChanges();
+                const directSubCategory = IModel.getDefaultSubCategoryId(directCategory);
+                const cascadeSubCategory = IModel.getDefaultSubCategoryId(cascadeCategory);
+                executeTestCase(txn, "category + its direct user", [directCategory, directUser], [directCategory, directSubCategory, directUser], success, [cascadeCategory, cascadeSubCategory, cascadeUser]);
+                executeTestCase(txn, "category + partition containing its only user", [cascadeCategory, partitionId], [cascadeCategory, cascadeSubCategory, partitionId, cascadeUser], success, [directCategory, directSubCategory, directUser]);
             });
         });
         describe("category and subcategory tests", () => {
@@ -559,53 +585,47 @@ describe("DeleteDefinitionElements", () => {
             afterEach(() => {
                 txn.end("abandon");
             });
-            it("keeps an in-use SpatialCategory in the failed set and does not delete it", () => {
-                const failed = txn.deleteElements([spatialCategoryId]);
-                assert.isTrue(failed.failedIds.has(spatialCategoryId), "in-use SpatialCategory must be in failed set");
-                assert.isDefined(iModelDb.elements.tryGetElement(spatialCategoryId), "in-use SpatialCategory must not be deleted");
+            it("reports an in-use SpatialCategory as an FK violator (plus its used SubCategories) and does not delete it", () => {
+                executeTestCase(txn, "in-use SpatialCategory", [spatialCategoryId], [], constraintViolation(...usedSpatialCategoryViolations()), [spatialCategoryId, subCategoryId, filteredSubCategoryId]);
             });
-            it("keeps the default SubCategory in the failed set when its parent SpatialCategory is in use", () => {
+            it("reports the default SubCategory as a failure when its parent SpatialCategory is in use", () => {
                 const spatialCategory = iModelDb.elements.getElement(spatialCategoryId, SpatialCategory);
                 const defaultSubCategoryId = spatialCategory.myDefaultSubCategoryId();
-                const failed = txn.deleteElements([defaultSubCategoryId]);
-                assert.isTrue(failed.failedIds.has(defaultSubCategoryId), "default SubCategory must be in failed set");
-                assert.isDefined(iModelDb.elements.tryGetElement(defaultSubCategoryId), "default SubCategory must not be deleted");
+                executeTestCase(txn, "default SubCategory", [defaultSubCategoryId], [], constraintViolation(definitionInUse(defaultSubCategoryId)), [defaultSubCategoryId]);
             });
-            it("keeps a used non-default SubCategory in the failed set and does not delete it", () => {
-                const failed = txn.deleteElements([subCategoryId]);
-                assert.isTrue(failed.failedIds.has(subCategoryId), "in-use SubCategory must be in failed set");
-                assert.isDefined(iModelDb.elements.tryGetElement(subCategoryId), "in-use SubCategory must not be deleted");
+            it("reports a used non-default SubCategory as a failure and does not delete it", () => {
+                executeTestCase(txn, "in-use SubCategory", [subCategoryId], [], constraintViolation(definitionInUse(subCategoryId)), [subCategoryId]);
             });
             it("deletes an unused non-default SubCategory", () => {
                 const unusedSubCategoryId = SubCategory.insert(txn, spatialCategoryId, "Unused SubCategory", {});
-                executeTestCase(txn, "unused SubCategory", [unusedSubCategoryId], [unusedSubCategoryId], [], [spatialCategoryId]);
+                executeTestCase(txn, "unused SubCategory", [unusedSubCategoryId], [unusedSubCategoryId], success, [spatialCategoryId]);
             });
             it("deletes an unused SpatialCategory together with its default SubCategory", () => {
                 const unusedCategoryId = SpatialCategory.insert(txn, definitionModelId, "Unused SpatialCategory", {});
                 const unusedCategory = iModelDb.elements.getElement(unusedCategoryId, SpatialCategory);
                 const unusedDefaultSubCategoryId = unusedCategory.myDefaultSubCategoryId();
-                executeTestCase(txn, "unused SpatialCategory + default SubCategory", [unusedCategoryId], [unusedCategoryId, unusedDefaultSubCategoryId], [], []);
+                executeTestCase(txn, "unused SpatialCategory + default SubCategory", [unusedCategoryId], [unusedCategoryId, unusedDefaultSubCategoryId], success, []);
             });
             it("deletes an unused DrawingCategory together with its default SubCategory", () => {
                 const unusedDrawingCategoryId = DrawingCategory.insert(txn, definitionModelId, "Unused DrawingCategory", {});
                 const unusedDrawingCategory = iModelDb.elements.getElement(unusedDrawingCategoryId, DrawingCategory);
                 const unusedDrawingSubCategoryId = unusedDrawingCategory.myDefaultSubCategoryId();
-                executeTestCase(txn, "unused DrawingCategory + default SubCategory", [unusedDrawingCategoryId], [unusedDrawingCategoryId, unusedDrawingSubCategoryId], [], []);
+                executeTestCase(txn, "unused DrawingCategory + default SubCategory", [unusedDrawingCategoryId], [unusedDrawingCategoryId, unusedDrawingSubCategoryId], success, []);
             });
-            it("keeps CategorySelector, ModelSelector, DisplayStyle3d in the failed set when their view still exists", () => {
-                executeTestCase(txn, "view-related still referenced", [spatialCategorySelectorId, modelSelectorId, displayStyle3dId], [], [spatialCategorySelectorId, modelSelectorId, displayStyle3dId], [spatialCategorySelectorId, modelSelectorId, displayStyle3dId, viewId]);
+            it("reports CategorySelector, ModelSelector, DisplayStyle3d as failures when their view still exists", () => {
+                executeTestCase(txn, "view-related still referenced", [spatialCategorySelectorId, modelSelectorId, displayStyle3dId], [], constraintViolation(definitionInUse(spatialCategorySelectorId), definitionInUse(modelSelectorId), definitionInUse(displayStyle3dId)), [spatialCategorySelectorId, modelSelectorId, displayStyle3dId, viewId]);
             });
             it("deletes CategorySelector, ModelSelector, DisplayStyle3d and the SpatialViewDefinition in one call", () => {
-                executeTestCase(txn, "view + view-related", [viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId], [viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId], [], []);
+                executeTestCase(txn, "view + view-related", [viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId], [viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId], success, []);
             });
             it("deletes DrawingCategorySelector, DisplayStyle2d and the DrawingViewDefinition in one call", () => {
-                executeTestCase(txn, "drawing view + drawing view-related", [drawingViewId, drawingCategorySelectorId, displayStyle2dId], [drawingViewId, drawingCategorySelectorId, displayStyle2dId], [], []);
+                executeTestCase(txn, "drawing view + drawing view-related", [drawingViewId, drawingCategorySelectorId, displayStyle2dId], [drawingViewId, drawingCategorySelectorId, displayStyle2dId], success, []);
             });
             it("deletes orphaned CategorySelector and DisplayStyle2d (no view references them)", () => {
                 // Insert a standalone CategorySelector and DisplayStyle2d that are not referenced by any view
                 const orphanCategorySelectorId = CategorySelector.insert(txn, definitionModelId, "OrphanCategorySelector", [drawingCategoryId]);
                 const orphanDisplayStyle2dId = DisplayStyle2d.insert(txn, definitionModelId, "OrphanDisplayStyle2d");
-                executeTestCase(txn, "orphaned view-related elements", [orphanCategorySelectorId, orphanDisplayStyle2dId], [orphanCategorySelectorId, orphanDisplayStyle2dId], [], []);
+                executeTestCase(txn, "orphaned view-related elements", [orphanCategorySelectorId, orphanDisplayStyle2dId], [orphanCategorySelectorId, orphanDisplayStyle2dId], success, []);
             });
         });
         describe("Element hierarchy", () => {
@@ -621,13 +641,13 @@ describe("DeleteDefinitionElements", () => {
                 const parentPart = insertDefinitionElement(txn);
                 const childPart = insertDefinitionElement(txn, parentPart);
                 // Only pass the parent - the child must be pulled in automatically
-                executeTestCase(txn, "parent + child definition elements", [parentPart], [parentPart, childPart], [], []);
+                executeTestCase(txn, "parent + child definition elements", [parentPart], [parentPart, childPart], success, []);
             });
             it("deletes a parent DefinitionElement and its child explicitly passed", () => {
                 const parentPart = insertDefinitionElement(txn);
                 const childPart = insertDefinitionElement(txn, parentPart);
                 // Pass both parent and child explicitly
-                executeTestCase(txn, "parent + child definition elements", [parentPart, childPart], [parentPart, childPart], [], []);
+                executeTestCase(txn, "parent + child definition elements", [parentPart, childPart], [parentPart, childPart], success, []);
             });
             // Intra-set code scope
             // Both partA and partB are in the input set; partB uses partA as its CodeScope.
@@ -644,7 +664,7 @@ describe("DeleteDefinitionElements", () => {
                 };
                 const partB = txn.insertElement(partBProps);
                 // Both unused externally; the intra-set code-scope link must not block deletion
-                executeTestCase(txn, "intra-set code scope", [partA, partB], [partA, partB], [], []);
+                executeTestCase(txn, "intra-set code scope", [partA, partB], [partA, partB], success, []);
             });
             // Multi-level parent-child hierarchy
             // Passing only the root must automatically pull in all descendants (leaf-first).
@@ -655,14 +675,14 @@ describe("DeleteDefinitionElements", () => {
                 const child = insertDefinitionElement(txn, root);
                 const grandchild = insertDefinitionElement(txn, child);
                 // Only supply the root - all descendants must be included and deleted leaf-first
-                executeTestCase(txn, "3-level hierarchy via root only", [root], [root, child, grandchild], [], []);
+                executeTestCase(txn, "3-level hierarchy via root only", [root], [root, child, grandchild], success, []);
             });
             it("deletes a 3-level parent-child hierarchy by passing all elements explicitly", () => {
                 const root = insertDefinitionElement(txn);
                 const child = insertDefinitionElement(txn, root);
                 const grandchild = insertDefinitionElement(txn, child);
                 // Pass all elements explicitly
-                executeTestCase(txn, "3-level hierarchy with all elements", [root, child, grandchild], [root, child, grandchild], [], []);
+                executeTestCase(txn, "3-level hierarchy with all elements", [root, child, grandchild], [root, child, grandchild], success, []);
             });
             // Mixed inputs
             it("deletes a mixed batch of unused DefinitionElements of different types in one call", () => {
@@ -670,7 +690,7 @@ describe("DeleteDefinitionElements", () => {
                 const unusedRenderMaterial = RenderMaterialElement.insert(txn, definitionModelId, "BatchRenderMaterial", { paletteName: "P" });
                 const unusedTexture = IModelTestUtils.insertTextureElement(txn, definitionModelId, "BatchTexture");
                 const unusedSubCategory = SubCategory.insert(txn, spatialCategoryId, "BatchSubCategory", {});
-                executeTestCase(txn, "mixed unused batch", [unusedPart, unusedRenderMaterial, unusedTexture, unusedSubCategory], [unusedPart, unusedRenderMaterial, unusedTexture, unusedSubCategory], [], []);
+                executeTestCase(txn, "mixed unused batch", [unusedPart, unusedRenderMaterial, unusedTexture, unusedSubCategory], [unusedPart, unusedRenderMaterial, unusedTexture, unusedSubCategory], success, []);
             });
             // Mixed inputs with intra scope violations and parent child hierarchies
             it("deletes a mixed batch of used and unused DefinitionElements in a hierarchy with conflicting code scopes with child", () => {
@@ -686,7 +706,7 @@ describe("DeleteDefinitionElements", () => {
                 };
                 const scopedPart = txn.insertElement(scopedPartProps);
                 // Pass both used and unused parts, with a child that has a code scope reference
-                executeTestCase(txn, "mixed used and unused batch", [usedPart, unusedPart, scopedPart], [usedPart, unusedPart, childPart, scopedPart], [], []);
+                executeTestCase(txn, "mixed used and unused batch", [usedPart, unusedPart, scopedPart], [usedPart, unusedPart, childPart, scopedPart], success, []);
             });
             // Mixed inputs with intra scope violations and parent child hierarchies
             it("deletes a mixed batch of used and unused DefinitionElements in a hierarchy with conflicting code scopes", () => {
@@ -701,8 +721,9 @@ describe("DeleteDefinitionElements", () => {
                     geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1)),
                 };
                 const scopedPart = txn.insertElement(scopedPartProps);
-                // Pass both used and unused parts, with a child that has a code scope reference
-                executeTestCase(txn, "mixed used and unused batch", [usedPart, unusedPart], [unusedPart], [usedPart], [usedPart, childPart, scopedPart]);
+                // Pass both used and unused parts; usedPart is the code scope of scopedPart (outside the set) so it is a direct FK violator
+                // and the whole call is rejected (unusedPart survives too).
+                executeTestCase(txn, "mixed used and unused batch", [usedPart, unusedPart], [], constraintViolation(codeScopeViolator(usedPart)), [usedPart, unusedPart, childPart, scopedPart]);
             });
         });
         describe("sub-model hierarchy", () => {
@@ -729,18 +750,18 @@ describe("DeleteDefinitionElements", () => {
                 const containerId = insertDefinitionContainer();
                 const partA = insertDefinitionElement(txn, undefined, containerId);
                 const partB = insertDefinitionElement(txn, undefined, containerId);
-                executeTestCase(txn, "unused elements in container sub-model", [partA, partB], [partA, partB], [], [], false);
+                executeTestCase(txn, "unused elements in container sub-model", [partA, partB], [partA, partB], success, [], false);
                 assertModelExists(containerId, "DefinitionContainer must survive when container is not in the input set");
             });
             it("deletes a DefinitionContainer and all definition elements inside it", () => {
                 const containerId = insertDefinitionContainer();
                 const defElem1 = insertDefinitionElement(txn, undefined, containerId);
                 const defElem2 = insertDefinitionElement(txn, undefined, containerId);
-                executeTestCase(txn, "container + sub-model contents deleted via container id", [containerId], [containerId, defElem1, defElem2], [], []);
+                executeTestCase(txn, "container + sub-model contents deleted via container id", [containerId], [containerId, defElem1, defElem2], success, []);
                 // Sub-model row is deleted once the container element is successfully purged.
                 assertModelDeleted(containerId, "DefinitionModel sub-model row must be deleted after container is purged");
             });
-            it("keeps an in-use element inside a DefinitionContainer sub-model in the failed set", () => {
+            it("reports an in-use element inside a DefinitionContainer sub-model as a failure", () => {
                 const containerId = insertDefinitionContainer();
                 const usedPart = insertDefinitionElement(txn, undefined, containerId);
                 const unusedPart = insertDefinitionElement(txn, undefined, containerId);
@@ -754,10 +775,10 @@ describe("DeleteDefinitionElements", () => {
                     geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1), spatialCategoryId, undefined, undefined, usedPart),
                 };
                 const physElemId = txn.insertElement(physElemProps);
-                executeTestCase(txn, "one used + one unused in container sub-model", [usedPart, unusedPart], [unusedPart], [usedPart], [usedPart, physElemId], false);
-                assertModelExists(containerId, "DefinitionContainer sub-model row must survive when an element inside it is blocked");
+                executeTestCase(txn, "one used + one unused in container sub-model", [usedPart, unusedPart], [], constraintViolation(definitionInUse(usedPart)), [usedPart, unusedPart, physElemId], false);
+                assertModelExists(containerId, "DefinitionContainer sub-model row must survive when the call is rejected");
             });
-            it("parent blocked in failed set when its child inside a DefinitionContainer sub-model is in use", () => {
+            it("call rejected when the child of a requested parent inside a DefinitionContainer sub-model is in use", () => {
                 const containerId = insertDefinitionContainer();
                 const parent = insertDefinitionElement(txn, undefined, containerId);
                 const child = insertDefinitionElement(txn, parent, containerId);
@@ -771,8 +792,9 @@ describe("DeleteDefinitionElements", () => {
                     geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1), spatialCategoryId, undefined, undefined, child),
                 };
                 const physElemId = txn.insertElement(physElemProps);
-                executeTestCase(txn, "parent blocked when child inside container sub-model is in use", [parent], [], [parent], [parent, child, physElemId], false);
-                assertModelExists(containerId, "DefinitionContainer sub-model row must survive when elements inside it are blocked");
+                // child (pulled into the set via parent) is a DefinitionInUse violator; only the direct violator is reported.
+                executeTestCase(txn, "parent rejected when child inside container sub-model is in use", [parent], [], constraintViolation(definitionInUse(child)), [parent, child, physElemId], false);
+                assertModelExists(containerId, "DefinitionContainer sub-model row must survive when the call is rejected");
             });
             it("deletes two elements inside a DefinitionContainer sub-model related by intra-delete-set code scope", () => {
                 const containerId = insertDefinitionContainer();
@@ -785,10 +807,10 @@ describe("DeleteDefinitionElements", () => {
                     geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1)),
                 };
                 const partB = txn.insertElement(partBProps);
-                executeTestCase(txn, "intra-set code scope in container sub-model", [partA, partB], [partA, partB], [], [], false);
+                executeTestCase(txn, "intra-set code scope in container sub-model", [partA, partB], [partA, partB], success, [], false);
                 assertModelExists(containerId, "DefinitionContainer sub-model row must survive when container is not in the input set");
             });
-            it("element inside a DefinitionContainer sub-model blocked when used as external code scope", () => {
+            it("element inside a DefinitionContainer sub-model rejects the call when used as external code scope", () => {
                 const containerId = insertDefinitionContainer();
                 const scopeSpecId = iModelDb.codeSpecs.insert(txn, "ExtScopeSpec", CodeScopeSpec.Type.RelatedElement);
                 const partA = insertDefinitionElement(txn, undefined, containerId);
@@ -801,8 +823,8 @@ describe("DeleteDefinitionElements", () => {
                     geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1)),
                 };
                 const externalId = txn.insertElement(externalProps);
-                executeTestCase(txn, "external code scope blocks element inside container sub-model", [partA, partB], [partB], [partA], [partA, externalId], false);
-                assertModelExists(containerId, "DefinitionContainer sub-model row must survive when an element inside it is blocked");
+                executeTestCase(txn, "external code scope rejects element inside container sub-model", [partA, partB], [], constraintViolation(codeScopeViolator(partA)), [partA, partB, externalId], false);
+                assertModelExists(containerId, "DefinitionContainer sub-model row must survive when the call is rejected");
             });
             it("cross-container intra-set code scope: both elements deleted cleanly", () => {
                 const container1 = insertDefinitionContainer();
@@ -816,11 +838,11 @@ describe("DeleteDefinitionElements", () => {
                     geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1)),
                 };
                 const partB = txn.insertElement(partBProps);
-                executeTestCase(txn, "cross-container intra-set code scope", [partA, partB], [partA, partB], [], [], false);
+                executeTestCase(txn, "cross-container intra-set code scope", [partA, partB], [partA, partB], success, [], false);
                 assertModelExists(container1, "container1 sub-model row must survive when container is not in the input set");
                 assertModelExists(container2, "container2 sub-model row must survive when container is not in the input set");
             });
-            it("mixed elements where in-use ones get blocked/ignored, unused get deleted", () => {
+            it("mixed elements where in-use ones reject the call and nothing is deleted", () => {
                 const containerId = insertDefinitionContainer();
                 const topUnused = insertDefinitionElement(txn, undefined, definitionModelId);
                 const topUsed = insertDefinitionElement(txn, undefined, definitionModelId);
@@ -839,8 +861,141 @@ describe("DeleteDefinitionElements", () => {
                 };
                 const topUsedPhysElem = makeUser(topUsed);
                 const nestedUsedPhysElem = makeUser(nestedUsed);
-                executeTestCase(txn, "mixed top-level and container sub-model: used blocked, unused deleted", [topUnused, topUsed, nestedUnused, nestedUsed], [topUnused, nestedUnused], [topUsed, nestedUsed], [topUsed, nestedUsed, topUsedPhysElem, nestedUsedPhysElem], false);
-                assertModelExists(containerId, "DefinitionContainer sub-model row must survive when an element inside it is blocked");
+                executeTestCase(txn, "mixed top-level and container sub-model: used reported, nothing deleted", [topUnused, topUsed, nestedUnused, nestedUsed], [], constraintViolation(definitionInUse(topUsed), definitionInUse(nestedUsed)), [topUnused, topUsed, nestedUnused, nestedUsed, topUsedPhysElem, nestedUsedPhysElem], false);
+                assertModelExists(containerId, "DefinitionContainer sub-model row must survive when the call is rejected");
+            });
+        });
+        describe("definition and its users deleted together", () => {
+            let txn;
+            beforeEach(() => {
+                txn = new EditTxn(iModelDb, "delete definition + users");
+                txn.start();
+            });
+            afterEach(() => {
+                txn.end("abandon");
+            });
+            const insertPhysicalObject = (opts = {}) => {
+                const category = opts.categoryId ?? spatialCategoryId;
+                // A material is only recorded in the geometry stream together with a sub-category.
+                const subCategory = opts.subCategoryId ?? (opts.renderMaterialId ? IModel.getDefaultSubCategoryId(category) : undefined);
+                return txn.insertElement({
+                    classFullName: "Generic:PhysicalObject",
+                    model: physicalModelId,
+                    category,
+                    code: Code.createEmpty(),
+                    placement: { origin: [0, 0, 0], angles: { yaw: 0, pitch: 0, roll: 0 } },
+                    geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1), category, subCategory, opts.renderMaterialId, opts.geometryPartId),
+                });
+            };
+            it("a GeometryPart with two users is still in use when only one user is in the delete set", () => {
+                const part = insertDefinitionElement(txn);
+                const user1 = insertPhysicalObject({ geometryPartId: part });
+                const user2 = insertPhysicalObject({ geometryPartId: part });
+                executeTestCase(txn, "part + one of two users", [part, user1], [], constraintViolation(definitionInUse(part)), [part, user1, user2]);
+            });
+            it("a DisplayStyle shared by two views is reported in use when only one view is in the delete set", () => {
+                const categorySelectorB = CategorySelector.insert(txn, definitionModelId, "CategorySelectorB", [spatialCategoryId]);
+                const modelSelectorB = ModelSelector.insert(txn, definitionModelId, "ModelSelectorB", [physicalModelId]);
+                const viewB = OrthographicViewDefinition.insert(txn, definitionModelId, "ViewB", modelSelectorB, categorySelectorB, displayStyle3dId, new Range3d(0, 0, 0, 1, 1, 1));
+                executeTestCase(txn, "view A + its selectors + shared style", [viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId], [], constraintViolation(definitionInUse(displayStyle3dId)), [viewId, spatialCategorySelectorId, modelSelectorId, displayStyle3dId, viewB, categorySelectorB, modelSelectorB], false);
+                // Deleting both views releases the shared style.
+                executeTestCase(txn, "both views + everything they reference", [viewId, viewB, spatialCategorySelectorId, modelSelectorId, categorySelectorB, modelSelectorB, displayStyle3dId], [viewId, viewB, spatialCategorySelectorId, modelSelectorId, categorySelectorB, modelSelectorB, displayStyle3dId], success, []);
+            });
+            it("an element referenced through several foreign keys is reported once", () => {
+                // A fresh category used by a physical object (CategoryId FK) AND used as the Code scope of a GeometryPart (CodeScopeId FK).
+                const category = SpatialCategory.insert(txn, definitionModelId, "DoublyReferencedCategory", {});
+                const user = insertPhysicalObject({ categoryId: category });
+                const scopeSpecId = iModelDb.codeSpecs.insert(txn, "CategoryScopedSpec", CodeScopeSpec.Type.RelatedElement);
+                const scopedPart = txn.insertElement({
+                    classFullName: GeometryPart.classFullName,
+                    model: definitionModelId,
+                    code: { spec: scopeSpecId, scope: category, value: "scoped-part" },
+                    geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1)),
+                });
+                const result = txn.deleteElements([category]);
+                assert.equal(result.status, BulkDeleteElementsStatus.ConstraintViolation);
+                assert.equal(result.failures.length, 1, `expected a single failure, got ${JSON.stringify(result.failures)}`);
+                assert.equal(result.failures[0].elementId, category);
+                assert.equal(result.failures[0].reason, BulkDeleteFailureReason.ReferencedByForeignKey);
+                for (const id of [category, user, scopedPart])
+                    assert.isDefined(iModelDb.elements.tryGetElement(id));
+            });
+        });
+        describe("all-or-nothing semantics with definition elements", () => {
+            let txn;
+            beforeEach(() => {
+                txn = new EditTxn(iModelDb, "all-or-nothing");
+                txn.start();
+            });
+            afterEach(() => {
+                txn.end("abandon");
+            });
+            it("DefinitionInUse is a constraint violation: nothing is deleted, including unused elements in the same call", () => {
+                const unusedPart = insertDefinitionElement(txn);
+                const result = txn.deleteElements([geometryPartId, unusedPart]);
+                assertResult(result, constraintViolation(definitionInUse(geometryPartId)), [], [geometryPartId, unusedPart], iModelDb);
+            });
+            it("a used Category is a constraint violation and every violator in the expanded set is reported", () => {
+                const unusedPart = insertDefinitionElement(txn);
+                const result = txn.deleteElements([spatialCategoryId, unusedPart]);
+                assertResult(result, constraintViolation(...usedSpatialCategoryViolations()), [], [spatialCategoryId, subCategoryId, filteredSubCategoryId, unusedPart], iModelDb);
+            });
+            it("reports the in-use cascaded child (not the requested parent) when the violator is a child", () => {
+                const parent = insertDefinitionElement(txn);
+                const child = insertDefinitionElement(txn, parent);
+                const user = txn.insertElement({
+                    classFullName: "Generic:PhysicalObject",
+                    model: physicalModelId,
+                    category: spatialCategoryId,
+                    code: Code.createEmpty(),
+                    placement: { origin: [0, 0, 0], angles: { yaw: 0, pitch: 0, roll: 0 } },
+                    geom: IModelTestUtils.createBox(Point3d.create(1, 1, 1), spatialCategoryId, undefined, undefined, child),
+                });
+                const result = txn.deleteElements([parent]);
+                assertResult(result, constraintViolation(definitionInUse(child)), [], [parent, child, user], iModelDb);
+            });
+            it("deprecated skipFKConstraintValidations flag is ignored and DefinitionInUse is still detected", () => {
+                // There is no way to bypass the definition usage check: geometry-stream references are not SQLite foreign keys, so
+                // skipping validation would silently leave dangling references. The deprecated flag is ignored.
+                const unusedPart = insertDefinitionElement(txn);
+                for (const skipFKConstraintValidations of [true, false]) {
+                    // eslint-disable-next-line @typescript-eslint/no-deprecated
+                    const result = txn.deleteElements([geometryPartId, unusedPart], { skipFKConstraintValidations });
+                    assertResult(result, constraintViolation(definitionInUse(geometryPartId)), [], [geometryPartId, unusedPart], iModelDb);
+                }
+            });
+            it("ConstraintViolation for a used Category (hard FK) leaves the txn clean", () => {
+                txn.saveChanges();
+                const result = txn.deleteElements([spatialCategoryId]);
+                assertResult(result, constraintViolation(...usedSpatialCategoryViolations()), [], [spatialCategoryId], iModelDb);
+                assert.isFalse(iModelDb[_nativeDb].hasUnsavedChanges(), "a rejected delete must not dirty the txn");
+            });
+        });
+        describe("cache coherence for cascaded definition elements", () => {
+            let txn;
+            beforeEach(() => {
+                txn = new EditTxn(iModelDb, "cache");
+                txn.start();
+            });
+            afterEach(() => {
+                txn.end("abandon");
+            });
+            it("a cached default SubCategory is not readable after its Category is deleted", () => {
+                const category = SpatialCategory.insert(txn, definitionModelId, "CachedCategory", {});
+                const defaultSubCategory = iModelDb.elements.getElement(category, SpatialCategory).myDefaultSubCategoryId();
+                assert.isDefined(iModelDb.elements.getElement(defaultSubCategory)); // prime the cache
+                executeTestCase(txn, "category with cached default subcategory", [category], [category, defaultSubCategory], success, [], false);
+                assert.isUndefined(iModelDb.elements.tryGetElementProps(defaultSubCategory), "cached default SubCategory props must not be served after deletion");
+            });
+            it("cached contents of a deleted DefinitionContainer are not readable afterwards", () => {
+                const codeSpecId = iModelDb.codeSpecs.insert(txn, "CachedContainerSpec", CodeScopeSpec.Type.Model);
+                const containerId = DefinitionContainer.insert(txn, definitionModelId, new Code({ spec: codeSpecId, scope: definitionModelId, value: "CachedContainer" }));
+                const inner = insertDefinitionElement(txn, undefined, containerId);
+                assert.isDefined(iModelDb.elements.getElement(inner));
+                assert.isDefined(iModelDb.models.getModelProps(containerId));
+                executeTestCase(txn, "container with cached contents", [containerId], [containerId, inner], success, [], false);
+                assert.isUndefined(iModelDb.elements.tryGetElementProps(inner));
+                assert.isUndefined(iModelDb.models.tryGetModelProps(containerId));
             });
         });
     });
@@ -961,10 +1116,9 @@ describe("DeleteDefinitionElements", () => {
         it("TypeDefinitionId is NOT NULLed when deleteElements deletes the type and NULLs the reference", () => {
             const physTypeId = insertPhysicalType();
             const physObjId = insertPhysicalObjectWithType(physTypeId);
-            const failed = txn.deleteElements([physTypeId]);
-            assert.isFalse(failed.failedIds.has(physTypeId), "physTypeId should NOT be in the failed set — TypeDefinitionId refs do not block deleteElements");
-            assert.isUndefined(iModelDb.elements.tryGetElement(physTypeId), "PhysicalType should be deleted");
-            assert.isDefined(iModelDb.elements.tryGetElement(physObjId), "PhysicalObject should still exist");
+            const result = txn.deleteElements([physTypeId]);
+            // TypeDefinitionId refs do not block deleteElements - the type is deleted, the referencing object survives, and no failures are reported.
+            assertResult(result, success, [physTypeId], [physObjId], iModelDb);
             assert.isUndefined(getTypeDefinitionId3d(physObjId), "TypeDefinitionId should be NULLed since the type was deleted");
         });
     });