@holmes-lab/holmes-kit 0.19.6 → 0.20.0

package/dist/holmes/mcp/handlers/entity-integration.js

@@ -0,0 +1,324 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renumberedMappingInputs = renumberedMappingInputs;
+exports.integrationSealTransitions = integrationSealTransitions;
+exports.createEntityIntegrationHandlers = createEntityIntegrationHandlers;
+// @implements A-SPEC-629
+// @implements A-SPEC-645
+// @implements A-SPEC-642
+// @implements A-SPEC-639
+// @implements A-SPEC-632
+// @implements A-SPEC-635
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const entity_store_1 = require("../../spec/entity-store");
+const root_1 = require("../../project/root");
+const entity_transaction_1 = require("../../spec/entity-transaction");
+const entity_integration_discharge_1 = require("../../spec/entity-integration-discharge");
+const entity_integration_transaction_1 = require("../../spec/entity-integration-transaction");
+const approval_grants_1 = require("../../governance/approval-grants");
+const approval_queue_1 = require("../../governance/approval-queue");
+const ledger_store_1 = require("../../governance/ledger-store");
+const provenance_chain_1 = require("../../governance/provenance-chain");
+const spec_parser_1 = require("../../spec/spec-parser");
+const spec_digest_1 = require("../../spec/spec-digest");
+/**
+ * @implements A-SPEC-635 — the seal transitions an integration performs, derived from its plan: every
+ * `unseal` step withdraws a seal, every `approve` step issues one whose digest is read from the
+ * published document bytes and must be that document's own `specDigest` (otherwise the seal is not
+ * what the transition policy computed → `audit-conflict`). Through the public tool a forged step is
+ * already refused `plan-changed` by step revalidation; this check is the audit's own invariant.
+ */
+/**
+ * @implements A-SPEC-645
+ * The `entity:`/`old-id:`/`new-id:` inputs for every mapping step whose record changes its display id,
+ * so an integration's renumbers are readable from the ledger like entity_renumber's. Without them the
+ * evidence consumers had no way to follow a document an integration renamed.
+ */
+function renumberedMappingInputs(steps, renames = []) {
+    const out = [];
+    for (const r of renames)
+        for (const input of ['entity:' + r.entityId, 'old-id:' + r.oldDisplayId, 'new-id:' + r.newDisplayId])
+            if (!out.includes(input))
+                out.push(input);
+    const decode = (bytes) => {
+        if (bytes === null)
+            return null;
+        try {
+            const value = JSON.parse(Buffer.from(bytes, 'base64').toString('utf8'));
+            return value && typeof value === 'object' ? value : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    for (const step of steps) {
+        if (step.phase !== 'mapping' || !step.change.locator.startsWith('.ax/entities/records/'))
+            continue;
+        const before = decode(step.change.before), after = decode(step.change.after);
+        if (!before || !after || typeof before.displayId !== 'string' || typeof after.displayId !== 'string' || before.displayId === after.displayId)
+            continue;
+        const entity = step.entityId ?? (typeof after.entityId === 'string' ? after.entityId : undefined);
+        for (const input of [...(entity ? ['entity:' + entity] : []), 'old-id:' + before.displayId, 'new-id:' + after.displayId])
+            if (!out.includes(input))
+                out.push(input);
+    }
+    return out;
+}
+function integrationSealTransitions(operation) {
+    const transitions = [];
+    for (const step of operation.steps) {
+        if (step.phase === 'unseal' && step.specId)
+            transitions.push({ kind: 'spec-unsealed', id: step.specId });
+        else if (step.phase === 'approve' && step.specId) {
+            if (typeof step.change.after !== 'string')
+                throw new entity_store_1.EntityStoreError('audit-conflict', 'Approve step ' + step.specId + ' publishes no document.');
+            let digest, computed;
+            try {
+                const parsed = (0, spec_parser_1.parseSpec)(Buffer.from(step.change.after, 'base64').toString('utf8'));
+                digest = parsed.frontmatter.approved_digest;
+                computed = (0, spec_digest_1.specDigest)(parsed);
+            }
+            catch {
+                throw new entity_store_1.EntityStoreError('audit-conflict', 'Approve step ' + step.specId + ' publishes an unreadable document.');
+            }
+            if (typeof digest !== 'string' || digest !== computed)
+                throw new entity_store_1.EntityStoreError('audit-conflict', 'Approve step ' + step.specId + ' is not sealed by its own digest.');
+            transitions.push({ kind: 'spec-approved', id: step.specId, digest });
+        }
+    }
+    return transitions;
+}
+function createEntityIntegrationHandlers(context) {
+    return {
+        async entity_integrate(a) {
+            try {
+                if (!context.storeRoot)
+                    throw new entity_store_1.EntityStoreError('unsupported-store', 'Git integration requires a configured filesystem spec store.');
+                const bound = (0, entity_store_1.entityStoreBinding)(context.storeRoot);
+                if (a.root !== undefined && fs.realpathSync((0, root_1.resolveProjectRoot)(a.root, { includeGit: false }).root) !== bound.root)
+                    throw new entity_store_1.EntityStoreError('foreign-workspace', 'The requested workspace differs from the configured store.');
+                const recoveryTarget = (plan) => 'entity-store:integrate-recover:' + (0, entity_transaction_1.entityContentVersion)(JSON.stringify(plan));
+                const requireStore = (plan) => {
+                    if (plan.storeLocator !== bound.locator)
+                        throw new entity_store_1.EntityStoreError('foreign-store', 'Integration plan differs from the configured store.');
+                };
+                // @implements A-SPEC-642 — an authority-spending operation is refused, naming the exit, while the
+                // merged ledger holds an unreconciled double-spend; the audit adapter's `audit-conflict` stays behind.
+                if (a.operation === 'apply' || a.operation === 'recover' || a.operation === 'abandon' || a.operation === 'discharge') {
+                    const conflict = (0, ledger_store_1.ledgerConflictReason)(path.join(bound.root, '.ax', 'ledger'));
+                    if (conflict)
+                        throw new entity_store_1.EntityStoreError('ledger-conflict', conflict);
+                }
+                // @implements A-SPEC-632 — replica-local discharge of a completed operation's derived obligations.
+                if (a.operation === 'obligations')
+                    return { ok: true, obligations: (0, entity_integration_discharge_1.inspectDerivedObligations)(bound.root) };
+                if (a.operation === 'discharge') {
+                    if (typeof a.operationId !== 'string')
+                        throw new entity_store_1.EntityStoreError('invalid-request', 'Provide the completed integration operationId.');
+                    if (!context.rebuildFor)
+                        throw new entity_store_1.EntityStoreError('unsupported-store', 'Discharge requires graph and semantic rebuild wiring.');
+                    return await (0, entity_integration_discharge_1.dischargeDerivedObligations)(bound.root, a.operationId, context.rebuildFor(bound.root));
+                }
+                if (a.operation === 'recovery-plan') {
+                    if (typeof a.operationId !== 'string')
+                        throw new entity_store_1.EntityStoreError('invalid-request', 'Provide the integration operationId.');
+                    const plan = (0, entity_integration_transaction_1.inspectEntityIntegrationRecovery)(bound.root, a.operationId);
+                    requireStore(plan.plan);
+                    return { ok: true, plan, target: recoveryTarget(plan), executable: plan.conflicts.length === 0 };
+                }
+                if (a.operation === 'abandon') {
+                    // @implements A-SPEC-639 — an authorized exit for a pending operation a third state blocked.
+                    const id = a.plan?.operationId;
+                    if (typeof id !== 'string')
+                        throw new entity_store_1.EntityStoreError('invalid-request', 'Provide the complete inspected recovery plan to abandon.');
+                    const recovery = (0, entity_integration_transaction_1.validateEntityIntegrationRecoveryRequest)(bound.root, a.plan);
+                    requireStore(recovery.plan);
+                    const target = 'entity-store:integrate-abandon:' + (0, entity_transaction_1.entityContentVersion)(JSON.stringify(a.plan));
+                    let env;
+                    try {
+                        env = process.env.HOLMES_APPROVAL ? JSON.parse(process.env.HOLMES_APPROVAL) : undefined;
+                    }
+                    catch {
+                        env = undefined;
+                    }
+                    const authorities = new Set();
+                    const requireAuthority = () => {
+                        const action = { kind: 'config-write', target };
+                        const resolved = (0, approval_grants_1.resolveApproval)(bound.root, env, action, new Date().toISOString());
+                        if (!resolved)
+                            throw new entity_store_1.EntityStoreError('approval-required', 'Current authority is required to abandon this integration.' + (0, approval_queue_1.queueHint)(bound.root, { ...action, why: 'Abandon the blocked integration: revert its own publications, preserve foreign bytes, release ownership.' }));
+                        authorities.add((0, provenance_chain_1.authorizationRef)(resolved.approval.actor, resolved.approval.token));
+                        return resolved;
+                    };
+                    requireAuthority();
+                    const audit = (operation, outcome) => {
+                        const authority = requireAuthority(), ledger = new ledger_store_1.FileLedgerStore(path.join(bound.root, '.ax/ledger'));
+                        if (!ledger.verifyAll().ok)
+                            throw new entity_store_1.EntityStoreError('audit-conflict', 'Abandonment audit cannot extend an invalid ledger.');
+                        const ref = 'entity-operation:' + operation.operationId;
+                        if (ledger.loadAll().some(event => event.kind === 'entity-integration-abandoned' && event.inputs?.includes(ref)))
+                            return;
+                        ledger.append({ ts: new Date().toISOString(), actor: authority.approval.actor, kind: 'entity-integration-abandoned', summary: 'Abandoned Git entity integration ' + operation.operationId,
+                            inputs: [ref, (0, entity_integration_transaction_1.entityIntegrationTarget)(operation), 'workspace:' + operation.workspaceId, 'store:' + operation.storeId, recovery.journalVersion, target,
+                                ...outcome.restored.map(locator => 'restored:' + locator), ...outcome.preserved.map(locator => 'preserved:' + locator), ...authorities],
+                            rationale: authority.approval.rationale, authorization: (0, provenance_chain_1.authorizationRef)(authority.approval.actor, authority.approval.token) });
+                    };
+                    return await (0, entity_integration_transaction_1.abandonEntityIntegration)(bound.root, recovery, requireAuthority, audit);
+                }
+                if (a.operation === 'apply' || a.operation === 'recover') {
+                    let recovery;
+                    if (a.operation === 'recover') {
+                        const id = a.plan?.operationId;
+                        if (typeof id !== 'string')
+                            throw new entity_store_1.EntityStoreError('invalid-request', 'Provide the complete inspected recovery plan.');
+                        recovery = (0, entity_integration_transaction_1.validateEntityIntegrationRecoveryRequest)(bound.root, a.plan);
+                    }
+                    const plan = recovery ? recovery.plan : (0, entity_integration_transaction_1.validateEntityIntegrationPlan)(a.plan);
+                    requireStore(plan);
+                    const target = recovery ? recoveryTarget(recovery) : (0, entity_integration_transaction_1.entityIntegrationTarget)(plan);
+                    let env;
+                    try {
+                        env = process.env.HOLMES_APPROVAL ? JSON.parse(process.env.HOLMES_APPROVAL) : undefined;
+                    }
+                    catch {
+                        env = undefined;
+                    }
+                    const grants = new Set(), authorities = new Set(), usedGrantRefs = new Set();
+                    const grantRef = (approval) => 'grant-use:' + (0, entity_transaction_1.entityContentVersion)(JSON.stringify({ actor: approval.actor, token: approval.token, nonce: approval.nonce, scope: approval.scope, expires: approval.expires }));
+                    const requireAuthority = (specId) => {
+                        const action = { kind: specId ? 'spec-approve' : 'config-write', target: specId ?? target };
+                        const resolved = (0, approval_grants_1.resolveApproval)(bound.root, env, action, new Date().toISOString());
+                        if (!resolved)
+                            throw new entity_store_1.EntityStoreError(specId ? 'spec-approval-required' : 'approval-required', 'Current authority is required for this integration.' + (0, approval_queue_1.queueHint)(bound.root, { ...action, why: 'Integrate the exact Git inputs while preserving entity identity and official seal transitions.' }));
+                        if (resolved.source === 'grant' && resolved.approval.nonce)
+                            grants.add(resolved.approval.nonce);
+                        if (resolved.source === 'grant')
+                            usedGrantRefs.add(grantRef(resolved.approval));
+                        authorities.add((0, provenance_chain_1.authorizationRef)(resolved.approval.actor, resolved.approval.token));
+                        return resolved;
+                    };
+                    const bindingFor = (operation) => ['entity-operation:' + operation.operationId, (0, entity_integration_transaction_1.entityIntegrationTarget)(operation), 'workspace:' + operation.workspaceId, 'store:' + operation.storeId,
+                        ...['base', 'left', 'right'].map(side => 'git-' + side + ':' + operation.commits[side])];
+                    const priorGrantUses = (ledger, operation) => {
+                        if (!ledger.verifyAll().ok)
+                            throw new entity_store_1.EntityStoreError('audit-conflict', 'Integration cannot rely on an invalid ledger.');
+                        const binding = bindingFor(operation), refs = new Set();
+                        for (const event of ledger.loadAll().filter(event => event.kind === 'entity-integration-grant-used' && event.inputs?.includes(binding[0]))) {
+                            const usages = (event.inputs ?? []).filter(ref => ref.startsWith('grant-use:'));
+                            if (binding.some(ref => !event.inputs?.includes(ref)) || usages.length === 0 || usages.some(ref => !/^grant-use:sha256:[0-9a-f]{64}$/.test(ref) || refs.has(ref)))
+                                throw new entity_store_1.EntityStoreError('audit-conflict', 'Integration grant usage has conflicting bindings.');
+                            for (const ref of usages)
+                                refs.add(ref);
+                        }
+                        return refs;
+                    };
+                    const recordGrantUse = (operation) => {
+                        const authority = requireAuthority(), ledger = new ledger_store_1.FileLedgerStore(path.join(bound.root, '.ax/ledger'));
+                        const prior = priorGrantUses(ledger, operation), additional = [...usedGrantRefs].filter(ref => !prior.has(ref));
+                        for (const ref of prior)
+                            usedGrantRefs.add(ref);
+                        if (!additional.length)
+                            return;
+                        ledger.append({ ts: new Date().toISOString(), actor: authority.approval.actor, kind: 'entity-integration-grant-used', summary: 'Recorded grant usage for integration ' + operation.operationId,
+                            inputs: [...bindingFor(operation), target, ...additional, ...authorities], rationale: authority.approval.rationale, authorization: (0, provenance_chain_1.authorizationRef)(authority.approval.actor, authority.approval.token) });
+                    };
+                    const audit = (operation, verifyOnly = false, renumbered = []) => {
+                        const authority = requireAuthority(), ledger = new ledger_store_1.FileLedgerStore(path.join(bound.root, '.ax/ledger'));
+                        const binding = bindingFor(operation);
+                        for (const ref of priorGrantUses(ledger, operation))
+                            usedGrantRefs.add(ref);
+                        const events = ledger.loadAll(), existing = events.filter(event => event.kind === 'entity-integrated' && event.inputs?.includes(binding[0]));
+                        if (existing.length) {
+                            if (existing.length !== 1 || binding.some(ref => !existing[0].inputs?.includes(ref)))
+                                throw new entity_store_1.EntityStoreError('audit-conflict', 'Integration completion audit has conflicting bindings.');
+                            for (const ref of existing[0].inputs ?? [])
+                                if (ref.startsWith('grant-use:'))
+                                    usedGrantRefs.add(ref);
+                            // Retain the original completion event, but persist any new authority use
+                            // before recovery/verification consumes that grant file.
+                            recordGrantUse(operation);
+                            return;
+                        }
+                        if (verifyOnly)
+                            throw new entity_store_1.EntityStoreError('audit-conflict', 'Completion receipt has no matching integration audit.');
+                        recordGrantUse(operation);
+                        // @implements A-SPEC-635 — the seal history the official acts would have written, attributed
+                        // to the per-spec authority and bound to this operation; skipped when already present so
+                        // recovery after an interrupted audit appends each exactly once.
+                        for (const transition of integrationSealTransitions(operation)) {
+                            if (events.some(event => event.kind === transition.kind && event.inputs?.includes(transition.id) && event.inputs?.includes(binding[0])))
+                                continue;
+                            const sealAuthority = requireAuthority(transition.id);
+                            ledger.append({ ts: new Date().toISOString(), actor: sealAuthority.approval.actor, kind: transition.kind,
+                                summary: transition.kind === 'spec-unsealed' ? 'unsealed ' + transition.id + ' (integration ' + operation.operationId + ')' : 'approved ' + transition.id + ' sealing ' + transition.digest,
+                                inputs: transition.kind === 'spec-unsealed' ? [transition.id, binding[0]] : [transition.id, transition.digest, binding[0]],
+                                rationale: sealAuthority.approval.rationale, authorization: (0, provenance_chain_1.authorizationRef)(sealAuthority.approval.actor, sealAuthority.approval.token) });
+                        }
+                        ledger.append({ ts: new Date().toISOString(), actor: authority.approval.actor, kind: 'entity-integrated', summary: 'Completed Git entity integration ' + operation.operationId,
+                            inputs: [...binding, target, ...new Set(operation.steps.flatMap(step => [
+                                    ...(step.entityId ? ['entity:' + step.entityId] : []), (step.change.after === null ? 'deleted-path:' : 'changed-path:') + step.change.locator
+                                ])),
+                                ...renumberedMappingInputs(operation.steps, renumbered).filter(input => !input.startsWith('entity:')), // A-SPEC-645
+                                'derived-obligations:' + operation.operationId, ...authorities, ...usedGrantRefs],
+                            rationale: authority.approval.rationale, authorization: (0, provenance_chain_1.authorizationRef)(authority.approval.actor, authority.approval.token) });
+                    };
+                    requireAuthority();
+                    const result = recovery ? await (0, entity_integration_transaction_1.recoverEntityIntegration)(bound.root, recovery, requireAuthority, audit, recordGrantUse)
+                        : await (0, entity_integration_transaction_1.applyEntityIntegration)(bound.root, plan, requireAuthority, audit, recordGrantUse);
+                    for (const grant of (0, approval_grants_1.readGrants)(bound.root).grants)
+                        if (grant.nonce && usedGrantRefs.has(grantRef(grant)))
+                            grants.add(grant.nonce);
+                    for (const nonce of grants)
+                        (0, approval_grants_1.consumeGrantFile)(bound.root, nonce);
+                    return result;
+                }
+                if (a.operation !== undefined && a.operation !== 'plan')
+                    throw new entity_store_1.EntityStoreError('unsupported-operation', 'Use plan, apply, recovery-plan, recover, abandon, discharge or obligations.');
+                if (typeof a.base !== 'string' || typeof a.left !== 'string' || typeof a.right !== 'string')
+                    throw new entity_store_1.EntityStoreError('invalid-request', 'Provide base, left and right Git revisions.');
+                const reviewed = await (0, entity_integration_transaction_1.reviewEntityIntegration)(bound.root, { base: a.base, left: a.left, right: a.right }, bound.locator);
+                return { ok: true, executable: !!reviewed.plan, ...reviewed, ...(reviewed.plan ? { target: (0, entity_integration_transaction_1.entityIntegrationTarget)(reviewed.plan) } : {}),
+                    blockers: [...reviewed.preview.conflicts, ...reviewed.preview.pending.map(item => item.file + ': ' + item.reason)] };
+            }
+            catch (error) {
+                if (error instanceof entity_store_1.EntityStoreError)
+                    return { ok: false, code: error.code, reason: error.message };
+                throw error;
+            }
+        },
+    };
+}

package/dist/holmes/mcp/handlers/entity-renumber.d.ts

@@ -0,0 +1,137 @@
+import { EntityRenumberChange } from '../../spec/entity-renumber';
+import { EntityRenumberPlan } from '../../spec/entity-renumber-transaction';
+export declare function createEntityRenumberHandlers(context: {
+    storeRoot?: string;
+}): {
+    entity_renumber(a: {
+        root?: string;
+        operation?: string;
+        changes?: EntityRenumberChange[];
+        plan?: unknown;
+    }): Promise<{
+        ok: true;
+        state: "completed";
+        operationId: string;
+    } | {
+        restored: string[];
+        untouched: string[];
+        preserved: string[];
+        ok: true;
+        state: "abandoned";
+        operationId: string;
+    } | {
+        ok: boolean;
+        plan: import("../../spec/entity-renumber-transaction").EntityRenumberRecoveryPlan;
+        code?: undefined;
+        reason?: undefined;
+        conflicts?: undefined;
+        ids?: undefined;
+        executable?: undefined;
+        blockers?: undefined;
+        inputVersion?: undefined;
+        preview?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        reason: string;
+        plan?: undefined;
+        conflicts?: undefined;
+        ids?: undefined;
+        executable?: undefined;
+        blockers?: undefined;
+        inputVersion?: undefined;
+        preview?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        conflicts: string[];
+        plan?: undefined;
+        reason?: undefined;
+        ids?: undefined;
+        executable?: undefined;
+        blockers?: undefined;
+        inputVersion?: undefined;
+        preview?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        code: string;
+        ids: string[];
+        reason: string;
+        plan?: undefined;
+        conflicts?: undefined;
+        executable?: undefined;
+        blockers?: undefined;
+        inputVersion?: undefined;
+        preview?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        executable: boolean;
+        blockers: string[];
+        inputVersion: string;
+        preview: {
+            proposal: import("../../spec/entity-renumber").EntityRenumberProposal;
+            sources: import("../../spec/renumber").SourceRenumberInventory;
+            workspaceId: string;
+            storeId: string;
+            storeLocator: string;
+            registrationVersion: string;
+            entries: {
+                entityId: string;
+                documentLocator: string;
+                text: string;
+                mapping: string;
+                mappingVersion: string;
+            }[];
+            referenceNamespaces: {
+                entityId: string;
+                displayId: string;
+                storeId: string;
+                workspaceId: string;
+            }[];
+            schema: string;
+        };
+        plan?: undefined;
+        code?: undefined;
+        reason?: undefined;
+        conflicts?: undefined;
+        ids?: undefined;
+        recoveryAvailable?: undefined;
+    } | {
+        ok: boolean;
+        executable: boolean;
+        plan: EntityRenumberPlan;
+        blockers: never[];
+        recoveryAvailable: boolean;
+        inputVersion: string;
+        preview: {
+            proposal: import("../../spec/entity-renumber").EntityRenumberProposal;
+            sources: import("../../spec/renumber").SourceRenumberInventory;
+            workspaceId: string;
+            storeId: string;
+            storeLocator: string;
+            registrationVersion: string;
+            entries: {
+                entityId: string;
+                documentLocator: string;
+                text: string;
+                mapping: string;
+                mappingVersion: string;
+            }[];
+            referenceNamespaces: {
+                entityId: string;
+                displayId: string;
+                storeId: string;
+                workspaceId: string;
+            }[];
+            schema: string;
+        };
+        code?: undefined;
+        reason?: undefined;
+        conflicts?: undefined;
+        ids?: undefined;
+    }>;
+};