@nuanu-ai/agentify-contracts 0.3.2

package/dist/api.d.ts

@@ -0,0 +1,1948 @@
+/**
+ * The HTTP surface: which calls exist, at which addresses, with which document
+ * going each way.
+ *
+ * It is written as data rather than as prose because two programs read it. The
+ * gateway serves these calls and the SDK makes them, and each of them
+ * previously would have learned the surface from a document a person had
+ * transcribed — which is how one side ends up posting to `/v0/order/:id/deliver`
+ * while the other serves `/v0/orders/:id/deliver`, and how a response shape
+ * agreed in a meeting becomes two shapes in two repositories. Here the table is
+ * the agreement, and both sides import it.
+ *
+ * What the table does not carry is deliberate. There is no header name for the
+ * merchant key, no status codes, no base address, no timeouts and no retry
+ * policy. `auth` says which door a call is behind, not how the door is built;
+ * the key's header, the status code a refusal comes back under and where the
+ * service lives are the gateway's, and a number invented here would read as a
+ * decision nobody took. What belongs here is what both sides have to agree on
+ * or fail: the address, the method, the door, and the documents.
+ *
+ * The paths are written the way an express-style router writes them — a colon
+ * and a lowercase name, `/v0/orders/:order_id/deliver`. That form was chosen
+ * over the braces of OpenAPI for one reason: the gateway can mount these
+ * strings unchanged, so the side that must never be wrong about an address is
+ * the side that does no translation at all. The SDK is the side that
+ * substitutes, and it does not write its own substitution either: `pathParamsOf`
+ * and `expandPath` below are here so that the encoding is done once. That is
+ * not a nicety. An identifier in this contract may contain a slash and a space
+ * — "SKU 100/1" is one we accept — and pasted into an address unencoded it
+ * becomes two path segments and a different route.
+ *
+ * What each route names is the document it answers with when the call works.
+ * How it says no is not a per-route question and is not written route by
+ * route: every refusal on this surface, from any call, arrives in the one
+ * envelope `ErrorEnvelopeSchema` describes below.
+ *
+ * Two ways of answering for an order sit in the table and they are not the
+ * same thing, which is worth reading before either is used. What a merchant's
+ * handler returns — delivered, refused, taken on — goes to the answer route,
+ * in every mode, and the SDK sends it without the merchant asking. `deliver`
+ * and `refuse` are the asynchronous mode's explicit closure verbs, called
+ * later by a merchant who took an order on and now has the goods or has run
+ * out of them. The order machine keeps the same two apart, and in the
+ * synchronous mode it is the returned answer that exists and the explicit
+ * calls that do not. The addendum of 2026-08-26 to ADR-0004 settles this; §2
+ * of that decision, read alone, leaves the synchronous handler with no address
+ * at all.
+ */
+import { z } from "zod";
+/**
+ * An order together with the word for where it stands.
+ *
+ * The order itself carries no state — reading state back is a separate call,
+ * and this is that call's document. It is the order with one field added
+ * rather than the order nested inside a wrapper, because to the merchant it is
+ * one order that has a status, and a wrapper would exist only to keep a strict
+ * parser happy. The consequence is worth naming: this is a different document
+ * from an order off the worker stream, and `OrderSchema` refuses it. That is
+ * the intended reading, not an accident of strictness.
+ */
+export declare const OrderWithStatusSchema: z.ZodObject<{
+    id: z.ZodString;
+    merchant_item_id: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    price: z.ZodObject<{
+        amount: z.ZodString;
+        currency: z.ZodString;
+        at: z.ZodISODateTime;
+        as_of: z.ZodISODateTime;
+    }, z.core.$strict>;
+    price_id: z.ZodOptional<z.ZodString>;
+    test: z.ZodBoolean;
+    status: z.ZodEnum<{
+        delivered: "delivered";
+        in_progress: "in_progress";
+        rejected: "rejected";
+        payment_unresolved: "payment_unresolved";
+        declined: "declined";
+        expired: "expired";
+        cancelled: "cancelled";
+        refund_due: "refund_due";
+        refunded: "refunded";
+        delivered_unpaid: "delivered_unpaid";
+    }>;
+}, z.core.$strict>;
+/**
+ * Every order the merchant asked for.
+ *
+ * An object rather than a bare array, because a bare array is the one shape
+ * that cannot grow. The day this list needs a cursor or a count, an array
+ * would have to become an object and every reader that already parses it would
+ * break at once.
+ */
+export declare const OrderListSchema: z.ZodObject<{
+    orders: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        merchant_item_id: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        price: z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodString;
+            at: z.ZodISODateTime;
+            as_of: z.ZodISODateTime;
+        }, z.core.$strict>;
+        price_id: z.ZodOptional<z.ZodString>;
+        test: z.ZodBoolean;
+        status: z.ZodEnum<{
+            delivered: "delivered";
+            in_progress: "in_progress";
+            rejected: "rejected";
+            payment_unresolved: "payment_unresolved";
+            declined: "declined";
+            expired: "expired";
+            cancelled: "cancelled";
+            refund_due: "refund_due";
+            refunded: "refunded";
+            delivered_unpaid: "delivered_unpaid";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * A merchant's own catalog: their cards, and whether they are selling at all.
+ *
+ * The merchant's own word sits beside the cards rather than being left to be
+ * inferred from them, because the two answer different questions and a screen
+ * needs both. Every card of a merchant who has stopped all selling reads
+ * paused, and nothing in the cards themselves says whether that is five
+ * separate decisions or one — which is exactly the difference between resuming
+ * a card and resuming the catalog.
+ *
+ * An object rather than a bare array for the reason the order list gives, and
+ * one more: a bare array has nowhere to put the merchant's own word at all.
+ */
+export declare const MerchantCardListSchema: z.ZodObject<{
+    selling: z.ZodEnum<{
+        open: "open";
+        paused: "paused";
+        departed: "departed";
+    }>;
+    cards: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        as_of: z.ZodISODateTime;
+        card: z.ZodObject<{
+            merchant_item_id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            price: z.ZodPreprocess<z.ZodObject<{
+                amount: z.ZodString;
+                currency: z.ZodString;
+            }, z.core.$strict>>;
+            params: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    integer: "integer";
+                }>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                title: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>>;
+            result: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    integer: "integer";
+                }>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                title: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fulfillment: z.ZodDefault<z.ZodEnum<{
+                sync: "sync";
+                async: "async";
+                confirm: "confirm";
+            }>>;
+            price_check: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"handler">, z.ZodObject<{
+                url: z.ZodURL;
+            }, z.core.$strict>]>>;
+            confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+            fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+        selling: z.ZodEnum<{
+            open: "open";
+            paused: "paused";
+            departed: "departed";
+        }>;
+        paused: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * Every receipt this merchant has.
+ *
+ * A receipt exists from the moment the money moves, so this is the list a
+ * merchant reconciles their wallet against. What it cannot show is worth
+ * knowing before it is reconciled from: a purchase that ended before any
+ * payment leaves no receipt at all, and no receipt is written while it is
+ * unknown whether the buyer was charged — `ReceiptSchema` works both through.
+ *
+ * An object rather than a bare array, so the day it needs paging it grows the
+ * field that says so instead of changing shape under every reader.
+ */
+export declare const ReceiptListSchema: z.ZodObject<{
+    receipts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        order_id: z.ZodString;
+        item_id: z.ZodString;
+        price: z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodString;
+            at: z.ZodISODateTime;
+            as_of: z.ZodISODateTime;
+        }, z.core.$strict>;
+        price_id: z.ZodOptional<z.ZodString>;
+        paid_at: z.ZodISODateTime;
+        outcome: z.ZodEnum<{
+            delivered: "delivered";
+            in_progress: "in_progress";
+            refund_due: "refund_due";
+            refunded: "refunded";
+        }>;
+        test: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * The question a merchant puts in the query string when listing orders.
+ *
+ * `open=true` narrows the list to the orders that are still owed something —
+ * which includes the two that stay open after the purchase itself is over, an
+ * order owing a refund and one delivered but never paid for. Leaving it out
+ * asks for everything.
+ *
+ * The value is text and not a boolean, because that is what a query string
+ * carries. Written as a boolean it would export as one, and an engineer
+ * generating a client from that document would build a request nobody can
+ * send. The two words are exact on purpose: a merchant who wrote `open=1`,
+ * meant "only the open ones" and silently received all of them would reconcile
+ * their books against the wrong list.
+ */
+export declare const OrderListQuerySchema: z.ZodObject<{
+    open: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+}, z.core.$strict>;
+/**
+ * What a worker asks of one poll.
+ *
+ * Neither field carries a ceiling, and the absence is deliberate. A first
+ * draft put a maximum on each and called them bounds on the format; they were
+ * not. The bounds this package does write down are anchored in something
+ * outside itself — eighteen fractional digits because that is what an ERC-20
+ * token carries — and no such anchor exists for a number of seconds or a
+ * number of messages. A card is already held to that rule from the other side:
+ * it takes any whole positive number of seconds for its deadlines rather than
+ * inventing a limit that would read as a decision nobody took. How long the
+ * gateway will actually hold a request and how many envelopes it will actually
+ * return are the gateway's, and it is the one that has to answer for them.
+ *
+ * The two lower bounds stay, because each refuses something that is not a
+ * request at all rather than something that is merely large.
+ */
+export declare const WorkerPollRequestSchema: z.ZodObject<{
+    wait_seconds: z.ZodOptional<z.ZodInt>;
+    max: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+/**
+ * What a poll answers with.
+ *
+ * The list may be empty, and an empty batch is the ordinary answer to a quiet
+ * window rather than a failure. A worker that read it as one would tear down
+ * and rebuild its subscription every time nothing happened.
+ *
+ * The contract version rides here because this is the call every worker makes
+ * first and then forever. The SDK checks it and refuses to start against a
+ * gateway speaking another dialect, which is the difference between failing at
+ * startup and failing on somebody's first order.
+ */
+export declare const WorkerPollResponseSchema: z.ZodObject<{
+    contract_version: z.ZodString;
+    envelopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"order">;
+        id: z.ZodString;
+        sent_at: z.ZodISODateTime;
+        payload: z.ZodObject<{
+            id: z.ZodString;
+            merchant_item_id: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            price: z.ZodObject<{
+                amount: z.ZodString;
+                currency: z.ZodString;
+                at: z.ZodISODateTime;
+                as_of: z.ZodISODateTime;
+            }, z.core.$strict>;
+            price_id: z.ZodOptional<z.ZodString>;
+            test: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"quote_request">;
+        id: z.ZodString;
+        sent_at: z.ZodISODateTime;
+        payload: z.ZodObject<{
+            merchant_item_id: z.ZodString;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            price_id: z.ZodString;
+            purpose: z.ZodEnum<{
+                purchase: "purchase";
+                poll: "poll";
+            }>;
+            expires_at: z.ZodISODateTime;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"order_event">;
+        id: z.ZodString;
+        sent_at: z.ZodISODateTime;
+        payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"order.refund_due">;
+            order_id: z.ZodString;
+            at: z.ZodISODateTime;
+            price: z.ZodObject<{
+                amount: z.ZodString;
+                currency: z.ZodString;
+            }, z.core.$strict>;
+            reason: z.ZodEnum<{
+                refused: "refused";
+                deadline_passed: "deadline_passed";
+                merchant_left: "merchant_left";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"order.unpaid_after_confirmation">;
+            order_id: z.ZodString;
+            at: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"order.payment_failed_after_delivery">;
+            order_id: z.ZodString;
+            at: z.ZodISODateTime;
+        }, z.core.$strict>], "type">;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+/**
+ * What delivering or refusing an order comes back as.
+ *
+ * `ok` is a value rather than a key, and it is the same envelope every
+ * merchant-facing call of this surface answers in; the reasons are written down
+ * once, in `results.ts`, rather than argued again at each route. What this
+ * route adds to them is a word for which success it was: the marker of success
+ * is one and the same for a first delivery and for a repeated one, so a
+ * merchant who wrote `if (result === "delivered")` would have turned their own
+ * safe retry into a failure branch, and branching on `ok` and recording the
+ * word is what this shape makes the easy thing to do.
+ *
+ * The failure is one `error` and not a list, and that is not an asymmetry with
+ * the publish. A call fails for one reason, wherever it is; what may be wrong
+ * in several places at once is the document that was sent, and those findings
+ * ride inside the error under `problems` — which is exactly what a delivery
+ * that is not what its card declares comes back with.
+ *
+ * Nothing here travels as an exception. A merchant's integration code is
+ * expected to read this, branch on it and write some of it down.
+ */
+export declare const OrderCallResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    result: z.ZodEnum<{
+        refused: "refused";
+        delivered: "delivered";
+        accepted: "accepted";
+        already_delivered: "already_delivered";
+        debt_closed_by_delivery: "debt_closed_by_delivery";
+        purchase_already_closed: "purchase_already_closed";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        problems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodArray<z.ZodString>;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "ok">;
+/**
+ * What taking an order on comes back as.
+ *
+ * The success carries no word, and that is a choice rather than a gap. The
+ * published results include `accepted`, so there is a word to carry; this
+ * route declines to carry it. Underneath, taking on an order that is waiting
+ * and taking on one already delivered are two different answers, and this
+ * route reports both as the same bare success — a merchant who takes on an
+ * order they have already finished learns nothing new here, which is what
+ * makes a repeat harmless. The answer route is where the word earns its
+ * place, because it carries whichever of the three things a handler returned
+ * and its success has to name which. `ok: true` here is a whole sentence on
+ * its own: true is true in every language, and the shape leaves room for a
+ * word beside it the day this route needs to tell two successes apart.
+ *
+ * Repeats are ordinary here. Delivery is at least once, so an order already
+ * taken on is taken on again every time it is redelivered, and an answer with
+ * no word in it has nothing to get wrong on the second pass.
+ *
+ * The failures are the same ones the other order calls have — accepting an
+ * order that has already closed, or accepting in a mode where acceptance does
+ * not exist.
+ */
+export declare const OrderAcceptResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        problems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodArray<z.ZodString>;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "ok">;
+/**
+ * What answering a price question comes back as.
+ *
+ * One fact, because one fact is what the merchant acts on. A merchant who set
+ * stock aside against the question needs to know whether the answer arrived in
+ * time to price the purchase; if it did not, they can release what they held.
+ *
+ * `used: false` also covers a question we no longer hold at all — a worker
+ * that restarted and replayed an envelope from an hour ago. The two are folded
+ * into one word deliberately, because the merchant does the same thing in
+ * either case, and the fold is written down here rather than left to be
+ * discovered. The flag is required, not defaulted: read as used, a missing
+ * flag leaves stock held forever; read as unused, it releases stock out from
+ * under a sale that is going through.
+ */
+export declare const QuoteAnswerAckSchema: z.ZodObject<{
+    used: z.ZodBoolean;
+}, z.core.$strict>;
+/**
+ * What an agent sends to buy.
+ *
+ * The parameters are always there, empty for a product that needs no input,
+ * for the same reason an order's are: nobody downstream should have to tell
+ * "no parameters" from "the field did not arrive".
+ *
+ * This document holds the envelope and not the contents. Whether these
+ * particular values fit this particular card is checked against that card's
+ * own declaration at the moment of purchase — one card, one check, one error
+ * message — and no schema written in advance of a catalog can do it.
+ */
+export declare const PurchaseRequestSchema: z.ZodObject<{
+    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+/**
+ * What became of a purchase, told to the agent that made it.
+ *
+ * Four fields, and the shape of the list is the decision rather than its
+ * length. This document is what the buyer is owed — where their order stands,
+ * what it cost them, and the goods once those exist — and it is deliberately
+ * smaller than the merchant's own view of the same order. It carries no
+ * merchant, no merchant's key for the product, none of the parameters the
+ * buyer sent and nothing about any other order, because whoever holds an
+ * order's identifier can read it (ADR-0011) and an answer assembled from the
+ * merchant's record would hand all of that to whoever guessed one.
+ *
+ * Both of the agent's doors answer in it, and that is one concept rather than
+ * two: the purchase and the later read are the same question — where does my
+ * order stand — asked at two moments. Two documents for it would be two
+ * readers for an integrator to write, and the one that came back from the
+ * purchase was the merchant's own, with the merchant's key for the product and
+ * the buyer's own parameters in it. What a purchase answers with beyond this
+ * document is the payment exchange that precedes it, which is a header and not
+ * a document at all.
+ *
+ * The two nullable fields are required rather than optional, and that is the
+ * fifth gate written into a shape. `price` is null for an order nobody ever
+ * named a price for — a product that was gone, a price question that went
+ * unanswered — and `delivered` is null while there are no goods to hand over.
+ * Left out instead, either would be a silence a reader cannot tell from an
+ * oversight; present and null, it is a fact.
+ *
+ * The status vocabulary folds several of the machine's endings into `rejected`
+ * on the argument that the reason travels separately, in the refusal code, and
+ * `refusal` is where it travels. It is optional because most endings have no
+ * refusal behind them, and what remains coarse is said in that field's own
+ * words rather than left to be discovered: a product that was gone and a
+ * payment that failed its check both still arrive as a bare `rejected`,
+ * because neither was worded by anybody.
+ */
+export declare const AgentOrderStatusSchema: z.ZodObject<{
+    order_id: z.ZodString;
+    status: z.ZodEnum<{
+        delivered: "delivered";
+        in_progress: "in_progress";
+        rejected: "rejected";
+        payment_unresolved: "payment_unresolved";
+        declined: "declined";
+        expired: "expired";
+        cancelled: "cancelled";
+        refund_due: "refund_due";
+        refunded: "refunded";
+        delivered_unpaid: "delivered_unpaid";
+    }>;
+    price: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodString;
+        currency: z.ZodString;
+        at: z.ZodISODateTime;
+        as_of: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    delivered: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    test: z.ZodBoolean;
+    refusal: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * The catalog as an agent reads it.
+ *
+ * An object rather than a bare array, so that the day it needs paging it can
+ * grow the field that says so instead of changing shape under every reader.
+ * Until then it makes no claim about completeness, and that is stated in the
+ * document itself: an agent must not read the absence of a field about paging
+ * as a promise that there is nothing more.
+ */
+export declare const CatalogPageSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        price: z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodString;
+        }, z.core.$strict>;
+        as_of: z.ZodISODateTime;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                integer: "integer";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        result: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                integer: "integer";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        price_checked_at_purchase: z.ZodBoolean;
+        fulfillment: z.ZodLiteral<"sync">;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        price: z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodString;
+        }, z.core.$strict>;
+        as_of: z.ZodISODateTime;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                integer: "integer";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        result: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                integer: "integer";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        price_checked_at_purchase: z.ZodBoolean;
+        fulfillment: z.ZodLiteral<"async">;
+        fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        price: z.ZodObject<{
+            amount: z.ZodString;
+            currency: z.ZodString;
+        }, z.core.$strict>;
+        as_of: z.ZodISODateTime;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                integer: "integer";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        result: z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                integer: "integer";
+            }>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        price_checked_at_purchase: z.ZodBoolean;
+        fulfillment: z.ZodLiteral<"confirm">;
+        confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+        fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>], "fulfillment">>;
+}, z.core.$strict>;
+/**
+ * The methods this surface uses.
+ *
+ * `DELETE` is here for the one call that removes rows rather than marking them,
+ * and it earns the third verb rather than being folded into a POST: what it
+ * does to a key is not what disabling one does, and a surface that spelled both
+ * as a POST would be inviting a reader to think it was.
+ */
+export declare const HTTP_METHODS: readonly ["GET", "POST", "DELETE"];
+export type HttpMethod = (typeof HTTP_METHODS)[number];
+/**
+ * Which door a call is behind.
+ *
+ * `merchant_key` is a key the merchant holds, sent as a bearer token; it names
+ * the merchant it belongs to, and a call behind this door acts on that
+ * merchant's cards, orders and receipts and on nobody else's. `none` is a
+ * call anybody may make — the catalog an agent browses, and the purchase,
+ * where the payment is what stands in for authorisation.
+ *
+ * `order_id` is the agent's own door and there is exactly one route behind it:
+ * knowing an order's identifier is what stands in for a key (ADR-0011). What
+ * that leans on is the identifier being generated from a random source and long
+ * enough not to be guessed — not on it being secret, which it is not. It
+ * travels in the payment challenge, on the merchant's stream and in the
+ * merchant's receipts, so the merchant who sold an order holds every identifier
+ * they would need to read one of these documents. That is why ownership of an
+ * order is settled by the verified payer and not by the identifier, and why the
+ * document behind this door carries only what the buyer is owed.
+ *
+ * It is a separate word from `none` because the two are not the same call: a
+ * route marked `none` answers everybody the same thing, and this one answers
+ * about the order the caller named and about no other. Whoever mounts it reads
+ * that difference off the word rather than out of a sentence. The weakness is
+ * stated in the decision rather than hidden: anyone who obtains an identifier
+ * can read that order, and the first real payment is the trigger to narrow it.
+ *
+ * `undecided` is not a scheme at all. It is the honest word for a route whose
+ * door nobody has chosen yet, and it exists because "I do not know" and "I
+ * know there is no door" cannot be the same value. A gateway must refuse to
+ * mount a route marked this way until somebody decides, which is exactly the
+ * behaviour wanted: the alternative is a route quietly serving everybody
+ * because `none` was the closest word to hand.
+ */
+export declare const AUTH_MODES: readonly ["merchant_key", "none", "order_id", "undecided"];
+export type AuthMode = (typeof AUTH_MODES)[number];
+/**
+ * The header the merchant's key travels in, and the two helpers that put a key
+ * into it and read one back out.
+ *
+ * `auth` above says which door a call is behind and not how the door is built,
+ * and that omission is deliberate — but how the door is built is still a thing
+ * the gateway and the SDK have to agree on exactly, because a mismatch is a call
+ * that fails with an authorisation error while both repositories look correct.
+ * They had agreed, by each writing the same two strings down apart from the
+ * other: the gateway parsed an `Authorization: Bearer` header and the SDK sent
+ * one. That is agreement by luck, and it is the very thing this table exists to
+ * remove for the addresses and the documents. So the strings live here now, in
+ * the one place both sides already import, and a change to either is a change in
+ * one file rather than a silent drift between two.
+ *
+ * The name is `authorization` and the scheme is `Bearer`. The name
+ * is lower-case because that is how a client writes a header and how the wire
+ * carries it; a reader on the gateway matches it without regard to case anyway.
+ */
+export declare const MERCHANT_KEY_HEADER = "authorization";
+/**
+ * The value of the {@link MERCHANT_KEY_HEADER} header for a given key — what the
+ * SDK sends, so that what the gateway parses is never guessed at.
+ */
+export declare const merchantKeyHeaderValue: (key: string) => string;
+/**
+ * The key inside a merchant-key header value, or null where there is not one.
+ *
+ * Null is every way the value is not a bearer token this contract issued: no
+ * header at all, another scheme, or the scheme with nothing after it. The caller
+ * is handed a key it can compare or nothing to compare, and never a half-parsed
+ * string that a constant-time comparison would then match against a prefix of
+ * the real key.
+ */
+export declare const merchantKeyFrom: (headerValue: string | undefined) => string | null;
+/**
+ * How every call on this surface says no.
+ *
+ * One shape, for every refusal of every route, whatever it is about and
+ * whatever status it arrives under: an object whose only field is `error`, and
+ * inside it a machine-readable `code` and a sentence a person can act on. It
+ * is declared here, once, rather than being described route by route — a
+ * refusal shape written down twenty-six times is a refusal shape that is
+ * already twenty-six shapes, and the one thing a caller does with every call
+ * it makes is find out whether the call was refused.
+ *
+ * Both fields are required, and the sentence is the one worth arguing for. A
+ * refusal with a code and no words is a refusal only the code's author can
+ * read: an integrator meeting it for the first time has a string to search our
+ * source for and nothing to act on, and the caller printing it has an empty
+ * space where the reason belongs. That is why this is required rather than
+ * optional, and why a refusal that carries findings — a card's problems, a
+ * body that did not fit — carries them beside the sentence rather than instead
+ * of it.
+ *
+ * Inside `error` the shape is open, and that is deliberate in both directions.
+ * A refusal may say more about itself than these two fields, and several do:
+ * where an order ended, whether the payment layer might vouch for a second
+ * attempt, which fields of a document did not fit. What no refusal may do is
+ * ride beside the envelope rather than inside it, which is why the outer
+ * object is closed: `{ "error": … }` and nothing else is how a reader tells a
+ * refusal from a document that happens to mention an error.
+ *
+ * The set of codes is open, and is not enumerated here. A gateway meets
+ * situations this contract has not named, and a closed list would leave it
+ * choosing between the nearest wrong word and no answer at all. What is
+ * promised is the shape, so that a caller can always find out that it was
+ * refused and always have something to print.
+ */
+export declare const ErrorEnvelopeSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$loose>;
+}, z.core.$strict>;
+export type ErrorEnvelope = z.infer<typeof ErrorEnvelopeSchema>;
+/**
+ * Every code this contract's gateway refuses a call with today.
+ *
+ * Named after the field it lands in — `error.code` — rather than "refusal
+ * code", which this contract already uses for something else: what a
+ * merchant's handler answers when it cannot deliver an order it was given
+ * (`RefusalCode` in `handler.ts`). Those are a merchant's words about one
+ * order; these are the surface's words about one call, and a reader who ran
+ * the two together would go looking for `out_of_stock` here.
+ *
+ * Two halves, and a consumer that takes only one of them will be wrong about
+ * this surface sooner or later.
+ *
+ * The wire is open. `ErrorEnvelopeSchema` holds `code` to a non-blank string
+ * and not to this list, deliberately and for the reason `results.ts` gives
+ * about its own codes: a situation nobody anticipated has to reach the caller
+ * in its own words rather than break the parse on the way. A gateway newer
+ * than the client, another implementation of this surface, or something
+ * standing in front of one, can all answer with a code that is not here, and
+ * the answer is still a refusal and still readable.
+ *
+ * So this list is what to switch over, not what to validate against. A
+ * consumer covers these exhaustively — the compiler tells them when the list
+ * grows — and keeps a default arm for the code it has never seen, which is not
+ * an error path: the envelope's `message` is required precisely so that arm
+ * has a sentence to show, written by the side that knows why. A consumer that
+ * refused an unknown code, or rendered nothing for it, would turn a version
+ * skew into a blank screen over a refusal the gateway explained perfectly
+ * well.
+ *
+ * The list is alphabetical because it is looked up rather than read through,
+ * and it is the codes and not their meanings: what each one means to whoever
+ * has to act on it belongs to the route that sends it and to the sentence the
+ * refusal carries.
+ */
+export declare const ERROR_CODES: readonly ["body_too_large", "body_undecodable", "call_refused", "charset_unsupported", "encoding_unsupported", "gateway_failed", "key_made_for_a_cabinet", "key_opened_this_call", "malformed_body", "malformed_query", "merchant_departed", "no_such_item", "no_such_key", "no_such_order", "no_such_route", "not_a_cabinet_key", "not_authorised", "not_invited", "not_selling", "not_this_purchase", "order_closed_before_it_was_priced", "order_not_priced_yet", "params_do_not_fit", "payment_already_spent", "payment_not_taken", "payment_not_verified"];
+/** One of the codes this gateway is known to refuse a call with. */
+export type ErrorCode = (typeof ERROR_CODES)[number];
+/**
+ * What a call answers with when it works.
+ *
+ * One document per route, always — how a call says no is not written here, it
+ * is {@link ErrorEnvelopeSchema} and it is the same for all of them. The
+ * purchase used to be the exception, on the grounds that it is a payment
+ * exchange before it is a document; it names a document now, and the exchange
+ * that precedes it is described in that route's own words. A route that
+ * genuinely cannot name one is a change to this type, made deliberately,
+ * rather than a field somebody left out.
+ */
+export interface RouteResponse {
+    readonly document: z.ZodType;
+}
+export interface RouteDefinition {
+    /** The method the call is made with, and the only one that carries the body. */
+    readonly method: HttpMethod;
+    /** The address, with path parameters written the way a router writes them. */
+    readonly path: string;
+    readonly auth: AuthMode;
+    /** What the call is for, and anything about it the shapes cannot carry. */
+    readonly description: string;
+    /** What the query string may carry, where a call takes one. */
+    readonly query?: z.ZodType;
+    /** The body, where a call has one. */
+    readonly request?: z.ZodType;
+    readonly response: RouteResponse;
+    /**
+     * Other methods this address has to answer on, where something outside our
+     * design requires it.
+     *
+     * One route has this and the reason has already been paid for once: the
+     * validators and crawlers that list a paid resource ask for it with GET, and
+     * a paywall bound to a single method makes the resource invisible to them.
+     * It is a field rather than a sentence in the description because a gateway
+     * mounts from data, and a sentence would be mounted by nobody.
+     *
+     * These methods carry no body. Whatever `request` names travels on `method`
+     * and on nothing else.
+     */
+    readonly also_answers_on?: readonly HttpMethod[];
+}
+/**
+ * Every call of the surface, under the name it is known by in both programs.
+ *
+ * The name is the key, so two routes cannot share one; a test holds the rest —
+ * that no two sit at one address under one method, and that every schema named
+ * here is one the contract registry publishes, since the registry and this
+ * table are the whole of what a reader outside TypeScript has.
+ *
+ * Two prefixes are in this table and they are two different kinds of address.
+ * `/v0` is the merchant's API, and it is versioned for the ordinary reason a
+ * classic API is: an integrator writes code against it, and the number is what
+ * lets that code keep working while the shapes underneath it change. `/x402` is
+ * the storefront — the catalog an agent browses, the address it buys at, and
+ * the door it comes back to for its own order — and it carries no version at
+ * all. Those three addresses are not something an integrator holds in a client
+ * library; they are a product identity. A discovery catalog keys a listing on
+ * the address it was given, strangers' agents construct them from a base and an
+ * identifier, and both of those outlive any dialect we speak. So the protocol
+ * versions where the protocol can be read — the `x402Version` field inside the
+ * challenge — and the address stays put. A version segment in a storefront path
+ * would be a promise to keep every old segment answering forever, made to
+ * catalogs we do not run.
+ *
+ * Which door a call is behind is still `auth` and never the prefix. The two
+ * happen to agree today, and a reader who took that for the rule would mount
+ * the next route by its address; `apps/gateway/src/http/server.ts` says what
+ * that costs.
+ */
+export declare const API_ROUTES: Readonly<{
+    publish_card: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodObject<{
+            merchant_item_id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            price: z.ZodPreprocess<z.ZodObject<{
+                amount: z.ZodString;
+                currency: z.ZodString;
+            }, z.core.$strict>>;
+            params: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    integer: "integer";
+                }>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                title: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>>;
+            result: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    integer: "integer";
+                }>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                title: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fulfillment: z.ZodDefault<z.ZodEnum<{
+                sync: "sync";
+                async: "async";
+                confirm: "confirm";
+            }>>;
+            price_check: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"handler">, z.ZodObject<{
+                url: z.ZodURL;
+            }, z.core.$strict>]>>;
+            confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+            fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+                id: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                error: z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    retryable: z.ZodBoolean;
+                    problems: z.ZodArray<z.ZodObject<{
+                        path: z.ZodArray<z.ZodString>;
+                        code: z.ZodString;
+                        message: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "ok">;
+        };
+    };
+    list_merchant_cards: {
+        method: "GET";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                selling: z.ZodEnum<{
+                    open: "open";
+                    paused: "paused";
+                    departed: "departed";
+                }>;
+                cards: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    as_of: z.ZodISODateTime;
+                    card: z.ZodObject<{
+                        merchant_item_id: z.ZodString;
+                        title: z.ZodString;
+                        description: z.ZodString;
+                        price: z.ZodPreprocess<z.ZodObject<{
+                            amount: z.ZodString;
+                            currency: z.ZodString;
+                        }, z.core.$strict>>;
+                        params: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            type: z.ZodEnum<{
+                                string: "string";
+                                number: "number";
+                                boolean: "boolean";
+                                integer: "integer";
+                            }>;
+                            required: z.ZodOptional<z.ZodBoolean>;
+                            title: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>>;
+                        result: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            type: z.ZodEnum<{
+                                string: "string";
+                                number: "number";
+                                boolean: "boolean";
+                                integer: "integer";
+                            }>;
+                            required: z.ZodOptional<z.ZodBoolean>;
+                            title: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>;
+                        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        fulfillment: z.ZodDefault<z.ZodEnum<{
+                            sync: "sync";
+                            async: "async";
+                            confirm: "confirm";
+                        }>>;
+                        price_check: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"handler">, z.ZodObject<{
+                            url: z.ZodURL;
+                        }, z.core.$strict>]>>;
+                        confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                        fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                    }, z.core.$strict>;
+                    selling: z.ZodEnum<{
+                        open: "open";
+                        paused: "paused";
+                        departed: "departed";
+                    }>;
+                    paused: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        };
+    };
+    pause_card: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                id: z.ZodString;
+                as_of: z.ZodISODateTime;
+                card: z.ZodObject<{
+                    merchant_item_id: z.ZodString;
+                    title: z.ZodString;
+                    description: z.ZodString;
+                    price: z.ZodPreprocess<z.ZodObject<{
+                        amount: z.ZodString;
+                        currency: z.ZodString;
+                    }, z.core.$strict>>;
+                    params: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>>;
+                    result: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    fulfillment: z.ZodDefault<z.ZodEnum<{
+                        sync: "sync";
+                        async: "async";
+                        confirm: "confirm";
+                    }>>;
+                    price_check: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"handler">, z.ZodObject<{
+                        url: z.ZodURL;
+                    }, z.core.$strict>]>>;
+                    confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                    fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                }, z.core.$strict>;
+                selling: z.ZodEnum<{
+                    open: "open";
+                    paused: "paused";
+                    departed: "departed";
+                }>;
+                paused: z.ZodBoolean;
+            }, z.core.$strict>;
+        };
+    };
+    resume_card: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                id: z.ZodString;
+                as_of: z.ZodISODateTime;
+                card: z.ZodObject<{
+                    merchant_item_id: z.ZodString;
+                    title: z.ZodString;
+                    description: z.ZodString;
+                    price: z.ZodPreprocess<z.ZodObject<{
+                        amount: z.ZodString;
+                        currency: z.ZodString;
+                    }, z.core.$strict>>;
+                    params: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>>;
+                    result: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    fulfillment: z.ZodDefault<z.ZodEnum<{
+                        sync: "sync";
+                        async: "async";
+                        confirm: "confirm";
+                    }>>;
+                    price_check: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"handler">, z.ZodObject<{
+                        url: z.ZodURL;
+                    }, z.core.$strict>]>>;
+                    confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                    fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                }, z.core.$strict>;
+                selling: z.ZodEnum<{
+                    open: "open";
+                    paused: "paused";
+                    departed: "departed";
+                }>;
+                paused: z.ZodBoolean;
+            }, z.core.$strict>;
+        };
+    };
+    pause_selling: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                selling: z.ZodEnum<{
+                    open: "open";
+                    paused: "paused";
+                    departed: "departed";
+                }>;
+                cards: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    as_of: z.ZodISODateTime;
+                    card: z.ZodObject<{
+                        merchant_item_id: z.ZodString;
+                        title: z.ZodString;
+                        description: z.ZodString;
+                        price: z.ZodPreprocess<z.ZodObject<{
+                            amount: z.ZodString;
+                            currency: z.ZodString;
+                        }, z.core.$strict>>;
+                        params: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            type: z.ZodEnum<{
+                                string: "string";
+                                number: "number";
+                                boolean: "boolean";
+                                integer: "integer";
+                            }>;
+                            required: z.ZodOptional<z.ZodBoolean>;
+                            title: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>>;
+                        result: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            type: z.ZodEnum<{
+                                string: "string";
+                                number: "number";
+                                boolean: "boolean";
+                                integer: "integer";
+                            }>;
+                            required: z.ZodOptional<z.ZodBoolean>;
+                            title: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>;
+                        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        fulfillment: z.ZodDefault<z.ZodEnum<{
+                            sync: "sync";
+                            async: "async";
+                            confirm: "confirm";
+                        }>>;
+                        price_check: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"handler">, z.ZodObject<{
+                            url: z.ZodURL;
+                        }, z.core.$strict>]>>;
+                        confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                        fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                    }, z.core.$strict>;
+                    selling: z.ZodEnum<{
+                        open: "open";
+                        paused: "paused";
+                        departed: "departed";
+                    }>;
+                    paused: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        };
+    };
+    resume_selling: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                selling: z.ZodEnum<{
+                    open: "open";
+                    paused: "paused";
+                    departed: "departed";
+                }>;
+                cards: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    as_of: z.ZodISODateTime;
+                    card: z.ZodObject<{
+                        merchant_item_id: z.ZodString;
+                        title: z.ZodString;
+                        description: z.ZodString;
+                        price: z.ZodPreprocess<z.ZodObject<{
+                            amount: z.ZodString;
+                            currency: z.ZodString;
+                        }, z.core.$strict>>;
+                        params: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            type: z.ZodEnum<{
+                                string: "string";
+                                number: "number";
+                                boolean: "boolean";
+                                integer: "integer";
+                            }>;
+                            required: z.ZodOptional<z.ZodBoolean>;
+                            title: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>>;
+                        result: z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            type: z.ZodEnum<{
+                                string: "string";
+                                number: "number";
+                                boolean: "boolean";
+                                integer: "integer";
+                            }>;
+                            required: z.ZodOptional<z.ZodBoolean>;
+                            title: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>>>;
+                        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        fulfillment: z.ZodDefault<z.ZodEnum<{
+                            sync: "sync";
+                            async: "async";
+                            confirm: "confirm";
+                        }>>;
+                        price_check: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"handler">, z.ZodObject<{
+                            url: z.ZodURL;
+                        }, z.core.$strict>]>>;
+                        confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                        fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                    }, z.core.$strict>;
+                    selling: z.ZodEnum<{
+                        open: "open";
+                        paused: "paused";
+                        departed: "departed";
+                    }>;
+                    paused: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        };
+    };
+    register_merchant: {
+        method: "POST";
+        path: string;
+        auth: "none";
+        description: string;
+        request: z.ZodObject<{
+            invitation: z.ZodString;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodObject<{
+                merchant_id: z.ZodString;
+                secret: z.ZodString;
+            }, z.core.$strict>;
+        };
+    };
+    get_seller_name: {
+        method: "GET";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                seller_name: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        };
+    };
+    set_seller_name: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodObject<{
+            seller_name: z.ZodPipe<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodObject<{
+                seller_name: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        };
+    };
+    get_payout_wallet: {
+        method: "GET";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                payout_wallet: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        };
+    };
+    set_payout_wallet: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodObject<{
+            payout_wallet: z.ZodPipe<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodObject<{
+                payout_wallet: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        };
+    };
+    list_keys: {
+        method: "GET";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                keys: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    created_at: z.ZodISODateTime;
+                    last_used_at: z.ZodNullable<z.ZodISODateTime>;
+                    disabled_at: z.ZodNullable<z.ZodISODateTime>;
+                }, z.core.$strict>>;
+                this_call: z.ZodString;
+            }, z.core.$strict>;
+        };
+    };
+    issue_key: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodObject<{
+            label: z.ZodString;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodObject<{
+                key: z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    created_at: z.ZodISODateTime;
+                    last_used_at: z.ZodNullable<z.ZodISODateTime>;
+                    disabled_at: z.ZodNullable<z.ZodISODateTime>;
+                }, z.core.$strict>;
+                secret: z.ZodString;
+            }, z.core.$strict>;
+        };
+    };
+    disable_key: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                key: z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    created_at: z.ZodISODateTime;
+                    last_used_at: z.ZodNullable<z.ZodISODateTime>;
+                    disabled_at: z.ZodNullable<z.ZodISODateTime>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        };
+    };
+    issue_cabinet_key: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                secret: z.ZodString;
+            }, z.core.$strict>;
+        };
+    };
+    forget_cabinet_key: {
+        method: "DELETE";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                forgotten: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+        };
+    };
+    get_order: {
+        method: "GET";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                id: z.ZodString;
+                merchant_item_id: z.ZodString;
+                params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                price: z.ZodObject<{
+                    amount: z.ZodString;
+                    currency: z.ZodString;
+                    at: z.ZodISODateTime;
+                    as_of: z.ZodISODateTime;
+                }, z.core.$strict>;
+                price_id: z.ZodOptional<z.ZodString>;
+                test: z.ZodBoolean;
+                status: z.ZodEnum<{
+                    delivered: "delivered";
+                    in_progress: "in_progress";
+                    rejected: "rejected";
+                    payment_unresolved: "payment_unresolved";
+                    declined: "declined";
+                    expired: "expired";
+                    cancelled: "cancelled";
+                    refund_due: "refund_due";
+                    refunded: "refunded";
+                    delivered_unpaid: "delivered_unpaid";
+                }>;
+            }, z.core.$strict>;
+        };
+    };
+    list_orders: {
+        method: "GET";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        query: z.ZodObject<{
+            open: z.ZodOptional<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodObject<{
+                orders: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    merchant_item_id: z.ZodString;
+                    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    price: z.ZodObject<{
+                        amount: z.ZodString;
+                        currency: z.ZodString;
+                        at: z.ZodISODateTime;
+                        as_of: z.ZodISODateTime;
+                    }, z.core.$strict>;
+                    price_id: z.ZodOptional<z.ZodString>;
+                    test: z.ZodBoolean;
+                    status: z.ZodEnum<{
+                        delivered: "delivered";
+                        in_progress: "in_progress";
+                        rejected: "rejected";
+                        payment_unresolved: "payment_unresolved";
+                        declined: "declined";
+                        expired: "expired";
+                        cancelled: "cancelled";
+                        refund_due: "refund_due";
+                        refunded: "refunded";
+                        delivered_unpaid: "delivered_unpaid";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        };
+    };
+    list_receipts: {
+        method: "GET";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                receipts: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    order_id: z.ZodString;
+                    item_id: z.ZodString;
+                    price: z.ZodObject<{
+                        amount: z.ZodString;
+                        currency: z.ZodString;
+                        at: z.ZodISODateTime;
+                        as_of: z.ZodISODateTime;
+                    }, z.core.$strict>;
+                    price_id: z.ZodOptional<z.ZodString>;
+                    paid_at: z.ZodISODateTime;
+                    outcome: z.ZodEnum<{
+                        delivered: "delivered";
+                        in_progress: "in_progress";
+                        refund_due: "refund_due";
+                        refunded: "refunded";
+                    }>;
+                    test: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        };
+    };
+    poll_worker: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodObject<{
+            wait_seconds: z.ZodOptional<z.ZodInt>;
+            max: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodObject<{
+                contract_version: z.ZodString;
+                envelopes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"order">;
+                    id: z.ZodString;
+                    sent_at: z.ZodISODateTime;
+                    payload: z.ZodObject<{
+                        id: z.ZodString;
+                        merchant_item_id: z.ZodString;
+                        params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        price: z.ZodObject<{
+                            amount: z.ZodString;
+                            currency: z.ZodString;
+                            at: z.ZodISODateTime;
+                            as_of: z.ZodISODateTime;
+                        }, z.core.$strict>;
+                        price_id: z.ZodOptional<z.ZodString>;
+                        test: z.ZodBoolean;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"quote_request">;
+                    id: z.ZodString;
+                    sent_at: z.ZodISODateTime;
+                    payload: z.ZodObject<{
+                        merchant_item_id: z.ZodString;
+                        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        price_id: z.ZodString;
+                        purpose: z.ZodEnum<{
+                            purchase: "purchase";
+                            poll: "poll";
+                        }>;
+                        expires_at: z.ZodISODateTime;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"order_event">;
+                    id: z.ZodString;
+                    sent_at: z.ZodISODateTime;
+                    payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"order.refund_due">;
+                        order_id: z.ZodString;
+                        at: z.ZodISODateTime;
+                        price: z.ZodObject<{
+                            amount: z.ZodString;
+                            currency: z.ZodString;
+                        }, z.core.$strict>;
+                        reason: z.ZodEnum<{
+                            refused: "refused";
+                            deadline_passed: "deadline_passed";
+                            merchant_left: "merchant_left";
+                        }>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"order.unpaid_after_confirmation">;
+                        order_id: z.ZodString;
+                        at: z.ZodISODateTime;
+                    }, z.core.$strict>, z.ZodObject<{
+                        type: z.ZodLiteral<"order.payment_failed_after_delivery">;
+                        order_id: z.ZodString;
+                        at: z.ZodISODateTime;
+                    }, z.core.$strict>], "type">;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>;
+        };
+    };
+    answer_order: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodUnion<readonly [z.ZodObject<{
+            delivered: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            refused: z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            accepted: z.ZodObject<{
+                eta_seconds: z.ZodOptional<z.ZodInt>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        response: {
+            document: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+                result: z.ZodEnum<{
+                    refused: "refused";
+                    delivered: "delivered";
+                    accepted: "accepted";
+                    already_delivered: "already_delivered";
+                    debt_closed_by_delivery: "debt_closed_by_delivery";
+                    purchase_already_closed: "purchase_already_closed";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                error: z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    retryable: z.ZodBoolean;
+                    problems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        path: z.ZodArray<z.ZodString>;
+                        code: z.ZodString;
+                        message: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "ok">;
+        };
+    };
+    deliver_order: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        response: {
+            document: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+                result: z.ZodEnum<{
+                    refused: "refused";
+                    delivered: "delivered";
+                    accepted: "accepted";
+                    already_delivered: "already_delivered";
+                    debt_closed_by_delivery: "debt_closed_by_delivery";
+                    purchase_already_closed: "purchase_already_closed";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                error: z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    retryable: z.ZodBoolean;
+                    problems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        path: z.ZodArray<z.ZodString>;
+                        code: z.ZodString;
+                        message: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "ok">;
+        };
+    };
+    refuse_order: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+                result: z.ZodEnum<{
+                    refused: "refused";
+                    delivered: "delivered";
+                    accepted: "accepted";
+                    already_delivered: "already_delivered";
+                    debt_closed_by_delivery: "debt_closed_by_delivery";
+                    purchase_already_closed: "purchase_already_closed";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                error: z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    retryable: z.ZodBoolean;
+                    problems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        path: z.ZodArray<z.ZodString>;
+                        code: z.ZodString;
+                        message: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "ok">;
+        };
+    };
+    accept_order: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodObject<{
+            eta_seconds: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>;
+        response: {
+            document: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+            }, z.core.$strict>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                error: z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                    retryable: z.ZodBoolean;
+                    problems: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        path: z.ZodArray<z.ZodString>;
+                        code: z.ZodString;
+                        message: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "ok">;
+        };
+    };
+    answer_quote: {
+        method: "POST";
+        path: string;
+        auth: "merchant_key";
+        description: string;
+        request: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            available: z.ZodLiteral<true>;
+            price: z.ZodObject<{
+                amount: z.ZodString;
+                currency: z.ZodString;
+            }, z.core.$strict>;
+            as_of: z.ZodISODateTime;
+        }, z.core.$strict>, z.ZodObject<{
+            available: z.ZodLiteral<false>;
+            as_of: z.ZodISODateTime;
+        }, z.core.$strict>], "available">;
+        response: {
+            document: z.ZodObject<{
+                used: z.ZodBoolean;
+            }, z.core.$strict>;
+        };
+    };
+    list_catalog: {
+        method: "GET";
+        path: string;
+        auth: "none";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    title: z.ZodString;
+                    description: z.ZodString;
+                    price: z.ZodObject<{
+                        amount: z.ZodString;
+                        currency: z.ZodString;
+                    }, z.core.$strict>;
+                    as_of: z.ZodISODateTime;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    result: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    price_checked_at_purchase: z.ZodBoolean;
+                    fulfillment: z.ZodLiteral<"sync">;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    title: z.ZodString;
+                    description: z.ZodString;
+                    price: z.ZodObject<{
+                        amount: z.ZodString;
+                        currency: z.ZodString;
+                    }, z.core.$strict>;
+                    as_of: z.ZodISODateTime;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    result: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    price_checked_at_purchase: z.ZodBoolean;
+                    fulfillment: z.ZodLiteral<"async">;
+                    fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    title: z.ZodString;
+                    description: z.ZodString;
+                    price: z.ZodObject<{
+                        amount: z.ZodString;
+                        currency: z.ZodString;
+                    }, z.core.$strict>;
+                    as_of: z.ZodISODateTime;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    result: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            integer: "integer";
+                        }>;
+                        required: z.ZodOptional<z.ZodBoolean>;
+                        title: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    price_checked_at_purchase: z.ZodBoolean;
+                    fulfillment: z.ZodLiteral<"confirm">;
+                    confirm_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                    fulfill_deadline_seconds: z.ZodOptional<z.ZodInt>;
+                }, z.core.$strict>], "fulfillment">>;
+            }, z.core.$strict>;
+        };
+    };
+    purchase_item: {
+        method: "POST";
+        path: string;
+        auth: "none";
+        description: string;
+        request: z.ZodObject<{
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>;
+        also_answers_on: "GET"[];
+        response: {
+            document: z.ZodObject<{
+                order_id: z.ZodString;
+                status: z.ZodEnum<{
+                    delivered: "delivered";
+                    in_progress: "in_progress";
+                    rejected: "rejected";
+                    payment_unresolved: "payment_unresolved";
+                    declined: "declined";
+                    expired: "expired";
+                    cancelled: "cancelled";
+                    refund_due: "refund_due";
+                    refunded: "refunded";
+                    delivered_unpaid: "delivered_unpaid";
+                }>;
+                price: z.ZodNullable<z.ZodObject<{
+                    amount: z.ZodString;
+                    currency: z.ZodString;
+                    at: z.ZodISODateTime;
+                    as_of: z.ZodISODateTime;
+                }, z.core.$strict>>;
+                delivered: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                test: z.ZodBoolean;
+                refusal: z.ZodOptional<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        };
+    };
+    get_order_status: {
+        method: "GET";
+        path: string;
+        auth: "order_id";
+        description: string;
+        response: {
+            document: z.ZodObject<{
+                order_id: z.ZodString;
+                status: z.ZodEnum<{
+                    delivered: "delivered";
+                    in_progress: "in_progress";
+                    rejected: "rejected";
+                    payment_unresolved: "payment_unresolved";
+                    declined: "declined";
+                    expired: "expired";
+                    cancelled: "cancelled";
+                    refund_due: "refund_due";
+                    refunded: "refunded";
+                    delivered_unpaid: "delivered_unpaid";
+                }>;
+                price: z.ZodNullable<z.ZodObject<{
+                    amount: z.ZodString;
+                    currency: z.ZodString;
+                    at: z.ZodISODateTime;
+                    as_of: z.ZodISODateTime;
+                }, z.core.$strict>>;
+                delivered: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                test: z.ZodBoolean;
+                refusal: z.ZodOptional<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        };
+    };
+}>;
+/** The name of one call in the table. */
+export type RouteName = keyof typeof API_ROUTES;
+/** The parameters an address takes, in the order it writes them. */
+export declare const pathParamsOf: (path: string) => string[];
+/**
+ * The address of one call, with its parameters filled in and encoded.
+ *
+ * Encoding is the reason this is not left to the caller. An identifier in this
+ * contract may hold a slash and a space — "SKU 100/1" is one we accept — and
+ * concatenated into a path unencoded it becomes two segments and a different
+ * route.
+ *
+ * A missing value and a value for a parameter the address does not take are
+ * both refused, and both are refused by throwing rather than by returning
+ * something. Everything this package returns rather than throws is a condition
+ * a consumer is expected to handle; this is not one of those. An address built
+ * with a hole in it is a bug in the caller, and the request it would send
+ * reads in a log as a route that exists and answers nothing to anybody.
+ *
+ * Three refusals are less obvious and each is a way an address stops being the
+ * one that was meant. A value is looked up with `Object.hasOwn`, because a
+ * parameter named `constructor` would otherwise find something on the
+ * prototype and expand into the source of a function. A value of "." or ".."
+ * is refused, because a relative-URL resolver walks it and the request lands
+ * somewhere else entirely. And a value that is not a string is refused rather
+ * than stringified: `null` would otherwise become the four letters that spell
+ * it, and the SDK is not always the one holding the types.
+ */
+export declare const expandPath: (path: string, values: Readonly<Record<string, string>>) => string;
+/**
+ * The routes a gateway may serve: every route whose door somebody has chosen.
+ *
+ * It exists because the natural way to mount a table is to ask whether a route
+ * needs the merchant key and to treat everything else as open — and that
+ * reading serves a route nobody has chosen a door for to the whole world.
+ * Mounting from this list instead makes the safe reading the easy one, and a
+ * route appears here the day its door is decided.
+ *
+ * Every route in the table has a door today, so this list is the whole of it.
+ * That is a fact about the table and not a reason to mount from `API_ROUTES`
+ * directly: the next route to be written down before it is designed is exactly
+ * the one this filter is for.
+ */
+export declare const mountableRoutes: () => [RouteName, RouteDefinition][];
+export type OrderWithStatus = z.infer<typeof OrderWithStatusSchema>;
+export type OrderList = z.infer<typeof OrderListSchema>;
+export type MerchantCardList = z.infer<typeof MerchantCardListSchema>;
+export type ReceiptList = z.infer<typeof ReceiptListSchema>;
+export type OrderListQuery = z.infer<typeof OrderListQuerySchema>;
+export type WorkerPollRequest = z.infer<typeof WorkerPollRequestSchema>;
+export type WorkerPollResponse = z.infer<typeof WorkerPollResponseSchema>;
+export type OrderCallResponse = z.infer<typeof OrderCallResponseSchema>;
+export type OrderAcceptResponse = z.infer<typeof OrderAcceptResponseSchema>;
+export type QuoteAnswerAck = z.infer<typeof QuoteAnswerAckSchema>;
+export type PurchaseRequest = z.infer<typeof PurchaseRequestSchema>;
+export type AgentOrderStatus = z.infer<typeof AgentOrderStatusSchema>;
+export type CatalogPage = z.infer<typeof CatalogPageSchema>;