@ixo/decision-oracle 0.0.0-stage → 0.2.0

package/dist/contracts/api.d.ts

@@ -0,0 +1,3367 @@
+/**
+ * The Decision API's wire contract (`/v1/api/*`, go-prod spec §4) as Zod — the mirror of
+ * `openapi/decision-api.yaml`, whose component schemas are GENERATED from these
+ * (`openapi/generate.ts`) and whose examples `test/node/contracts-openapi.test.ts` parses here.
+ * x402 and UDID shapes mirror the board's contracts (`board/contracts/{x402,ixo-pay,udid}`).
+ *
+ * REQUEST bodies are `z.strictObject`: an unknown key is a `400 VALIDATION` (§4.3 "validation is
+ * complete before anything is charged or stored"), never silently dropped. RESPONSES are
+ * `z.object`, so a reader tolerates the additive changes §4.1 ships without a bump. Query strings
+ * are loose: an unknown parameter is ignored. URLs we ACCEPT are https only (§14); URLs we RETURN
+ * are plain `z.url()`, so a local dev oracle on http still validates.
+ *
+ * Not a published subpath: the router parses with it, and clients (S7) are generated from the
+ * OpenAPI. NODE-SAFE all the same (zod + the engine's type mirror), because the node lane tests it.
+ */
+import { z } from "zod";
+import { Verdict } from "../lib/engine/types.js";
+import { Capability, MemberRole } from "./capabilities.js";
+/** `Prefer: wait=N` / `?wait=N` ceiling: under the step's 4-minute timeout and the ~100 s most
+ *  gateways cut at, above the typical AI + external-source budget (§4.6). */
+export declare const MAX_WAIT_SECONDS = 90;
+export declare const MAX_BATCH_CLAIMS = 100;
+export declare const MAX_PAGE_LIMIT = 500;
+/** `metadata` is echoed on every GET and webhook, never evaluated — kept small (§4.3). */
+export declare const MAX_METADATA_BYTES = 4096;
+export declare const MAX_JSON_BODY_BYTES: number;
+export declare const MAX_UPLOAD_BYTES = 25000000;
+/** `apc_` + 40 hex of sha256(sourceId|Idempotency-Key) — so the ledger's PK insert IS the
+ *  duplicate guard (§4.6) — or `apc_` + a fresh ULID when the caller sent no key. */
+export declare const ClaimId: z.ZodString;
+/** Any claim a record can show (contracts v1.2): an API claim's `ClaimId`, or a chain claim's own
+ *  id — a CID, or (on older collections) a Matrix event id — at most 512 chars. What the READ
+ *  routes take as `:claimId` (the record, timeline, receipt, report — a source's for its linked
+ *  collections' chain claims, and the operator's); submit, review and erase stay `ClaimId`. */
+export declare const RecordClaimId: z.ZodString;
+export declare const SourceId: z.ZodString;
+export declare const EndpointId: z.ZodString;
+export declare const EventId: z.ZodString;
+export declare const MemberId: z.ZodString;
+export declare const UploadId: z.ZodString;
+export declare const AuditId: z.ZodString;
+/** `wh:<eventId>:<endpointId>`, or `wh:<eventId>:claim` for the claim's own `webhookUrl` — the
+ *  `matrix_deliveries.dedupeKey`, so a redelivery can never double-post one event to one target. */
+export declare const DeliveryId: z.ZodString;
+/** The facilitator's settlement id (`org.udid.receipt@1` `settlementId`, payments spec §13.1): 64
+ *  hex, one per offer — a batch's claims share it. Replaces the hold id `chargeId` (contracts v1.3). */
+export declare const SettlementId: z.ZodString;
+/** The 8-char lookup prefix of an API key (`eo_live_<prefix>_<secret>`, §3.2). */
+export declare const KeyPrefix: z.ZodString;
+export declare const ProtocolDid: z.ZodString;
+/** An IXO user account (`ixo1` + 38 bech32 chars) — members, owners, payers. Contract and DAO
+ *  accounts are not supported at launch (the board's `didIxo`). */
+export declare const AccountDid: z.ZodString;
+/** A company entity (company authority D1): the on-chain entity whose controllers administer every
+ *  source linked to it. */
+export declare const EntityDid: z.ZodString;
+/** A reviewer key: `did:key` (Ed25519) generated in the member's browser (§3.2, §10). */
+export declare const ReviewerDid: z.ZodString;
+/** ISO-8601 UTC (§4.1) — `Z`, never an offset — on everything we write. */
+export declare const Timestamp: z.ZodISODateTime;
+/** A compact JWS: base64url(header).base64url(payload).base64url(signature). */
+export declare const CompactJws: z.ZodString;
+/** SSRF control §14 starts at the schema: https only. The public-DNS / private-range checks run
+ *  at fetch time, per redirect hop, where the resolved address is known. */
+export declare const HttpsUrl: z.ZodURL;
+/** A non-negative integer in an asset's base units as a decimal STRING, never a float — PAY
+ *  (`upay`, 1 PAY = 1 USD = 1,000,000 upay) or a customer's own asset. 78 digits covers uint256. */
+export declare const BaseUnitAmount: z.ZodString;
+/** Any CAIP-2 `namespace:reference` — the network of a customer's own x402 offer. */
+export declare const Caip2Network: z.ZodString;
+/** x402's network id for the IXO chain the facilitator settles on, CAIP-2 `cosmos:<chain-id>`
+ *  (`cosmos:devnet-1`, `cosmos:pandora-8` testnet, `cosmos:ixo-5` mainnet). */
+export declare const IxoNetwork: z.ZodString;
+/** The card scheme's networks (payments spec §6.3, `stripe-manual-capture`): Stripe test or live. */
+export declare const StripeNetwork: z.ZodEnum<{
+    "stripe:live": "stripe:live";
+    "stripe:test": "stripe:test";
+}>;
+/** CAIP-2 `eip155:<chainId>`: the `exact` scheme's EVM chain (USDC on Base: `eip155:8453`). */
+export declare const EvmNetwork: z.ZodString;
+/** A 20-byte EVM account, hex: an `exact` payment's payer (its EIP-3009 authorization's signer). */
+export declare const EvmAddress: z.ZodString;
+/** Where a payment settles: the IXO chain (PAY), Stripe (card, contracts v1.4) or an EVM chain
+ *  (`exact`: USDC on Base, a plan without PAY). */
+export declare const SettleNetwork: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
+    "stripe:live": "stripe:live";
+    "stripe:test": "stripe:test";
+}>, z.ZodString]>;
+/** The facilitator's offer id, the 402's single-use nonce: a lowercase UUID. */
+export declare const OfferNonce: z.ZodString;
+export declare const Scope: z.ZodEnum<{
+    "claims:read": "claims:read";
+    "claims:write": "claims:write";
+    "webhooks:manage": "webhooks:manage";
+}>;
+export type Scope = z.infer<typeof Scope>;
+export { Capability, MemberRole };
+/** The ledger's `claim_ingests.status` — where the claim got to, independent of the verdict. */
+export declare const ClaimStatus: z.ZodEnum<{
+    failed: "failed";
+    processed: "processed";
+    processing: "processing";
+    queued: "queued";
+}>;
+export type ClaimStatus = z.infer<typeof ClaimStatus>;
+/** How a claim arrived (contracts v1.2): `POST /v1/api/claims`, or the cron's scan of a watched
+ *  on-chain collection. */
+export declare const ClaimLane: z.ZodEnum<{
+    api: "api";
+    chain: "chain";
+}>;
+export type ClaimLane = z.infer<typeof ClaimLane>;
+/** The `decisions.chainStatus` column: where a verdict got to on chain. Always `skipped` on the API
+ *  lane (nothing is signed); a chain claim's is the act lane's real state. */
+export declare const ChainStatus: z.ZodEnum<{
+    blocked: "blocked";
+    held: "held";
+    owner_submitted: "owner_submitted";
+    pending: "pending";
+    skipped: "skipped";
+    submitted: "submitted";
+}>;
+export type ChainStatus = z.infer<typeof ChainStatus>;
+/**
+ * The `decisions.status` column: the engine's three, the facts lane's own `invalid_facts`, and the
+ * engine's two refusals of the claim's content (v1.7): `content_mismatch` (the facts don't match the
+ * content you sent) and `payload_too_large` — both with no decision, and the claim `failed`.
+ */
+export declare const DecisionStatus: z.ZodEnum<{
+    content_mismatch: "content_mismatch";
+    decided: "decided";
+    invalid_facts: "invalid_facts";
+    payload_too_large: "payload_too_large";
+    pending_review: "pending_review";
+    unusable: "unusable";
+}>;
+export type DecisionStatus = z.infer<typeof DecisionStatus>;
+/**
+ * A claim's payment (contracts v1.3, payments spec §4): `reserved` at accept (`/verify` reserved the
+ * price; the claim runs), `settled` once the engine's receipt was accepted (the minute's transfer has
+ * not paid it yet), `paid` with the transfer's `transaction`, `released` when no receipt came within
+ * 24 h (nothing moved), `failed` when the facilitator refused the receipt (nothing moved).
+ */
+/** `refunded` / `partially_refunded` (v1.4.3) are a paid CARD payment the operator refunded since —
+ *  PAY is final on chain and never reaches them. */
+export declare const PaymentStatus: z.ZodEnum<{
+    failed: "failed";
+    paid: "paid";
+    partially_refunded: "partially_refunded";
+    refunded: "refunded";
+    released: "released";
+    reserved: "reserved";
+    settled: "settled";
+}>;
+export type PaymentStatus = z.infer<typeof PaymentStatus>;
+/** `failed` will be retried; `dead` spent its 8 attempts (§4.5) and waits for a redeliver. The
+ *  delivery row's `sent` is `delivered` here: the wire says what the receiver got. */
+export declare const DeliveryStatus: z.ZodEnum<{
+    dead: "dead";
+    delivered: "delivered";
+    failed: "failed";
+    pending: "pending";
+}>;
+export type DeliveryStatus = z.infer<typeof DeliveryStatus>;
+/**
+ * v1.8 (D10): a source starts `pending-link` — created by a controller of its organisation, waiting
+ * for the engine to hold the organisation's link for it — and turns `active` at the company sync.
+ * `disputed`: the engine holds a link for ANOTHER entity (first link wins), or says disputed — no
+ * authority; delete the source and add the oracle again. Neither takes claims, keys, invites or
+ * webhooks. `paused` is the only state with a `pausedReason`.
+ */
+export declare const SourceStatus: z.ZodEnum<{
+    active: "active";
+    disputed: "disputed";
+    paused: "paused";
+    "pending-link": "pending-link";
+}>;
+export type SourceStatus = z.infer<typeof SourceStatus>;
+/**
+ * How a source pays (§3.2): `x402` — an outside customer pays per decision (§11) — or `none` — the
+ * operator's own organisation or a partner it does not charge: no 402, no `api_charges` row. Set
+ * only by the oracle's operator; the engine bills the oracle's owner its fee either way (§11.12).
+ */
+export declare const BillingMode: z.ZodEnum<{
+    none: "none";
+    x402: "x402";
+}>;
+export type BillingMode = z.infer<typeof BillingMode>;
+export { Verdict };
+/**
+ * The oracle's published price for one protocol (payments spec §3.1) — what
+ * `GET /v1/api/protocols/:did` serves, every offer quotes and the facilitator checks each charge
+ * against (`price_mismatch` otherwise). `amountMicroUsd` is the price, and the PAY base units
+ * (`amount`, 1 upay = 1 micro-USD) the same number; `amountCents` is it rounded DOWN to a whole
+ * cent, for display and the per-key daily cap.
+ */
+export declare const Price: z.ZodObject<{
+    amountMicroUsd: z.ZodInt;
+    amountCents: z.ZodInt;
+    currency: z.ZodLiteral<"USD">;
+    amount: z.ZodString;
+    asset: z.ZodLiteral<"upay">;
+}, z.core.$strip>;
+export type Price = z.infer<typeof Price>;
+/**
+ * x402 v2 `PaymentRequirements` in its generic form — what a customer's own payment service
+ * advertised, forwarded to the engine untouched (§11.10 step 1). LOOSE on purpose, the one loose
+ * request object: the engine binds the decision-to-pay to `sha256(RFC 8785 canonical JSON of
+ * requirements)`, so dropping a key we do not know would change the digest the payer's
+ * facilitator recomputes — and the credential would never verify. v2 has no `resource` here.
+ */
+export declare const PaymentRequirements: z.ZodObject<{
+    scheme: z.ZodString;
+    network: z.ZodString;
+    amount: z.ZodString;
+    asset: z.ZodString;
+    payTo: z.ZodString;
+    maxTimeoutSeconds: z.ZodInt;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+export type PaymentRequirements = z.infer<typeof PaymentRequirements>;
+/** x402 v2 `ResourceInfo`: what is paid for. LOOSE — upstream grows it. */
+export declare const ResourceInfo: z.ZodObject<{
+    url: z.ZodURL;
+    description: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type ResourceInfo = z.infer<typeof ResourceInfo>;
+/**
+ * One ixo-pay `accepts[]` entry (§11.2) exactly as the facilitator registered it — strict, because
+ * the payer echoes it byte for byte as `accepted` and the facilitator refuses anything not
+ * canonically equal (`terms_mismatch`). `extra.nonce` is the facilitator's single-use offerId.
+ */
+export declare const IxoPayRequirements: z.ZodObject<{
+    scheme: z.ZodLiteral<"ixo-pay">;
+    network: z.ZodString;
+    asset: z.ZodLiteral<"upay">;
+    amount: z.ZodString;
+    payTo: z.ZodString;
+    maxTimeoutSeconds: z.ZodInt;
+    extra: z.ZodObject<{
+        nonce: z.ZodString;
+        fundingUrl: z.ZodURL;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type IxoPayRequirements = z.infer<typeof IxoPayRequirements>;
+/**
+ * The `PAYMENT-REQUIRED` header (base64 of UTF-8 JSON) — authoritative for x402 clients (board
+ * D30). It is the facilitator's `/offers` answer verbatim: `resource.url` is the submit URL with
+ * the claimId as fragment, or the batch URL. `accepts` holds the ways the oracle's plan takes: an
+ * ixo-pay entry (PAY, IXO-run oracles only), the facilitator's `stripe-manual-capture` entry when
+ * it takes card (contracts v1.4, payments spec §6.3), and x402's `exact` EVM entry when it takes
+ * USDC on Base — a plan without PAY lists no ixo-pay entry at all (§11.7).
+ */
+export declare const X402PaymentRequired: z.ZodObject<{
+    x402Version: z.ZodLiteral<2>;
+    error: z.ZodOptional<z.ZodString>;
+    resource: z.ZodObject<{
+        url: z.ZodURL;
+        description: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    accepts: z.ZodArray<z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodInt;
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type X402PaymentRequired = z.infer<typeof X402PaymentRequired>;
+/** The `PAYMENT-SIGNATURE` request header (base64 of UTF-8 JSON, x402 v2 PaymentPayload): the
+ *  chosen terms echoed as `accepted`, and the developer's delegation with the 402's nonce. */
+export declare const IxoPayPaymentPayload: z.ZodObject<{
+    x402Version: z.ZodLiteral<2>;
+    resource: z.ZodOptional<z.ZodObject<{
+        url: z.ZodURL;
+        description: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodLiteral<"ixo-pay">;
+        network: z.ZodString;
+        asset: z.ZodLiteral<"upay">;
+        amount: z.ZodString;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodInt;
+        extra: z.ZodObject<{
+            nonce: z.ZodString;
+            fundingUrl: z.ZodURL;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    payload: z.ZodObject<{
+        delegation: z.ZodString;
+        nonce: z.ZodString;
+    }, z.core.$strict>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type IxoPayPaymentPayload = z.infer<typeof IxoPayPaymentPayload>;
+/**
+ * One card `accepts[]` entry (contracts v1.4, payments spec §6.3): the facilitator's
+ * `stripe-manual-capture` terms — `amount` in US cents, `payTo` the operator's Stripe account,
+ * `extra` exactly `{ nonce }`. Listed after the ixo-pay entry when the oracle takes card.
+ */
+export declare const CardRequirements: z.ZodObject<{
+    scheme: z.ZodLiteral<"stripe-manual-capture">;
+    network: z.ZodEnum<{
+        "stripe:live": "stripe:live";
+        "stripe:test": "stripe:test";
+    }>;
+    amount: z.ZodString;
+    asset: z.ZodLiteral<"usd">;
+    payTo: z.ZodString;
+    maxTimeoutSeconds: z.ZodInt;
+    extra: z.ZodObject<{
+        nonce: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CardRequirements = z.infer<typeof CardRequirements>;
+/**
+ * The `PAYMENT-SIGNATURE` header for card (contracts v1.4): the card entry echoed as `accepted` and
+ * the PaymentIntent the payer authorized (uncaptured) on its saved card. There is no delegation:
+ * the payer is the account the facilitator's `/verify` names. After a 3-D Secure confirmation the
+ * SAME header (the original offer) is sent again, even past the offer's `maxTimeoutSeconds`.
+ */
+export declare const CardPaymentPayload: z.ZodObject<{
+    x402Version: z.ZodLiteral<2>;
+    resource: z.ZodOptional<z.ZodObject<{
+        url: z.ZodURL;
+        description: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodLiteral<"stripe-manual-capture">;
+        network: z.ZodEnum<{
+            "stripe:live": "stripe:live";
+            "stripe:test": "stripe:test";
+        }>;
+        amount: z.ZodString;
+        asset: z.ZodLiteral<"usd">;
+        payTo: z.ZodString;
+        maxTimeoutSeconds: z.ZodInt;
+        extra: z.ZodObject<{
+            nonce: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    payload: z.ZodObject<{
+        paymentIntentId: z.ZodString;
+        customerId: z.ZodString;
+    }, z.core.$strict>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type CardPaymentPayload = z.infer<typeof CardPaymentPayload>;
+/** One claim of a (possibly batched) settlement and where it got to at the facilitator. */
+/**
+ * A chain claim's id as the facilitator keys its reservation (1.22.0, x402-ixo-pay 0.7.0): a CIDv1
+ * in lowercase base32 — checked by form, as the facilitator does.
+ */
+export declare const ChainClaimId: z.ZodString;
+/** A settled claim: an API claim, or (1.22.0) a chain claim a per-review collection paid for. */
+export declare const SettlementClaim: z.ZodObject<{
+    claimId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    state: z.ZodString;
+}, z.core.$loose>;
+export type SettlementClaim = z.infer<typeof SettlementClaim>;
+/** `org.udid.receipt@1` — the settlement receipt: one `settlementId` per offer, the claims the
+ *  `/settle` call carried receipts for; `decision` is absent on ixo-pay (no decision-to-pay). */
+export declare const UdidReceipt: z.ZodObject<{
+    settlementId: z.ZodString;
+    offerId: z.ZodString;
+    replayed: z.ZodBoolean;
+    claims: z.ZodArray<z.ZodObject<{
+        claimId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        state: z.ZodString;
+    }, z.core.$loose>>;
+    decision: z.ZodOptional<z.ZodObject<{
+        issuer: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type UdidReceipt = z.infer<typeof UdidReceipt>;
+export declare const X402PaymentResponse: z.ZodUnion<readonly [z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    transaction: z.ZodString;
+    network: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
+        "stripe:live": "stripe:live";
+        "stripe:test": "stripe:test";
+    }>, z.ZodString]>;
+    payer: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    extensions: z.ZodObject<{
+        "org.udid.receipt@1": z.ZodObject<{
+            settlementId: z.ZodString;
+            offerId: z.ZodString;
+            replayed: z.ZodBoolean;
+            claims: z.ZodArray<z.ZodObject<{
+                claimId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                state: z.ZodString;
+            }, z.core.$loose>>;
+            decision: z.ZodOptional<z.ZodObject<{
+                issuer: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    errorReason: z.ZodLiteral<"settlement_pending">;
+    transaction: z.ZodString;
+    network: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
+        "stripe:live": "stripe:live";
+        "stripe:test": "stripe:test";
+    }>, z.ZodString]>;
+    payer: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    extensions: z.ZodObject<{
+        "org.udid.receipt@1": z.ZodObject<{
+            settlementId: z.ZodString;
+            offerId: z.ZodString;
+            replayed: z.ZodBoolean;
+            claims: z.ZodArray<z.ZodObject<{
+                claimId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                state: z.ZodString;
+            }, z.core.$loose>>;
+            decision: z.ZodOptional<z.ZodObject<{
+                issuer: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>]>;
+export type X402PaymentResponse = z.infer<typeof X402PaymentResponse>;
+/**
+ * The 402 BODY (Appendix A, board D30): our error envelope, the x402 object in
+ * `details.paymentRequired` for a client that reads bodies, and `price` / `fundingUrl` for a human.
+ * Only `PAYMENT_REQUIRED` carries an offer: `SPEND_CAP` and `INSUFFICIENT_CREDITS` have nothing an
+ * SDK may auto-pay, so it branches on `error.code` and surfaces those two to the developer.
+ */
+export declare const PaymentRequiredBody: z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        requestId: z.ZodString;
+        docsUrl: z.ZodURL;
+        code: z.ZodEnum<{
+            INSUFFICIENT_CREDITS: "INSUFFICIENT_CREDITS";
+            PAYMENT_REQUIRED: "PAYMENT_REQUIRED";
+            SPEND_CAP: "SPEND_CAP";
+        }>;
+        details: z.ZodObject<{
+            paymentRequired: z.ZodOptional<z.ZodObject<{
+                x402Version: z.ZodLiteral<2>;
+                error: z.ZodOptional<z.ZodString>;
+                resource: z.ZodObject<{
+                    url: z.ZodURL;
+                    description: z.ZodOptional<z.ZodString>;
+                    mimeType: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>;
+                accepts: z.ZodArray<z.ZodObject<{
+                    scheme: z.ZodString;
+                    network: z.ZodString;
+                    amount: z.ZodString;
+                    asset: z.ZodString;
+                    payTo: z.ZodString;
+                    maxTimeoutSeconds: z.ZodInt;
+                    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$loose>>;
+                extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+            price: z.ZodObject<{
+                amountMicroUsd: z.ZodInt;
+                amountCents: z.ZodInt;
+                currency: z.ZodLiteral<"USD">;
+                amount: z.ZodString;
+                asset: z.ZodLiteral<"upay">;
+            }, z.core.$strip>;
+            fundingUrl: z.ZodURL;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PaymentRequiredBody = z.infer<typeof PaymentRequiredBody>;
+/**
+ * A file the claim points at: EXACTLY one of an https `url` or an `uploadId` from
+ * `PUT /v1/api/uploads` (strict objects, so both-or-neither matches no branch). An `uploadId` is
+ * resolved to its R2 object inside the workflow — never through a signed URL, whose `exp` would
+ * expire under a slow retry ladder. v1.7: an upload carries the `cid` its upload returned — it is
+ * part of the claim's content (company authority: the engine binds the file by it), and accept
+ * refuses one that is not the upload's.
+ */
+export declare const Attachment: z.ZodUnion<readonly [z.ZodObject<{
+    question: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    mediaType: z.ZodOptional<z.ZodString>;
+    cid: z.ZodOptional<z.ZodString>;
+    url: z.ZodURL;
+}, z.core.$strict>, z.ZodObject<{
+    question: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    mediaType: z.ZodOptional<z.ZodString>;
+    uploadId: z.ZodString;
+    cid: z.ZodString;
+}, z.core.$strict>]>;
+export type Attachment = z.infer<typeof Attachment>;
+export declare const SubmitClaimRequest: z.ZodObject<{
+    protocolDid: z.ZodOptional<z.ZodString>;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        question: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        cid: z.ZodOptional<z.ZodString>;
+        url: z.ZodURL;
+    }, z.core.$strict>, z.ZodObject<{
+        question: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        uploadId: z.ZodString;
+        cid: z.ZodString;
+    }, z.core.$strict>]>>>;
+    submitter: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    webhookUrl: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>;
+export type SubmitClaimRequest = z.infer<typeof SubmitClaimRequest>;
+/** `202` when the decision did not land inside the wait budget — also a repeat of a running key. */
+export declare const Accepted: z.ZodObject<{
+    claimId: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        processed: "processed";
+        processing: "processing";
+        queued: "queued";
+    }>;
+    pollUrl: z.ZodURL;
+}, z.core.$strip>;
+export type Accepted = z.infer<typeof Accepted>;
+/**
+ * Async only; ONE offer covers the batch (price × valid items), one reservation per claim, each
+ * settled on its own receipt. With an `Idempotency-Key` K on the batch, item i's claimId derives from
+ * `K:i`, so a retried batch re-finds every item.
+ */
+export declare const BatchSubmitRequest: z.ZodObject<{
+    claims: z.ZodArray<z.ZodObject<{
+        protocolDid: z.ZodOptional<z.ZodString>;
+        answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            question: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+            cid: z.ZodOptional<z.ZodString>;
+            url: z.ZodURL;
+        }, z.core.$strict>, z.ZodObject<{
+            question: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+            uploadId: z.ZodString;
+            cid: z.ZodString;
+        }, z.core.$strict>]>>>;
+        submitter: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        webhookUrl: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BatchSubmitRequest = z.infer<typeof BatchSubmitRequest>;
+/** One item's answer: accepted, or its own validation error inline — one bad item never fails the batch. */
+export declare const BatchItemResult: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    index: z.ZodInt;
+    status: z.ZodLiteral<"accepted">;
+    claimId: z.ZodString;
+    pollUrl: z.ZodURL;
+}, z.core.$strip>, z.ZodObject<{
+    index: z.ZodInt;
+    status: z.ZodLiteral<"rejected">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            ATTESTATION_INVALID: "ATTESTATION_INVALID";
+            ATTESTATION_ISSUER_MISMATCH: "ATTESTATION_ISSUER_MISMATCH";
+            ATTESTATION_KEY_UNKNOWN: "ATTESTATION_KEY_UNKNOWN";
+            ATTESTATION_MISMATCH: "ATTESTATION_MISMATCH";
+            ATTESTATION_REQUIRED: "ATTESTATION_REQUIRED";
+            ATTESTATION_UNRESOLVABLE: "ATTESTATION_UNRESOLVABLE";
+            CONFLICT: "CONFLICT";
+            FORBIDDEN: "FORBIDDEN";
+            IDEMPOTENCY_MISMATCH: "IDEMPOTENCY_MISMATCH";
+            INSUFFICIENT_CREDITS: "INSUFFICIENT_CREDITS";
+            INTERNAL: "INTERNAL";
+            NOT_FOUND: "NOT_FOUND";
+            NOT_PENDING_REVIEW: "NOT_PENDING_REVIEW";
+            PAYER_NOT_MEMBER: "PAYER_NOT_MEMBER";
+            PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+            PAYMENT_REQUIRED: "PAYMENT_REQUIRED";
+            PROTOCOL_NOT_ALLOWED: "PROTOCOL_NOT_ALLOWED";
+            RATE_LIMITED: "RATE_LIMITED";
+            REVIEWER_GRANT_INVALID: "REVIEWER_GRANT_INVALID";
+            REVIEWER_NOT_AUTHORIZED: "REVIEWER_NOT_AUTHORIZED";
+            REVIEW_EXPIRED: "REVIEW_EXPIRED";
+            SCOPE: "SCOPE";
+            SOURCE_DISPUTED: "SOURCE_DISPUTED";
+            SOURCE_PAUSED: "SOURCE_PAUSED";
+            SOURCE_PENDING_LINK: "SOURCE_PENDING_LINK";
+            SPEND_CAP: "SPEND_CAP";
+            UNAUTHORIZED: "UNAUTHORIZED";
+            UNAVAILABLE: "UNAVAILABLE";
+            UPLOADS_DISABLED: "UPLOADS_DISABLED";
+            VALIDATION: "VALIDATION";
+        }>;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodUnknown>;
+        docsUrl: z.ZodURL;
+    }, z.core.$strip>;
+}, z.core.$strip>], "status">;
+export type BatchItemResult = z.infer<typeof BatchItemResult>;
+export declare const BatchSubmitResponse: z.ZodObject<{
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        index: z.ZodInt;
+        status: z.ZodLiteral<"accepted">;
+        claimId: z.ZodString;
+        pollUrl: z.ZodURL;
+    }, z.core.$strip>, z.ZodObject<{
+        index: z.ZodInt;
+        status: z.ZodLiteral<"rejected">;
+        error: z.ZodObject<{
+            code: z.ZodEnum<{
+                ATTESTATION_INVALID: "ATTESTATION_INVALID";
+                ATTESTATION_ISSUER_MISMATCH: "ATTESTATION_ISSUER_MISMATCH";
+                ATTESTATION_KEY_UNKNOWN: "ATTESTATION_KEY_UNKNOWN";
+                ATTESTATION_MISMATCH: "ATTESTATION_MISMATCH";
+                ATTESTATION_REQUIRED: "ATTESTATION_REQUIRED";
+                ATTESTATION_UNRESOLVABLE: "ATTESTATION_UNRESOLVABLE";
+                CONFLICT: "CONFLICT";
+                FORBIDDEN: "FORBIDDEN";
+                IDEMPOTENCY_MISMATCH: "IDEMPOTENCY_MISMATCH";
+                INSUFFICIENT_CREDITS: "INSUFFICIENT_CREDITS";
+                INTERNAL: "INTERNAL";
+                NOT_FOUND: "NOT_FOUND";
+                NOT_PENDING_REVIEW: "NOT_PENDING_REVIEW";
+                PAYER_NOT_MEMBER: "PAYER_NOT_MEMBER";
+                PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE";
+                PAYMENT_REQUIRED: "PAYMENT_REQUIRED";
+                PROTOCOL_NOT_ALLOWED: "PROTOCOL_NOT_ALLOWED";
+                RATE_LIMITED: "RATE_LIMITED";
+                REVIEWER_GRANT_INVALID: "REVIEWER_GRANT_INVALID";
+                REVIEWER_NOT_AUTHORIZED: "REVIEWER_NOT_AUTHORIZED";
+                REVIEW_EXPIRED: "REVIEW_EXPIRED";
+                SCOPE: "SCOPE";
+                SOURCE_DISPUTED: "SOURCE_DISPUTED";
+                SOURCE_PAUSED: "SOURCE_PAUSED";
+                SOURCE_PENDING_LINK: "SOURCE_PENDING_LINK";
+                SPEND_CAP: "SPEND_CAP";
+                UNAUTHORIZED: "UNAUTHORIZED";
+                UNAVAILABLE: "UNAVAILABLE";
+                UPLOADS_DISABLED: "UPLOADS_DISABLED";
+                VALIDATION: "VALIDATION";
+            }>;
+            message: z.ZodString;
+            details: z.ZodOptional<z.ZodUnknown>;
+            docsUrl: z.ZodURL;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "status">>;
+}, z.core.$strip>;
+export type BatchSubmitResponse = z.infer<typeof BatchSubmitResponse>;
+export declare const ReceiptRef: z.ZodObject<{
+    cid: z.ZodString;
+    jws: z.ZodString;
+}, z.core.$strip>;
+export type ReceiptRef = z.infer<typeof ReceiptRef>;
+/**
+ * The `decisions` row as the API shows it. `decision` is the ENGINE's `Decision` verbatim — the
+ * oracle never decides, so there is no field here it computed; null for the facts lane's
+ * `invalid_facts` (no engine call was made). `chainStatus` is always `skipped` on the API lane;
+ * on a chain claim it is where the `MsgEvaluateClaim` got to (contracts v1.2).
+ */
+export declare const ClaimDecision: z.ZodObject<{
+    status: z.ZodEnum<{
+        content_mismatch: "content_mismatch";
+        decided: "decided";
+        invalid_facts: "invalid_facts";
+        payload_too_large: "payload_too_large";
+        pending_review: "pending_review";
+        unusable: "unusable";
+    }>;
+    verdict: z.ZodNullable<z.ZodEnum<{
+        approve: "approve";
+        partial: "partial";
+        reject: "reject";
+        review: "review";
+    }>>;
+    rubricId: z.ZodNullable<z.ZodString>;
+    factsDigest: z.ZodNullable<z.ZodString>;
+    resultDigest: z.ZodNullable<z.ZodString>;
+    decision: z.ZodNullable<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>;
+    receipt: z.ZodNullable<z.ZodObject<{
+        cid: z.ZodString;
+        jws: z.ZodString;
+    }, z.core.$strip>>;
+    chainStatus: z.ZodEnum<{
+        blocked: "blocked";
+        held: "held";
+        owner_submitted: "owner_submitted";
+        pending: "pending";
+        skipped: "skipped";
+        submitted: "submitted";
+    }>;
+    erroredFacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        detail: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ClaimDecision = z.infer<typeof ClaimDecision>;
+/** A task a human must answer (§10), with the prompt and answer shape the manifest declares. */
+export declare const ReviewTask: 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.$strip>;
+export type ReviewTask = z.infer<typeof ReviewTask>;
+/**
+ * `pendingTasks` are what the engine asked for, with prompt and answer shape from the manifest —
+ * stored in the claim's `review_required` timeline event at decision time, so a later manifest
+ * change never rewrites what the reviewer was asked.
+ */
+export declare const ClaimReviewState: z.ZodObject<{
+    pendingTasks: 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.$strip>>;
+    answeredAt: z.ZodNullable<z.ZodISODateTime>;
+    foldedAt: z.ZodNullable<z.ZodISODateTime>;
+    foldError: z.ZodNullable<z.ZodString>;
+    answerBy: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type ClaimReviewState = z.infer<typeof ClaimReviewState>;
+export declare const ClaimPayment: z.ZodObject<{
+    scheme: z.ZodEnum<{
+        exact: "exact";
+        "ixo-pay": "ixo-pay";
+        "stripe-manual-capture": "stripe-manual-capture";
+    }>;
+    amount: z.ZodString;
+    asset: z.ZodEnum<{
+        upay: "upay";
+        usd: "usd";
+        usdc: "usdc";
+    }>;
+    settlementId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        paid: "paid";
+        partially_refunded: "partially_refunded";
+        refunded: "refunded";
+        released: "released";
+        reserved: "reserved";
+        settled: "settled";
+    }>;
+    transaction: z.ZodNullable<z.ZodString>;
+    refundedAt: z.ZodNullable<z.ZodISODateTime>;
+    refundId: z.ZodNullable<z.ZodString>;
+    refundedAmountCents: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type ClaimPayment = z.infer<typeof ClaimPayment>;
+/** The claim's latest event, aggregated over its deliveries (the claim's own `webhookUrl` and
+ *  every subscribed endpoint): `delivered` only when all are; `dead` if any is; the attempts summed. */
+export declare const ClaimWebhookState: z.ZodObject<{
+    status: z.ZodEnum<{
+        dead: "dead";
+        delivered: "delivered";
+        failed: "failed";
+        pending: "pending";
+    }>;
+    attempts: z.ZodInt;
+}, z.core.$strip>;
+export type ClaimWebhookState = z.infer<typeof ClaimWebhookState>;
+/** Why a claim failed (§5): the facts lane missed the work order, the engine refused the facts,
+ *  the stored body no longer matched its digest, or the retry ladder (~4 h) ran out. */
+export declare const ClaimErrorCode: z.ZodEnum<{
+    body_mismatch: "body_mismatch";
+    engine_rejected: "engine_rejected";
+    invalid_facts: "invalid_facts";
+    retries_exhausted: "retries_exhausted";
+}>;
+export type ClaimErrorCode = z.infer<typeof ClaimErrorCode>;
+/**
+ * §4.4 — the sync 200, the GET, and every `claim.*` webhook's `data`. NEVER the answers (§6.3):
+ * they are personal data and only the fold re-reads them. `null` wherever a part has not happened.
+ * Since v1.2 it shows either lane: an API claim has its `sourceId` and no `collectionId`; a chain
+ * claim its on-chain `collectionId`, `metadata` and `payment` null, and a `sourceId` only when read
+ * through a source's linked collection.
+ */
+export declare const ClaimRecord: z.ZodObject<{
+    claimId: z.ZodString;
+    lane: z.ZodEnum<{
+        api: "api";
+        chain: "chain";
+    }>;
+    sourceId: z.ZodNullable<z.ZodString>;
+    collectionId: z.ZodNullable<z.ZodString>;
+    protocolDid: z.ZodString;
+    submitter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    submittedBy: z.ZodNullable<z.ZodString>;
+    submittedVia: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        verified: z.ZodBoolean;
+    }, z.core.$strict>>;
+    contentDigest: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        processed: "processed";
+        processing: "processing";
+        queued: "queued";
+    }>;
+    decision: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            content_mismatch: "content_mismatch";
+            decided: "decided";
+            invalid_facts: "invalid_facts";
+            payload_too_large: "payload_too_large";
+            pending_review: "pending_review";
+            unusable: "unusable";
+        }>;
+        verdict: z.ZodNullable<z.ZodEnum<{
+            approve: "approve";
+            partial: "partial";
+            reject: "reject";
+            review: "review";
+        }>>;
+        rubricId: z.ZodNullable<z.ZodString>;
+        factsDigest: z.ZodNullable<z.ZodString>;
+        resultDigest: z.ZodNullable<z.ZodString>;
+        decision: z.ZodNullable<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>;
+        receipt: z.ZodNullable<z.ZodObject<{
+            cid: z.ZodString;
+            jws: z.ZodString;
+        }, z.core.$strip>>;
+        chainStatus: z.ZodEnum<{
+            blocked: "blocked";
+            held: "held";
+            owner_submitted: "owner_submitted";
+            pending: "pending";
+            skipped: "skipped";
+            submitted: "submitted";
+        }>;
+        erroredFacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            detail: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    review: z.ZodNullable<z.ZodObject<{
+        pendingTasks: 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.$strip>>;
+        answeredAt: z.ZodNullable<z.ZodISODateTime>;
+        foldedAt: z.ZodNullable<z.ZodISODateTime>;
+        foldError: z.ZodNullable<z.ZodString>;
+        answerBy: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+    payment: z.ZodNullable<z.ZodObject<{
+        scheme: z.ZodEnum<{
+            exact: "exact";
+            "ixo-pay": "ixo-pay";
+            "stripe-manual-capture": "stripe-manual-capture";
+        }>;
+        amount: z.ZodString;
+        asset: z.ZodEnum<{
+            upay: "upay";
+            usd: "usd";
+            usdc: "usdc";
+        }>;
+        settlementId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            paid: "paid";
+            partially_refunded: "partially_refunded";
+            refunded: "refunded";
+            released: "released";
+            reserved: "reserved";
+            settled: "settled";
+        }>;
+        transaction: z.ZodNullable<z.ZodString>;
+        refundedAt: z.ZodNullable<z.ZodISODateTime>;
+        refundId: z.ZodNullable<z.ZodString>;
+        refundedAmountCents: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    webhook: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            dead: "dead";
+            delivered: "delivered";
+            failed: "failed";
+            pending: "pending";
+        }>;
+        attempts: z.ZodInt;
+    }, z.core.$strip>>;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            body_mismatch: "body_mismatch";
+            engine_rejected: "engine_rejected";
+            invalid_facts: "invalid_facts";
+            retries_exhausted: "retries_exhausted";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodISODateTime;
+    decidedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type ClaimRecord = z.infer<typeof ClaimRecord>;
+export declare const ClaimPage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        claimId: z.ZodString;
+        lane: z.ZodEnum<{
+            api: "api";
+            chain: "chain";
+        }>;
+        sourceId: z.ZodNullable<z.ZodString>;
+        collectionId: z.ZodNullable<z.ZodString>;
+        protocolDid: z.ZodString;
+        submitter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        submittedBy: z.ZodNullable<z.ZodString>;
+        submittedVia: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            verified: z.ZodBoolean;
+        }, z.core.$strict>>;
+        contentDigest: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            processed: "processed";
+            processing: "processing";
+            queued: "queued";
+        }>;
+        decision: z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<{
+                content_mismatch: "content_mismatch";
+                decided: "decided";
+                invalid_facts: "invalid_facts";
+                payload_too_large: "payload_too_large";
+                pending_review: "pending_review";
+                unusable: "unusable";
+            }>;
+            verdict: z.ZodNullable<z.ZodEnum<{
+                approve: "approve";
+                partial: "partial";
+                reject: "reject";
+                review: "review";
+            }>>;
+            rubricId: z.ZodNullable<z.ZodString>;
+            factsDigest: z.ZodNullable<z.ZodString>;
+            resultDigest: z.ZodNullable<z.ZodString>;
+            decision: z.ZodNullable<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>;
+            receipt: z.ZodNullable<z.ZodObject<{
+                cid: z.ZodString;
+                jws: z.ZodString;
+            }, z.core.$strip>>;
+            chainStatus: z.ZodEnum<{
+                blocked: "blocked";
+                held: "held";
+                owner_submitted: "owner_submitted";
+                pending: "pending";
+                skipped: "skipped";
+                submitted: "submitted";
+            }>;
+            erroredFacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                detail: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        review: z.ZodNullable<z.ZodObject<{
+            pendingTasks: 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.$strip>>;
+            answeredAt: z.ZodNullable<z.ZodISODateTime>;
+            foldedAt: z.ZodNullable<z.ZodISODateTime>;
+            foldError: z.ZodNullable<z.ZodString>;
+            answerBy: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        payment: z.ZodNullable<z.ZodObject<{
+            scheme: z.ZodEnum<{
+                exact: "exact";
+                "ixo-pay": "ixo-pay";
+                "stripe-manual-capture": "stripe-manual-capture";
+            }>;
+            amount: z.ZodString;
+            asset: z.ZodEnum<{
+                upay: "upay";
+                usd: "usd";
+                usdc: "usdc";
+            }>;
+            settlementId: z.ZodNullable<z.ZodString>;
+            status: z.ZodEnum<{
+                failed: "failed";
+                paid: "paid";
+                partially_refunded: "partially_refunded";
+                refunded: "refunded";
+                released: "released";
+                reserved: "reserved";
+                settled: "settled";
+            }>;
+            transaction: z.ZodNullable<z.ZodString>;
+            refundedAt: z.ZodNullable<z.ZodISODateTime>;
+            refundId: z.ZodNullable<z.ZodString>;
+            refundedAmountCents: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        webhook: z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<{
+                dead: "dead";
+                delivered: "delivered";
+                failed: "failed";
+                pending: "pending";
+            }>;
+            attempts: z.ZodInt;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodObject<{
+            code: z.ZodEnum<{
+                body_mismatch: "body_mismatch";
+                engine_rejected: "engine_rejected";
+                invalid_facts: "invalid_facts";
+                retries_exhausted: "retries_exhausted";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodISODateTime;
+        decidedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ClaimPage = z.infer<typeof ClaimPage>;
+/**
+ * v1.2.1 — the operator's read of a record (`/admin/claims*`): the owning source's display name
+ * beside its `sourceId`, since an operator is no member of its customers' sources and cannot look
+ * the name up. `null` for a chain claim, which no source owns.
+ */
+export declare const AdminClaimRecord: z.ZodObject<{
+    claimId: z.ZodString;
+    lane: z.ZodEnum<{
+        api: "api";
+        chain: "chain";
+    }>;
+    sourceId: z.ZodNullable<z.ZodString>;
+    collectionId: z.ZodNullable<z.ZodString>;
+    protocolDid: z.ZodString;
+    submitter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    submittedBy: z.ZodNullable<z.ZodString>;
+    submittedVia: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        verified: z.ZodBoolean;
+    }, z.core.$strict>>;
+    contentDigest: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        processed: "processed";
+        processing: "processing";
+        queued: "queued";
+    }>;
+    decision: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            content_mismatch: "content_mismatch";
+            decided: "decided";
+            invalid_facts: "invalid_facts";
+            payload_too_large: "payload_too_large";
+            pending_review: "pending_review";
+            unusable: "unusable";
+        }>;
+        verdict: z.ZodNullable<z.ZodEnum<{
+            approve: "approve";
+            partial: "partial";
+            reject: "reject";
+            review: "review";
+        }>>;
+        rubricId: z.ZodNullable<z.ZodString>;
+        factsDigest: z.ZodNullable<z.ZodString>;
+        resultDigest: z.ZodNullable<z.ZodString>;
+        decision: z.ZodNullable<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>;
+        receipt: z.ZodNullable<z.ZodObject<{
+            cid: z.ZodString;
+            jws: z.ZodString;
+        }, z.core.$strip>>;
+        chainStatus: z.ZodEnum<{
+            blocked: "blocked";
+            held: "held";
+            owner_submitted: "owner_submitted";
+            pending: "pending";
+            skipped: "skipped";
+            submitted: "submitted";
+        }>;
+        erroredFacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            detail: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    review: z.ZodNullable<z.ZodObject<{
+        pendingTasks: 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.$strip>>;
+        answeredAt: z.ZodNullable<z.ZodISODateTime>;
+        foldedAt: z.ZodNullable<z.ZodISODateTime>;
+        foldError: z.ZodNullable<z.ZodString>;
+        answerBy: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+    payment: z.ZodNullable<z.ZodObject<{
+        scheme: z.ZodEnum<{
+            exact: "exact";
+            "ixo-pay": "ixo-pay";
+            "stripe-manual-capture": "stripe-manual-capture";
+        }>;
+        amount: z.ZodString;
+        asset: z.ZodEnum<{
+            upay: "upay";
+            usd: "usd";
+            usdc: "usdc";
+        }>;
+        settlementId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            paid: "paid";
+            partially_refunded: "partially_refunded";
+            refunded: "refunded";
+            released: "released";
+            reserved: "reserved";
+            settled: "settled";
+        }>;
+        transaction: z.ZodNullable<z.ZodString>;
+        refundedAt: z.ZodNullable<z.ZodISODateTime>;
+        refundId: z.ZodNullable<z.ZodString>;
+        refundedAmountCents: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    webhook: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            dead: "dead";
+            delivered: "delivered";
+            failed: "failed";
+            pending: "pending";
+        }>;
+        attempts: z.ZodInt;
+    }, z.core.$strip>>;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            body_mismatch: "body_mismatch";
+            engine_rejected: "engine_rejected";
+            invalid_facts: "invalid_facts";
+            retries_exhausted: "retries_exhausted";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodISODateTime;
+    decidedAt: z.ZodNullable<z.ZodISODateTime>;
+    sourceName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AdminClaimRecord = z.infer<typeof AdminClaimRecord>;
+export declare const AdminClaimPage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        claimId: z.ZodString;
+        lane: z.ZodEnum<{
+            api: "api";
+            chain: "chain";
+        }>;
+        sourceId: z.ZodNullable<z.ZodString>;
+        collectionId: z.ZodNullable<z.ZodString>;
+        protocolDid: z.ZodString;
+        submitter: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        submittedBy: z.ZodNullable<z.ZodString>;
+        submittedVia: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            verified: z.ZodBoolean;
+        }, z.core.$strict>>;
+        contentDigest: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            processed: "processed";
+            processing: "processing";
+            queued: "queued";
+        }>;
+        decision: z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<{
+                content_mismatch: "content_mismatch";
+                decided: "decided";
+                invalid_facts: "invalid_facts";
+                payload_too_large: "payload_too_large";
+                pending_review: "pending_review";
+                unusable: "unusable";
+            }>;
+            verdict: z.ZodNullable<z.ZodEnum<{
+                approve: "approve";
+                partial: "partial";
+                reject: "reject";
+                review: "review";
+            }>>;
+            rubricId: z.ZodNullable<z.ZodString>;
+            factsDigest: z.ZodNullable<z.ZodString>;
+            resultDigest: z.ZodNullable<z.ZodString>;
+            decision: z.ZodNullable<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>;
+            receipt: z.ZodNullable<z.ZodObject<{
+                cid: z.ZodString;
+                jws: z.ZodString;
+            }, z.core.$strip>>;
+            chainStatus: z.ZodEnum<{
+                blocked: "blocked";
+                held: "held";
+                owner_submitted: "owner_submitted";
+                pending: "pending";
+                skipped: "skipped";
+                submitted: "submitted";
+            }>;
+            erroredFacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                detail: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        review: z.ZodNullable<z.ZodObject<{
+            pendingTasks: 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.$strip>>;
+            answeredAt: z.ZodNullable<z.ZodISODateTime>;
+            foldedAt: z.ZodNullable<z.ZodISODateTime>;
+            foldError: z.ZodNullable<z.ZodString>;
+            answerBy: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        payment: z.ZodNullable<z.ZodObject<{
+            scheme: z.ZodEnum<{
+                exact: "exact";
+                "ixo-pay": "ixo-pay";
+                "stripe-manual-capture": "stripe-manual-capture";
+            }>;
+            amount: z.ZodString;
+            asset: z.ZodEnum<{
+                upay: "upay";
+                usd: "usd";
+                usdc: "usdc";
+            }>;
+            settlementId: z.ZodNullable<z.ZodString>;
+            status: z.ZodEnum<{
+                failed: "failed";
+                paid: "paid";
+                partially_refunded: "partially_refunded";
+                refunded: "refunded";
+                released: "released";
+                reserved: "reserved";
+                settled: "settled";
+            }>;
+            transaction: z.ZodNullable<z.ZodString>;
+            refundedAt: z.ZodNullable<z.ZodISODateTime>;
+            refundId: z.ZodNullable<z.ZodString>;
+            refundedAmountCents: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        webhook: z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<{
+                dead: "dead";
+                delivered: "delivered";
+                failed: "failed";
+                pending: "pending";
+            }>;
+            attempts: z.ZodInt;
+        }, z.core.$strip>>;
+        error: z.ZodNullable<z.ZodObject<{
+            code: z.ZodEnum<{
+                body_mismatch: "body_mismatch";
+                engine_rejected: "engine_rejected";
+                invalid_facts: "invalid_facts";
+                retries_exhausted: "retries_exhausted";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodISODateTime;
+        decidedAt: z.ZodNullable<z.ZodISODateTime>;
+        sourceName: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** `GET /v1/api/claims` filters (§4.2); newest first, keyset (§4.1). Loose: an unknown
+ *  parameter is ignored, as HTTP caches and tracing proxies add their own. `lane` picks one lane;
+ *  absent, a console member gets both — the source's API claims and its linked collections' chain
+ *  claims (contracts v1.2) — and an API key `api`, so an integration written before 1.2 sees no
+ *  chain record it did not ask for (`lane=chain`). `collectionId` narrows to one linked
+ *  collection's chain claims. */
+export declare const ListClaimsQuery: z.ZodObject<{
+    lane: z.ZodOptional<z.ZodEnum<{
+        api: "api";
+        chain: "chain";
+    }>>;
+    collectionId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        processed: "processed";
+        processing: "processing";
+        queued: "queued";
+    }>>;
+    decision: z.ZodOptional<z.ZodEnum<{
+        content_mismatch: "content_mismatch";
+        decided: "decided";
+        invalid_facts: "invalid_facts";
+        payload_too_large: "payload_too_large";
+        pending_review: "pending_review";
+        unusable: "unusable";
+    }>>;
+    protocol: z.ZodOptional<z.ZodString>;
+    verdict: z.ZodOptional<z.ZodEnum<{
+        approve: "approve";
+        partial: "partial";
+        reject: "reject";
+        review: "review";
+    }>>;
+    since: z.ZodOptional<z.ZodISODateTime>;
+    until: z.ZodOptional<z.ZodISODateTime>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListClaimsQuery = z.infer<typeof ListClaimsQuery>;
+/** `GET /v1/api/admin/claims` (contracts v1.2): the source list's filters over EVERY source and
+ *  every watched collection, plus `sourceId` — which finds API claims only. */
+export declare const AdminListClaimsQuery: z.ZodObject<{
+    lane: z.ZodOptional<z.ZodEnum<{
+        api: "api";
+        chain: "chain";
+    }>>;
+    collectionId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        processed: "processed";
+        processing: "processing";
+        queued: "queued";
+    }>>;
+    decision: z.ZodOptional<z.ZodEnum<{
+        content_mismatch: "content_mismatch";
+        decided: "decided";
+        invalid_facts: "invalid_facts";
+        payload_too_large: "payload_too_large";
+        pending_review: "pending_review";
+        unusable: "unusable";
+    }>>;
+    protocol: z.ZodOptional<z.ZodString>;
+    verdict: z.ZodOptional<z.ZodEnum<{
+        approve: "approve";
+        partial: "partial";
+        reject: "reject";
+        review: "review";
+    }>>;
+    since: z.ZodOptional<z.ZodISODateTime>;
+    until: z.ZodOptional<z.ZodISODateTime>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AdminListClaimsQuery = z.infer<typeof AdminListClaimsQuery>;
+export declare const ClaimEventType: z.ZodEnum<{
+    accepted: "accepted";
+    chain_submitted: "chain_submitted";
+    decided: "decided";
+    erased: "erased";
+    facts_produced: "facts_produced";
+    failed: "failed";
+    folded: "folded";
+    paid: "paid";
+    review_answered: "review_answered";
+    review_expired: "review_expired";
+    review_required: "review_required";
+    unusable: "unusable";
+    webhook_attempt: "webhook_attempt";
+}>;
+export type ClaimEventType = z.infer<typeof ClaimEventType>;
+/** One `api_events` row — or, for a chain claim, one step derived from its ledger rows' times.
+ *  `data` carries names, codes, durations and counts — for `facts_produced` the fact names and
+ *  their timings, NEVER a value (§4.2). `accepted` carries `protocolDid`, and `via:
+ *  "oauth:<client_id>"` (1.4.6) when an AI app submitted the claim over OAuth. */
+export declare const ClaimEvent: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        accepted: "accepted";
+        chain_submitted: "chain_submitted";
+        decided: "decided";
+        erased: "erased";
+        facts_produced: "facts_produced";
+        failed: "failed";
+        folded: "folded";
+        paid: "paid";
+        review_answered: "review_answered";
+        review_expired: "review_expired";
+        review_required: "review_required";
+        unusable: "unusable";
+        webhook_attempt: "webhook_attempt";
+    }>;
+    at: z.ZodISODateTime;
+    data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ClaimEvent = z.infer<typeof ClaimEvent>;
+export declare const ClaimEvents: z.ZodObject<{
+    claimId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            accepted: "accepted";
+            chain_submitted: "chain_submitted";
+            decided: "decided";
+            erased: "erased";
+            facts_produced: "facts_produced";
+            failed: "failed";
+            folded: "folded";
+            paid: "paid";
+            review_answered: "review_answered";
+            review_expired: "review_expired";
+            review_required: "review_required";
+            unusable: "unusable";
+            webhook_attempt: "webhook_attempt";
+        }>;
+        at: z.ZodISODateTime;
+        data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ClaimEvents = z.infer<typeof ClaimEvents>;
+/** Everything needed to verify offline: the engine's receipt and where its keys live. */
+export declare const Receipt: z.ZodObject<{
+    cid: z.ZodString;
+    jws: z.ZodString;
+    issuerKeysUrl: z.ZodURL;
+    verifyUrl: z.ZodURL;
+}, z.core.$strip>;
+export type Receipt = z.infer<typeof Receipt>;
+/**
+ * Mirrors the chain lane's review body (`routes/v1/reviews.ts`): answers cover EXACTLY the
+ * pending tasks, and `attestation` — the reviewer's signed statement — is required: a member's
+ * from its registered `did:key` (§10), an organisation controller's (a root, 1.11.0) from its
+ * `did:ixo` with a `kid` on that DID's document. It is typed optional only so a missing one
+ * answers `ATTESTATION_REQUIRED` rather than a generic `VALIDATION`, as on the chain lane.
+ */
+export declare const ReviewRequest: z.ZodObject<{
+    answers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    attestation: z.ZodOptional<z.ZodString>;
+    reviewerGrant: z.ZodOptional<z.ZodString>;
+    answeredAgainst: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ReviewRequest = z.infer<typeof ReviewRequest>;
+/** The stored review, as the chain lane's `reviewBody` shows it — the JWS itself never leaves. */
+export declare const ReviewRow: z.ZodObject<{
+    claimId: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    reviewerDid: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    answeredAt: z.ZodISODateTime;
+    foldedAt: z.ZodNullable<z.ZodISODateTime>;
+    foldError: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ReviewRow = z.infer<typeof ReviewRow>;
+/**
+ * Why the CALLER cannot answer reviews on this oracle (1.15.0), known before it tries — only what is
+ * cheap and certain: `oracle-owner`, it is the account that registered this oracle with the decision
+ * engine, which never folds an answer from the oracle's own side (`403 REVIEWER_NOT_AUTHORIZED`,
+ * `details.reason: "oracle-owner"`); `not-reviewer`, the caller does not sign answers — an API key
+ * (which may still relay a member-signed answer), or a member or AI app without `claims/review`.
+ */
+export declare const ReviewBlock: z.ZodEnum<{
+    "not-reviewer": "not-reviewer";
+    "oracle-owner": "oracle-owner";
+}>;
+export type ReviewBlock = z.infer<typeof ReviewBlock>;
+/** Can the caller answer this review? `reason` is set iff `ok` is false. */
+export declare const CanAnswer: z.ZodObject<{
+    ok: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodEnum<{
+        "not-reviewer": "not-reviewer";
+        "oracle-owner": "oracle-owner";
+    }>>;
+}, z.core.$strip>;
+export type CanAnswer = z.infer<typeof CanAnswer>;
+export declare const ReviewView: z.ZodObject<{
+    claimId: z.ZodString;
+    protocolDid: z.ZodString;
+    resultDigest: z.ZodString;
+    pendingTasks: 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.$strip>>;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    files: z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        mediaType: z.ZodNullable<z.ZodString>;
+        url: z.ZodURL;
+    }, z.core.$strip>>;
+    submittedAt: z.ZodISODateTime;
+    answerBy: z.ZodNullable<z.ZodISODateTime>;
+    canAnswer: z.ZodObject<{
+        ok: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodEnum<{
+            "not-reviewer": "not-reviewer";
+            "oracle-owner": "oracle-owner";
+        }>>;
+    }, z.core.$strip>;
+    erroredFacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        detail: z.ZodString;
+    }, z.core.$strip>>>;
+    duplicates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        ruleId: z.ZodString;
+        score: z.ZodOptional<z.ZodNumber>;
+        prior: z.ZodObject<{
+            outcome: z.ZodNullable<z.ZodEnum<{
+                approve: "approve";
+                partial: "partial";
+                reject: "reject";
+                review: "review";
+            }>>;
+            claimId: z.ZodOptional<z.ZodString>;
+            submittedAt: z.ZodOptional<z.ZodISODateTime>;
+            files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                question: z.ZodString;
+                name: z.ZodNullable<z.ZodString>;
+                mediaType: z.ZodNullable<z.ZodString>;
+                url: z.ZodURL;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ReviewView = z.infer<typeof ReviewView>;
+/** The engine's decision report in JSON (`Accept: application/json`), proxied as-is — LOOSE
+ *  because its body is the engine's to grow; only the keys a client joins on are pinned. */
+export declare const DecisionReport: z.ZodObject<{
+    claimId: z.ZodString;
+    verdict: z.ZodNullable<z.ZodEnum<{
+        approve: "approve";
+        partial: "partial";
+        reject: "reject";
+        review: "review";
+    }>>;
+}, z.core.$loose>;
+export type DecisionReport = z.infer<typeof DecisionReport>;
+/** `url` is a short-lived signed read (`/v1/api/files/:uploadId?exp=&sig=`) for a person to look at
+ *  the file, never a public object; a claim references the file by `uploadId`. */
+export declare const Upload: z.ZodObject<{
+    uploadId: z.ZodString;
+    url: z.ZodURL;
+    cid: z.ZodString;
+    mediaType: z.ZodString;
+    size: z.ZodInt;
+}, z.core.$strip>;
+export type Upload = z.infer<typeof Upload>;
+/**
+ * v1.7: a one-use, signed `PUT` for a client that must not hold the API key (an AI app's sandboxed
+ * widget). `uploadUrl` is the whole credential — `PUT` the bytes to it with no `Authorization`
+ * before `expiresAt`, and the answer is the same `Upload` as `PUT /v1/api/uploads`, under this
+ * `uploadId`. `GET /v1/api/uploads/{uploadId}` reads it back once used.
+ */
+export declare const UploadLink: z.ZodObject<{
+    uploadId: z.ZodString;
+    uploadUrl: z.ZodURL;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type UploadLink = z.infer<typeof UploadLink>;
+/** `price: null` — this oracle publishes no price for the protocol (contract v1.1.1): nothing is
+ *  offered for it, and the facilitator refuses any offer that names it. */
+export declare const ProtocolSummary: z.ZodObject<{
+    protocolDid: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    price: z.ZodNullable<z.ZodObject<{
+        amountMicroUsd: z.ZodInt;
+        amountCents: z.ZodInt;
+        currency: z.ZodLiteral<"USD">;
+        amount: z.ZodString;
+        asset: z.ZodLiteral<"upay">;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProtocolSummary = z.infer<typeof ProtocolSummary>;
+export declare const ProtocolList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        protocolDid: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        price: z.ZodNullable<z.ZodObject<{
+            amountMicroUsd: z.ZodInt;
+            amountCents: z.ZodInt;
+            currency: z.ZodLiteral<"USD">;
+            amount: z.ZodString;
+            asset: z.ZodLiteral<"upay">;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProtocolList = z.infer<typeof ProtocolList>;
+export declare const FileQuestion: z.ZodObject<{
+    question: z.ZodString;
+    required: z.ZodBoolean;
+    mediaTypes: z.ZodArray<z.ZodString>;
+    maxBytes: z.ZodInt;
+}, z.core.$strip>;
+export type FileQuestion = z.infer<typeof FileQuestion>;
+/**
+ * The work order a CALLER needs (§4.2): what to send, and what will happen to it. Facts are NAMES
+ * only — the engine's manifest carries endpoints, audiences and AI instructions that are the
+ * oracle's business, not the customer's.
+ */
+export declare const ProtocolWorkOrder: z.ZodObject<{
+    protocolDid: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    rubricId: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    files: z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        required: z.ZodBoolean;
+        mediaTypes: z.ZodArray<z.ZodString>;
+        maxBytes: z.ZodInt;
+    }, z.core.$strip>>;
+    facts: z.ZodObject<{
+        ext: z.ZodArray<z.ZodString>;
+        ai: z.ZodArray<z.ZodString>;
+        unique: z.ZodBoolean;
+        frequency: z.ZodBoolean;
+    }, z.core.$strip>;
+    reviewTasks: 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.$strip>>;
+    price: z.ZodNullable<z.ZodObject<{
+        amountMicroUsd: z.ZodInt;
+        amountCents: z.ZodInt;
+        currency: z.ZodLiteral<"USD">;
+        amount: z.ZodString;
+        asset: z.ZodLiteral<"upay">;
+    }, z.core.$strip>>;
+    example: z.ZodObject<{
+        protocolDid: z.ZodOptional<z.ZodString>;
+        answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            question: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+            cid: z.ZodOptional<z.ZodString>;
+            url: z.ZodURL;
+        }, z.core.$strict>, z.ZodObject<{
+            question: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+            uploadId: z.ZodString;
+            cid: z.ZodString;
+        }, z.core.$strict>]>>>;
+        submitter: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        webhookUrl: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export type ProtocolWorkOrder = z.infer<typeof ProtocolWorkOrder>;
+/** One allowed protocol. The price is the oracle's published one (payments spec §3.1) — no
+ *  per-source prices (owner, v1.1): a partner who should not pay gets billing mode `none`. */
+export declare const AllowedProtocol: z.ZodObject<{
+    protocolDid: z.ZodString;
+}, z.core.$strip>;
+export type AllowedProtocol = z.infer<typeof AllowedProtocol>;
+export declare const Source: z.ZodObject<{
+    sourceId: z.ZodString;
+    name: z.ZodString;
+    ownerDid: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        disputed: "disputed";
+        paused: "paused";
+        "pending-link": "pending-link";
+    }>;
+    pausedReason: z.ZodNullable<z.ZodEnum<{
+        "engine-credits": "engine-credits";
+        operator: "operator";
+        "payments-disabled": "payments-disabled";
+        "rubric-unusable": "rubric-unusable";
+    }>>;
+    billingMode: z.ZodEnum<{
+        none: "none";
+        x402: "x402";
+    }>;
+    allowedProtocols: z.ZodArray<z.ZodObject<{
+        protocolDid: z.ZodString;
+    }, z.core.$strip>>;
+    refillFloorCents: z.ZodNullable<z.ZodInt>;
+    defaultWebhookUrl: z.ZodNullable<z.ZodURL>;
+    contactEmail: z.ZodNullable<z.ZodEmail>;
+    companyEntityDid: z.ZodString;
+    payeeField: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    activatedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type Source = z.infer<typeof Source>;
+/** Sign-up (§12.3, D10): a current controller of `entityDid` adds this oracle to the organisation.
+ *  The source starts `pending-link`; the invoker pays (`ownerDid`) but holds no membership — as a
+ *  controller it is root already. */
+export declare const CreateSourceRequest: z.ZodObject<{
+    name: z.ZodString;
+    contactEmail: z.ZodEmail;
+    entityDid: z.ZodString;
+}, z.core.$strict>;
+export type CreateSourceRequest = z.infer<typeof CreateSourceRequest>;
+/**
+ * Where a member stands: `invited` (an email invite nobody has accepted), `accepted` (an account
+ * joined, no grant uploaded yet — it can call nothing), `active` (a live grant), `expired`,
+ * `revoked`. The owner is always `active`: the root needs no grant.
+ */
+export declare const MemberStatus: z.ZodEnum<{
+    accepted: "accepted";
+    active: "active";
+    expired: "expired";
+    invited: "invited";
+    revoked: "revoked";
+}>;
+export type MemberStatus = z.infer<typeof MemberStatus>;
+export declare const Member: z.ZodObject<{
+    memberId: z.ZodString;
+    did: z.ZodNullable<z.ZodString>;
+    email: z.ZodNullable<z.ZodEmail>;
+    role: z.ZodEnum<{
+        developer: "developer";
+        owner: "owner";
+        reviewer: "reviewer";
+        submitter: "submitter";
+        viewer: "viewer";
+    }>;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        active: "active";
+        expired: "expired";
+        invited: "invited";
+        revoked: "revoked";
+    }>;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        "audit/read": "audit/read";
+        "claims/read": "claims/read";
+        "claims/review": "claims/review";
+        "claims/submit": "claims/submit";
+        "keys/manage": "keys/manage";
+        "settings/manage": "settings/manage";
+        "source/*": "source/*";
+        "spend/read": "spend/read";
+        "webhooks/manage": "webhooks/manage";
+    }>>;
+    protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    delegationCid: z.ZodNullable<z.ZodString>;
+    revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    reviewerDid: z.ZodNullable<z.ZodString>;
+    reviewerDelegationExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+    notifyReviews: z.ZodBoolean;
+    invitedAt: z.ZodISODateTime;
+    acceptedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type Member = z.infer<typeof Member>;
+export declare const MemberList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        memberId: z.ZodString;
+        did: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodEmail>;
+        role: z.ZodEnum<{
+            developer: "developer";
+            owner: "owner";
+            reviewer: "reviewer";
+            submitter: "submitter";
+            viewer: "viewer";
+        }>;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            active: "active";
+            expired: "expired";
+            invited: "invited";
+            revoked: "revoked";
+        }>;
+        capabilities: z.ZodArray<z.ZodEnum<{
+            "audit/read": "audit/read";
+            "claims/read": "claims/read";
+            "claims/review": "claims/review";
+            "claims/submit": "claims/submit";
+            "keys/manage": "keys/manage";
+            "settings/manage": "settings/manage";
+            "source/*": "source/*";
+            "spend/read": "spend/read";
+            "webhooks/manage": "webhooks/manage";
+        }>>;
+        protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        delegationCid: z.ZodNullable<z.ZodString>;
+        revokedAt: z.ZodNullable<z.ZodISODateTime>;
+        reviewerDid: z.ZodNullable<z.ZodString>;
+        reviewerDelegationExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+        notifyReviews: z.ZodBoolean;
+        invitedAt: z.ZodISODateTime;
+        acceptedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MemberList = z.infer<typeof MemberList>;
+/** `webhookSecret` signs deliveries to a claim's own `webhookUrl` and the source's default URL
+ *  (§4.5) — shown here once; `POST /v1/api/source/webhook-secret` rotates it. */
+export declare const CreateSourceResponse: z.ZodObject<{
+    source: z.ZodObject<{
+        sourceId: z.ZodString;
+        name: z.ZodString;
+        ownerDid: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            disputed: "disputed";
+            paused: "paused";
+            "pending-link": "pending-link";
+        }>;
+        pausedReason: z.ZodNullable<z.ZodEnum<{
+            "engine-credits": "engine-credits";
+            operator: "operator";
+            "payments-disabled": "payments-disabled";
+            "rubric-unusable": "rubric-unusable";
+        }>>;
+        billingMode: z.ZodEnum<{
+            none: "none";
+            x402: "x402";
+        }>;
+        allowedProtocols: z.ZodArray<z.ZodObject<{
+            protocolDid: z.ZodString;
+        }, z.core.$strip>>;
+        refillFloorCents: z.ZodNullable<z.ZodInt>;
+        defaultWebhookUrl: z.ZodNullable<z.ZodURL>;
+        contactEmail: z.ZodNullable<z.ZodEmail>;
+        companyEntityDid: z.ZodString;
+        payeeField: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        activatedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>;
+    webhookSecret: z.ZodString;
+}, z.core.$strip>;
+export type CreateSourceResponse = z.infer<typeof CreateSourceResponse>;
+/** The old secret keeps signing beside the new one until `previousExpiresAt` (24 h). */
+export declare const RotateWebhookSecretResponse: z.ZodObject<{
+    webhookSecret: z.ZodString;
+    previousExpiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type RotateWebhookSecretResponse = z.infer<typeof RotateWebhookSecretResponse>;
+/**
+ * `GET /v1/api/sources` — the signed-in account's sources on THIS oracle (the console asks every
+ * oracle it lists). `delegation` is the member's stored grant (base64 CAR), which the console
+ * attaches as its invocation's proof; null for the owner, and until a grant is uploaded.
+ */
+export declare const MySource: z.ZodObject<{
+    source: z.ZodObject<{
+        sourceId: z.ZodString;
+        name: z.ZodString;
+        ownerDid: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            disputed: "disputed";
+            paused: "paused";
+            "pending-link": "pending-link";
+        }>;
+        pausedReason: z.ZodNullable<z.ZodEnum<{
+            "engine-credits": "engine-credits";
+            operator: "operator";
+            "payments-disabled": "payments-disabled";
+            "rubric-unusable": "rubric-unusable";
+        }>>;
+        billingMode: z.ZodEnum<{
+            none: "none";
+            x402: "x402";
+        }>;
+        allowedProtocols: z.ZodArray<z.ZodObject<{
+            protocolDid: z.ZodString;
+        }, z.core.$strip>>;
+        refillFloorCents: z.ZodNullable<z.ZodInt>;
+        defaultWebhookUrl: z.ZodNullable<z.ZodURL>;
+        contactEmail: z.ZodNullable<z.ZodEmail>;
+        companyEntityDid: z.ZodString;
+        payeeField: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        activatedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>;
+    memberId: z.ZodString;
+    role: z.ZodEnum<{
+        developer: "developer";
+        owner: "owner";
+        reviewer: "reviewer";
+        submitter: "submitter";
+        viewer: "viewer";
+    }>;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        active: "active";
+        expired: "expired";
+        invited: "invited";
+        revoked: "revoked";
+    }>;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        "audit/read": "audit/read";
+        "claims/read": "claims/read";
+        "claims/review": "claims/review";
+        "claims/submit": "claims/submit";
+        "keys/manage": "keys/manage";
+        "settings/manage": "settings/manage";
+        "source/*": "source/*";
+        "spend/read": "spend/read";
+        "webhooks/manage": "webhooks/manage";
+    }>>;
+    protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    delegation: z.ZodNullable<z.ZodString>;
+    delegationCid: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type MySource = z.infer<typeof MySource>;
+export declare const MySourceList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        source: z.ZodObject<{
+            sourceId: z.ZodString;
+            name: z.ZodString;
+            ownerDid: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                disputed: "disputed";
+                paused: "paused";
+                "pending-link": "pending-link";
+            }>;
+            pausedReason: z.ZodNullable<z.ZodEnum<{
+                "engine-credits": "engine-credits";
+                operator: "operator";
+                "payments-disabled": "payments-disabled";
+                "rubric-unusable": "rubric-unusable";
+            }>>;
+            billingMode: z.ZodEnum<{
+                none: "none";
+                x402: "x402";
+            }>;
+            allowedProtocols: z.ZodArray<z.ZodObject<{
+                protocolDid: z.ZodString;
+            }, z.core.$strip>>;
+            refillFloorCents: z.ZodNullable<z.ZodInt>;
+            defaultWebhookUrl: z.ZodNullable<z.ZodURL>;
+            contactEmail: z.ZodNullable<z.ZodEmail>;
+            companyEntityDid: z.ZodString;
+            payeeField: z.ZodNullable<z.ZodString>;
+            createdAt: z.ZodISODateTime;
+            activatedAt: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strip>;
+        memberId: z.ZodString;
+        role: z.ZodEnum<{
+            developer: "developer";
+            owner: "owner";
+            reviewer: "reviewer";
+            submitter: "submitter";
+            viewer: "viewer";
+        }>;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            active: "active";
+            expired: "expired";
+            invited: "invited";
+            revoked: "revoked";
+        }>;
+        capabilities: z.ZodArray<z.ZodEnum<{
+            "audit/read": "audit/read";
+            "claims/read": "claims/read";
+            "claims/review": "claims/review";
+            "claims/submit": "claims/submit";
+            "keys/manage": "keys/manage";
+            "settings/manage": "settings/manage";
+            "source/*": "source/*";
+            "spend/read": "spend/read";
+            "webhooks/manage": "webhooks/manage";
+        }>>;
+        protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        delegation: z.ZodNullable<z.ZodString>;
+        delegationCid: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MySourceList = z.infer<typeof MySourceList>;
+/**
+ * `GET /v1/api/organisations/{entityDid}/sources` query (1.17.0): the organisation's sources on this
+ * oracle in every state, keyset-paged (`SourcePage`), for a current controller of the entity only.
+ */
+export declare const ListOrganisationSourcesQuery: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListOrganisationSourcesQuery = z.infer<typeof ListOrganisationSourcesQuery>;
+/**
+ * `POST /v1/api/sources/{sourceId}/company/sync` (v1.8): the source as mirrored from the engine's
+ * stored link for its organisation, and its members.
+ */
+export declare const CompanySyncResponse: z.ZodObject<{
+    source: z.ZodObject<{
+        sourceId: z.ZodString;
+        name: z.ZodString;
+        ownerDid: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            disputed: "disputed";
+            paused: "paused";
+            "pending-link": "pending-link";
+        }>;
+        pausedReason: z.ZodNullable<z.ZodEnum<{
+            "engine-credits": "engine-credits";
+            operator: "operator";
+            "payments-disabled": "payments-disabled";
+            "rubric-unusable": "rubric-unusable";
+        }>>;
+        billingMode: z.ZodEnum<{
+            none: "none";
+            x402: "x402";
+        }>;
+        allowedProtocols: z.ZodArray<z.ZodObject<{
+            protocolDid: z.ZodString;
+        }, z.core.$strip>>;
+        refillFloorCents: z.ZodNullable<z.ZodInt>;
+        defaultWebhookUrl: z.ZodNullable<z.ZodURL>;
+        contactEmail: z.ZodNullable<z.ZodEmail>;
+        companyEntityDid: z.ZodString;
+        payeeField: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        activatedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>;
+    members: z.ZodArray<z.ZodObject<{
+        memberId: z.ZodString;
+        did: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodEmail>;
+        role: z.ZodEnum<{
+            developer: "developer";
+            owner: "owner";
+            reviewer: "reviewer";
+            submitter: "submitter";
+            viewer: "viewer";
+        }>;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            active: "active";
+            expired: "expired";
+            invited: "invited";
+            revoked: "revoked";
+        }>;
+        capabilities: z.ZodArray<z.ZodEnum<{
+            "audit/read": "audit/read";
+            "claims/read": "claims/read";
+            "claims/review": "claims/review";
+            "claims/submit": "claims/submit";
+            "keys/manage": "keys/manage";
+            "settings/manage": "settings/manage";
+            "source/*": "source/*";
+            "spend/read": "spend/read";
+            "webhooks/manage": "webhooks/manage";
+        }>>;
+        protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        delegationCid: z.ZodNullable<z.ZodString>;
+        revokedAt: z.ZodNullable<z.ZodISODateTime>;
+        reviewerDid: z.ZodNullable<z.ZodString>;
+        reviewerDelegationExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+        notifyReviews: z.ZodBoolean;
+        invitedAt: z.ZodISODateTime;
+        acceptedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CompanySyncResponse = z.infer<typeof CompanySyncResponse>;
+/** An invite names the role the owner will grant; the grant itself is `PUT …/delegation`. An
+ *  invite by `did` is accepted at once (the account exists); by `email` it waits for `accept`.
+ *  `owner` here makes a CO-owner: a grant of `source/*`, revocable like any other — the source's
+ *  roots stay its organisation's current controllers (D10); `ownerDid`, the creator who pays, is
+ *  not one. */
+export declare const InviteMemberRequest: z.ZodObject<{
+    email: z.ZodOptional<z.ZodEmail>;
+    did: z.ZodOptional<z.ZodString>;
+    role: z.ZodEnum<{
+        developer: "developer";
+        owner: "owner";
+        reviewer: "reviewer";
+        submitter: "submitter";
+        viewer: "viewer";
+    }>;
+}, z.core.$strict>;
+export type InviteMemberRequest = z.infer<typeof InviteMemberRequest>;
+/** `inviteToken` is shown once (an email invite only); the console turns it into the link. */
+export declare const InviteMemberResponse: z.ZodObject<{
+    memberId: z.ZodString;
+    did: z.ZodNullable<z.ZodString>;
+    email: z.ZodNullable<z.ZodEmail>;
+    role: z.ZodEnum<{
+        developer: "developer";
+        owner: "owner";
+        reviewer: "reviewer";
+        submitter: "submitter";
+        viewer: "viewer";
+    }>;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        active: "active";
+        expired: "expired";
+        invited: "invited";
+        revoked: "revoked";
+    }>;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        "audit/read": "audit/read";
+        "claims/read": "claims/read";
+        "claims/review": "claims/review";
+        "claims/submit": "claims/submit";
+        "keys/manage": "keys/manage";
+        "settings/manage": "settings/manage";
+        "source/*": "source/*";
+        "spend/read": "spend/read";
+        "webhooks/manage": "webhooks/manage";
+    }>>;
+    protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    delegationCid: z.ZodNullable<z.ZodString>;
+    revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    reviewerDid: z.ZodNullable<z.ZodString>;
+    reviewerDelegationExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+    notifyReviews: z.ZodBoolean;
+    invitedAt: z.ZodISODateTime;
+    acceptedAt: z.ZodNullable<z.ZodISODateTime>;
+    inviteToken: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type InviteMemberResponse = z.infer<typeof InviteMemberResponse>;
+/** `POST /v1/api/members/accept` — the invoking account becomes that member. */
+export declare const AcceptInviteRequest: z.ZodObject<{
+    inviteToken: z.ZodString;
+}, z.core.$strict>;
+export type AcceptInviteRequest = z.infer<typeof AcceptInviteRequest>;
+/**
+ * `PUT /v1/api/members/:memberId/delegation` — the owner's signed grant (§3.4 step 3), base64 of
+ * the delegation CAR. Checked before it is stored: issued by the owner (or a co-owner holding
+ * `source/*` from the owner), to this member's DID, over this source's resource, capabilities
+ * EXACTLY the role's preset, not expired. Replacing a grant revokes the previous one.
+ */
+export declare const GrantMemberRequest: z.ZodObject<{
+    delegation: z.ZodString;
+    role: z.ZodEnum<{
+        developer: "developer";
+        owner: "owner";
+        reviewer: "reviewer";
+        submitter: "submitter";
+        viewer: "viewer";
+    }>;
+}, z.core.$strict>;
+export type GrantMemberRequest = z.infer<typeof GrantMemberRequest>;
+/**
+ * A member's own settings: their reviewer key (§10) and their review-email switch (§10.1).
+ * Registering a key needs `reviewerProof`: a compact JWS signed by THAT did:key over `{ memberId,
+ * sourceId, reviewerDid, iat }` — proof of possession, so a stolen console session cannot enrol a
+ * key it does not hold (§14). Clearing it (`null`) needs none. A field left out is left alone. A
+ * role change is a revoke plus a new grant, never a PATCH.
+ */
+export declare const UpdateMemberRequest: z.ZodObject<{
+    reviewerDid: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reviewerProof: z.ZodOptional<z.ZodString>;
+    notifyReviews: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type UpdateMemberRequest = z.infer<typeof UpdateMemberRequest>;
+/** A key as every read shows it: the prefix, never the secret (§3.3 — shown once, at create). */
+export declare const ApiKey: z.ZodObject<{
+    prefix: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    masked: z.ZodString;
+    environment: z.ZodEnum<{
+        live: "live";
+        test: "test";
+    }>;
+    scopes: z.ZodArray<z.ZodEnum<{
+        "claims:read": "claims:read";
+        "claims:write": "claims:write";
+        "webhooks:manage": "webhooks:manage";
+    }>>;
+    maxSpendCentsPerDay: z.ZodNullable<z.ZodInt>;
+    createdAt: z.ZodISODateTime;
+    lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+    revokedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type ApiKey = z.infer<typeof ApiKey>;
+export declare const KeyList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        prefix: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        masked: z.ZodString;
+        environment: z.ZodEnum<{
+            live: "live";
+            test: "test";
+        }>;
+        scopes: z.ZodArray<z.ZodEnum<{
+            "claims:read": "claims:read";
+            "claims:write": "claims:write";
+            "webhooks:manage": "webhooks:manage";
+        }>>;
+        maxSpendCentsPerDay: z.ZodNullable<z.ZodInt>;
+        createdAt: z.ZodISODateTime;
+        lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+        revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type KeyList = z.infer<typeof KeyList>;
+export declare const CreateApiKeyRequest: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    scopes: z.ZodArray<z.ZodEnum<{
+        "claims:read": "claims:read";
+        "claims:write": "claims:write";
+        "webhooks:manage": "webhooks:manage";
+    }>>;
+    maxSpendCentsPerDay: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export type CreateApiKeyRequest = z.infer<typeof CreateApiKeyRequest>;
+/** `DELETE /v1/api/keys/:prefix` — `graceDays` > 0 lets a rotation overlap (§3.3: up to 30 days). */
+export declare const RevokeApiKeyQuery: z.ZodObject<{
+    graceDays: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type RevokeApiKeyQuery = z.infer<typeof RevokeApiKeyQuery>;
+/** The only response that ever carries the full key. */
+export declare const CreateApiKeyResponse: z.ZodObject<{
+    prefix: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    masked: z.ZodString;
+    environment: z.ZodEnum<{
+        live: "live";
+        test: "test";
+    }>;
+    scopes: z.ZodArray<z.ZodEnum<{
+        "claims:read": "claims:read";
+        "claims:write": "claims:write";
+        "webhooks:manage": "webhooks:manage";
+    }>>;
+    maxSpendCentsPerDay: z.ZodNullable<z.ZodInt>;
+    createdAt: z.ZodISODateTime;
+    lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+    revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    key: z.ZodString;
+}, z.core.$strip>;
+export type CreateApiKeyResponse = z.infer<typeof CreateApiKeyResponse>;
+/** A source's settings (§12.2 Settings). The allow-list and the billing mode are the operator's
+ *  (`/v1/api/admin/sources/:id/…`), because they are commercial terms. */
+export declare const SourceSettings: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    defaultWebhookUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+    contactEmail: z.ZodOptional<z.ZodEmail>;
+    refillFloorCents: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+}, z.core.$strict>;
+export type SourceSettings = z.infer<typeof SourceSettings>;
+export declare const AuditEntry: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodNullable<z.ZodString>;
+    actor: z.ZodObject<{
+        kind: z.ZodEnum<{
+            key: "key";
+            member: "member";
+            oauth: "oauth";
+            operator: "operator";
+            system: "system";
+        }>;
+        id: z.ZodString;
+        clientId: z.ZodOptional<z.ZodString>;
+        clientName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    action: z.ZodString;
+    target: z.ZodNullable<z.ZodString>;
+    at: z.ZodISODateTime;
+    details: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type AuditEntry = z.infer<typeof AuditEntry>;
+export declare const AuditPage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodNullable<z.ZodString>;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                key: "key";
+                member: "member";
+                oauth: "oauth";
+                operator: "operator";
+                system: "system";
+            }>;
+            id: z.ZodString;
+            clientId: z.ZodOptional<z.ZodString>;
+            clientName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        action: z.ZodString;
+        target: z.ZodNullable<z.ZodString>;
+        at: z.ZodISODateTime;
+        details: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AuditPage = z.infer<typeof AuditPage>;
+/** Appendix B. Declared here, not in webhooks.ts, because endpoints subscribe to them and the
+ *  envelope there carries `ClaimRecord` — one direction of import, no cycle. */
+export declare const WebhookEventType: z.ZodEnum<{
+    "balance.low": "balance.low";
+    "claim.accepted": "claim.accepted";
+    "claim.decided": "claim.decided";
+    "claim.failed": "claim.failed";
+    "claim.folded": "claim.folded";
+    "claim.review_expired": "claim.review_expired";
+    "claim.review_required": "claim.review_required";
+    "claim.unusable": "claim.unusable";
+    "payment.settled": "payment.settled";
+    "source.paused": "source.paused";
+    "source.resumed": "source.resumed";
+}>;
+export type WebhookEventType = z.infer<typeof WebhookEventType>;
+export declare const WebhookEndpoint: z.ZodObject<{
+    endpointId: z.ZodString;
+    url: z.ZodURL;
+    events: z.ZodArray<z.ZodEnum<{
+        "balance.low": "balance.low";
+        "claim.accepted": "claim.accepted";
+        "claim.decided": "claim.decided";
+        "claim.failed": "claim.failed";
+        "claim.folded": "claim.folded";
+        "claim.review_expired": "claim.review_expired";
+        "claim.review_required": "claim.review_required";
+        "claim.unusable": "claim.unusable";
+        "payment.settled": "payment.settled";
+        "source.paused": "source.paused";
+        "source.resumed": "source.resumed";
+    }>>;
+    enabled: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type WebhookEndpoint = z.infer<typeof WebhookEndpoint>;
+export declare const EndpointList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        endpointId: z.ZodString;
+        url: z.ZodURL;
+        events: z.ZodArray<z.ZodEnum<{
+            "balance.low": "balance.low";
+            "claim.accepted": "claim.accepted";
+            "claim.decided": "claim.decided";
+            "claim.failed": "claim.failed";
+            "claim.folded": "claim.folded";
+            "claim.review_expired": "claim.review_expired";
+            "claim.review_required": "claim.review_required";
+            "claim.unusable": "claim.unusable";
+            "payment.settled": "payment.settled";
+            "source.paused": "source.paused";
+            "source.resumed": "source.resumed";
+        }>>;
+        enabled: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type EndpointList = z.infer<typeof EndpointList>;
+export declare const CreateWebhookEndpointRequest: z.ZodObject<{
+    url: z.ZodURL;
+    events: z.ZodArray<z.ZodEnum<{
+        "balance.low": "balance.low";
+        "claim.accepted": "claim.accepted";
+        "claim.decided": "claim.decided";
+        "claim.failed": "claim.failed";
+        "claim.folded": "claim.folded";
+        "claim.review_expired": "claim.review_expired";
+        "claim.review_required": "claim.review_required";
+        "claim.unusable": "claim.unusable";
+        "payment.settled": "payment.settled";
+        "source.paused": "source.paused";
+        "source.resumed": "source.resumed";
+    }>>;
+}, z.core.$strict>;
+export type CreateWebhookEndpointRequest = z.infer<typeof CreateWebhookEndpointRequest>;
+export declare const CreateWebhookEndpointResponse: z.ZodObject<{
+    endpointId: z.ZodString;
+    url: z.ZodURL;
+    events: z.ZodArray<z.ZodEnum<{
+        "balance.low": "balance.low";
+        "claim.accepted": "claim.accepted";
+        "claim.decided": "claim.decided";
+        "claim.failed": "claim.failed";
+        "claim.folded": "claim.folded";
+        "claim.review_expired": "claim.review_expired";
+        "claim.review_required": "claim.review_required";
+        "claim.unusable": "claim.unusable";
+        "payment.settled": "payment.settled";
+        "source.paused": "source.paused";
+        "source.resumed": "source.resumed";
+    }>>;
+    enabled: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+    secret: z.ZodString;
+}, z.core.$strip>;
+export type CreateWebhookEndpointResponse = z.infer<typeof CreateWebhookEndpointResponse>;
+export declare const UpdateWebhookEndpointRequest: z.ZodObject<{
+    url: z.ZodOptional<z.ZodURL>;
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "balance.low": "balance.low";
+        "claim.accepted": "claim.accepted";
+        "claim.decided": "claim.decided";
+        "claim.failed": "claim.failed";
+        "claim.folded": "claim.folded";
+        "claim.review_expired": "claim.review_expired";
+        "claim.review_required": "claim.review_required";
+        "claim.unusable": "claim.unusable";
+        "payment.settled": "payment.settled";
+        "source.paused": "source.paused";
+        "source.resumed": "source.resumed";
+    }>>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    rotateSecret: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type UpdateWebhookEndpointRequest = z.infer<typeof UpdateWebhookEndpointRequest>;
+/** `secret` present iff the PATCH rotated it. */
+export declare const UpdateWebhookEndpointResponse: z.ZodObject<{
+    endpointId: z.ZodString;
+    url: z.ZodURL;
+    events: z.ZodArray<z.ZodEnum<{
+        "balance.low": "balance.low";
+        "claim.accepted": "claim.accepted";
+        "claim.decided": "claim.decided";
+        "claim.failed": "claim.failed";
+        "claim.folded": "claim.folded";
+        "claim.review_expired": "claim.review_expired";
+        "claim.review_required": "claim.review_required";
+        "claim.unusable": "claim.unusable";
+        "payment.settled": "payment.settled";
+        "source.paused": "source.paused";
+        "source.resumed": "source.resumed";
+    }>>;
+    enabled: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+    secret: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UpdateWebhookEndpointResponse = z.infer<typeof UpdateWebhookEndpointResponse>;
+export declare const WebhookDelivery: z.ZodObject<{
+    id: z.ZodString;
+    eventId: z.ZodString;
+    type: z.ZodEnum<{
+        "balance.low": "balance.low";
+        "claim.accepted": "claim.accepted";
+        "claim.decided": "claim.decided";
+        "claim.failed": "claim.failed";
+        "claim.folded": "claim.folded";
+        "claim.review_expired": "claim.review_expired";
+        "claim.review_required": "claim.review_required";
+        "claim.unusable": "claim.unusable";
+        "payment.settled": "payment.settled";
+        "source.paused": "source.paused";
+        "source.resumed": "source.resumed";
+    }>;
+    status: z.ZodEnum<{
+        dead: "dead";
+        delivered: "delivered";
+        failed: "failed";
+        pending: "pending";
+    }>;
+    attempts: z.ZodInt;
+    lastStatusCode: z.ZodNullable<z.ZodInt>;
+    nextAttemptAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type WebhookDelivery = z.infer<typeof WebhookDelivery>;
+export declare const DeliveryPage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        eventId: z.ZodString;
+        type: z.ZodEnum<{
+            "balance.low": "balance.low";
+            "claim.accepted": "claim.accepted";
+            "claim.decided": "claim.decided";
+            "claim.failed": "claim.failed";
+            "claim.folded": "claim.folded";
+            "claim.review_expired": "claim.review_expired";
+            "claim.review_required": "claim.review_required";
+            "claim.unusable": "claim.unusable";
+            "payment.settled": "payment.settled";
+            "source.paused": "source.paused";
+            "source.resumed": "source.resumed";
+        }>;
+        status: z.ZodEnum<{
+            dead: "dead";
+            delivered: "delivered";
+            failed: "failed";
+            pending: "pending";
+        }>;
+        attempts: z.ZodInt;
+        lastStatusCode: z.ZodNullable<z.ZodInt>;
+        nextAttemptAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DeliveryPage = z.infer<typeof DeliveryPage>;
+/**
+ * `GET /v1/api/webhooks/deliveries/:deliveryId` — one delivery with what was sent. Only the LAST
+ * attempt's outcome is kept (v1.1); the envelope is null once the claim's body retention erased it.
+ */
+export declare const WebhookDeliveryDetail: z.ZodObject<{
+    id: z.ZodString;
+    eventId: z.ZodString;
+    type: z.ZodEnum<{
+        "balance.low": "balance.low";
+        "claim.accepted": "claim.accepted";
+        "claim.decided": "claim.decided";
+        "claim.failed": "claim.failed";
+        "claim.folded": "claim.folded";
+        "claim.review_expired": "claim.review_expired";
+        "claim.review_required": "claim.review_required";
+        "claim.unusable": "claim.unusable";
+        "payment.settled": "payment.settled";
+        "source.paused": "source.paused";
+        "source.resumed": "source.resumed";
+    }>;
+    status: z.ZodEnum<{
+        dead: "dead";
+        delivered: "delivered";
+        failed: "failed";
+        pending: "pending";
+    }>;
+    attempts: z.ZodInt;
+    lastStatusCode: z.ZodNullable<z.ZodInt>;
+    nextAttemptAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+    endpointId: z.ZodNullable<z.ZodString>;
+    targetUrl: z.ZodNullable<z.ZodURL>;
+    request: z.ZodObject<{
+        body: z.ZodNullable<z.ZodUnknown>;
+    }, z.core.$strip>;
+    lastError: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type WebhookDeliveryDetail = z.infer<typeof WebhookDeliveryDetail>;
+/** An on-chain claim collection id (a uint64, as the chain and Blocksync print it). */
+export declare const CollectionId: z.ZodString;
+/**
+ * An on-chain collection the source has linked: its chain claims then read with the source's own.
+ * `linkedBy` is either a member who owns the collection entity on chain (company authority D9) —
+ * re-checked hourly; a link whose linker no longer owns it is dropped — or (1.21.0) the source's
+ * own `companyEntityDid`, for a link the oracle made at the collection's registration because the
+ * engine names that organisation as the collection's company — re-checked hourly against the
+ * engine, dropped when it no longer does. Only a drop hides a link (1.23.0): a re-check that cannot
+ * read the chain or the engine keeps it in the reads. Billing stays the collection owner's on-chain evaluation
+ * payment: never a 402 here.
+ */
+export declare const LinkedCollection: z.ZodObject<{
+    collectionId: z.ZodString;
+    protocolDid: z.ZodString;
+    linkedBy: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    linkedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type LinkedCollection = z.infer<typeof LinkedCollection>;
+export declare const LinkedCollectionList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        collectionId: z.ZodString;
+        protocolDid: z.ZodString;
+        linkedBy: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        linkedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LinkedCollectionList = z.infer<typeof LinkedCollectionList>;
+export declare const LinkCollectionRequest: z.ZodObject<{
+    collectionId: z.ZodString;
+}, z.core.$strict>;
+export type LinkCollectionRequest = z.infer<typeof LinkCollectionRequest>;
+/**
+ * The source owner's balance — the deed of `ownerDid`, not of whichever live member paid a given
+ * offer — as the facilitator sees it (`GET /v1/balances`, payments spec §5.3), base units
+ * of `upay` (1 upay = 1 micro-USD): `balance` in the deed, `sendLimit` left on the send permission
+ * (null = no permission granted yet), `reserved` for claims awaiting their receipt, `settled` on a
+ * receipt and not yet transferred, `paying` in the transfer under way, `available` = what a new
+ * reservation may take (contracts v1.3; was `held` / `spent`).
+ */
+export declare const Credits: z.ZodObject<{
+    asset: z.ZodLiteral<"upay">;
+    balance: z.ZodString;
+    sendLimit: z.ZodNullable<z.ZodString>;
+    reserved: z.ZodString;
+    settled: z.ZodString;
+    paying: z.ZodString;
+    available: z.ZodString;
+}, z.core.$strip>;
+export type Credits = z.infer<typeof Credits>;
+/**
+ * A source's standing review-billing delegation (while IXO's plan lets the oracle bill reviews): the x402-ixo-pay
+ * payment delegation (base64 CAR, one `billing/pay` on `billing:decision-api` to the facilitator,
+ * `nb: { maxAmount, denom: "upay", oracles: [<this oracle's did:web>] }`, an `exp`, no proofs, no
+ * facts) its organisation's CURRENT chain owner signed. It pays for every review of the
+ * organisation's chain collections' claims, from the owner's subscription credits.
+ */
+export declare const SetReviewBillingRequest: z.ZodObject<{
+    delegation: z.ZodString;
+}, z.core.$strict>;
+export type SetReviewBillingRequest = z.infer<typeof SetReviewBillingRequest>;
+/**
+ * `active`; `expired` past its `exp`; `exhausted` when what is left of `maxAmount` covers no
+ * review; `payer_not_owner` when its signer is no longer the organisation's chain owner.
+ */
+export declare const ReviewBillingState: z.ZodEnum<{
+    active: "active";
+    exhausted: "exhausted";
+    expired: "expired";
+    payer_not_owner: "payer_not_owner";
+}>;
+export type ReviewBillingState = z.infer<typeof ReviewBillingState>;
+/**
+ * Why a collection's reviews are paused: `payer-credits` — the payer's credits (or the send
+ * permission behind them) do not cover a review: top up; `payer-delegation` — no usable delegation
+ * (none, expired, used up, its signer no longer the owner): store a new one.
+ */
+export declare const PayerPausedReason: z.ZodEnum<{
+    "payer-credits": "payer-credits";
+    "payer-delegation": "payer-delegation";
+}>;
+export type PayerPausedReason = z.infer<typeof PayerPausedReason>;
+/**
+ * The stored delegation as the Console reads it — never the token. `spent` / `remaining` are this
+ * oracle's own count against `maxAmount` (the facilitator exposes none; the delegation is bound to
+ * this oracle alone, so the two agree); `credits` the payer's balance at the facilitator, null until
+ * it answers this oracle (after the first review is reserved).
+ */
+export declare const ReviewBilling: z.ZodObject<{
+    sourceId: z.ZodString;
+    state: z.ZodEnum<{
+        active: "active";
+        exhausted: "exhausted";
+        expired: "expired";
+        payer_not_owner: "payer_not_owner";
+    }>;
+    payer: z.ZodString;
+    delegationCid: z.ZodString;
+    maxAmount: z.ZodString;
+    spent: z.ZodString;
+    remaining: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+    credits: z.ZodNullable<z.ZodObject<{
+        asset: z.ZodLiteral<"upay">;
+        balance: z.ZodString;
+        sendLimit: z.ZodNullable<z.ZodString>;
+        reserved: z.ZodString;
+        settled: z.ZodString;
+        paying: z.ZodString;
+        available: z.ZodString;
+    }, z.core.$strip>>;
+    pricePerReview: z.ZodArray<z.ZodObject<{
+        protocolDid: z.ZodString;
+        amount: z.ZodString;
+        amountCents: z.ZodInt;
+    }, z.core.$strip>>;
+    pausedCollections: z.ZodArray<z.ZodObject<{
+        collectionId: z.ZodString;
+        reason: z.ZodEnum<{
+            "payer-credits": "payer-credits";
+            "payer-delegation": "payer-delegation";
+        }>;
+        since: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    createdBy: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type ReviewBilling = z.infer<typeof ReviewBilling>;
+/** `DELETE`'s answer: whether a delegation was held, and what a full stop takes. */
+export declare const ReviewBillingDeleted: z.ZodObject<{
+    deleted: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type ReviewBillingDeleted = z.infer<typeof ReviewBillingDeleted>;
+export declare const Limits: z.ZodObject<{
+    maxBodyBytes: z.ZodInt;
+    maxUploadBytes: z.ZodInt;
+    maxBatchClaims: z.ZodInt;
+    maxWaitSeconds: z.ZodInt;
+    maxConcurrentWaiters: z.ZodInt;
+    maxPageLimit: z.ZodInt;
+}, z.core.$strip>;
+export type Limits = z.infer<typeof Limits>;
+/** Who is asking — the console resolves its API-developer role from this (§12.3). */
+export declare const Caller: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"key">;
+    prefix: z.ZodString;
+    scopes: z.ZodArray<z.ZodEnum<{
+        "claims:read": "claims:read";
+        "claims:write": "claims:write";
+        "webhooks:manage": "webhooks:manage";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"member">;
+    memberId: z.ZodString;
+    did: z.ZodString;
+    role: z.ZodEnum<{
+        developer: "developer";
+        owner: "owner";
+        reviewer: "reviewer";
+        submitter: "submitter";
+        viewer: "viewer";
+    }>;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        "audit/read": "audit/read";
+        "claims/read": "claims/read";
+        "claims/review": "claims/review";
+        "claims/submit": "claims/submit";
+        "keys/manage": "keys/manage";
+        "settings/manage": "settings/manage";
+        "source/*": "source/*";
+        "spend/read": "spend/read";
+        "webhooks/manage": "webhooks/manage";
+    }>>;
+    protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"controller">;
+    did: z.ZodString;
+    capabilities: z.ZodArray<z.ZodEnum<{
+        "audit/read": "audit/read";
+        "claims/read": "claims/read";
+        "claims/review": "claims/review";
+        "claims/submit": "claims/submit";
+        "keys/manage": "keys/manage";
+        "settings/manage": "settings/manage";
+        "source/*": "source/*";
+        "spend/read": "spend/read";
+        "webhooks/manage": "webhooks/manage";
+    }>>;
+}, z.core.$strip>], "kind">;
+export type Caller = z.infer<typeof Caller>;
+/**
+ * Least exposure (§14): `members` (emails, DIDs) only to a console member — never to an API key;
+ * `keys` to a key or a member with `keys/manage`; `webhookEndpoints` to a key with
+ * `webhooks:manage` or a member with `webhooks/manage`; `credits` to a key or a member with
+ * `spend/read`. `credits` is the source owner's balance (another live member who pays an offer
+ * has their own, not shown here); null when the source pays nothing here (billing mode `none`,
+ * payments off) or the facilitator could not be read.
+ */
+export declare const Me: z.ZodObject<{
+    caller: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"key">;
+        prefix: z.ZodString;
+        scopes: z.ZodArray<z.ZodEnum<{
+            "claims:read": "claims:read";
+            "claims:write": "claims:write";
+            "webhooks:manage": "webhooks:manage";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"member">;
+        memberId: z.ZodString;
+        did: z.ZodString;
+        role: z.ZodEnum<{
+            developer: "developer";
+            owner: "owner";
+            reviewer: "reviewer";
+            submitter: "submitter";
+            viewer: "viewer";
+        }>;
+        capabilities: z.ZodArray<z.ZodEnum<{
+            "audit/read": "audit/read";
+            "claims/read": "claims/read";
+            "claims/review": "claims/review";
+            "claims/submit": "claims/submit";
+            "keys/manage": "keys/manage";
+            "settings/manage": "settings/manage";
+            "source/*": "source/*";
+            "spend/read": "spend/read";
+            "webhooks/manage": "webhooks/manage";
+        }>>;
+        protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"controller">;
+        did: z.ZodString;
+        capabilities: z.ZodArray<z.ZodEnum<{
+            "audit/read": "audit/read";
+            "claims/read": "claims/read";
+            "claims/review": "claims/review";
+            "claims/submit": "claims/submit";
+            "keys/manage": "keys/manage";
+            "settings/manage": "settings/manage";
+            "source/*": "source/*";
+            "spend/read": "spend/read";
+            "webhooks/manage": "webhooks/manage";
+        }>>;
+    }, z.core.$strip>], "kind">;
+    source: z.ZodObject<{
+        sourceId: z.ZodString;
+        name: z.ZodString;
+        ownerDid: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            disputed: "disputed";
+            paused: "paused";
+            "pending-link": "pending-link";
+        }>;
+        pausedReason: z.ZodNullable<z.ZodEnum<{
+            "engine-credits": "engine-credits";
+            operator: "operator";
+            "payments-disabled": "payments-disabled";
+            "rubric-unusable": "rubric-unusable";
+        }>>;
+        billingMode: z.ZodEnum<{
+            none: "none";
+            x402: "x402";
+        }>;
+        allowedProtocols: z.ZodArray<z.ZodObject<{
+            protocolDid: z.ZodString;
+        }, z.core.$strip>>;
+        refillFloorCents: z.ZodNullable<z.ZodInt>;
+        defaultWebhookUrl: z.ZodNullable<z.ZodURL>;
+        contactEmail: z.ZodNullable<z.ZodEmail>;
+        companyEntityDid: z.ZodString;
+        payeeField: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        activatedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>;
+    members: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        memberId: z.ZodString;
+        did: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodEmail>;
+        role: z.ZodEnum<{
+            developer: "developer";
+            owner: "owner";
+            reviewer: "reviewer";
+            submitter: "submitter";
+            viewer: "viewer";
+        }>;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            active: "active";
+            expired: "expired";
+            invited: "invited";
+            revoked: "revoked";
+        }>;
+        capabilities: z.ZodArray<z.ZodEnum<{
+            "audit/read": "audit/read";
+            "claims/read": "claims/read";
+            "claims/review": "claims/review";
+            "claims/submit": "claims/submit";
+            "keys/manage": "keys/manage";
+            "settings/manage": "settings/manage";
+            "source/*": "source/*";
+            "spend/read": "spend/read";
+            "webhooks/manage": "webhooks/manage";
+        }>>;
+        protocols: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        delegationCid: z.ZodNullable<z.ZodString>;
+        revokedAt: z.ZodNullable<z.ZodISODateTime>;
+        reviewerDid: z.ZodNullable<z.ZodString>;
+        reviewerDelegationExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+        notifyReviews: z.ZodBoolean;
+        invitedAt: z.ZodISODateTime;
+        acceptedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>>;
+    keys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        prefix: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        masked: z.ZodString;
+        environment: z.ZodEnum<{
+            live: "live";
+            test: "test";
+        }>;
+        scopes: z.ZodArray<z.ZodEnum<{
+            "claims:read": "claims:read";
+            "claims:write": "claims:write";
+            "webhooks:manage": "webhooks:manage";
+        }>>;
+        maxSpendCentsPerDay: z.ZodNullable<z.ZodInt>;
+        createdAt: z.ZodISODateTime;
+        lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+        revokedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>>;
+    credits: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        asset: z.ZodLiteral<"upay">;
+        balance: z.ZodString;
+        sendLimit: z.ZodNullable<z.ZodString>;
+        reserved: z.ZodString;
+        settled: z.ZodString;
+        paying: z.ZodString;
+        available: z.ZodString;
+    }, z.core.$strip>>>;
+    limits: z.ZodObject<{
+        maxBodyBytes: z.ZodInt;
+        maxUploadBytes: z.ZodInt;
+        maxBatchClaims: z.ZodInt;
+        maxWaitSeconds: z.ZodInt;
+        maxConcurrentWaiters: z.ZodInt;
+        maxPageLimit: z.ZodInt;
+    }, z.core.$strip>;
+    webhookEndpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        endpointId: z.ZodString;
+        url: z.ZodURL;
+        events: z.ZodArray<z.ZodEnum<{
+            "balance.low": "balance.low";
+            "claim.accepted": "claim.accepted";
+            "claim.decided": "claim.decided";
+            "claim.failed": "claim.failed";
+            "claim.folded": "claim.folded";
+            "claim.review_expired": "claim.review_expired";
+            "claim.review_required": "claim.review_required";
+            "claim.unusable": "claim.unusable";
+            "payment.settled": "payment.settled";
+            "source.paused": "source.paused";
+            "source.resumed": "source.resumed";
+        }>>;
+        enabled: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>>;
+    reviewBlocked: z.ZodNullable<z.ZodEnum<{
+        "not-reviewer": "not-reviewer";
+        "oracle-owner": "oracle-owner";
+    }>>;
+}, z.core.$strip>;
+export type Me = z.infer<typeof Me>;
+export declare const SourcePage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        name: z.ZodString;
+        ownerDid: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            disputed: "disputed";
+            paused: "paused";
+            "pending-link": "pending-link";
+        }>;
+        pausedReason: z.ZodNullable<z.ZodEnum<{
+            "engine-credits": "engine-credits";
+            operator: "operator";
+            "payments-disabled": "payments-disabled";
+            "rubric-unusable": "rubric-unusable";
+        }>>;
+        billingMode: z.ZodEnum<{
+            none: "none";
+            x402: "x402";
+        }>;
+        allowedProtocols: z.ZodArray<z.ZodObject<{
+            protocolDid: z.ZodString;
+        }, z.core.$strip>>;
+        refillFloorCents: z.ZodNullable<z.ZodInt>;
+        defaultWebhookUrl: z.ZodNullable<z.ZodURL>;
+        contactEmail: z.ZodNullable<z.ZodEmail>;
+        companyEntityDid: z.ZodString;
+        payeeField: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        activatedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SourcePage = z.infer<typeof SourcePage>;
+export declare const PauseSourceRequest: z.ZodObject<{
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PauseSourceRequest = z.infer<typeof PauseSourceRequest>;
+/** Replaces the allow-list whole — a PUT, so the console's form is the truth. */
+export declare const SetSourceProtocolsRequest: z.ZodObject<{
+    protocols: z.ZodArray<z.ZodObject<{
+        protocolDid: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SetSourceProtocolsRequest = z.infer<typeof SetSourceProtocolsRequest>;
+/** `PUT /v1/api/admin/sources/:sourceId/billing-mode` — operators only, never the source's members. */
+export declare const SetBillingModeRequest: z.ZodObject<{
+    billingMode: z.ZodEnum<{
+        none: "none";
+        x402: "x402";
+    }>;
+}, z.core.$strict>;
+export type SetBillingModeRequest = z.infer<typeof SetBillingModeRequest>;
+/**
+ * `GET /v1/api/admin/facilitator-delegation` (contracts v1.4.1): S10's card facilitator
+ * (`ixo-pay-facilitator`) trusts this oracle's did:web as its root for operator actions, so an
+ * operator reaches it with a delegation the oracle signs — one capability per requested action
+ * (never `*`, never the retired `operators/manage`), no `nb`, to the operator's own did:ixo, at
+ * most an hour. Minted fresh every call (a nonce each), never cached.
+ */
+export declare const FACILITATOR_RESOURCE = "ixo:ixo-pay-facilitator";
+export declare const FACILITATOR_DELEGATION_MAX_TTL_SEC = 3600;
+/** The facilitator's operator actions (S10), in the order a delegation lists them. */
+export declare const FacilitatorAction: z.ZodEnum<{
+    "operators/evidence": "operators/evidence";
+    "operators/onboard": "operators/onboard";
+    "operators/read": "operators/read";
+    "operators/refund": "operators/refund";
+}>;
+export type FacilitatorAction = z.infer<typeof FacilitatorAction>;
+export declare const FacilitatorDelegationQuery: z.ZodObject<{
+    actions: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<("operators/evidence" | "operators/onboard" | "operators/read" | "operators/refund")[], string | undefined>>;
+    ttl: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type FacilitatorDelegationQuery = z.infer<typeof FacilitatorDelegationQuery>;
+export declare const FacilitatorCapability: z.ZodObject<{
+    with: z.ZodLiteral<"ixo:ixo-pay-facilitator">;
+    can: z.ZodEnum<{
+        "operators/evidence": "operators/evidence";
+        "operators/onboard": "operators/onboard";
+        "operators/read": "operators/read";
+        "operators/refund": "operators/refund";
+    }>;
+}, z.core.$strip>;
+export type FacilitatorCapability = z.infer<typeof FacilitatorCapability>;
+export declare const FacilitatorDelegation: z.ZodObject<{
+    delegation: z.ZodString;
+    issuer: z.ZodString;
+    audience: z.ZodString;
+    capabilities: z.ZodArray<z.ZodObject<{
+        with: z.ZodLiteral<"ixo:ixo-pay-facilitator">;
+        can: z.ZodEnum<{
+            "operators/evidence": "operators/evidence";
+            "operators/onboard": "operators/onboard";
+            "operators/read": "operators/read";
+            "operators/refund": "operators/refund";
+        }>;
+    }, z.core.$strip>>;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type FacilitatorDelegation = z.infer<typeof FacilitatorDelegation>;
+/** The source's personal data (claim bodies, metadata, members, endpoints, the list of uploaded files,
+ *  the webhook delivery log, review answers) as one archive, behind a short-lived signed URL
+ *  — the export route §6.3 promises. */
+export declare const DataExport: z.ZodObject<{
+    url: z.ZodURL;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type DataExport = z.infer<typeof DataExport>;
+//# sourceMappingURL=api.d.ts.map