@ixo/decision-oracle 0.0.0-stage → 0.2.1

package/dist/lib/engine/types.d.ts

@@ -0,0 +1,1356 @@
+/**
+ * The eval engine's wire contract as THIS kit codes against it — docs/ENGINE-CONTRACT.md is the
+ * source of truth; this file is its Zod mirror. Responses are PARSED, not trusted: a shape drift on
+ * the engine side surfaces here as a loud error, never as an `undefined` verdict written to a row.
+ *
+ * `Decision` is eval-engine's `Decision` (its `rubric/eval/decide.ts`) copied as a TYPE only: the
+ * kit never decides — it records what the engine decided (codes, scores and identifiers; never
+ * answer values) and acts on `evaluationStatus`.
+ */
+import { z } from "zod";
+export declare const Verdict: z.ZodEnum<{
+    approve: "approve";
+    partial: "partial";
+    reject: "reject";
+    review: "review";
+}>;
+export type Verdict = z.infer<typeof Verdict>;
+/** The owner-readable evaluation record — codes, scores and outcomes ONLY, never answer values. */
+export declare const Decision: z.ZodObject<{
+    status: z.ZodEnum<{
+        decided: "decided";
+        pending_review: "pending_review";
+        unusable: "unusable";
+    }>;
+    verdict: z.ZodEnum<{
+        approve: "approve";
+        partial: "partial";
+        reject: "reject";
+        review: "review";
+    }>;
+    class: z.ZodEnum<{
+        insufficient_evidence: "insufficient_evidence";
+        invalid_evidence: "invalid_evidence";
+        out_of_authority: "out_of_authority";
+        partial: "partial";
+        refuted: "refuted";
+        requires_human_review: "requires_human_review";
+        supported: "supported";
+    }>;
+    evaluationStatus: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<5>]>;
+    action: z.ZodEnum<{
+        auto_approve: "auto_approve";
+        auto_reject: "auto_reject";
+        needs_human_review: "needs_human_review";
+    }>;
+    totalBps: z.ZodNullable<z.ZodNumber>;
+    gates: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        outcome: z.ZodEnum<{
+            failed: "failed";
+            not_reached: "not_reached";
+            passed: "passed";
+            skipped: "skipped";
+            unevaluated: "unevaluated";
+        }>;
+    }, z.core.$loose>>;
+    criteria: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        scoreBps: z.ZodNullable<z.ZodNumber>;
+        pending: z.ZodBoolean;
+        capped: z.ZodBoolean;
+    }, z.core.$loose>>;
+    pendingTasks: z.ZodArray<z.ZodString>;
+    reasons: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        reason: z.ZodString;
+        class: z.ZodEnum<{
+            insufficient_evidence: "insufficient_evidence";
+            invalid_evidence: "invalid_evidence";
+            out_of_authority: "out_of_authority";
+            partial: "partial";
+            refuted: "refuted";
+            requires_human_review: "requires_human_review";
+            supported: "supported";
+        }>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type Decision = z.infer<typeof Decision>;
+/**
+ * The facts that came back `error` (S1c, `erroredFacts`): `name` is the lane-prefixed fact name
+ * (`ext.<name>` / `ai.<name>`), `detail` the fact's own error text off the engine's stored trace
+ * (`trace.ext[<name>].detail` — the text this oracle froze), in trace order, capped at
+ * `MAX_ERRORED_FACT_DETAIL` on both sides. WHY a claim was held: the engine's reason line is
+ * generic and hashed into `resultDigest`, so it never says. Display only — never a decide input,
+ * and never logged (a handler wrote the text).
+ */
+export declare const MAX_ERRORED_FACT_DETAIL = 500;
+export declare const ErroredFact: z.ZodObject<{
+    name: z.ZodString;
+    detail: z.ZodString;
+}, z.core.$strip>;
+export type ErroredFact = z.infer<typeof ErroredFact>;
+/**
+ * What a pending `unique:<ruleId>` task asks about (S1c, `pendingTaskDetails`), off the engine's
+ * stored trace: `score` the frozen unique fact's `scoreBps` (absent when the fact never resolved),
+ * `priorClaimId` its winning candidate (absent without one) — a claim id out of THIS oracle's own
+ * registry. Loose: the engine may grow it; the review view reads only these keys.
+ */
+export declare const PendingTaskDetail: z.ZodObject<{
+    kind: z.ZodString;
+    ruleId: z.ZodString;
+    score: z.ZodOptional<z.ZodNumber>;
+    priorClaimId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type PendingTaskDetail = z.infer<typeof PendingTaskDetail>;
+/** `$` then `.key` / `[n]` segments — the engine's path subset: no filters, wildcards, recursion or
+ *  expressions. The same regex validates `OracleConfig.payouts` at module evaluation. */
+export declare const PAYOUT_PATH: RegExp;
+export declare const PayoutPath: z.ZodString;
+export declare const Iso4217: z.ZodString;
+/** OUTSIDE `facts` on both calls: never in `factsDigest`. Strict, like the engine's. */
+export declare const PayoutRequest: z.ZodUnion<readonly [z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    amountPath: z.ZodString;
+    currency: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    amountPath: z.ZodString;
+    currencyPath: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    amountPath: z.ZodString;
+    asset: z.ZodString;
+    decimals: z.ZodInt;
+}, z.core.$strict>]>;
+export type PayoutRequest = z.infer<typeof PayoutRequest>;
+/**
+ * The API claim CONTENT (contract "The claim content and `contentDigest`"): the submitted body as the
+ * API's strict schema parsed it, minus transport (`webhookUrl`), with the resolved `protocolDid`;
+ * `submitter` only the caller's explicit one (hosted MCP: the signed-in user's DID), never an oracle
+ * fill. Absent optionals are omitted, never null — the digest is over exactly these keys.
+ */
+export declare const ApiClaimContent: z.ZodObject<{
+    protocolDid: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    submitter: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type ApiClaimContent = z.infer<typeof ApiClaimContent>;
+/**
+ * The claim's content (D3). Chain: the claim CID, plus the stored document's EXACT bytes (base64)
+ * when the read lane CID-verified them — never re-serialised JSON; a bot-lane body sends no
+ * `document`. API: the content itself; the engine computes its `contentDigest` (never the
+ * idempotency `requestDigest`).
+ */
+export declare const ClaimContent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"chain">;
+    cid: z.ZodString;
+    document: z.ZodOptional<z.ZodBase64>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"api">;
+    body: z.ZodObject<{
+        protocolDid: z.ZodString;
+        answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        submitter: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export type ClaimContent = z.infer<typeof ClaimContent>;
+/** The reviewer's grant chain (D2): a base64 CAR, root → member did:ixo → [reviewer did:key]. */
+export declare const ReviewerGrant: z.ZodBase64;
+export declare const DecideRequest: z.ZodObject<{
+    subject: z.ZodObject<{
+        kind: z.ZodEnum<{
+            api: "api";
+            claim: "claim";
+        }>;
+        claimId: z.ZodString;
+        collectionId: z.ZodString;
+        protocolDid: z.ZodString;
+    }, z.core.$strip>;
+    rubric: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    facts: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        frozenAt: z.ZodISODateTime;
+        answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        attachments: z.ZodArray<z.ZodObject<{
+            question: z.ZodString;
+            name: z.ZodString;
+            mediaType: z.ZodString;
+            cid: z.ZodNullable<z.ZodString>;
+            size: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        ctx: z.ZodObject<{
+            now: z.ZodISODateTime;
+            collection: z.ZodObject<{
+                startDate: z.ZodNullable<z.ZodISODateTime>;
+                endDate: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>;
+            claim: z.ZodObject<{
+                submitter: z.ZodNullable<z.ZodString>;
+                submitterAddress: z.ZodNullable<z.ZodString>;
+                submissionDate: z.ZodNullable<z.ZodISODateTime>;
+                useIntent: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        ext: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"ok">;
+            value: z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber]>;
+            reason: z.ZodNullable<z.ZodString>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            transcript: z.ZodOptional<z.ZodObject<{
+                request: z.ZodObject<{
+                    url: z.ZodString;
+                    body: z.ZodUnknown;
+                    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>;
+                response: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodInt;
+                    body: z.ZodUnknown;
+                }, z.core.$strict>>;
+                attempts: z.ZodInt;
+                elapsedMs: z.ZodInt;
+                latencyMs: z.ZodOptional<z.ZodInt>;
+                genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    promptTokens: z.ZodNumber;
+                    completionTokens: z.ZodNumber;
+                    cachedTokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$strict>>>;
+                provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    cid: z.ZodNullable<z.ZodString>;
+                    result: z.ZodNullable<z.ZodObject<{
+                        vendor: z.ZodEnum<{
+                            google: "google";
+                            openai: "openai";
+                            other: "other";
+                            unknown: "unknown";
+                        }>;
+                        issuer: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        modelVersion: z.ZodOptional<z.ZodString>;
+                        aiGenerated: z.ZodBoolean;
+                        watermarked: z.ZodBoolean;
+                        signedAt: z.ZodOptional<z.ZodString>;
+                        trusted: z.ZodBoolean;
+                        failures: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"error">;
+            onError: z.ZodEnum<{
+                reject: "reject";
+                review: "review";
+            }>;
+            detail: z.ZodString;
+            transcript: z.ZodOptional<z.ZodObject<{
+                request: z.ZodObject<{
+                    url: z.ZodString;
+                    body: z.ZodUnknown;
+                    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>;
+                response: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodInt;
+                    body: z.ZodUnknown;
+                }, z.core.$strict>>;
+                attempts: z.ZodInt;
+                elapsedMs: z.ZodInt;
+                latencyMs: z.ZodOptional<z.ZodInt>;
+                genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    promptTokens: z.ZodNumber;
+                    completionTokens: z.ZodNumber;
+                    cachedTokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$strict>>>;
+                provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    cid: z.ZodNullable<z.ZodString>;
+                    result: z.ZodNullable<z.ZodObject<{
+                        vendor: z.ZodEnum<{
+                            google: "google";
+                            openai: "openai";
+                            other: "other";
+                            unknown: "unknown";
+                        }>;
+                        issuer: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        modelVersion: z.ZodOptional<z.ZodString>;
+                        aiGenerated: z.ZodBoolean;
+                        watermarked: z.ZodBoolean;
+                        signedAt: z.ZodOptional<z.ZodString>;
+                        trusted: z.ZodBoolean;
+                        failures: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "status">>;
+        ai: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"ok">;
+            value: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+            failedRules: z.ZodArray<z.ZodString>;
+            score: z.ZodNumber;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            transcript: z.ZodOptional<z.ZodObject<{
+                request: z.ZodObject<{
+                    url: z.ZodString;
+                    body: z.ZodUnknown;
+                    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>;
+                response: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodInt;
+                    body: z.ZodUnknown;
+                }, z.core.$strict>>;
+                attempts: z.ZodInt;
+                elapsedMs: z.ZodInt;
+                latencyMs: z.ZodOptional<z.ZodInt>;
+                genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    promptTokens: z.ZodNumber;
+                    completionTokens: z.ZodNumber;
+                    cachedTokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$strict>>>;
+                provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    cid: z.ZodNullable<z.ZodString>;
+                    result: z.ZodNullable<z.ZodObject<{
+                        vendor: z.ZodEnum<{
+                            google: "google";
+                            openai: "openai";
+                            other: "other";
+                            unknown: "unknown";
+                        }>;
+                        issuer: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        modelVersion: z.ZodOptional<z.ZodString>;
+                        aiGenerated: z.ZodBoolean;
+                        watermarked: z.ZodBoolean;
+                        signedAt: z.ZodOptional<z.ZodString>;
+                        trusted: z.ZodBoolean;
+                        failures: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"error">;
+            onError: z.ZodEnum<{
+                reject: "reject";
+                review: "review";
+            }>;
+            detail: z.ZodString;
+            transcript: z.ZodOptional<z.ZodObject<{
+                request: z.ZodObject<{
+                    url: z.ZodString;
+                    body: z.ZodUnknown;
+                    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>;
+                response: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodInt;
+                    body: z.ZodUnknown;
+                }, z.core.$strict>>;
+                attempts: z.ZodInt;
+                elapsedMs: z.ZodInt;
+                latencyMs: z.ZodOptional<z.ZodInt>;
+                genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    promptTokens: z.ZodNumber;
+                    completionTokens: z.ZodNumber;
+                    cachedTokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$strict>>>;
+                provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    cid: z.ZodNullable<z.ZodString>;
+                    result: z.ZodNullable<z.ZodObject<{
+                        vendor: z.ZodEnum<{
+                            google: "google";
+                            openai: "openai";
+                            other: "other";
+                            unknown: "unknown";
+                        }>;
+                        issuer: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        modelVersion: z.ZodOptional<z.ZodString>;
+                        aiGenerated: z.ZodBoolean;
+                        watermarked: z.ZodBoolean;
+                        signedAt: z.ZodOptional<z.ZodString>;
+                        trusted: z.ZodBoolean;
+                        failures: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "status">>;
+        unique: z.ZodOptional<z.ZodObject<{
+            ruleId: z.ZodString;
+            digest: z.ZodString;
+            scoreBps: z.ZodNumber;
+            band: z.ZodEnum<{
+                pass: "pass";
+                reject: "reject";
+                review: "review";
+            }>;
+        }, z.core.$loose>>;
+        frequency: z.ZodOptional<z.ZodObject<{
+            ruleId: z.ZodString;
+            count: z.ZodInt;
+            max: z.ZodInt;
+            per: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                month: "month";
+                week: "week";
+                year: "year";
+            }>>;
+            windowStartISO: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+            windowEndISO: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+            breach: z.ZodBoolean;
+            unresolved: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$loose>>;
+        settings: z.ZodObject<{
+            allowAiChecks: z.ZodBoolean;
+            allowImageChecks: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    payout: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        amountPath: z.ZodString;
+        currency: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        amountPath: z.ZodString;
+        currencyPath: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        amountPath: z.ZodString;
+        asset: z.ZodString;
+        decimals: z.ZodInt;
+    }, z.core.$strict>]>>;
+    claimContent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"chain">;
+        cid: z.ZodString;
+        document: z.ZodOptional<z.ZodBase64>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"api">;
+        body: z.ZodObject<{
+            protocolDid: z.ZodString;
+            answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            submitter: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strip>;
+export type DecideRequest = z.infer<typeof DecideRequest>;
+/** The dev lane (`POST /v1/decisions/preview`): the rubric may be inline, and so may the claim form. */
+export declare const PreviewRequest: z.ZodObject<{
+    subject: z.ZodObject<{
+        kind: z.ZodEnum<{
+            api: "api";
+            claim: "claim";
+        }>;
+        claimId: z.ZodString;
+        collectionId: z.ZodString;
+        protocolDid: z.ZodString;
+    }, z.core.$strip>;
+    rubric: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        doc: z.ZodUnknown;
+    }, z.core.$strip>]>;
+    form: z.ZodOptional<z.ZodObject<{
+        doc: z.ZodUnknown;
+        proof: z.ZodString;
+    }, z.core.$strip>>;
+    facts: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        frozenAt: z.ZodISODateTime;
+        answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        attachments: z.ZodArray<z.ZodObject<{
+            question: z.ZodString;
+            name: z.ZodString;
+            mediaType: z.ZodString;
+            cid: z.ZodNullable<z.ZodString>;
+            size: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        ctx: z.ZodObject<{
+            now: z.ZodISODateTime;
+            collection: z.ZodObject<{
+                startDate: z.ZodNullable<z.ZodISODateTime>;
+                endDate: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strict>;
+            claim: z.ZodObject<{
+                submitter: z.ZodNullable<z.ZodString>;
+                submitterAddress: z.ZodNullable<z.ZodString>;
+                submissionDate: z.ZodNullable<z.ZodISODateTime>;
+                useIntent: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        ext: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"ok">;
+            value: z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber]>;
+            reason: z.ZodNullable<z.ZodString>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            transcript: z.ZodOptional<z.ZodObject<{
+                request: z.ZodObject<{
+                    url: z.ZodString;
+                    body: z.ZodUnknown;
+                    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>;
+                response: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodInt;
+                    body: z.ZodUnknown;
+                }, z.core.$strict>>;
+                attempts: z.ZodInt;
+                elapsedMs: z.ZodInt;
+                latencyMs: z.ZodOptional<z.ZodInt>;
+                genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    promptTokens: z.ZodNumber;
+                    completionTokens: z.ZodNumber;
+                    cachedTokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$strict>>>;
+                provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    cid: z.ZodNullable<z.ZodString>;
+                    result: z.ZodNullable<z.ZodObject<{
+                        vendor: z.ZodEnum<{
+                            google: "google";
+                            openai: "openai";
+                            other: "other";
+                            unknown: "unknown";
+                        }>;
+                        issuer: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        modelVersion: z.ZodOptional<z.ZodString>;
+                        aiGenerated: z.ZodBoolean;
+                        watermarked: z.ZodBoolean;
+                        signedAt: z.ZodOptional<z.ZodString>;
+                        trusted: z.ZodBoolean;
+                        failures: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"error">;
+            onError: z.ZodEnum<{
+                reject: "reject";
+                review: "review";
+            }>;
+            detail: z.ZodString;
+            transcript: z.ZodOptional<z.ZodObject<{
+                request: z.ZodObject<{
+                    url: z.ZodString;
+                    body: z.ZodUnknown;
+                    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>;
+                response: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodInt;
+                    body: z.ZodUnknown;
+                }, z.core.$strict>>;
+                attempts: z.ZodInt;
+                elapsedMs: z.ZodInt;
+                latencyMs: z.ZodOptional<z.ZodInt>;
+                genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    promptTokens: z.ZodNumber;
+                    completionTokens: z.ZodNumber;
+                    cachedTokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$strict>>>;
+                provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    cid: z.ZodNullable<z.ZodString>;
+                    result: z.ZodNullable<z.ZodObject<{
+                        vendor: z.ZodEnum<{
+                            google: "google";
+                            openai: "openai";
+                            other: "other";
+                            unknown: "unknown";
+                        }>;
+                        issuer: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        modelVersion: z.ZodOptional<z.ZodString>;
+                        aiGenerated: z.ZodBoolean;
+                        watermarked: z.ZodBoolean;
+                        signedAt: z.ZodOptional<z.ZodString>;
+                        trusted: z.ZodBoolean;
+                        failures: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "status">>;
+        ai: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"ok">;
+            value: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+            failedRules: z.ZodArray<z.ZodString>;
+            score: z.ZodNumber;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            transcript: z.ZodOptional<z.ZodObject<{
+                request: z.ZodObject<{
+                    url: z.ZodString;
+                    body: z.ZodUnknown;
+                    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>;
+                response: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodInt;
+                    body: z.ZodUnknown;
+                }, z.core.$strict>>;
+                attempts: z.ZodInt;
+                elapsedMs: z.ZodInt;
+                latencyMs: z.ZodOptional<z.ZodInt>;
+                genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    promptTokens: z.ZodNumber;
+                    completionTokens: z.ZodNumber;
+                    cachedTokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$strict>>>;
+                provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    cid: z.ZodNullable<z.ZodString>;
+                    result: z.ZodNullable<z.ZodObject<{
+                        vendor: z.ZodEnum<{
+                            google: "google";
+                            openai: "openai";
+                            other: "other";
+                            unknown: "unknown";
+                        }>;
+                        issuer: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        modelVersion: z.ZodOptional<z.ZodString>;
+                        aiGenerated: z.ZodBoolean;
+                        watermarked: z.ZodBoolean;
+                        signedAt: z.ZodOptional<z.ZodString>;
+                        trusted: z.ZodBoolean;
+                        failures: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"error">;
+            onError: z.ZodEnum<{
+                reject: "reject";
+                review: "review";
+            }>;
+            detail: z.ZodString;
+            transcript: z.ZodOptional<z.ZodObject<{
+                request: z.ZodObject<{
+                    url: z.ZodString;
+                    body: z.ZodUnknown;
+                    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>;
+                response: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodInt;
+                    body: z.ZodUnknown;
+                }, z.core.$strict>>;
+                attempts: z.ZodInt;
+                elapsedMs: z.ZodInt;
+                latencyMs: z.ZodOptional<z.ZodInt>;
+                genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    promptTokens: z.ZodNumber;
+                    completionTokens: z.ZodNumber;
+                    cachedTokens: z.ZodNumber;
+                    costUsd: z.ZodNumber;
+                }, z.core.$strict>>>;
+                provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    cid: z.ZodNullable<z.ZodString>;
+                    result: z.ZodNullable<z.ZodObject<{
+                        vendor: z.ZodEnum<{
+                            google: "google";
+                            openai: "openai";
+                            other: "other";
+                            unknown: "unknown";
+                        }>;
+                        issuer: z.ZodOptional<z.ZodString>;
+                        model: z.ZodOptional<z.ZodString>;
+                        modelVersion: z.ZodOptional<z.ZodString>;
+                        aiGenerated: z.ZodBoolean;
+                        watermarked: z.ZodBoolean;
+                        signedAt: z.ZodOptional<z.ZodString>;
+                        trusted: z.ZodBoolean;
+                        failures: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "status">>;
+        unique: z.ZodOptional<z.ZodObject<{
+            ruleId: z.ZodString;
+            digest: z.ZodString;
+            scoreBps: z.ZodNumber;
+            band: z.ZodEnum<{
+                pass: "pass";
+                reject: "reject";
+                review: "review";
+            }>;
+        }, z.core.$loose>>;
+        frequency: z.ZodOptional<z.ZodObject<{
+            ruleId: z.ZodString;
+            count: z.ZodInt;
+            max: z.ZodInt;
+            per: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                month: "month";
+                week: "week";
+                year: "year";
+            }>>;
+            windowStartISO: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+            windowEndISO: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+            breach: z.ZodBoolean;
+            unresolved: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$loose>>;
+        settings: z.ZodObject<{
+            allowAiChecks: z.ZodBoolean;
+            allowImageChecks: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export type PreviewRequest = z.infer<typeof PreviewRequest>;
+/** LOOSE on purpose: the engine may add fields without a wire bump. `rubricId` is null iff the protocol has no `#rub`. */
+export declare const DecideResponse: z.ZodObject<{
+    subject: z.ZodObject<{
+        claimId: z.ZodString;
+        collectionId: z.ZodString;
+    }, z.core.$loose>;
+    rubricId: z.ZodNullable<z.ZodString>;
+    decision: z.ZodObject<{
+        status: z.ZodEnum<{
+            decided: "decided";
+            pending_review: "pending_review";
+            unusable: "unusable";
+        }>;
+        verdict: z.ZodEnum<{
+            approve: "approve";
+            partial: "partial";
+            reject: "reject";
+            review: "review";
+        }>;
+        class: z.ZodEnum<{
+            insufficient_evidence: "insufficient_evidence";
+            invalid_evidence: "invalid_evidence";
+            out_of_authority: "out_of_authority";
+            partial: "partial";
+            refuted: "refuted";
+            requires_human_review: "requires_human_review";
+            supported: "supported";
+        }>;
+        evaluationStatus: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<5>]>;
+        action: z.ZodEnum<{
+            auto_approve: "auto_approve";
+            auto_reject: "auto_reject";
+            needs_human_review: "needs_human_review";
+        }>;
+        totalBps: z.ZodNullable<z.ZodNumber>;
+        gates: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                not_reached: "not_reached";
+                passed: "passed";
+                skipped: "skipped";
+                unevaluated: "unevaluated";
+            }>;
+        }, z.core.$loose>>;
+        criteria: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            scoreBps: z.ZodNullable<z.ZodNumber>;
+            pending: z.ZodBoolean;
+            capped: z.ZodBoolean;
+        }, z.core.$loose>>;
+        pendingTasks: z.ZodArray<z.ZodString>;
+        reasons: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            reason: z.ZodString;
+            class: z.ZodEnum<{
+                insufficient_evidence: "insufficient_evidence";
+                invalid_evidence: "invalid_evidence";
+                out_of_authority: "out_of_authority";
+                partial: "partial";
+                refuted: "refuted";
+                requires_human_review: "requires_human_review";
+                supported: "supported";
+            }>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+    explanation: z.ZodNullable<z.ZodString>;
+    factsDigest: z.ZodString;
+    resultDigest: z.ZodString;
+    receipt: z.ZodNullable<z.ZodObject<{
+        cid: z.ZodString;
+        jws: z.ZodString;
+    }, z.core.$strip>>;
+    traceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    billing: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        totalMicroUsd: z.ZodInt;
+    }, z.core.$loose>>>;
+    preferences: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$loose>>>;
+    decisionToPayRefused: z.ZodOptional<z.ZodLiteral<"NO_PAYEE">>;
+    erroredFacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        detail: z.ZodString;
+    }, z.core.$loose>>>;
+    pendingTaskDetails: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodString;
+        ruleId: z.ZodString;
+        score: z.ZodOptional<z.ZodNumber>;
+        priorClaimId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type DecideResponse = z.infer<typeof DecideResponse>;
+export declare const ReviewRequest: z.ZodObject<{
+    answeredAgainst: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    reviewerDid: z.ZodString;
+    attestation: z.ZodString;
+    claim: z.ZodObject<{
+        answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        frozenAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    payout: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        amountPath: z.ZodString;
+        currency: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        amountPath: z.ZodString;
+        currencyPath: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        amountPath: z.ZodString;
+        asset: z.ZodString;
+        decimals: z.ZodInt;
+    }, z.core.$strict>]>>;
+    claimContent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"chain">;
+        cid: z.ZodString;
+        document: z.ZodOptional<z.ZodBase64>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"api">;
+        body: z.ZodObject<{
+            protocolDid: z.ZodString;
+            answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            submitter: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">;
+    reviewerGrant: z.ZodOptional<z.ZodBase64>;
+}, z.core.$strip>;
+export type ReviewRequest = z.infer<typeof ReviewRequest>;
+/** The ADR-36 address proof: who this did:web is on chain (adr36.ts owns producing/checking this). */
+export declare const AddressProof: z.ZodObject<{
+    address: z.ZodString;
+    pubKey: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;
+export type AddressProof = z.infer<typeof AddressProof>;
+/**
+ * The register body: the address proof, plus the oracle OWNER's UCAN delegation to the engine
+ * (base64 CAR — config.OWNER_DELEGATION_CAR) carrying `subscriptions/read` on `ixo:subscriptions`
+ * and `billing/pay` bound to THIS oracle's did:web. This is how the engine finds — and bills — the
+ * owner's subscription per decision (spec §9); the kit never parses the CAR, only forwards it.
+ */
+export declare const RegisterRequest: z.ZodObject<{
+    address: z.ZodString;
+    pubKey: z.ZodString;
+    signature: z.ZodString;
+    ownerDelegation: z.ZodString;
+}, z.core.$strip>;
+export type RegisterRequest = z.infer<typeof RegisterRequest>;
+export declare const CompanyLinkState: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    link: z.ZodNull;
+    entityDid: z.ZodNull;
+    payeeField: z.ZodNull;
+    issuedAt: z.ZodNull;
+    nonce: z.ZodNull;
+    state: z.ZodLiteral<"unlinked">;
+}, z.core.$strict>, z.ZodObject<{
+    link: z.ZodNull;
+    entityDid: z.ZodNull;
+    payeeField: z.ZodNull;
+    issuedAt: z.ZodNull;
+    nonce: z.ZodNull;
+    state: z.ZodLiteral<"disputed">;
+}, z.core.$strict>, z.ZodObject<{
+    state: z.ZodLiteral<"linked">;
+    link: z.ZodString;
+    entityDid: z.ZodString;
+    payeeField: z.ZodNullable<z.ZodString>;
+    issuedAt: z.ZodISODateTime;
+    nonce: z.ZodString;
+}, z.core.$strict>], "state">;
+export type CompanyLinkState = z.infer<typeof CompanyLinkState>;
+/**
+ * The company the engine derives for one chain collection (contract "Company authority" → "Read
+ * it", CA11): the collection's own entity, or — on a poster's deed with exactly one org linked both
+ * ways — that org. Only the engine resolves it (the same function and cache as the decide); the
+ * register reads it to pick whose Decision API source contact a collection defaults to
+ * (lib/register.ts). `kind` is the company entity's chain type, open-ended on the engine's side.
+ */
+export declare const CollectionCompany: z.ZodObject<{
+    entityDid: z.ZodString;
+    kind: z.ZodString;
+    state: z.ZodEnum<{
+        disputed: "disputed";
+        ok: "ok";
+    }>;
+    source: z.ZodEnum<{
+        entity: "entity";
+        "request-link": "request-link";
+    }>;
+}, z.core.$strip>;
+export type CollectionCompany = z.infer<typeof CollectionCompany>;
+/** `GET /v1/oracles/me` — the one field the cron reads; the rest is dashboard material. */
+export declare const OracleMe: z.ZodObject<{
+    address: z.ZodOptional<z.ZodString>;
+    billingStatus: z.ZodEnum<{
+        needs_funds: "needs_funds";
+        ok: "ok";
+    }>;
+    manageSubscriptionUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ixoManaged: z.ZodOptional<z.ZodBoolean>;
+    reviewBilling: z.ZodOptional<z.ZodBoolean>;
+    accepts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type OracleMe = z.infer<typeof OracleMe>;
+/**
+ * The buyer statement the engine stores centrally (contract "Agreements"). `doc` is NEVER
+ * interpreted by the kit beyond `kind` — a connector reads it and produces facts from it.
+ */
+export declare const Agreement: z.ZodObject<{
+    id: z.ZodString;
+    digest: z.ZodString;
+    counterparty: z.ZodNullable<z.ZodString>;
+    doc: z.ZodObject<{
+        kind: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type Agreement = z.infer<typeof Agreement>;
+/**
+ * The engine's human-readable report of one of OUR decisions (its `lib/decision/report.ts`):
+ * `gates`/`criteria`/`checks` straight off the signed receipt, `explanation` the row's own (or the
+ * fold's). LOOSE — the Decision API proxies it as-is; only what the HTML view renders is pinned.
+ */
+export declare const Report: z.ZodObject<{
+    verdict: z.ZodEnum<{
+        approve: "approve";
+        partial: "partial";
+        reject: "reject";
+        review: "review";
+    }>;
+    explanation: z.ZodString;
+    gates: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        outcome: z.ZodEnum<{
+            failed: "failed";
+            not_reached: "not_reached";
+            passed: "passed";
+            skipped: "skipped";
+            unevaluated: "unevaluated";
+        }>;
+    }, z.core.$loose>>;
+    criteria: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        scoreBps: z.ZodNullable<z.ZodNumber>;
+        weightBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        pending: z.ZodBoolean;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type Report = z.infer<typeof Report>;
+/** A declared external source, verbatim from the rubric — the engine never acts on it, a producer does. */
+export declare const ManifestExt: z.ZodObject<{
+    expect: z.ZodEnum<{
+        boolean: "boolean";
+        score: "score";
+    }>;
+    onError: z.ZodEnum<{
+        reject: "reject";
+        review: "review";
+    }>;
+    endpoint: z.ZodString;
+    audience: z.ZodString;
+    capability: z.ZodOptional<z.ZodObject<{
+        can: z.ZodString;
+        with: z.ZodString;
+    }, z.core.$strip>>;
+    send: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    usedBy: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+export type ManifestExt = z.infer<typeof ManifestExt>;
+/** A declared AI check, verbatim — v1 checks are yes/no only. */
+export declare const ManifestAi: z.ZodObject<{
+    expect: z.ZodLiteral<"boolean">;
+    onError: z.ZodEnum<{
+        reject: "reject";
+        review: "review";
+    }>;
+    instructions: z.ZodArray<z.ZodString>;
+    send: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    usedBy: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+export type ManifestAi = z.infer<typeof ManifestAi>;
+/**
+ * A review task's answer shape — a frozen contract with the portal, and what the Matrix review-request
+ * lane (lib/matrix/events.ts) sends verbatim into the room, and what the portal's inline card
+ * renders a control for. LOOSE per variant (the engine may add fields without a wire bump).
+ */
+export declare const ManifestReviewAnswer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"enum">;
+    options: z.ZodArray<z.ZodString>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+}, z.core.$loose>], "type">;
+export type ManifestReviewAnswer = z.infer<typeof ManifestReviewAnswer>;
+/**
+ * The duplicate rule's declaration (docs/ENGINE-CONTRACT.md "Duplicate + frequency detection"):
+ * the engine (≥ 444aeae) sends the FULL post-default rule — what its `Unique.parse` yields, minus
+ * `label`/`@type`; `by` only when declared; an older engine sends `{ ruleId }` only. Every
+ * parameter is optional HERE so both parse; the stock producer fills a missing one from the
+ * engine's own defaults (lib/facts/stock/rule-defaults.ts — kept in lock-step).
+ */
+export declare const ManifestUnique: z.ZodObject<{
+    ruleId: z.ZodString;
+    by: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        ref: z.ZodString;
+        granularity: z.ZodOptional<z.ZodEnum<{
+            day: "day";
+            month: "month";
+            year: "year";
+        }>>;
+    }, z.core.$loose>]>>>;
+    countPrior: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        approved: "approved";
+        pending_review: "pending_review";
+        queued: "queued";
+    }>>>;
+    attachments: z.ZodOptional<z.ZodBoolean>;
+    ai: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        maxPairs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    thresholds: z.ZodOptional<z.ZodObject<{
+        rejectAtBps: z.ZodOptional<z.ZodNumber>;
+        reviewAtBps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type ManifestUnique = z.infer<typeof ManifestUnique>;
+/**
+ * The frequency rule's declaration, same posture: full post-default from the engine, `{ ruleId }`
+ * from an older one — but `max`/`per` have NO default, so without them the rule cannot run
+ * (rule-defaults.ts answers null; validate.ts refuses the build as `invalid_facts`).
+ */
+export declare const ManifestFrequency: z.ZodObject<{
+    ruleId: z.ZodString;
+    max: z.ZodOptional<z.ZodNumber>;
+    per: z.ZodOptional<z.ZodEnum<{
+        day: "day";
+        month: "month";
+        week: "week";
+        year: "year";
+    }>>;
+    onBreach: z.ZodOptional<z.ZodEnum<{
+        reject: "reject";
+        review: "review";
+    }>>;
+}, z.core.$loose>;
+export type ManifestFrequency = z.infer<typeof ManifestFrequency>;
+/**
+ * The rubric's WORK ORDER as the engine's binder computed it (docs/ENGINE-CONTRACT.md "Manifest"):
+ * the `ext`/`ai` facts a producer must return, what the rules read (`ctx`, `fields`) and what the
+ * engine computes itself (`derived`). LOOSE: the engine may add fields without a wire bump, and
+ * `review` is informational — tolerated absent. `unique`/`frequency` are part of the ORDER too: a
+ * declared rule means the producer must return that fact (validate.ts).
+ */
+export declare const Manifest: z.ZodObject<{
+    rubricId: z.ZodString;
+    formProof: z.ZodObject<{
+        pinned: z.ZodString;
+        live: z.ZodNullable<z.ZodString>;
+        drifted: z.ZodBoolean;
+    }, z.core.$strip>;
+    ext: z.ZodRecord<z.ZodString, z.ZodObject<{
+        expect: z.ZodEnum<{
+            boolean: "boolean";
+            score: "score";
+        }>;
+        onError: z.ZodEnum<{
+            reject: "reject";
+            review: "review";
+        }>;
+        endpoint: z.ZodString;
+        audience: z.ZodString;
+        capability: z.ZodOptional<z.ZodObject<{
+            can: z.ZodString;
+            with: z.ZodString;
+        }, z.core.$strip>>;
+        send: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        usedBy: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>;
+    ai: z.ZodRecord<z.ZodString, z.ZodObject<{
+        expect: z.ZodLiteral<"boolean">;
+        onError: z.ZodEnum<{
+            reject: "reject";
+            review: "review";
+        }>;
+        instructions: z.ZodArray<z.ZodString>;
+        send: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        usedBy: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>;
+    hasAiChecks: z.ZodBoolean;
+    ctx: z.ZodArray<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodString;
+    }, z.core.$loose>>;
+    derived: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        expression: z.ZodString;
+    }, z.core.$loose>>;
+    review: z.ZodOptional<z.ZodObject<{
+        tasks: z.ZodArray<z.ZodString>;
+        taskDetails: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            prompt: z.ZodString;
+            answer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"boolean">;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"enum">;
+                options: z.ZodArray<z.ZodString>;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"number">;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, z.core.$loose>], "type">;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+    unique: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        ruleId: z.ZodString;
+        by: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            ref: z.ZodString;
+            granularity: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                month: "month";
+                year: "year";
+            }>>;
+        }, z.core.$loose>]>>>;
+        countPrior: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            approved: "approved";
+            pending_review: "pending_review";
+            queued: "queued";
+        }>>>;
+        attachments: z.ZodOptional<z.ZodBoolean>;
+        ai: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            maxPairs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        thresholds: z.ZodOptional<z.ZodObject<{
+            rejectAtBps: z.ZodOptional<z.ZodNumber>;
+            reviewAtBps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    frequency: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        ruleId: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+        per: z.ZodOptional<z.ZodEnum<{
+            day: "day";
+            month: "month";
+            week: "week";
+            year: "year";
+        }>>;
+        onBreach: z.ZodOptional<z.ZodEnum<{
+            reject: "reject";
+            review: "review";
+        }>>;
+    }, z.core.$loose>>>;
+    sizeProbes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        maxSizeMB: z.ZodNumber;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type Manifest = z.infer<typeof Manifest>;
+/** A rubric the engine cannot resolve or bind — a 200, never an HTTP error; `issues` say why (spec §12). */
+export declare const ManifestUnusable: z.ZodObject<{
+    status: z.ZodLiteral<"unusable">;
+    issues: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export type ManifestUnusable = z.infer<typeof ManifestUnusable>;
+/** Either shape, told apart by `status` — a usable manifest carries none (spec §12). */
+export declare const ManifestResponse: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodLiteral<"unusable">;
+    issues: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$strip>, z.ZodObject<{
+    rubricId: z.ZodString;
+    formProof: z.ZodObject<{
+        pinned: z.ZodString;
+        live: z.ZodNullable<z.ZodString>;
+        drifted: z.ZodBoolean;
+    }, z.core.$strip>;
+    ext: z.ZodRecord<z.ZodString, z.ZodObject<{
+        expect: z.ZodEnum<{
+            boolean: "boolean";
+            score: "score";
+        }>;
+        onError: z.ZodEnum<{
+            reject: "reject";
+            review: "review";
+        }>;
+        endpoint: z.ZodString;
+        audience: z.ZodString;
+        capability: z.ZodOptional<z.ZodObject<{
+            can: z.ZodString;
+            with: z.ZodString;
+        }, z.core.$strip>>;
+        send: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        usedBy: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>;
+    ai: z.ZodRecord<z.ZodString, z.ZodObject<{
+        expect: z.ZodLiteral<"boolean">;
+        onError: z.ZodEnum<{
+            reject: "reject";
+            review: "review";
+        }>;
+        instructions: z.ZodArray<z.ZodString>;
+        send: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        usedBy: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>;
+    hasAiChecks: z.ZodBoolean;
+    ctx: z.ZodArray<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodString;
+    }, z.core.$loose>>;
+    derived: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        expression: z.ZodString;
+    }, z.core.$loose>>;
+    review: z.ZodOptional<z.ZodObject<{
+        tasks: z.ZodArray<z.ZodString>;
+        taskDetails: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            prompt: z.ZodString;
+            answer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"boolean">;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"enum">;
+                options: z.ZodArray<z.ZodString>;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"number">;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, z.core.$loose>], "type">;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+    unique: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        ruleId: z.ZodString;
+        by: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            ref: z.ZodString;
+            granularity: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                month: "month";
+                year: "year";
+            }>>;
+        }, z.core.$loose>]>>>;
+        countPrior: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            approved: "approved";
+            pending_review: "pending_review";
+            queued: "queued";
+        }>>>;
+        attachments: z.ZodOptional<z.ZodBoolean>;
+        ai: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            maxPairs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        thresholds: z.ZodOptional<z.ZodObject<{
+            rejectAtBps: z.ZodOptional<z.ZodNumber>;
+            reviewAtBps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    frequency: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        ruleId: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+        per: z.ZodOptional<z.ZodEnum<{
+            day: "day";
+            month: "month";
+            week: "week";
+            year: "year";
+        }>>;
+        onBreach: z.ZodOptional<z.ZodEnum<{
+            reject: "reject";
+            review: "review";
+        }>>;
+    }, z.core.$loose>>>;
+    sizeProbes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        maxSizeMB: z.ZodNumber;
+    }, z.core.$loose>>>;
+}, z.core.$loose>]>;
+export declare const isManifestUnusable: (m: Manifest | ManifestUnusable) => m is ManifestUnusable;
+/** The engine's error envelope — the same `{ error: {…} }` shape this service returns. */
+export declare const ErrorEnvelope: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        requestId: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+/**
+ * A non-2xx engine answer, carrying the contract's `code` so the workflow can route it (pause the
+ * collection, retry, fail closed) without parsing messages. `status >= 500` — or the engine's
+ * own `UNAVAILABLE` — is the retryable class, and so is 429 `RATE_LIMITED`: the engine's per-IP
+ * limiter (100/60 s) throttles a backlog burst, which is a "not now", never a "no" — a
+ * `Retry-After` it sends is exposed as `retryAfterMs` (the step's own backoff is what actually
+ * waits). Every other 4xx is deterministic, except `INSUFFICIENT_CREDITS`, which the contract
+ * says to retry after the top-up. The fold's own refusals — 409 `STALE_REVIEW`, 409
+ * `FACTS_MISMATCH`, 422 `REVIEW_INCOMPLETE` (with `details.pendingTasks`), 400 not pending, 403
+ * decided by another oracle, 404 never decided — are all in the deterministic class: the review
+ * lane surfaces the code on the review row, never retries. So is the manifest's 404
+ * `RUBRIC_UNKNOWN` (a pin the engine never decided under).
+ */
+export declare class EngineError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly requestId?: string;
+    readonly details?: unknown;
+    /** The engine's `Retry-After` (a 429), in ms — absent when it sent none. */
+    readonly retryAfterMs?: number;
+    constructor(status: number, code: string, message: string, extra?: {
+        requestId?: string;
+        details?: unknown;
+        retryAfterMs?: number;
+    });
+    get retryable(): boolean;
+    /** The engine's `details.manageSubscriptionUrl` on a 402 — where the OWNER tops up. */
+    get topUpUrl(): string | null;
+}
+//# sourceMappingURL=types.d.ts.map