@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/refusal.d.ts

@@ -1,43 +1,471 @@
-import type { LeadingOutcome } from "../protocol/outcome.js";
-import { type ContractId } from "../core/facts/types.js";
-import type { IntentOutcome, IntentRefusal, IntentRetry } from "../protocol/operations.js";
-import type { AcceptedIntent } from "./mutation.js";
 import { z } from "zod";
-export type ForkSourceRefusal = Readonly<{
-    kind: "fork-source-missing" | "fork-source-unavailable" | "fork-source-invalid" | "fork-source-moved";
-    contractId: ContractId;
-}>;
-export type NukeConfirmationRefusal = Readonly<{
-    kind: "nuke-confirmation-mismatch";
-    world: string;
-    confirmation: string;
-}>;
-export type NukeConfirmationRequiredRefusal = Readonly<{
-    kind: "nuke-confirmation-required";
-    world: string;
-}>;
-export type KeiyakuRefusal = IntentRefusal | ForkSourceRefusal | NukeConfirmationRefusal | NukeConfirmationRequiredRefusal;
-export type KeiyakuRetryReason = IntentRetry;
-export declare function decodeKeiyakuRefusal(value: unknown): KeiyakuRefusal;
-export declare const keiyakuRefusalSchema: z.ZodType<KeiyakuRefusal, unknown, z.core.$ZodTypeInternals<KeiyakuRefusal, unknown>>;
-export declare const keiyakuRetryReasonSchema: z.ZodType<import("../protocol/run.js").ProtocolTerminal, unknown, z.core.$ZodTypeInternals<import("../protocol/run.js").ProtocolTerminal, unknown>>;
-export declare class KeiyakuRefused extends Error {
-    readonly refusal: KeiyakuRefusal;
-    readonly kind: "refused";
-    constructor(refusal: KeiyakuRefusal);
-    get code(): KeiyakuRefusal["kind"];
-}
-export declare class KeiyakuRetry extends Error {
-    readonly reason: KeiyakuRetryReason;
-    readonly kind: "retry";
-    constructor(reason: KeiyakuRetryReason);
-    get code(): KeiyakuRetryReason["kind"];
-}
-export type PostAdmissionFailureCategory = "authority-corruption" | "type-error" | "error";
-export declare function postAdmissionFailureCategory(error: unknown): PostAdmissionFailureCategory;
-export declare function encodeContractLiveFailure(error: unknown): unknown | null;
-export declare function decodeContractLiveFailure(value: unknown): Error | null;
-export declare function requireAccepted<Value, Refusal extends KeiyakuRefusal>(result: IntentOutcome<Value, Refusal>): AcceptedIntent<Value>;
-export declare function requireLeadingAdmission<Value, Refusal extends KeiyakuRefusal>(result: LeadingOutcome<Value, Refusal>): Extract<LeadingOutcome<Value, Refusal>, {
-    kind: "accepted";
-}>;
+declare const forkSourceRefusalSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        "fork-source-missing": "fork-source-missing";
+        "fork-source-unavailable": "fork-source-unavailable";
+    }>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fork-source-moved">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>]>;
+export type ForkSourceRefusal = z.infer<typeof forkSourceRefusalSchema>;
+export declare const nukeConfirmationRefusalSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"nuke-confirmation-mismatch">;
+    world: z.ZodString;
+    confirmation: z.ZodString;
+}, z.core.$strict>;
+export type NukeConfirmationRefusal = z.infer<typeof nukeConfirmationRefusalSchema>;
+export declare const nukeConfirmationRequiredRefusalSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"nuke-confirmation-required">;
+    world: z.ZodString;
+}, z.core.$strict>;
+export type NukeConfirmationRequiredRefusal = z.infer<typeof nukeConfirmationRequiredRefusalSchema>;
+export declare const keiyakuRefusalSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        terminal: "terminal";
+        "contract-missing": "contract-missing";
+    }>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        terminal: "terminal";
+        "contract-missing": "contract-missing";
+        "unknown-prerequisite": "unknown-prerequisite";
+        "terms-moved": "terms-moved";
+        "cyclic-prerequisite": "cyclic-prerequisite";
+    }>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        "contract-exists": "contract-exists";
+        "invalid-after": "invalid-after";
+        "unknown-prerequisite": "unknown-prerequisite";
+    }>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fork-source-moved">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        terminal: "terminal";
+        "contract-missing": "contract-missing";
+        "document-moved": "document-moved";
+    }>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"target-missing">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-missing">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"dirty-workspace">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    staged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    unstaged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    untracked: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    submodules: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    shortStat: z.ZodObject<{
+        filesChanged: z.ZodNumber;
+        insertions: z.ZodNumber;
+        deletions: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"unmerged-paths">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+    kind: z.ZodLiteral<"integration-failed">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    reason: z.ZodEnum<{
+        "not-based-on-target": "not-based-on-target";
+        "unrelated-histories": "unrelated-histories";
+        conflict: "conflict";
+    }>;
+    targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").SnapshotId, string>>;
+    conflictPaths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>, z.ZodTransform<{
+    kind: "integration-failed";
+    contractId: import("../index.js").ContractId;
+    reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+    targetHead: import("../index.js").SnapshotId;
+} & {
+    conflictPaths?: readonly string[];
+}, {
+    kind: "integration-failed";
+    contractId: import("../index.js").ContractId;
+    reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+    targetHead: import("../index.js").SnapshotId;
+    conflictPaths?: readonly string[] | undefined;
+}>>, z.ZodObject<{
+    kind: z.ZodLiteral<"integration-unsupported">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    requiredGit: z.ZodLiteral<"2.38">;
+}, z.core.$strict>]>, z.ZodObject<{
+    kind: z.ZodLiteral<"merge-state-present">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    workspace: z.ZodObject<{
+        kind: z.ZodLiteral<"worktree">;
+        path: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"checkout-not-followable">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    target: z.ZodString;
+    path: z.ZodString;
+    reason: z.ZodLiteral<"untracked">;
+    paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>]>, z.ZodObject<{
+    kind: z.ZodLiteral<"integration-failed">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    reason: z.ZodLiteral<"conflict">;
+    targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").SnapshotId, string>>;
+    conflictPaths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    recovery: z.ZodObject<{
+        materialize: z.ZodLiteral<"deliver --materialize-conflict --include-dirty">;
+        deliver: z.ZodLiteral<"deliver --include-dirty">;
+        staging: z.ZodLiteral<"not-required">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        terminal: "terminal";
+        "contract-missing": "contract-missing";
+        "delivery-missing": "delivery-missing";
+    }>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"gates-unsatisfied">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    unmet: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        gate: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").Gate, string>>;
+        current: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"attested">;
+            verdict: z.ZodEnum<{
+                satisfied: "satisfied";
+                unsatisfied: "unsatisfied";
+            }>;
+            at: z.ZodString;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"stale">;
+            priorVerdict: z.ZodEnum<{
+                satisfied: "satisfied";
+                unsatisfied: "unsatisfied";
+            }>;
+            reason: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"candidate-content-changed">;
+                target: z.ZodOptional<z.ZodString>;
+                previousChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ChangeId, string>>;
+                currentChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ChangeId, string>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>>;
+    target: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"prerequisites-unsatisfied">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    unmet: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        state: z.ZodEnum<{
+            abandoned: "abandoned";
+            missing: "missing";
+            active: "active";
+        }>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>]>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        "target-missing": "target-missing";
+        "unborn-head": "unborn-head";
+        "invalid-target": "invalid-target";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"verification-declaration-invalid">;
+    contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>>;
+}, z.core.$strict>]>, z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        "fork-source-missing": "fork-source-missing";
+        "fork-source-unavailable": "fork-source-unavailable";
+    }>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fork-source-moved">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+}, z.core.$strict>]>, z.ZodObject<{
+    kind: z.ZodLiteral<"nuke-confirmation-mismatch">;
+    world: z.ZodString;
+    confirmation: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"nuke-confirmation-required">;
+    world: z.ZodString;
+}, z.core.$strict>]>;
+export type KeiyakuRefusal = z.infer<typeof keiyakuRefusalSchema>;
+export declare const keiyakuRetryReasonSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        exhausted: "exhausted";
+        collision: "collision";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"publication-failed">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>]>, z.ZodObject<{
+    kind: z.ZodLiteral<"owner-reason-unavailable">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>]>;
+export type KeiyakuRetryReason = z.infer<typeof keiyakuRetryReasonSchema>;
+export declare const operationRetrySchemas: {
+    readonly bind: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            exhausted: "exhausted";
+            collision: "collision";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"publication-failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+    readonly amend: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            exhausted: "exhausted";
+            collision: "collision";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"publication-failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+    readonly deliver: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            exhausted: "exhausted";
+            collision: "collision";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"publication-failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>, z.ZodObject<{
+        kind: z.ZodLiteral<"owner-reason-unavailable">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+    readonly review: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            exhausted: "exhausted";
+            collision: "collision";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"publication-failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>, z.ZodObject<{
+        kind: z.ZodLiteral<"owner-reason-unavailable">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+    readonly audit: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            exhausted: "exhausted";
+            collision: "collision";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"publication-failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>, z.ZodObject<{
+        kind: z.ZodLiteral<"owner-reason-unavailable">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+    readonly arc: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            exhausted: "exhausted";
+            collision: "collision";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"publication-failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+    readonly abandon: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            exhausted: "exhausted";
+            collision: "collision";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"publication-failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+};
+export type OperationRetries = {
+    readonly [Operation in keyof typeof operationRetrySchemas]: z.infer<(typeof operationRetrySchemas)[Operation]>;
+};
+export declare const operationRefusalSchemas: {
+    readonly bind: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            "contract-exists": "contract-exists";
+            "invalid-after": "invalid-after";
+            "unknown-prerequisite": "unknown-prerequisite";
+        }>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            "target-missing": "target-missing";
+            "unborn-head": "unborn-head";
+            "invalid-target": "invalid-target";
+        }>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            "fork-source-missing": "fork-source-missing";
+            "fork-source-unavailable": "fork-source-unavailable";
+        }>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fork-source-moved">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>]>, z.ZodObject<{
+        kind: z.ZodLiteral<"verification-declaration-invalid">;
+        contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>>;
+    }, z.core.$strict>]>;
+    readonly amend: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            terminal: "terminal";
+            "contract-missing": "contract-missing";
+            "unknown-prerequisite": "unknown-prerequisite";
+            "terms-moved": "terms-moved";
+            "cyclic-prerequisite": "cyclic-prerequisite";
+        }>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"verification-declaration-invalid">;
+        contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>>;
+    }, z.core.$strict>]>;
+    readonly deliver: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            terminal: "terminal";
+            "contract-missing": "contract-missing";
+            "document-moved": "document-moved";
+        }>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"target-missing">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"worktree-missing">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"dirty-workspace">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        staged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        unstaged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        untracked: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        submodules: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        shortStat: z.ZodObject<{
+            filesChanged: z.ZodNumber;
+            insertions: z.ZodNumber;
+            deletions: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unmerged-paths">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+        kind: z.ZodLiteral<"integration-failed">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        reason: z.ZodEnum<{
+            "not-based-on-target": "not-based-on-target";
+            "unrelated-histories": "unrelated-histories";
+            conflict: "conflict";
+        }>;
+        targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").SnapshotId, string>>;
+        conflictPaths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        kind: "integration-failed";
+        contractId: import("../index.js").ContractId;
+        reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+        targetHead: import("../index.js").SnapshotId;
+    } & {
+        conflictPaths?: readonly string[];
+    }, {
+        kind: "integration-failed";
+        contractId: import("../index.js").ContractId;
+        reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+        targetHead: import("../index.js").SnapshotId;
+        conflictPaths?: readonly string[] | undefined;
+    }>>, z.ZodObject<{
+        kind: z.ZodLiteral<"integration-unsupported">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        requiredGit: z.ZodLiteral<"2.38">;
+    }, z.core.$strict>]>, z.ZodObject<{
+        kind: z.ZodLiteral<"merge-state-present">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        workspace: z.ZodObject<{
+            kind: z.ZodLiteral<"worktree">;
+            path: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"checkout-not-followable">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        target: z.ZodString;
+        path: z.ZodString;
+        reason: z.ZodLiteral<"untracked">;
+        paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>, z.ZodObject<{
+        kind: z.ZodLiteral<"integration-failed">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        reason: z.ZodLiteral<"conflict">;
+        targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").SnapshotId, string>>;
+        conflictPaths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        recovery: z.ZodObject<{
+            materialize: z.ZodLiteral<"deliver --materialize-conflict --include-dirty">;
+            deliver: z.ZodLiteral<"deliver --include-dirty">;
+            staging: z.ZodLiteral<"not-required">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"verification-declaration-invalid">;
+        contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>>;
+    }, z.core.$strict>]>;
+    readonly review: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            terminal: "terminal";
+            "contract-missing": "contract-missing";
+        }>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"worktree-missing">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"dirty-workspace">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+        staged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        unstaged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        untracked: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        submodules: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        shortStat: z.ZodObject<{
+            filesChanged: z.ZodNumber;
+            insertions: z.ZodNumber;
+            deletions: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+    readonly audit: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            terminal: "terminal";
+            "contract-missing": "contract-missing";
+            "document-moved": "document-moved";
+        }>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"verification-declaration-invalid">;
+        contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>>;
+    }, z.core.$strict>]>;
+    readonly arc: z.ZodObject<{
+        kind: z.ZodEnum<{
+            terminal: "terminal";
+            "contract-missing": "contract-missing";
+        }>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>;
+    readonly abandon: z.ZodObject<{
+        kind: z.ZodEnum<{
+            terminal: "terminal";
+            "contract-missing": "contract-missing";
+        }>;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    }, z.core.$strict>;
+};
+export type OperationRefusals = {
+    readonly [Operation in keyof typeof operationRefusalSchemas]: z.infer<(typeof operationRefusalSchemas)[Operation]>;
+};
+export {};