@greatwait/contracts 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/operations.d.ts

@@ -161,6 +161,15 @@ export interface OperationDefinition {
      * scopes every call needs. Generators publish them for consent clients.
      */
     readonly conditionalScopes?: readonly Scope[];
+    /**
+     * When `conditionalScopes` apply, as the clause the published description
+     * ends with ("… is required as well when …"). Absent means the original
+     * case: a target the caller did not create. W9-44 added the second case — a
+     * schedule write naming a `url` with no endpoint behind it — and a document
+     * describing it with the credential wording would send an integrator
+     * looking for somebody else's resource.
+     */
+    readonly conditionalScopesWhen?: string;
     /** Problem codes this operation may return, beyond the universal ones. */
     readonly problems: readonly ProblemCode[];
     /**
@@ -275,20 +284,224 @@ type BillingFundingContract = {
 type NamedOperation<TId extends string> = OperationDefinition & {
     readonly id: TId;
 };
-export declare const OPERATIONS: readonly [OperationDefinition & {
+export declare const OPERATIONS: readonly [{
+    readonly creates: false;
+    readonly description: "" | "Read the verified organization's execution-credit payments with bounded cursor continuation. Existing recent-history responses remain compatible.";
+    readonly example: {
+        data?: never;
+        freshness?: never;
+    } | {
+        data: never[];
+        freshness: {
+            kind: string;
+        };
+    };
+    readonly id: "billing.paymenthistory";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "GET";
+    readonly mutates: false;
+    readonly path: "/v1/billing/payment-history";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["invalid_request", "service_unavailable"];
+    readonly query: import("zod").ZodObject<{
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    readonly response: import("zod").ZodObject<{
+        data: import("zod").ZodArray<import("zod").ZodObject<{
+            createdAt: import("zod").ZodString;
+            credit: import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>;
+            gross: import("zod").ZodNullable<import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>>;
+            id: import("zod").ZodString;
+            kind: import("zod").ZodEnum<{
+                manual: "manual";
+                automatic: "automatic";
+            }>;
+            paymentUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            receiptUrl: import("zod").ZodOptional<import("zod").ZodString>;
+            state: import("zod").ZodEnum<{
+                pending: "pending";
+                paid: "paid";
+                failed: "failed";
+                "authentication-required": "authentication-required";
+                "action-required": "action-required";
+                canceled: "canceled";
+                refunded: "refunded";
+                reversed: "reversed";
+                disputed: "disputed";
+            }>;
+            tax: import("zod").ZodNullable<import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>>;
+            taxStatus: import("zod").ZodEnum<{
+                confirmed: "confirmed";
+                "calculated-at-checkout": "calculated-at-checkout";
+            }>;
+            updatedAt: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        freshness: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"authoritative">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            asOf: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"projected">;
+            lagSeconds: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>], "kind">;
+        nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict> | import("zod").ZodNever;
+    readonly scopes: readonly ["usage:read"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Page execution-credit payments";
+    readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Read the verified organization's project subscription invoices with bounded cursor continuation. Existing recent-history responses remain compatible.";
+    readonly example: {
+        data?: never;
+        freshness?: never;
+    } | {
+        data: never[];
+        freshness: {
+            kind: string;
+        };
+    };
+    readonly id: "billing.invoicehistory";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "GET";
+    readonly mutates: false;
+    readonly path: "/v1/billing/invoice-history";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["invalid_request", "service_unavailable"];
+    readonly query: import("zod").ZodObject<{
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    readonly response: import("zod").ZodObject<{
+        data: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            createdAt: import("zod").ZodString;
+            amount: import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>;
+            state: import("zod").ZodEnum<{
+                void: "void";
+                paid: "paid";
+                open: "open";
+                uncollectible: "uncollectible";
+            }>;
+            receiptUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>>;
+        freshness: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"authoritative">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            asOf: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"projected">;
+            lagSeconds: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>], "kind">;
+        nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict> | import("zod").ZodNever;
+    readonly scopes: readonly ["usage:read"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Page project subscription invoices";
+    readonly surfaces: readonly ["api", "mock"];
+}, OperationDefinition & {
     readonly id: "exports.create";
+} & {
+    readonly request: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
 }, OperationDefinition & {
     readonly id: "exports.read";
 }, OperationDefinition & {
     readonly id: "exports.part";
 }, OperationDefinition & {
     readonly id: "exports.cancel";
+}, OperationDefinition & {
+    readonly id: "members.list";
+}, OperationDefinition & {
+    readonly id: "invitations.list";
+}, OperationDefinition & {
+    readonly id: "invitations.create";
+} & {
+    readonly request: import("zod").ZodObject<{
+        email: import("zod").ZodString;
+        role: import("zod").ZodEnum<{
+            admin: "admin";
+            member: "member";
+        }>;
+        projects: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+}, OperationDefinition & {
+    readonly id: "invitations.resend";
+} & {
+    readonly request: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+}, OperationDefinition & {
+    readonly id: "invitations.revoke";
+} & {
+    readonly request: import("zod").ZodObject<{
+        confirmed: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strict>;
+}, OperationDefinition & {
+    readonly id: "members.role";
+} & {
+    readonly request: import("zod").ZodObject<{
+        role: import("zod").ZodEnum<{
+            admin: "admin";
+            member: "member";
+        }>;
+    }, import("zod/v4/core").$strict>;
+}, OperationDefinition & {
+    readonly id: "members.remove";
+} & {
+    readonly request: import("zod").ZodObject<{
+        confirmed: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strict>;
+}, OperationDefinition & {
+    readonly id: "projectmembers.add";
+} & {
+    readonly request: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
+}, OperationDefinition & {
+    readonly id: "projectmembers.remove";
+} & {
+    readonly request: import("zod").ZodObject<{
+        confirmed: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strict>;
 }, OperationDefinition & {
     readonly id: "organizations.lifecycle";
 }, OperationDefinition & {
     readonly id: "organizations.close";
+} & {
+    readonly request: import("zod").ZodObject<{
+        expectedGeneration: import("zod").ZodNumber;
+        immediate: import("zod").ZodBoolean;
+        confirmation: import("zod").ZodLiteral<"delete organization">;
+    }, import("zod/v4/core").$strict>;
 }, OperationDefinition & {
     readonly id: "organizations.restore";
+} & {
+    readonly request: import("zod").ZodObject<{
+        expectedGeneration: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
 }, {
     readonly creates: false;
     readonly description: "" | "Reports the service, environment, and build the request reached. Unauthenticated: it carries no customer data and is used by canaries and deployment smoke checks.";
@@ -443,7 +656,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly surfaces: readonly ["mock"];
 }, {
     readonly creates: true;
-    readonly description: "" | "Creates a reusable callback endpoint in the caller's project and environment. The destination must be HTTPS on effective port 443, contain no URL credentials or fragment, and resolve only to public unicast addresses. The endpoint is active and usable the moment it exists; there is nothing to verify. A disabled endpoint is never delivered to, and a schedule write naming one answers not_found, because disabling is terminal rather than a state to recover from. The per-endpoint secret is returned in this response and nowhere else. The 50-record safety ceiling includes disabled endpoints because they remain readable for audit.";
+    readonly description: "" | "Creates a reusable callback endpoint in the caller's project and environment. The destination must be HTTPS on effective port 443, contain no URL credentials or fragment, and resolve only to public unicast addresses. The endpoint is active and usable the moment it exists; there is nothing to verify. A disabled endpoint is never delivered to, and a schedule write naming one answers not_found, because disabling is terminal rather than a state to recover from. The per-endpoint secret is returned to this call and to no other call an API credential or an OAuth token can make; a signed-in member can read it again through endpoints.revealSigningSecret. There is no endpoint-count ceiling. Disabled endpoints remain readable for audit; request and DNS inspection admission bound creation work and reads are paged. Optional `headers` set reusable defaults. Ordinary values remain readable; `secret: true` encrypts a write-only value that is never returned. Header edits use explicit `set`, `keep`, and `remove` actions.";
     readonly example: {
         createdAt?: never;
         environmentKind?: never;
@@ -477,7 +690,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly idempotent: false;
     readonly mcp: {
         readonly kind: "unavailable";
-        readonly reason: "Creation returns a one-time endpoint signing secret, and MCP has no negotiated secure-result channel that can keep it out of ordinary tool history.";
+        readonly reason: "Creation returns a one-time endpoint signing secret, and MCP has no negotiated secure-result channel that can keep it out of ordinary tool history. Agents use endpoints_ensure, or schedules_create with a `url`, which create an endpoint without returning its secret.";
     };
     readonly method: "POST";
     readonly mutates: true;
@@ -485,6 +698,21 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["state_conflict", "invalid_request", "plan_limit_reached", "rate_limited"];
     readonly request: import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"set">;
+            name: import("zod").ZodString;
+            value: import("zod").ZodString;
+            secret: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"keep">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"remove">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"suppress">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>], "action">>>;
         name: import("zod").ZodOptional<import("zod").ZodString>;
         url: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
@@ -494,6 +722,19 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         url: string;
     };
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
         createdAt: import("zod").ZodString;
         disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
         environmentKind: import("zod").ZodEnum<{
@@ -526,6 +767,127 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly sessionAuthority: "headers";
     readonly summary: "" | "Create a callback endpoint";
     readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Finds or creates the callback endpoint at a URL in the caller's project and environment, without returning its signing secret. With no `name`, an existing endpoint that is not disabled at exactly this address is returned unchanged, preferring the one named after its URL; with a `name`, the endpoint must also carry that name. Otherwise one is created under the same rules as endpoints.create — HTTPS on effective port 443, no URL credentials or fragment, resolving only to public unicast addresses — and `created` is true. Optional `headers` apply only to an endpoint this call creates. Sent when the endpoint already exists, they are accepted if they are exactly its ordinary headers — what a retry of the creating call sends — and otherwise refused as `state_conflict` naming it; endpoints.update changes them. A secret value cannot be compared, so a call carrying one is refused for an endpoint that already exists. The result is metadata only: `signingSecret` says that the secret is not returned and where a signed-in member reveals it (`revealUrl`, the endpoint's dashboard page). Every callback is signed with that secret whether or not the receiver checks it. This is the endpoint operation agents use over MCP; endpoints.create, which returns the secret once, is withheld there.";
+    readonly example: {
+        created?: never;
+        createdAt?: never;
+        environmentKind?: never;
+        id?: never;
+        name?: never;
+        project?: never;
+        signingKeys?: never;
+        signingSecret?: never;
+        status?: never;
+        updatedAt?: never;
+        url?: never;
+        version?: never;
+    } | {
+        created: boolean;
+        createdAt: string;
+        environmentKind: string;
+        id: string;
+        name: string;
+        project: string;
+        signingKeys: {
+            current: string;
+        };
+        signingSecret: {
+            guidance: string;
+            returned: boolean;
+            revealUrl: string;
+        };
+        status: string;
+        updatedAt: string;
+        url: string;
+        version: number;
+    };
+    readonly id: "endpoints.ensure";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: true;
+    };
+    readonly method: "POST";
+    readonly mutates: true;
+    readonly path: "/v1/endpoints/ensure";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["state_conflict", "invalid_request", "plan_limit_reached", "rate_limited"];
+    readonly request: import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"set">;
+            name: import("zod").ZodString;
+            value: import("zod").ZodString;
+            secret: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"keep">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"remove">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"suppress">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>], "action">>>;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        url: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    readonly requestExample: {
+        url?: never;
+    } | {
+        url: string;
+    };
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
+        createdAt: import("zod").ZodString;
+        disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
+        environmentKind: import("zod").ZodEnum<{
+            test: "test";
+            live: "live";
+        }>;
+        id: import("zod").ZodString;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        project: import("zod").ZodString;
+        signingKeys: import("zod").ZodObject<{
+            current: import("zod").ZodString;
+            next: import("zod").ZodOptional<import("zod").ZodObject<{
+                acknowledgedAt: import("zod").ZodOptional<import("zod").ZodString>;
+                id: import("zod").ZodString;
+                overlapEndsAt: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        status: import("zod").ZodEnum<{
+            disabled: "disabled";
+            active: "active";
+        }>;
+        updatedAt: import("zod").ZodString;
+        url: import("zod").ZodString;
+        version: import("zod").ZodNumber;
+        created: import("zod").ZodBoolean;
+        signingSecret: import("zod").ZodObject<{
+            guidance: import("zod").ZodString;
+            returned: import("zod").ZodLiteral<false>;
+            revealUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    readonly scopes: readonly ["endpoints:write"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Find or create a callback endpoint by URL";
+    readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
     readonly description: "" | "Lists the caller's callback endpoints for exactly its own project and environment. The result is authoritative and metadata-only: no signing secret or sealed key material has a field in this shape.";
@@ -568,6 +930,19 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     }, import("zod/v4/core").$strip>;
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         data: import("zod").ZodArray<import("zod").ZodObject<{
+            headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<false>;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<true>;
+                configured: import("zod").ZodLiteral<true>;
+                value: import("zod").ZodOptional<import("zod").ZodNever>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                suppressed: import("zod").ZodLiteral<true>;
+            }, import("zod/v4/core").$strict>]>>>;
             createdAt: import("zod").ZodString;
             disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
             environmentKind: import("zod").ZodEnum<{
@@ -654,6 +1029,19 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["invalid_request", "not_found"];
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
         createdAt: import("zod").ZodString;
         disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
         environmentKind: import("zod").ZodEnum<{
@@ -688,7 +1076,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         ETag: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
     readonly creates: false;
-    readonly description: "" | "Replaces an endpoint's destination after applying the complete URL and DNS policy, and renames it when a name is given. Deliveries go to the new destination from the next one on. Disabled endpoints cannot be updated. Send If-Match with the version the endpoint was read at to be refused rather than overwrite a destination somebody else changed in the meantime.";
+    readonly description: "" | "Replaces an endpoint's destination after applying the complete URL and DNS policy, and renames it when a name is given. Optional `headers` patch endpoint defaults with `set`, `keep`, or `remove`; omitted headers preserve them. A secret value can be retained, replaced (including an empty string), or removed, but cannot be revealed. Header and destination edits apply to newly admitted attempts, including retries; recovery of the same admitted attempt keeps its snapshot. Disabled endpoints cannot be updated. Send If-Match with the version the endpoint was read at to be refused rather than overwrite a destination somebody else changed in the meantime.";
     readonly example: {
         createdAt?: never;
         environmentKind?: never;
@@ -725,6 +1113,21 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["invalid_request", "not_found", "rate_limited", "state_conflict", "version_conflict"];
     readonly request: import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"set">;
+            name: import("zod").ZodString;
+            value: import("zod").ZodString;
+            secret: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"keep">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"remove">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            action: import("zod").ZodLiteral<"suppress">;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>], "action">>>;
         name: import("zod").ZodOptional<import("zod").ZodString>;
         url: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
@@ -737,6 +1140,19 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         "If-Match": import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
         createdAt: import("zod").ZodString;
         disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
         environmentKind: import("zod").ZodEnum<{
@@ -771,7 +1187,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         ETag: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
     readonly creates: true;
-    readonly description: "" | "Creates the next endpoint signing key and selects it immediately for new deliveries while retaining the current key in the receiver acceptance set for a bounded overlap. The overlap defaults to and cannot exceed 24 hours. A second rotation is refused until the current overlap ends. The new secret is returned once and has no recovery operation, so a call whose answer was never read may have rotated a key nobody holds: read the endpoint and compare its signing keys before repeating one. Send If-Match with the version the endpoint was read at to be refused rather than rotate an endpoint that has changed since.";
+    readonly description: "" | "Creates the next endpoint signing key and selects it immediately for new deliveries while retaining the current key in the receiver acceptance set for a bounded overlap. The overlap defaults to and cannot exceed 24 hours. A second rotation is refused until the current overlap ends. The new secret is returned once to this call, so a call whose answer was never read has rotated a key the caller does not hold. It is recoverable: a signed-in member can read both keys, and the instant the overlap ends, through endpoints.revealSigningSecret. An API credential or an OAuth token cannot, so an integration that loses the answer needs a member to read it back rather than a second rotation, which is refused until the overlap ends. Send If-Match with the version the endpoint was read at to be refused rather than rotate an endpoint that has changed since.";
     readonly example: {
         endpoint?: never;
         keyId?: never;
@@ -823,6 +1239,19 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     }, import("zod/v4/core").$strip>;
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         endpoint: import("zod").ZodObject<{
+            headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<false>;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<true>;
+                configured: import("zod").ZodLiteral<true>;
+                value: import("zod").ZodOptional<import("zod").ZodNever>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                suppressed: import("zod").ZodLiteral<true>;
+            }, import("zod/v4/core").$strict>]>>>;
             createdAt: import("zod").ZodString;
             disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
             environmentKind: import("zod").ZodEnum<{
@@ -905,6 +1334,19 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         "If-Match": import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
         createdAt: import("zod").ZodString;
         disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
         environmentKind: import("zod").ZodEnum<{
@@ -1018,6 +1460,19 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["invalid_request", "not_found"];
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
         createdAt: import("zod").ZodString;
         disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
         environmentKind: import("zod").ZodEnum<{
@@ -1091,6 +1546,19 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["invalid_request", "not_found", "state_conflict"];
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
         createdAt: import("zod").ZodString;
         disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
         environmentKind: import("zod").ZodEnum<{
@@ -1933,6 +2401,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         }>;
         project: import("zod").ZodString;
         scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+            "members:manage": "members:manage";
             "credentials:administer": "credentials:administer";
             "billing:write": "billing:write";
             "credentials:read": "credentials:read";
@@ -1995,6 +2464,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         }>;
         project: import("zod").ZodString;
         scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+            "members:manage": "members:manage";
             "credentials:administer": "credentials:administer";
             "billing:write": "billing:write";
             "credentials:read": "credentials:read";
@@ -2038,6 +2508,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         revokedAt: import("zod").ZodOptional<import("zod").ZodString>;
         supersededBy: import("zod").ZodOptional<import("zod").ZodString>;
         scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+            "members:manage": "members:manage";
             "credentials:administer": "credentials:administer";
             "billing:write": "billing:write";
             "credentials:read": "credentials:read";
@@ -2117,6 +2588,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             revokedAt: import("zod").ZodOptional<import("zod").ZodString>;
             supersededBy: import("zod").ZodOptional<import("zod").ZodString>;
             scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+                "members:manage": "members:manage";
                 "credentials:administer": "credentials:administer";
                 "billing:write": "billing:write";
                 "credentials:read": "credentials:read";
@@ -2186,6 +2658,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         endpoint: import("zod").ZodString;
         id: import("zod").ZodString;
         scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+            "members:manage": "members:manage";
             "credentials:administer": "credentials:administer";
             "billing:write": "billing:write";
             "credentials:read": "credentials:read";
@@ -2206,8 +2679,8 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         }>>;
         state: import("zod").ZodEnum<{
             revoked: "revoked";
-            usable: "usable";
             expired: "expired";
+            usable: "usable";
         }>;
         tools: import("zod").ZodArray<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
@@ -2590,6 +3063,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             }>>;
             revokedAt: import("zod").ZodOptional<import("zod").ZodString>;
             scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+                "members:manage": "members:manage";
                 "credentials:administer": "credentials:administer";
                 "billing:write": "billing:write";
                 "credentials:read": "credentials:read";
@@ -2672,6 +3146,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             }>>;
             revokedAt: import("zod").ZodOptional<import("zod").ZodString>;
             scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+                "members:manage": "members:manage";
                 "credentials:administer": "credentials:administer";
                 "billing:write": "billing:write";
                 "credentials:read": "credentials:read";
@@ -2765,6 +3240,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             revokedAt: import("zod").ZodOptional<import("zod").ZodString>;
             supersededBy: import("zod").ZodOptional<import("zod").ZodString>;
             scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+                "members:manage": "members:manage";
                 "credentials:administer": "credentials:administer";
                 "billing:write": "billing:write";
                 "credentials:read": "credentials:read";
@@ -2801,6 +3277,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             revokedAt: import("zod").ZodOptional<import("zod").ZodString>;
             supersededBy: import("zod").ZodOptional<import("zod").ZodString>;
             scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+                "members:manage": "members:manage";
                 "credentials:administer": "credentials:administer";
                 "billing:write": "billing:write";
                 "credentials:read": "credentials:read";
@@ -2870,6 +3347,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             revokedAt: import("zod").ZodOptional<import("zod").ZodString>;
             supersededBy: import("zod").ZodOptional<import("zod").ZodString>;
             scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+                "members:manage": "members:manage";
                 "credentials:administer": "credentials:administer";
                 "billing:write": "billing:write";
                 "credentials:read": "credentials:read";
@@ -2904,7 +3382,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         "Idempotency-Replayed": import("zod").ZodOptional<import("zod").ZodLiteral<"true">>;
     }, import("zod/v4/core").$strip>;
     readonly creates: true;
-    readonly description: "" | "Creates a schedule and returns it together with its first planned occurrence. Give exactly one of `at`, `delaySeconds`, `everySeconds` and `cron`. An optional `partitionKey` selects a fairness lane inside this project and environment; it is fixed after create. Add a verified `endpoint` to deliver each occurrence there; optional JSON `data` is encrypted before PostgreSQL persistence, placed in the signed callback, and returned as given by a schedule read. `at` and `delaySeconds` fire once; a delay is converted to an absolute instant when the request is accepted, so a schedule created either way reads back the same afterwards. `everySeconds` is a fixed duration and its first occurrence falls one interval after acceptance — it stays the same length across a daylight-saving change, and takes no timezone for that reason. `cron` is a wall clock: it is read against the IANA `timeZone` sent with it, `UTC` when none is, and the first occurrence is the first instant the expression names after acceptance. Where the clocks go forward and the wall time named does not exist that day, the occurrence falls at the first instant after the gap; where they go back and it happens twice, it falls once, at the earlier of the two. A recurring schedule is materialized one occurrence at a time: the next one is planned once the current one is due, so a read always shows one occurrence still to come. `lateness.policy` decides what happens when an occurrence reaches its first attempt after its planned instant: `skipAhead` never carries a recurring arrival across its next scheduled instant (and a shorter custom window may retire it earlier), while `catchUp` admits one arrival within `maxStalenessSeconds` even after later recurrence instants passed. A one-shot has no next recurrence, so either explicit policy uses its window and the default is `catchUp` with 24 hours; recurring schedules default to `skipAhead`, and a `catchUp` without an override has a one-interval window. A retry already in progress is exempt because it arrived and failed; its retry and give-up policy still decide the outcome. The organization, project and environment come from the verified principal; a body cannot name them, and the endpoint must belong to the same tuple, so a credential issued for one project can only ever create schedules in that project. Send an `Idempotency-Key` to make a retry safe: the identical request returns the schedule that key already created, marked `Idempotency-Replayed: true`, and creates nothing further; the same key with a different request is refused `idempotency_key_reused`. A replay reports the schedule **as it stands now**, not a frozen copy of the first response — if it was paused in between, the replay says so.";
+    readonly description: "" | "Creates a schedule and returns it together with its first planned occurrence. Give exactly one of `at`, `delaySeconds`, `everySeconds` and `cron`. An optional `partitionKey` selects a fairness lane inside this project and environment; it is fixed after create. Add a verified `endpoint` to deliver each occurrence there. Instead of `endpoint`, give a `url`: the service uses this project and environment's existing endpoint at exactly that address, or creates one silently. Its signing secret is never returned; the response's `endpointSigningSecret` says where a signed-in member reveals it. Reusing an endpoint needs only `schedules:write`; creating one also needs `endpoints:write`, and without it the request is refused as `scope_missing`. Optional JSON `data` is encrypted before PostgreSQL persistence, placed in the signed callback, and returned as given by a schedule read. Optional `http` selects POST (default), PUT, or bodyless GET and schedule header overrides. Omitted HTTP settings preserve the signed structured envelope; `body: { mode: 'json', value: ... }` sends that JSON directly without interpolation. Ordinary headers remain readable and secret values are encrypted and write-only. Schedule headers override endpoint defaults case-insensitively, with `suppress` to omit an inherited header and `remove` to resume inheritance. Product signing, content and transport headers are reserved. Raw JSON and GET carry asynchronous completion details in reserved Callback-Completion headers. `at` and `delaySeconds` fire once; a delay is converted to an absolute instant when the request is accepted, so a schedule created either way reads back the same afterwards. `everySeconds` is a fixed duration and its first occurrence falls one interval after acceptance — it stays the same length across a daylight-saving change, and takes no timezone for that reason. `cron` is a wall clock: it is read against the IANA `timeZone` sent with it, `UTC` when none is, and the first occurrence is the first instant the expression names after acceptance. Where the clocks go forward and the wall time named does not exist that day, the occurrence falls at the first instant after the gap; where they go back and it happens twice, it falls once, at the earlier of the two. A recurring schedule is materialized one occurrence at a time: the next one is planned once the current one is due, so a read always shows one occurrence still to come. `lateness.policy` decides what happens when an occurrence reaches its first attempt after its planned instant: `skipAhead` never carries a recurring arrival across its next scheduled instant (and a shorter custom window may retire it earlier), while `catchUp` admits one arrival within `maxStalenessSeconds` even after later recurrence instants passed. A one-shot has no next recurrence, so either explicit policy uses its window and the default is `catchUp` with 24 hours; recurring schedules default to `skipAhead`, and a `catchUp` without an override has a one-interval window. A retry already in progress is exempt because it arrived and failed; its retry and give-up policy still decide the outcome. The organization, project and environment come from the verified principal; a body cannot name them, and the endpoint must belong to the same tuple, so a credential issued for one project can only ever create schedules in that project. Send an `Idempotency-Key` to make a retry safe: the identical request returns the schedule that key already created, marked `Idempotency-Replayed: true`, and creates nothing further; the same key with a different request is refused `idempotency_key_reused`. A replay reports the schedule **as it stands now**, not a frozen copy of the first response — if it was paused in between, the replay says so.";
     readonly example: {
         occurrence?: never;
         schedule?: never;
@@ -2946,9 +3424,39 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly method: "POST";
     readonly mutates: true;
     readonly path: "/v1/schedules";
+    readonly conditionalScopes: readonly ["endpoints:write"];
+    readonly conditionalScopesWhen: "the request names a `url` this project and environment has no endpoint at yet";
     readonly principals: readonly ["api-credential", "oauth", "session"];
-    readonly problems: readonly ["idempotency_key_reused", "invalid_request", "not_found", "plan_limit_reached", "service_unavailable", "state_conflict"];
+    readonly problems: readonly ["idempotency_key_reused", "invalid_request", "not_found", "plan_limit_reached", "rate_limited", "scope_missing", "service_unavailable", "state_conflict"];
     readonly request: import("zod").ZodObject<{
+        http: import("zod").ZodOptional<import("zod").ZodObject<{
+            method: import("zod").ZodOptional<import("zod").ZodEnum<{
+                POST: "POST";
+                PUT: "PUT";
+                GET: "GET";
+            }>>;
+            body: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"envelope">;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"json">;
+                value: import("zod").ZodJSONSchema;
+            }, import("zod/v4/core").$strict>], "mode">>;
+            headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                action: import("zod").ZodLiteral<"set">;
+                name: import("zod").ZodString;
+                value: import("zod").ZodString;
+                secret: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                action: import("zod").ZodLiteral<"keep">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                action: import("zod").ZodLiteral<"remove">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                action: import("zod").ZodLiteral<"suppress">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>], "action">>>;
+        }, import("zod/v4/core").$strict>>;
         at: import("zod").ZodOptional<import("zod").ZodString>;
         cron: import("zod").ZodOptional<import("zod").ZodString>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
@@ -2966,6 +3474,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         }, import("zod/v4/core").$strict>>;
         everySeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
         endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+        url: import("zod").ZodOptional<import("zod").ZodString>;
         latencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
             realtime: "realtime";
             bulk: "bulk";
@@ -3004,7 +3513,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly requestHeaders: import("zod").ZodObject<{
         "Idempotency-Key": import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         occurrence: import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -3035,6 +3544,34 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             attemptCount: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
         schedule: import("zod").ZodObject<{
+            http: import("zod").ZodOptional<import("zod").ZodObject<{
+                method: import("zod").ZodEnum<{
+                    POST: "POST";
+                    PUT: "PUT";
+                    GET: "GET";
+                }>;
+                body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"envelope">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"json">;
+                    value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+                }, import("zod/v4/core").$strict>], "mode">;
+                headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<false>;
+                    value: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<true>;
+                    configured: import("zod").ZodLiteral<true>;
+                    value: import("zod").ZodOptional<import("zod").ZodNever>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    suppressed: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>>;
             archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
             data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
             createdAt: import("zod").ZodString;
@@ -3086,7 +3623,12 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             updatedAt: import("zod").ZodString;
             version: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+        endpointSigningSecret: import("zod").ZodOptional<import("zod").ZodObject<{
+            guidance: import("zod").ZodString;
+            returned: import("zod").ZodLiteral<false>;
+            revealUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
 }, {
     readonly scopes: readonly ["schedules:read"];
     readonly sessionAuthority: "headers";
@@ -3096,7 +3638,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         ETag: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
     readonly creates: false;
-    readonly description: "" | "Reads one schedule and its next occurrence from the partition that owns it. A schedule belonging to another organization, project or environment answers not_found rather than a refusal that would confirm it exists. The response carries the schedule's version as a strong ETag; send it back in `If-Match` to make a later write conditional on nothing having changed in between. The response carries the schedule's `data` when it has one, exactly as it was given; the listing leaves it off.";
+    readonly description: "" | "Reads one schedule and its next occurrence from the partition that owns it. A schedule belonging to another organization, project or environment answers not_found rather than a refusal that would confirm it exists. The response carries the schedule's version as a strong ETag; send it back in `If-Match` to make a later write conditional on nothing having changed in between. The response carries the schedule's `data` when it has one, exactly as it was given; the listing leaves it off. Detail reads also include the custom JSON body; listings and mutation responses omit its content. HTTP settings expose ordinary values and configured secret markers, never secret values.";
     readonly example: {
         occurrence?: never;
         schedule?: never;
@@ -3143,7 +3685,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly path: "/v1/schedules/{scheduleId}";
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["invalid_request", "not_found"];
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         occurrence: import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -3174,6 +3716,34 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             attemptCount: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
         schedule: import("zod").ZodObject<{
+            http: import("zod").ZodOptional<import("zod").ZodObject<{
+                method: import("zod").ZodEnum<{
+                    POST: "POST";
+                    PUT: "PUT";
+                    GET: "GET";
+                }>;
+                body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"envelope">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"json">;
+                    value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+                }, import("zod/v4/core").$strict>], "mode">;
+                headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<false>;
+                    value: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<true>;
+                    configured: import("zod").ZodLiteral<true>;
+                    value: import("zod").ZodOptional<import("zod").ZodNever>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    suppressed: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>>;
             archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
             data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
             createdAt: import("zod").ZodString;
@@ -3225,7 +3795,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             updatedAt: import("zod").ZodString;
             version: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
 }, {
     readonly creates: false;
     readonly description: "" | "Lists the caller's own schedules, oldest first, one page at a time. Archived schedules are left out: archiving is how a schedule leaves the working set, and a listing that still carried them would make the operation pointless. Give `endpoint` to keep the page to the schedules that deliver to that endpoint — the way back from a destination to everything pointed at it, which is what somebody who disabled or is about to move an endpoint needs to see. Items are schedules rather than schedules-with-occurrences, because a cross-partition listing is served from a projection that holds a summary; read a schedule to get its authoritative next occurrence. Every page states whether it is authoritative or projected.";
@@ -3279,8 +3849,36 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             due: "due";
         }>>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         data: import("zod").ZodArray<import("zod").ZodObject<{
+            http: import("zod").ZodOptional<import("zod").ZodObject<{
+                method: import("zod").ZodEnum<{
+                    POST: "POST";
+                    PUT: "PUT";
+                    GET: "GET";
+                }>;
+                body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"envelope">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"json">;
+                    value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+                }, import("zod/v4/core").$strict>], "mode">;
+                headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<false>;
+                    value: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<true>;
+                    configured: import("zod").ZodLiteral<true>;
+                    value: import("zod").ZodOptional<import("zod").ZodNever>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    suppressed: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>>;
             archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
             data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
             createdAt: import("zod").ZodString;
@@ -3340,14 +3938,14 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             lagSeconds: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>], "kind">;
         nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
     readonly scopes: readonly ["schedules:read"];
     readonly sessionAuthority: "headers";
     readonly summary: "" | "List schedules";
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Counts the occurrences this project and environment expect to fire, in epoch-aligned time buckets, with a latency-class split on every bucket and an optional customer partition-key breakdown. A recurring series contributes every instant it fires inside the window rather than only its next one, and `nextFireCount` reports how many of a bucket's occurrences are a schedule's next firing. The answer states its own freshness and is refused rather than shortened when a partition cannot complete it. It carries counts only: no schedule identifier, callback destination, payload or endpoint detail has a field in the response.";
+    readonly description: "" | "Counts the occurrences this project and environment expect to fire, in epoch-aligned time buckets, with a latency-class split on every bucket and an optional customer partition-key breakdown. A recurring series contributes every instant it fires inside the window rather than only its next one, and `nextFireCount` reports how many of a bucket's occurrences are a schedule's next firing. The answer states freshness and explicit coverage. Clients sending X-Greatwait-Accept-Partial-Forecast: true receive bounded lower-bound counts when a book reaches a row, cell or recurrence-work bound, with coverage.complete false and the exact bounds reached. Without this capability header the previous refusal behavior remains safe for clients that only read totals. Unavailable or stale sources still refuse. Coverage identifies the selected recurring schedule range but never includes destinations, payload or endpoint detail.";
     readonly example: {
         buckets?: never;
         freshness?: never;
@@ -3378,6 +3976,9 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             to: string;
         };
     };
+    readonly requestHeaders: import("zod").ZodObject<{
+        "X-Greatwait-Accept-Partial-Forecast": import("zod").ZodOptional<import("zod").ZodLiteral<"true">>;
+    }, import("zod/v4/core").$strip>;
     readonly id: "forecast.read";
     readonly idempotent: true;
     readonly mcp: {
@@ -3400,6 +4001,52 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         to: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        coverage: import("zod").ZodOptional<import("zod").ZodObject<{
+            complete: import("zod").ZodBoolean;
+            countMeaning: import("zod").ZodEnum<{
+                "complete-total": "complete-total";
+                "lower-bound": "lower-bound";
+            }>;
+            projectedWindow: import("zod").ZodObject<{
+                from: import("zod").ZodString;
+                to: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+            completeThrough: import("zod").ZodString;
+            heads: import("zod").ZodObject<{
+                groupsRead: import("zod").ZodNumber;
+                occurrencesCounted: import("zod").ZodNumber;
+                complete: import("zod").ZodBoolean;
+                selection: import("zod").ZodLiteral<"earliest bucket, latency class, partition key groups">;
+                lastGroup: import("zod").ZodOptional<import("zod").ZodObject<{
+                    start: import("zod").ZodString;
+                    latencyClass: import("zod").ZodEnum<{
+                        realtime: "realtime";
+                        bulk: "bulk";
+                    }>;
+                    partitionKey: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>;
+            recurring: import("zod").ZodObject<{
+                schedulesRead: import("zod").ZodNumber;
+                populationComplete: import("zod").ZodBoolean;
+                selection: import("zod").ZodLiteral<"oldest eligible active recurring schedules by createdAt and scheduleId">;
+                firstScheduleId: import("zod").ZodOptional<import("zod").ZodString>;
+                lastScheduleId: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+            work: import("zod").ZodObject<{
+                usedUnits: import("zod").ZodNumber;
+                limitUnits: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            boundsReached: import("zod").ZodArray<import("zod").ZodObject<{
+                kind: import("zod").ZodEnum<{
+                    "head-cells": "head-cells";
+                    "recurring-series": "recurring-series";
+                    "projection-work": "projection-work";
+                    "projection-cells": "projection-cells";
+                }>;
+                limit: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
         buckets: import("zod").ZodArray<import("zod").ZodObject<{
             byLatencyClass: import("zod").ZodObject<{
                 bulk: import("zod").ZodNumber;
@@ -3428,7 +4075,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Reads the verified principal's organization-wide prepaid execution position from the authoritative PostgreSQL ledger. Desired and effective revisions remain distinct, and pending stays true until D1 records PostgreSQL confirmation. Amounts are exact integer microdollars encoded as decimal strings; currency is USD and scale is six. Reserved credit has already been committed to a logical attempt but is not yet a settled debit. A missing hard cap means the customer elected no execution spending cap, never zero room. Shadow mode records what enforcement would have done without charging or blocking, and the activation boundary prevents retroactive charges.";
+    readonly description: "" | "Reads the verified principal's organization-wide prepaid execution position from the authoritative PostgreSQL ledger. Desired and effective revisions remain distinct, and pending stays true until the control plane records PostgreSQL confirmation. Amounts are exact integer microdollars encoded as decimal strings; currency is USD and scale is six. Reserved credit has already been committed to a logical attempt but is not yet a settled debit. A missing hard cap means the customer elected no execution spending cap, never zero room. Shadow mode records what enforcement would have done without charging or blocking, and the activation boundary prevents retroactive charges.";
     readonly example: {};
     readonly id: "billing.summary";
     readonly idempotent: true;
@@ -3441,7 +4088,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly mutates: false;
     readonly path: "/v1/billing/summary";
     readonly principals: readonly ["api-credential", "oauth", "session"];
-    readonly problems: readonly [];
+    readonly problems: readonly ["billing_not_ready", "service_unavailable"];
     readonly response: import("zod").ZodObject<{
         activation: import("zod").ZodObject<{
             boundary: import("zod").ZodString;
@@ -3668,6 +4315,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["idempotency_key_reused", "invalid_request", "not_found", "revision_conflict", "service_unavailable", "state_conflict", "test_to_live_escalation"];
     readonly request: import("zod").ZodObject<{
+        automaticTopUp: import("zod").ZodOptional<import("zod").ZodBoolean>;
         confirmed: import("zod").ZodLiteral<true>;
         expectedRevision: import("zod").ZodNumber;
         quote: import("zod").ZodString;
@@ -3684,6 +4332,26 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly requestHeaders: import("zod").ZodObject<{
         "Idempotency-Key": import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
+} & BillingFundingContract, {
+    readonly creates: false;
+    readonly description: "" | "Confirms one execution-credit payment or saved-payment-method setup now, typically when the customer returns from hosted Checkout, instead of waiting for the provider's notification or the scheduled repair. It reads that one operation from the payment provider under the caller organization's authenticated account and applies what the provider reports: a paid Checkout grants its exact credit once, an open or unpaid one stays pending, and an operation already settled is answered without reading the provider. Nothing in the request can claim a payment succeeded — it names only which operation to read. Repeating the call is safe and converges on the same state. Returns the same execution-funding position as billing.funding.";
+    readonly environments: readonly ["live"];
+    readonly id: "billing.fundingconfirm";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "POST";
+    readonly mutates: true;
+    readonly path: "/v1/billing/funding/{paymentOperation}/confirm";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["not_found", "service_unavailable", "state_conflict", "test_to_live_escalation"];
+    readonly scopes: readonly ["billing:write"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Confirm one payment with the provider now";
+    readonly surfaces: readonly ["api", "mock"];
 } & BillingFundingContract, {
     readonly scopes: readonly ["billing:write"];
     readonly sessionAuthority: "headers";
@@ -3731,14 +4399,13 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     }, import("zod/v4/core").$strip>;
 } & BillingFundingContract, NamedOperation<"billing.autotopuppreview">, NamedOperation<"billing.autotopup">, {
     readonly scopes: readonly ["billing:write"];
-    readonly sessionAuthority: "headers";
-    readonly summary: "" | "Request operator-reviewed refund";
+    readonly summary: "" | "Reserve credit against a payment for refund";
     readonly surfaces: readonly ["api", "mock"];
     readonly responseHeaders?: import("zod").ZodObject<{
         "Idempotency-Replayed": import("zod").ZodOptional<import("zod").ZodLiteral<"true">>;
     }, import("zod/v4/core").$strip>;
     readonly creates: true;
-    readonly description: "" | "Records an explicitly approved billing-owner request for operator review of unused purchased execution credit. It never submits a refund, cashes out credit or grants an MCP cash-out path; the Idempotency-Key preserves one request across retries. Trial credit has no cash value, provider submission remains an operator action, and any later refund does not restore automatic purchasing authority for the month.";
+    readonly description: "" | "Reserves unused purchased execution credit against one original payment, with the billing owner's explicit confirmation. Purchased credit is not refundable except where a charge is refunded because the service did not work as described, so this records no promise of a refund: it never calls Stripe, cashes out credit or grants an MCP cash-out path. A Stripe refund of that payment settles the reservation when it carries the same credit and supersedes it otherwise; the Idempotency-Key preserves one reservation across retries. Trial credit has no cash value, and a refund does not restore automatic purchasing authority used in the month.";
     readonly environments: readonly ["live"];
     readonly example: {
         amount?: never;
@@ -3767,7 +4434,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly method: "POST";
     readonly mutates: true;
     readonly path: "/v1/billing/funding/refunds";
-    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly principals: readonly ["api-credential", "oauth"];
     readonly problems: readonly ["idempotency_key_reused", "invalid_request", "not_found", "service_unavailable", "state_conflict", "test_to_live_escalation"];
     readonly request: import("zod").ZodObject<{
         amount: import("zod").ZodObject<{
@@ -3810,14 +4477,13 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     }, import("zod/v4/core").$strict> | import("zod").ZodNever;
 }, {
     readonly scopes: readonly ["billing:write"];
-    readonly sessionAuthority: "headers";
-    readonly summary: "" | "Record a reviewed refund decision";
+    readonly summary: "" | "Complete or decline a refund reservation";
     readonly surfaces: readonly ["api", "mock"];
     readonly responseHeaders?: import("zod").ZodObject<{
         "Idempotency-Replayed": import("zod").ZodOptional<import("zod").ZodLiteral<"true">>;
     }, import("zod/v4/core").$strip>;
     readonly creates: false;
-    readonly description: "" | "Records an already-made external operator decision on a pending unused-credit refund request. Completion verifies an existing Stripe refund by authenticated provider read before applying the exact credit, tax and gross adjustment; it never creates a provider refund. Decline releases the reserved credit without contacting the provider. The Idempotency-Key makes either decision converge across retries.";
+    readonly description: "" | "Completes or declines a pending refund reservation. Completion verifies an existing Stripe refund by authenticated provider read before applying the exact credit, tax and gross adjustment, and converges on the recorded adjustment when that refund already settled the reservation; it never creates a provider refund. Decline releases the reserved credit without contacting the provider, and a reservation a Stripe refund superseded is refused as a state conflict. The Idempotency-Key makes either outcome converge across retries.";
     readonly environments: readonly ["live"];
     readonly id: "billing.refundresolution";
     readonly idempotent: true;
@@ -3829,7 +4495,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly method: "PATCH";
     readonly mutates: true;
     readonly path: "/v1/billing/funding/refunds/{refundRequest}";
-    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly principals: readonly ["api-credential", "oauth"];
     readonly problems: readonly ["idempotency_key_reused", "invalid_request", "not_found", "service_unavailable", "state_conflict", "test_to_live_escalation"];
     readonly request: import("zod").ZodObject<{
         confirmed: import("zod").ZodLiteral<true>;
@@ -4082,6 +4748,282 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     };
     readonly summary: "" | "Open hosted payment recovery";
     readonly problems: readonly ["service_unavailable", "state_conflict", "not_found", "revision_conflict", "test_to_live_escalation"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Reads the verified organization's saved payment method: the one method automatic execution top-ups and project subscriptions charge. It is the payment provider's default payment method for the organization, read by authenticated provider call. method says what it is — type card with brand, last four digits and expiry; type link with the email Link reports, when it reports one; or type other with the provider's type name (cashapp, amazon_pay, klarna and the like) — and every variant carries label, the name to show a person. card repeats the card details when the method is a card and is null otherwise; it is kept for clients written before other payment methods were accepted. A method the organization already authorized for automatic top-up or a project subscription is adopted as the saved method, so an existing customer is not told they have none. method and card are null when the organization has none.";
+    readonly example: {
+        card?: never;
+        method?: never;
+    } | {
+        card: {
+            brand: string;
+            expMonth: number;
+            expYear: number;
+            last4: string;
+        };
+        method: {
+            brand: string;
+            expMonth: number;
+            expYear: number;
+            label: string;
+            last4: string;
+            type: string;
+        };
+    };
+    readonly id: "billing.paymentmethod";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "GET";
+    readonly mutates: false;
+    readonly path: "/v1/billing/payment-method";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["service_unavailable"];
+    readonly response: import("zod").ZodObject<{
+        card: import("zod").ZodNullable<import("zod").ZodObject<{
+            brand: import("zod").ZodString;
+            last4: import("zod").ZodString;
+            expMonth: import("zod").ZodNumber;
+            expYear: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>>;
+        method: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            brand: import("zod").ZodString;
+            last4: import("zod").ZodString;
+            expMonth: import("zod").ZodNumber;
+            expYear: import("zod").ZodNumber;
+            type: import("zod").ZodLiteral<"card">;
+            label: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"link">;
+            label: import("zod").ZodString;
+            email: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"other">;
+            label: import("zod").ZodString;
+            providerType: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>], "type">>;
+    }, import("zod/v4/core").$strict> | import("zod").ZodNever;
+    readonly scopes: readonly ["usage:read"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Read the saved payment method";
+    readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Lists the verified organization's project subscription charges: the payment provider's invoices for its project subscription, read by authenticated provider call, most recent first and at most 24. Execution-credit purchases are not listed here; billing.funding reports them. Draft and zero-amount invoices are omitted. Each amount is the invoice total including tax, and the receipt link, when present, is the provider-hosted invoice page. An organization that has never been billed has an empty list; reading it creates nothing and changes nothing.";
+    readonly example: {
+        data?: never;
+    } | {
+        data: {
+            amount: {
+                currency: string;
+                microdollars: string;
+                scale: number;
+            };
+            createdAt: string;
+            id: string;
+            receiptUrl: string;
+            state: string;
+        }[];
+    };
+    readonly id: "billing.invoices";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "GET";
+    readonly mutates: false;
+    readonly path: "/v1/billing/invoices";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["service_unavailable"];
+    readonly response: import("zod").ZodObject<{
+        data: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            createdAt: import("zod").ZodString;
+            amount: import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>;
+            state: import("zod").ZodEnum<{
+                void: "void";
+                paid: "paid";
+                open: "open";
+                uncollectible: "uncollectible";
+            }>;
+            receiptUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict> | import("zod").ZodNever;
+    readonly scopes: readonly ["usage:read"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "List project subscription charges";
+    readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Creates a short-lived provider-hosted payment-method setup session for the verified organization and returns its address. It offers every payment method the provider account enables that can be charged later without the customer present — cards, Link and others. Saving one there charges nothing; it becomes the saved payment method only once billing.paymentmethodconfirm (when the browser returns) or the provider's notification reads the completed setup by authenticated provider call. An optional return address must share the origin of the configured billing page.";
+    readonly environments: readonly ["live"];
+    readonly example: {
+        url?: never;
+    } | {
+        url: string;
+    };
+    readonly id: "billing.paymentmethodsetup";
+    readonly idempotent: false;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "POST";
+    readonly mutates: true;
+    readonly path: "/v1/billing/payment-method/setup";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["invalid_request", "service_unavailable", "state_conflict", "not_found", "revision_conflict", "test_to_live_escalation"];
+    readonly request: import("zod").ZodObject<{
+        returnUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strict>;
+    readonly requestExample: {};
+    readonly response: import("zod").ZodObject<{
+        url: import("zod").ZodString;
+    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    readonly scopes: readonly ["billing:write"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Start saving a payment method";
+    readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Makes the payment method saved in one completed hosted setup the organization's saved payment method, typically when the browser returns from it. The session is read by authenticated provider call and must belong to the verified organization's own customer; a session of another organization is answered not found. It becomes the provider default for invoices, the default of the organization's project subscription, and the automatic top-up payment method — readying a top-up rule that was waiting for one. The response has the shape billing.paymentmethod returns. When the previous method was removed (billing.paymentmethodremove) and the paid period it let run out has not ended, renewal resumes for the projects that removal stopped; a project the customer cancelled themselves stays cancelled. Nothing in the request can claim a setup succeeded, and repeating the call is safe.";
+    readonly environments: readonly ["live"];
+    readonly example: {
+        card?: never;
+        method?: never;
+    } | {
+        card: {
+            brand: string;
+            expMonth: number;
+            expYear: number;
+            last4: string;
+        };
+        method: {
+            brand: string;
+            expMonth: number;
+            expYear: number;
+            label: string;
+            last4: string;
+            type: string;
+        };
+    };
+    readonly id: "billing.paymentmethodconfirm";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "POST";
+    readonly mutates: true;
+    readonly path: "/v1/billing/payment-method/confirm";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["invalid_request", "not_found", "service_unavailable", "state_conflict", "revision_conflict", "test_to_live_escalation"];
+    readonly request: import("zod").ZodObject<{
+        checkoutSession: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>;
+    readonly requestExample: {
+        checkoutSession?: never;
+    } | {
+        checkoutSession: string;
+    };
+    readonly response: import("zod").ZodObject<{
+        card: import("zod").ZodNullable<import("zod").ZodObject<{
+            brand: import("zod").ZodString;
+            last4: import("zod").ZodString;
+            expMonth: import("zod").ZodNumber;
+            expYear: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>>;
+        method: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            brand: import("zod").ZodString;
+            last4: import("zod").ZodString;
+            expMonth: import("zod").ZodNumber;
+            expYear: import("zod").ZodNumber;
+            type: import("zod").ZodLiteral<"card">;
+            label: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"link">;
+            label: import("zod").ZodString;
+            email: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"other">;
+            label: import("zod").ZodString;
+            providerType: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>], "type">>;
+    }, import("zod/v4/core").$strict> | import("zod").ZodNever;
+    readonly scopes: readonly ["billing:write"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Confirm a saved payment method";
+    readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Removes the verified organization's saved payment method, and with it everything that charges it. Removing it stops renewal: every project subscription is set to end at the end of the period already paid for, so paid projects keep running until then and then stop, with nothing refunded and nothing more charged; billing.projects shows each one's cancellationAt. The included free project is unaffected. Automatic top-up turns off immediately and forgets its payment method. A pending or declined project addition is ended, so nothing later starts a checkout or a charge, and no project can be added until a payment method is saved again. The method stops being the provider default and is detached from the organization's customer. The request must carry confirmed: true. Repeating the call is safe: with nothing on file it answers a null method and card and still makes sure nothing is left that could charge one. Saving a payment method through billing.paymentmethodsetup before the period ends keeps those projects: renewal resumes on the new method, except for any project the customer cancelled themselves. After the period ends, a paid project must be added again.";
+    readonly environments: readonly ["live"];
+    readonly example: {
+        card?: never;
+        method?: never;
+    } | {
+        card: null;
+        method: null;
+    };
+    readonly id: "billing.paymentmethodremove";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: true;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "POST";
+    readonly mutates: true;
+    readonly path: "/v1/billing/payment-method/remove";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["invalid_request", "not_found", "service_unavailable", "state_conflict", "revision_conflict", "test_to_live_escalation"];
+    readonly request: import("zod").ZodObject<{
+        confirmed: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strict>;
+    readonly requestExample: {
+        confirmed?: never;
+    } | {
+        confirmed: boolean;
+    };
+    readonly response: import("zod").ZodObject<{
+        card: import("zod").ZodNullable<import("zod").ZodObject<{
+            brand: import("zod").ZodString;
+            last4: import("zod").ZodString;
+            expMonth: import("zod").ZodNumber;
+            expYear: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>>;
+        method: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            brand: import("zod").ZodString;
+            last4: import("zod").ZodString;
+            expMonth: import("zod").ZodNumber;
+            expYear: import("zod").ZodNumber;
+            type: import("zod").ZodLiteral<"card">;
+            label: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"link">;
+            label: import("zod").ZodString;
+            email: import("zod").ZodNullable<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"other">;
+            label: import("zod").ZodString;
+            providerType: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>], "type">>;
+    }, import("zod/v4/core").$strict> | import("zod").ZodNever;
+    readonly scopes: readonly ["billing:write"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Remove the saved payment method";
+    readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
     readonly description: "" | "Advances at most one due, already-authorized desired billing-policy revision for the caller's organization into PostgreSQL, then returns the same exact desired/effective summary as billing.summary. The command never changes the desired document. A transport failure is recorded for bounded retry and remains pending. Repeating the command may advance the next queued revision, so each call requires approval.";
@@ -4098,7 +5040,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly mutates: true;
     readonly path: "/v1/billing/reconcile";
     readonly principals: readonly ["api-credential", "oauth", "session"];
-    readonly problems: readonly ["service_unavailable", "test_to_live_escalation"];
+    readonly problems: readonly ["billing_not_ready", "service_unavailable", "test_to_live_escalation"];
     readonly response: import("zod").ZodObject<{
         activation: import("zod").ZodObject<{
             boundary: import("zod").ZodString;
@@ -4423,6 +5365,9 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
                 service_blocked: "service_blocked";
                 service_restored: "service_restored";
             }>;
+            note: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "provider-details-attached": "provider-details-attached";
+            }>>;
             period: import("zod").ZodOptional<import("zod").ZodString>;
             recordedAt: import("zod").ZodString;
             reference: import("zod").ZodObject<{
@@ -4442,6 +5387,83 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly sessionAuthority: "headers";
     readonly summary: "" | "List immutable billing entries";
     readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Read effective customer allowances for the verified organization. Deployment and organization revisions identify the policy used; infrastructure and other organizations' settings are excluded.";
+    readonly example: {
+        limits?: never;
+        provenance?: never;
+        revision?: never;
+    } | {
+        limits: {
+            inlinePayloadBytes: number;
+            forecastHorizonSeconds: number;
+            usageWindowDays: number;
+        };
+        provenance: {
+            inlinePayloadBytes: string;
+            forecastHorizonSeconds: string;
+            usageWindowDays: string;
+        };
+        revision: {
+            global: number;
+            organization: number;
+        };
+    };
+    readonly id: "limits.read";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "GET";
+    readonly mutates: false;
+    readonly path: "/v1/limits";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["service_unavailable"];
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        limits: import("zod").ZodObject<{
+            inlinePayloadBytes: import("zod").ZodNumber;
+            partitionKeyCeiling: import("zod").ZodOptional<import("zod").ZodNumber>;
+            forecastHorizonSeconds: import("zod").ZodNumber;
+            usageWindowDays: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        provenance: import("zod").ZodObject<{
+            inlinePayloadBytes: import("zod").ZodEnum<{
+                organization: "organization";
+                default: "default";
+                global: "global";
+                deployment: "deployment";
+            }>;
+            partitionKeyCeiling: import("zod").ZodOptional<import("zod").ZodEnum<{
+                organization: "organization";
+                default: "default";
+                global: "global";
+                deployment: "deployment";
+            }>>;
+            forecastHorizonSeconds: import("zod").ZodEnum<{
+                organization: "organization";
+                default: "default";
+                global: "global";
+                deployment: "deployment";
+            }>;
+            usageWindowDays: import("zod").ZodEnum<{
+                organization: "organization";
+                default: "default";
+                global: "global";
+                deployment: "deployment";
+            }>;
+        }, import("zod/v4/core").$strict>;
+        revision: import("zod").ZodObject<{
+            global: import("zod").ZodNumber;
+            organization: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>;
+    readonly scopes: readonly ["schedules:read"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Read effective customer limits";
+    readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
     readonly description: "" | "Legacy terminal-occurrence volume by UTC day from the authoritative scheduling model. This is an operational outcome aggregate retained for compatibility; it is not the PAYG invoice meter. Billing is per logical delivery attempt, including retries and redeliveries, and is exposed exactly by billing.summary and billing.ledger. Days with no terminal occurrence are absent rather than zero, and the window states which days the answer covers. `from` and `to` are snapped outward to UTC midnight, so an answer always covers whole days.";
@@ -4645,7 +5667,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly idempotent: true;
     readonly mcp: {
         readonly kind: "unavailable";
-        readonly reason: "A transitional shape for the autoscaler migration, scheduled for withdrawal once W6-02 has cut over. forecast.read is the same data in the shape this product publishes, and it is the tool an agent should reach for.";
+        readonly reason: "A transitional shape for the autoscaler migration, withdrawn after its cutover. forecast.read is the same data in the shape this product publishes, and it is the tool an agent should reach for.";
     };
     readonly method: "GET";
     readonly mutates: false;
@@ -4725,7 +5747,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             newest: "newest";
         }>>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         data: import("zod").ZodArray<import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -4759,7 +5781,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         freshness: import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"authoritative">;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
     readonly scopes: readonly ["occurrences:read"];
     readonly sessionAuthority: "headers";
     readonly summary: "" | "List retained occurrences";
@@ -4820,7 +5842,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         schedule: import("zod").ZodOptional<import("zod").ZodString>;
         to: import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         data: import("zod").ZodArray<import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -4857,7 +5879,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         retention: import("zod").ZodObject<{
             from: import("zod").ZodString;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
     readonly scopes: readonly ["occurrences:read"];
     readonly sessionAuthority: "headers";
     readonly summary: "" | "List project executions";
@@ -4899,7 +5921,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly path: "/v1/schedules/{scheduleId}/occurrences/{occurrenceId}";
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["invalid_request", "not_found"];
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         freshness: import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"authoritative">;
         }, import("zod/v4/core").$strip>;
@@ -4932,7 +5954,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             timingPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
             attemptCount: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
     readonly scopes: readonly ["occurrences:read"];
     readonly sessionAuthority: "headers";
     readonly summary: "" | "Read an occurrence";
@@ -4948,6 +5970,8 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         data: {
             attemptNumber: number;
             classifiedAt: string;
+            dispatchRecoveries: number;
+            localReceiptRecoveries: number;
             delivery: string;
             diagnostic: string;
             durationMs: number;
@@ -4986,10 +6010,12 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         cursor: import("zod").ZodOptional<import("zod").ZodString>;
         limit: import("zod").ZodDefault<import("zod").ZodNumber>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         data: import("zod").ZodArray<import("zod").ZodObject<{
             id: import("zod").ZodString;
+            localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
             occurrence: import("zod").ZodString;
+            rescues: import("zod").ZodOptional<import("zod").ZodInt>;
             remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
                 none: "none";
                 review_retry_policy: "review_retry_policy";
@@ -5048,13 +6074,14 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
                 network_ambiguous: "network_ambiguous";
                 payload_unavailable: "payload_unavailable";
             }>>;
+            dispatchRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
             durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>>;
         nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
         freshness: import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"authoritative">;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
     readonly scopes: readonly ["occurrences:read"];
     readonly sessionAuthority: "headers";
     readonly summary: "" | "List delivery attempts";
@@ -5069,6 +6096,8 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         attempt: {
             attemptNumber: number;
             classifiedAt: string;
+            dispatchRecoveries: number;
+            localReceiptRecoveries: number;
             delivery: string;
             diagnostic: string;
             durationMs: number;
@@ -5101,10 +6130,12 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly path: "/v1/schedules/{scheduleId}/occurrences/{occurrenceId}/attempts/{attemptId}";
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly ["invalid_request", "not_found"];
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         attempt: import("zod").ZodObject<{
             id: import("zod").ZodString;
+            localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
             occurrence: import("zod").ZodString;
+            rescues: import("zod").ZodOptional<import("zod").ZodInt>;
             remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
                 none: "none";
                 review_retry_policy: "review_retry_policy";
@@ -5163,12 +6194,13 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
                 network_ambiguous: "network_ambiguous";
                 payload_unavailable: "payload_unavailable";
             }>>;
+            dispatchRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
             durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>;
         freshness: import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"authoritative">;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
     readonly scopes: readonly ["occurrences:read"];
     readonly sessionAuthority: "headers";
     readonly summary: "" | "Read a delivery attempt";
@@ -5189,6 +6221,8 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     } | {
         attempt: {
             attemptNumber: number;
+            dispatchRecoveries: number;
+            localReceiptRecoveries: number;
             delivery: string;
             id: string;
             occurrence: string;
@@ -5217,10 +6251,12 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly requestHeaders: import("zod").ZodObject<{
         "Idempotency-Key": import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         attempt: import("zod").ZodObject<{
             id: import("zod").ZodString;
+            localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
             occurrence: import("zod").ZodString;
+            rescues: import("zod").ZodOptional<import("zod").ZodInt>;
             remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
                 none: "none";
                 review_retry_policy: "review_retry_policy";
@@ -5279,12 +6315,13 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
                 network_ambiguous: "network_ambiguous";
                 payload_unavailable: "payload_unavailable";
             }>>;
+            dispatchRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
             durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>;
         freshness: import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"authoritative">;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
 }, {
     readonly scopes: readonly ["schedules:write"];
     readonly sessionAuthority: "headers";
@@ -5294,7 +6331,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         ETag: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
     readonly creates: false;
-    readonly description: "" | "Replaces a schedule's definition, starting a new generation. Takes the same four ways of saying when as a create, so a one-shot can be replaced by a recurring definition and the other way round. An omitted callback endpoint/data pair preserves the stored callback; sending `data` alone replaces the encrypted data for the current endpoint, and sending `endpoint` selects a verified endpoint in the same authority tuple. The occurrence planned under the old definition is settled `skipped_stale` and can never fire unless it was already in flight, in which case its immutable attempt is allowed to settle honestly; a fresh occurrence is planned under the new definition, and the old definition's series stops advancing. `lateness` is resolved afresh against the replacement recurrence: omit it for that kind's default, or state `skipAhead`, `catchUp`, and an optional `maxStalenessSeconds` override. The policy applies only before an occurrence's first attempt; a retry already in progress remains on its retry and give-up ladder. Send `If-Match` with the version you read to make this conditional; without it the replace is unconditional and the last writer wins. A cancelled or completed schedule cannot be replaced. `partitionKey` is fixed when the schedule is created: omit it to preserve the stored value or echo that exact value in a GET → modify → PUT flow. Adding, changing, or clearing it is refused as `invalid_request` with `/partitionKey` identified. `latencyClass` remains derived from the replacement recurrence when the caller omits it.";
+    readonly description: "" | "Replaces a schedule's definition, starting a new generation. Takes the same four ways of saying when as a create, so a one-shot can be replaced by a recurring definition and the other way round. An omitted callback endpoint/data pair preserves the stored callback; sending `data` alone replaces the encrypted data for the current endpoint, and sending `endpoint` selects a verified endpoint in the same authority tuple. Sending `url` instead selects the endpoint at that address in the same tuple, creating one silently when there is none; creating needs `endpoints:write` as well, and the response's `endpointSigningSecret` says where its signing secret is revealed. Omitted `http` preserves HTTP settings. Its headers are a patch: `set` replaces a value, `keep` retains a configured value, `suppress` omits an endpoint default, and `remove` resumes inheritance. Explicit GET with no body clears a saved custom template; POST/PUT with `body: { mode: 'envelope' }` restores the structured callback. The occurrence planned under the old definition is settled `skipped_stale` and can never fire unless it was already in flight, in which case its immutable attempt is allowed to settle honestly; a fresh occurrence is planned under the new definition, and the old definition's series stops advancing. `lateness` is resolved afresh against the replacement recurrence: omit it for that kind's default, or state `skipAhead`, `catchUp`, and an optional `maxStalenessSeconds` override. The policy applies only before an occurrence's first attempt; a retry already in progress remains on its retry and give-up ladder. Send `If-Match` with the version you read to make this conditional; without it the replace is unconditional and the last writer wins. A cancelled or completed schedule cannot be replaced. `partitionKey` is fixed when the schedule is created: omit it to preserve the stored value or echo that exact value in a GET → modify → PUT flow. Adding, changing, or clearing it is refused as `invalid_request` with `/partitionKey` identified. `latencyClass` remains derived from the replacement recurrence when the caller omits it.";
     readonly example: {
         occurrence?: never;
         schedule?: never;
@@ -5336,9 +6373,39 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly method: "PUT";
     readonly mutates: true;
     readonly path: "/v1/schedules/{scheduleId}";
+    readonly conditionalScopes: readonly ["endpoints:write"];
+    readonly conditionalScopesWhen: "the request names a `url` this project and environment has no endpoint at yet";
     readonly principals: readonly ["api-credential", "oauth", "session"];
-    readonly problems: readonly ["invalid_request", "not_found", "plan_limit_reached", "service_unavailable", "state_conflict", "version_conflict"];
+    readonly problems: readonly ["invalid_request", "not_found", "plan_limit_reached", "rate_limited", "scope_missing", "service_unavailable", "state_conflict", "version_conflict"];
     readonly request: import("zod").ZodObject<{
+        http: import("zod").ZodOptional<import("zod").ZodObject<{
+            method: import("zod").ZodOptional<import("zod").ZodEnum<{
+                POST: "POST";
+                PUT: "PUT";
+                GET: "GET";
+            }>>;
+            body: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"envelope">;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"json">;
+                value: import("zod").ZodJSONSchema;
+            }, import("zod/v4/core").$strict>], "mode">>;
+            headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                action: import("zod").ZodLiteral<"set">;
+                name: import("zod").ZodString;
+                value: import("zod").ZodString;
+                secret: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                action: import("zod").ZodLiteral<"keep">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                action: import("zod").ZodLiteral<"remove">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                action: import("zod").ZodLiteral<"suppress">;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>], "action">>>;
+        }, import("zod/v4/core").$strict>>;
         at: import("zod").ZodOptional<import("zod").ZodString>;
         cron: import("zod").ZodOptional<import("zod").ZodString>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
@@ -5356,6 +6423,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
         }, import("zod/v4/core").$strict>>;
         everySeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
         endpoint: import("zod").ZodOptional<import("zod").ZodString>;
+        url: import("zod").ZodOptional<import("zod").ZodString>;
         latencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
             realtime: "realtime";
             bulk: "bulk";
@@ -5392,7 +6460,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly requestHeaders: import("zod").ZodObject<{
         "If-Match": import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         occurrence: import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -5423,6 +6491,34 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             attemptCount: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
         schedule: import("zod").ZodObject<{
+            http: import("zod").ZodOptional<import("zod").ZodObject<{
+                method: import("zod").ZodEnum<{
+                    POST: "POST";
+                    PUT: "PUT";
+                    GET: "GET";
+                }>;
+                body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"envelope">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"json">;
+                    value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+                }, import("zod/v4/core").$strict>], "mode">;
+                headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<false>;
+                    value: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<true>;
+                    configured: import("zod").ZodLiteral<true>;
+                    value: import("zod").ZodOptional<import("zod").ZodNever>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    suppressed: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>>;
             archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
             data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
             createdAt: import("zod").ZodString;
@@ -5474,7 +6570,12 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             updatedAt: import("zod").ZodString;
             version: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+        endpointSigningSecret: import("zod").ZodOptional<import("zod").ZodObject<{
+            guidance: import("zod").ZodString;
+            returned: import("zod").ZodLiteral<false>;
+            revealUrl: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
 }, {
     readonly scopes: readonly ["schedules:write"];
     readonly sessionAuthority: "headers";
@@ -5529,7 +6630,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly requestHeaders: import("zod").ZodObject<{
         "If-Match": import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         occurrence: import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -5560,6 +6661,34 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             attemptCount: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
         schedule: import("zod").ZodObject<{
+            http: import("zod").ZodOptional<import("zod").ZodObject<{
+                method: import("zod").ZodEnum<{
+                    POST: "POST";
+                    PUT: "PUT";
+                    GET: "GET";
+                }>;
+                body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"envelope">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"json">;
+                    value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+                }, import("zod/v4/core").$strict>], "mode">;
+                headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<false>;
+                    value: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<true>;
+                    configured: import("zod").ZodLiteral<true>;
+                    value: import("zod").ZodOptional<import("zod").ZodNever>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    suppressed: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>>;
             archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
             data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
             createdAt: import("zod").ZodString;
@@ -5611,7 +6740,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             updatedAt: import("zod").ZodString;
             version: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
 }, {
     readonly scopes: readonly ["schedules:write"];
     readonly sessionAuthority: "headers";
@@ -5666,7 +6795,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly requestHeaders: import("zod").ZodObject<{
         "If-Match": import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         occurrence: import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -5697,6 +6826,34 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             attemptCount: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
         schedule: import("zod").ZodObject<{
+            http: import("zod").ZodOptional<import("zod").ZodObject<{
+                method: import("zod").ZodEnum<{
+                    POST: "POST";
+                    PUT: "PUT";
+                    GET: "GET";
+                }>;
+                body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"envelope">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"json">;
+                    value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+                }, import("zod/v4/core").$strict>], "mode">;
+                headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<false>;
+                    value: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<true>;
+                    configured: import("zod").ZodLiteral<true>;
+                    value: import("zod").ZodOptional<import("zod").ZodNever>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    suppressed: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>>;
             archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
             data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
             createdAt: import("zod").ZodString;
@@ -5748,7 +6905,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             updatedAt: import("zod").ZodString;
             version: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
 }, {
     readonly scopes: readonly ["schedules:write"];
     readonly sessionAuthority: "headers";
@@ -5804,7 +6961,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly requestHeaders: import("zod").ZodObject<{
         "If-Match": import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         occurrence: import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -5835,6 +6992,34 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             attemptCount: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
         schedule: import("zod").ZodObject<{
+            http: import("zod").ZodOptional<import("zod").ZodObject<{
+                method: import("zod").ZodEnum<{
+                    POST: "POST";
+                    PUT: "PUT";
+                    GET: "GET";
+                }>;
+                body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"envelope">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"json">;
+                    value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+                }, import("zod/v4/core").$strict>], "mode">;
+                headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<false>;
+                    value: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<true>;
+                    configured: import("zod").ZodLiteral<true>;
+                    value: import("zod").ZodOptional<import("zod").ZodNever>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    suppressed: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>>;
             archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
             data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
             createdAt: import("zod").ZodString;
@@ -5886,7 +7071,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             updatedAt: import("zod").ZodString;
             version: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
 }, {
     readonly scopes: readonly ["schedules:write"];
     readonly sessionAuthority: "headers";
@@ -5943,7 +7128,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
     readonly requestHeaders: import("zod").ZodObject<{
         "If-Match": import("zod").ZodOptional<import("zod").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly response: import("zod").ZodObject<{
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         occurrence: import("zod").ZodObject<{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
@@ -5974,6 +7159,34 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             attemptCount: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
         schedule: import("zod").ZodObject<{
+            http: import("zod").ZodOptional<import("zod").ZodObject<{
+                method: import("zod").ZodEnum<{
+                    POST: "POST";
+                    PUT: "PUT";
+                    GET: "GET";
+                }>;
+                body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"envelope">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    mode: import("zod").ZodLiteral<"json">;
+                    value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+                }, import("zod/v4/core").$strict>], "mode">;
+                headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<false>;
+                    value: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    secret: import("zod").ZodLiteral<true>;
+                    configured: import("zod").ZodLiteral<true>;
+                    value: import("zod").ZodOptional<import("zod").ZodNever>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    suppressed: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strict>>;
             archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
             data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
             createdAt: import("zod").ZodString;
@@ -6025,7 +7238,7 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
             updatedAt: import("zod").ZodString;
             version: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip> | import("zod").ZodNever;
+    }, import("zod/v4/core").$strip>;
 }];
 /**
  * Every declared operation id, as a literal union.
@@ -6036,6 +7249,40 @@ export declare const OPERATIONS: readonly [OperationDefinition & {
  * list and the implementation can drift together while the test still passes.
  */
 export type OperationId = (typeof OPERATIONS)[number]["id"];
+/**
+ * The body a caller sends to an operation, as its request schema accepts it.
+ *
+ * What the generated client types each builder's `body` with (W9-46). Until
+ * then every body was `unknown`, so a field the API had accepted for weeks —
+ * `url` on `schedules.create` — compiled exactly as well as a misspelling of
+ * it, and the published package could not tell a TypeScript reader either was
+ * wrong. The schema's *input* rather than its output: a caller writes what the
+ * schema parses, before defaults and transforms.
+ */
+export type OperationRequestBody<TId extends OperationId> = [
+    OperationEntry<TId>
+] extends [never] ? unknown : OperationEntry<TId> extends {
+    readonly request: infer TSchema extends z.ZodTypeAny;
+} ? ReadonlyInput<z.input<TSchema>> : unknown;
+/**
+ * A request body as a caller may hold it: readonly at every depth.
+ *
+ * A builder only reads what it is handed, and a caller keeping its settings in
+ * `readonly` arrays (the dashboard's header changes do) should not have to copy
+ * them to satisfy a type that promises nothing about mutation.
+ */
+type ReadonlyInput<T> = T extends readonly (infer TItem)[] ? readonly ReadonlyInput<TItem>[] : T extends object ? {
+    readonly [TKey in keyof T]: ReadonlyInput<T[TKey]>;
+} : T;
+/**
+ * One registry entry, by id — `never` for an entry contributed by a module
+ * that declares its operations as plain `OperationDefinition`s, whose `id` is
+ * `string`. Those bodies stay `unknown` rather than collapsing to `never`,
+ * which would make the operation uncallable.
+ */
+type OperationEntry<TId extends OperationId> = Extract<(typeof OPERATIONS)[number], {
+    readonly id: TId;
+}>;
 /**
  * Headers the contract mock uses to expose state a body cannot carry.
  *