@greatwait/contracts 0.3.1 → 0.3.2

package/dist/operations.d.ts

@@ -767,17 +767,22 @@ export declare const OPERATIONS: readonly [{
                 memberIds: import("zod").ZodArray<import("zod").ZodString>;
             }, import("zod/v4/core").$strict>], "kind">;
             scheduleKinds: import("zod").ZodEnum<{
+                recurring: "recurring";
                 both: "both";
                 "one-shot": "one-shot";
-                recurring: "recurring";
             }>;
         }, import("zod/v4/core").$strict>>;
-        statusWebhook: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
+        statusWebhook: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            endpoint: import("zod").ZodString;
+            events: import("zod").ZodArray<import("zod").ZodEnum<{
+                failed: "failed";
+            }>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
             url: import("zod").ZodString;
             events: import("zod").ZodArray<import("zod").ZodEnum<{
                 failed: "failed";
             }>>;
-        }, import("zod/v4/core").$strict>>>;
+        }, import("zod/v4/core").$strict>]>>>;
     }, import("zod/v4/core").$strict>;
 }, OperationDefinition & {
     readonly id: "projectnotifications.rotateSigningKey";
@@ -1191,7 +1196,7 @@ export declare const OPERATIONS: readonly [{
     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.";
+    readonly description: "" | "Lists the caller's callback endpoints for exactly its own project and environment, oldest first, one page at a time (default 25, at most 100): follow `nextCursor` until it is absent before counting endpoints or concluding one does not exist. Optional `text` (case-insensitive substring of the name, address or identifier), `status` and `rotation=unacknowledged` filters intersect before paging, so a match on any page is found on the first; a cursor continues only under the filters that issued it. Metadata only: no signing secret or sealed key material has a field in this shape.";
     readonly example: {
         data?: never;
         freshness?: never;
@@ -1228,6 +1233,14 @@ export declare const OPERATIONS: readonly [{
     readonly query: import("zod").ZodObject<{
         cursor: import("zod").ZodOptional<import("zod").ZodString>;
         limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        text: import("zod").ZodOptional<import("zod").ZodString>;
+        status: import("zod").ZodOptional<import("zod").ZodEnum<{
+            active: "active";
+            disabled: "disabled";
+        }>>;
+        rotation: import("zod").ZodOptional<import("zod").ZodEnum<{
+            unacknowledged: "unacknowledged";
+        }>>;
     }, import("zod/v4/core").$strip>;
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         data: import("zod").ZodArray<import("zod").ZodObject<{
@@ -2991,19 +3004,13 @@ export declare const OPERATIONS: readonly [{
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Lists the active and archived projects in the signed-in member's organization, with the environment kinds, lifecycle state, version and deletion-preview counts each one has. Active and archived rows both occupy a plan slot; deleted projects are absent. Archived rows are management targets rather than projects work may run inside, so a picker must not offer them as switch targets. The result is a display aid rather than an authorization control — naming a project on a later request re-resolves it against the member's own organization, and a project that is not theirs answers exactly as one that does not exist.";
+    readonly description: "" | "Lists the active and archived projects in the signed-in member's organization, with the environment kinds, lifecycle state and version each one has. It carries no deletion counts: counting reads a project's whole history, so the exact counts a permanent deletion would destroy come from `projects.read`, one project at a time. Active and archived rows both occupy a plan slot; deleted projects are absent. Archived rows are management targets rather than projects work may run inside, so a picker must not offer them as switch targets. The result is a display aid rather than an authorization control — naming a project on a later request re-resolves it against the member's own organization, and a project that is not theirs answers exactly as one that does not exist.";
     readonly example: {
         data?: never;
         total?: never;
     } | {
         data: {
             createdAt: string;
-            deletionCounts: {
-                endpoints: number;
-                keys: number;
-                runs: number;
-                schedules: number;
-            };
             environmentKinds: string[];
             id: string;
             name: string;
@@ -3025,24 +3032,18 @@ export declare const OPERATIONS: readonly [{
     readonly problems: readonly [];
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
         data: import("zod").ZodArray<import("zod").ZodObject<{
-            createdAt: import("zod").ZodNullable<import("zod").ZodString>;
-            deletionCounts: import("zod").ZodObject<{
-                endpoints: import("zod").ZodNumber;
-                keys: import("zod").ZodNumber;
-                runs: import("zod").ZodNumber;
-                schedules: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            environmentKinds: import("zod").ZodArray<import("zod").ZodEnum<{
-                test: "test";
-                live: "live";
-            }>>;
-            id: import("zod").ZodString;
-            name: import("zod").ZodString;
             status: import("zod").ZodEnum<{
                 active: "active";
                 archived: "archived";
             }>;
+            name: import("zod").ZodString;
             version: import("zod").ZodNumber;
+            id: import("zod").ZodString;
+            createdAt: import("zod").ZodNullable<import("zod").ZodString>;
+            environmentKinds: import("zod").ZodArray<import("zod").ZodEnum<{
+                test: "test";
+                live: "live";
+            }>>;
         }, import("zod/v4/core").$strip>>;
         total: import("zod").ZodNumber;
     }, import("zod/v4/core").$strip>;
@@ -3050,6 +3051,69 @@ export declare const OPERATIONS: readonly [{
     readonly sessionAuthority: "organization";
     readonly summary: "" | "List the member's projects";
     readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly scopes: readonly ["projects:read"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Read a project with its deletion counts";
+    readonly surfaces: readonly ["api", "mock"];
+    readonly responseHeaders?: import("zod").ZodObject<{
+        ETag: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    readonly creates: false;
+    readonly description: "" | "Reads one active or archived project in the signed-in member's organization, with the exact counts of the schedules, endpoints, keys and runs a permanent deletion would destroy now. Counting reads the project's whole history, which is why the list does not carry these counts and why this is the read a deletion confirmation makes. A project the member cannot see answers exactly as one that does not exist.";
+    readonly example: {
+        createdAt?: never;
+        deletionCounts?: never;
+        environmentKinds?: never;
+        id?: never;
+        name?: never;
+        status?: never;
+        version?: never;
+    } | {
+        createdAt: string;
+        deletionCounts: {
+            endpoints: number;
+            keys: number;
+            runs: number;
+            schedules: number;
+        };
+        environmentKinds: string[];
+        id: string;
+        name: string;
+        status: string;
+        version: number;
+    };
+    readonly id: "projects.read";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly kind: "unavailable";
+        readonly reason: "The counted read is the deletion preview a signed-in member sees before deleting a project. Counting reads the project's whole history, so it is not offered as an agent tool; rename, archive and delete each answer with the project they changed.";
+    };
+    readonly method: "GET";
+    readonly mutates: false;
+    readonly path: "/v1/projects/{projectId}";
+    readonly principals: readonly ["session"];
+    readonly problems: readonly ["not_found"];
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        createdAt: import("zod").ZodNullable<import("zod").ZodString>;
+        deletionCounts: import("zod").ZodObject<{
+            endpoints: import("zod").ZodNumber;
+            keys: import("zod").ZodNumber;
+            runs: import("zod").ZodNumber;
+            schedules: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        environmentKinds: import("zod").ZodArray<import("zod").ZodEnum<{
+            test: "test";
+            live: "live";
+        }>>;
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        status: import("zod").ZodEnum<{
+            active: "active";
+            archived: "archived";
+        }>;
+        version: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
 }, {
     readonly creates: true;
     readonly description: "" | "Creates a project in the signed-in member's organization, with both of its environments. This is the first call a new customer makes: an organization has no project until somebody makes one, and every other operation on this surface acts inside one. The `test` and `live` environments are provisioned with it in a single transaction rather than asked for, so a project is never observable in a half-provisioned state. The organization comes from the verified session and is never read from the request — a member who belongs to one organization cannot create a project in another. `PROJECT_LIST_LIMIT` bounds how many an organization may hold, and it is the same ceiling the listing publishes: a create that would take an organization past a list it can no longer return is refused rather than silently truncating a later read. A name is unique within the organization, compared ignoring case and surrounding or repeated spaces; a second project with a name already taken is refused with `state_conflict`, and the refusal says nothing about any other organization's names.";
@@ -3778,8 +3842,9 @@ export declare const OPERATIONS: readonly [{
         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";
+            realtime: "realtime";
+            auto: "auto";
         }>>;
         lateness: import("zod").ZodOptional<import("zod").ZodObject<{
             maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -3823,6 +3888,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -3903,9 +3969,14 @@ export declare const OPERATIONS: readonly [{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
             latencyClass: import("zod").ZodEnum<{
-                realtime: "realtime";
                 bulk: "bulk";
+                realtime: "realtime";
             }>;
+            requestedLatencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bulk: "bulk";
+                realtime: "realtime";
+                auto: "auto";
+            }>>;
             lateness: import("zod").ZodObject<{
                 maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 policy: import("zod").ZodEnum<{
@@ -4005,6 +4076,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -4085,9 +4157,14 @@ export declare const OPERATIONS: readonly [{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
             latencyClass: import("zod").ZodEnum<{
-                realtime: "realtime";
                 bulk: "bulk";
+                realtime: "realtime";
             }>;
+            requestedLatencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bulk: "bulk";
+                realtime: "realtime";
+                auto: "auto";
+            }>>;
             lateness: import("zod").ZodObject<{
                 maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 policy: import("zod").ZodEnum<{
@@ -4122,7 +4199,7 @@ export declare const OPERATIONS: readonly [{
     }, 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.";
+    readonly description: "" | "Lists the caller's own schedules one page at a time (default 25, at most 100); follow `nextCursor` until it is absent before counting or ranking schedules, or use schedules.summary for whole-project counts. `order=created` (the default) walks creation order and includes every unarchived schedule; `order=due` walks next-due order and includes only schedules with an occurrence on the books, so cancelled, completed and paused schedules with nothing upcoming are not in it. Giving `dueBefore` or `dueAfter` forces due order. `direction=desc` reverses either order: newest-created first, or latest-due first. Due-order paging is not stable while schedules fire: a schedule's next-due instant moves as it runs, so across pages it can appear twice or be skipped; read again from the first page, or de-duplicate by id, when exactness matters. Archived schedules are left out. Give `endpoint` to keep the page to the schedules that deliver to that endpoint, or `text`, `status`, `recurrence`, `tag` or `external_identifier` to filter; filters intersect before paging, and a cursor continues only under the order, direction and filters that issued it. Creation order examines a bounded number of schedules per page, so a page filtered by `status`, or one crossing many archived schedules, can come back short, or empty, and still carry `nextCursor`: keep following it. Every page is authoritative.";
     readonly example: {
         data?: never;
         freshness?: never;
@@ -4145,9 +4222,7 @@ export declare const OPERATIONS: readonly [{
             version: number;
         }[];
         freshness: {
-            asOf: string;
             kind: string;
-            lagSeconds: number;
         };
         nextCursor: string;
     };
@@ -4170,6 +4245,10 @@ export declare const OPERATIONS: readonly [{
             due: "due";
             created: "created";
         }>>;
+        direction: import("zod").ZodDefault<import("zod").ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
         external_identifier: import("zod").ZodOptional<import("zod").ZodString>;
         tag: import("zod").ZodOptional<import("zod").ZodString>;
         status: import("zod").ZodOptional<import("zod").ZodEnum<{
@@ -4246,9 +4325,14 @@ export declare const OPERATIONS: readonly [{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
             latencyClass: import("zod").ZodEnum<{
-                realtime: "realtime";
                 bulk: "bulk";
+                realtime: "realtime";
             }>;
+            requestedLatencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bulk: "bulk";
+                realtime: "realtime";
+                auto: "auto";
+            }>>;
             lateness: import("zod").ZodObject<{
                 maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 policy: import("zod").ZodEnum<{
@@ -4293,6 +4377,97 @@ export declare const OPERATIONS: readonly [{
     readonly sessionAuthority: "headers";
     readonly summary: "" | "List schedules";
     readonly surfaces: readonly ["api", "mock"];
+}, {
+    readonly creates: false;
+    readonly description: "" | "Summarizes every retained, unarchived schedule in the caller's project and environment: exact counts by status (active, paused, completed, cancelled), how many paused schedules paused themselves after repeated failures with up to five of them, and per-day created and finished counts for the last 30 days (today included, zero days included) in `timeZone` (default UTC). Use this rather than counting schedules_list pages. The answer is computed on read and reused for up to five minutes per project, environment and time zone: `freshness` is projected, with `asOf` the instant the counts were taken and `lagSeconds` their age. Counts cover retained schedules only; retention removes cancelled schedules and one-offs that ran once their history horizon passes.";
+    readonly example: {
+        counts?: never;
+        days?: never;
+        freshness?: never;
+        pausedAfterFailures?: never;
+        window?: never;
+    } | {
+        counts: {
+            active: number;
+            cancelled: number;
+            completed: number;
+            paused: number;
+        };
+        days: {
+            created: number;
+            date: string;
+            finished: number;
+        }[];
+        freshness: {
+            asOf: string;
+            kind: string;
+            lagSeconds: number;
+        };
+        pausedAfterFailures: {
+            count: number;
+            schedules: never[];
+        };
+        window: {
+            from: string;
+            timeZone: string;
+            to: string;
+        };
+    };
+    readonly id: "schedules.summary";
+    readonly idempotent: true;
+    readonly mcp: {
+        readonly destructive: false;
+        readonly kind: "tool";
+        readonly openWorld: false;
+    };
+    readonly method: "GET";
+    readonly mutates: false;
+    readonly path: "/v1/schedule-summary";
+    readonly principals: readonly ["api-credential", "oauth", "session"];
+    readonly problems: readonly ["invalid_request"];
+    readonly query: import("zod").ZodObject<{
+        timeZone: import("zod").ZodDefault<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>>;
+    }, import("zod/v4/core").$strip>;
+    readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        counts: import("zod").ZodObject<{
+            active: import("zod").ZodNumber;
+            paused: import("zod").ZodNumber;
+            completed: import("zod").ZodNumber;
+            cancelled: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        pausedAfterFailures: import("zod").ZodObject<{
+            count: import("zod").ZodNumber;
+            schedules: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+                autoPauseReason: import("zod").ZodObject<{
+                    failedRuns: import("zod").ZodNumber;
+                    status: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    diagnostic: import("zod").ZodString;
+                    pausedAt: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        days: import("zod").ZodArray<import("zod").ZodObject<{
+            date: import("zod").ZodString;
+            created: import("zod").ZodNumber;
+            finished: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+        window: import("zod").ZodObject<{
+            from: import("zod").ZodString;
+            to: import("zod").ZodString;
+            timeZone: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+        }, import("zod/v4/core").$strip>;
+        freshness: import("zod").ZodObject<{
+            asOf: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"projected">;
+            lagSeconds: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    readonly scopes: readonly ["schedules:read"];
+    readonly sessionAuthority: "headers";
+    readonly summary: "" | "Summarize 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 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.";
@@ -4370,8 +4545,8 @@ export declare const OPERATIONS: readonly [{
                 lastGroup: import("zod").ZodOptional<import("zod").ZodObject<{
                     start: import("zod").ZodString;
                     latencyClass: import("zod").ZodEnum<{
-                        realtime: "realtime";
                         bulk: "bulk";
+                        realtime: "realtime";
                     }>;
                     partitionKey: import("zod").ZodString;
                 }, import("zod/v4/core").$strip>>;
@@ -4448,6 +4623,18 @@ export declare const OPERATIONS: readonly [{
                 enforced: "enforced";
             }>;
         }, import("zod/v4/core").$strip>;
+        attemptPrice: import("zod").ZodOptional<import("zod").ZodObject<{
+            bulk: import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>;
+            realtime: import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>>;
         blockingReasons: import("zod").ZodArray<import("zod").ZodEnum<{
             "billing-state-missing": "billing-state-missing";
             "billing-account-closed": "billing-account-closed";
@@ -4913,9 +5100,9 @@ export declare const OPERATIONS: readonly [{
             restrictions: import("zod").ZodArray<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>;
     }, import("zod/v4/core").$strip>;
-}, NamedOperation<"billing.notices">, NamedOperation<"billing.notificationsettings">, NamedOperation<"billing.notificationsettingsupdate">, {
+}, NamedOperation<"billing.notices">, NamedOperation<"billing.noticesdismiss">, NamedOperation<"billing.notificationsettings">, NamedOperation<"billing.notificationsettingsupdate">, {
     readonly creates: false;
-    readonly description: "" | "Reads the verified principal's authoritative execution-funding position, including available and reserved credit, amount owed, recurring project fees, the current UTC month's automatic-charge ceiling and its settled, pending and remaining gross authority, and bounded payment history. Manual purchases and project subscriptions are separately authorized and never consume the automatic ceiling. Pending gross charges include applicable tax; refunds never restore monthly automatic purchasing authority. Receipt and payment links are limited to supported provider-hosted HTTPS URLs.";
+    readonly description: "" | "Reads the verified principal's authoritative execution-funding position, including available and reserved credit, amount owed, recurring project fees, the current UTC month's automatic-charge ceiling and its settled, pending and remaining gross authority, and bounded recent payment history in `paymentOperations` (billing.paymenthistory pages through the full history with a cursor). Manual purchases and project subscriptions are separately authorized and never consume the automatic ceiling. Pending gross charges include applicable tax; refunds never restore monthly automatic purchasing authority. Receipt and payment links are limited to supported provider-hosted HTTPS URLs.";
     readonly id: "billing.funding";
     readonly idempotent: true;
     readonly mcp: {
@@ -5567,7 +5754,7 @@ export declare const OPERATIONS: readonly [{
     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 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; billing.invoicehistory pages through the full history with a cursor. Execution-credit purchases are not listed here; billing.paymenthistory pages through 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;
     } | {
@@ -5805,6 +5992,18 @@ export declare const OPERATIONS: readonly [{
                 enforced: "enforced";
             }>;
         }, import("zod/v4/core").$strip>;
+        attemptPrice: import("zod").ZodOptional<import("zod").ZodObject<{
+            bulk: import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>;
+            realtime: import("zod").ZodObject<{
+                currency: import("zod").ZodLiteral<"USD">;
+                microdollars: import("zod").ZodString;
+                scale: import("zod").ZodLiteral<6>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>>;
         blockingReasons: import("zod").ZodArray<import("zod").ZodEnum<{
             "billing-state-missing": "billing-state-missing";
             "billing-account-closed": "billing-account-closed";
@@ -6237,7 +6436,7 @@ export declare const OPERATIONS: readonly [{
         revision?: never;
     } | {
         limits: {
-            inlinePayloadBytes: number;
+            inlinePayloadBytes: 8192;
             forecastHorizonSeconds: number;
             usageWindowDays: number;
         };
@@ -6274,26 +6473,26 @@ export declare const OPERATIONS: readonly [{
             inlinePayloadBytes: import("zod").ZodEnum<{
                 organization: "organization";
                 default: "default";
-                global: "global";
                 deployment: "deployment";
+                global: "global";
             }>;
             partitionKeyCeiling: import("zod").ZodOptional<import("zod").ZodEnum<{
                 organization: "organization";
                 default: "default";
-                global: "global";
                 deployment: "deployment";
+                global: "global";
             }>>;
             forecastHorizonSeconds: import("zod").ZodEnum<{
                 organization: "organization";
                 default: "default";
-                global: "global";
                 deployment: "deployment";
+                global: "global";
             }>;
             usageWindowDays: import("zod").ZodEnum<{
                 organization: "organization";
                 default: "default";
-                global: "global";
                 deployment: "deployment";
+                global: "global";
             }>;
         }, import("zod/v4/core").$strict>;
         revision: import("zod").ZodObject<{
@@ -6383,8 +6582,9 @@ export declare const OPERATIONS: readonly [{
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Reads the verified principal's project timing cohort over the authoritative rolling 24-hour due-time window. Exact 5,000ms and 15,000ms counters include eligible work that has not fired; customer blocks, platform blocks, skipped work and missing evidence stay visible beside the verdict. Values equal to a target meet it, and a threshold with no matured population is unknown. Delivered-sample p95 and p99 lateness are separate observations, including negative early-delivery defects. These are internal operating objectives, not a contractual SLA or service-credit promise.";
+    readonly description: "" | "Reads the verified principal's project timing cohort over the authoritative rolling 24-hour due-time window. Policy timing-v2-service-bands judges each run from its original plannedFor against its occurrence service band's p95 first-outbound target: realtime 1,000ms, short_bulk 10,000ms, bulk 60,000ms. bandTargets contains the exact per-band counts and 95% verdicts; targets retains the 5,000ms (95%) and 15,000ms (99%) counters for legacy rows with no band only. All counters include eligible work that has not fired; customer blocks, platform blocks, skipped work and missing evidence stay visible beside the verdict. Values equal to a target meet it, and a threshold with no matured population is unknown. Delivered-sample p95 and p99 lateness are separate observations, including negative early-delivery defects. These are internal operating objectives, not a contractual SLA or service-credit promise.";
     readonly example: {
+        bandTargets?: never;
         customerBlockedCount?: never;
         deliveredSampleCount?: never;
         freshness?: never;
@@ -6398,6 +6598,16 @@ export declare const OPERATIONS: readonly [{
         windowEnd?: never;
         windowStart?: never;
     } | {
+        bandTargets: {
+            serviceBand: string;
+            targetMs: number;
+            breachCount: number;
+            customerBlockedCount: number;
+            eligibleOutstandingBreachCount: number;
+            maturedCount: number;
+            verdict: string;
+            withinTargetCount: number;
+        }[];
         customerBlockedCount: number;
         deliveredSampleCount: number;
         freshness: {
@@ -6434,6 +6644,24 @@ export declare const OPERATIONS: readonly [{
     readonly principals: readonly ["api-credential", "oauth", "session"];
     readonly problems: readonly [];
     readonly response: import("zod").ZodNever | import("zod").ZodObject<{
+        bandTargets: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            serviceBand: import("zod").ZodEnum<{
+                short_bulk: "short_bulk";
+                bulk: "bulk";
+                realtime: "realtime";
+            }>;
+            targetMs: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<1000>, import("zod").ZodLiteral<10000>, import("zod").ZodLiteral<60000>]>;
+            breachCount: import("zod").ZodInt;
+            customerBlockedCount: import("zod").ZodInt;
+            eligibleOutstandingBreachCount: import("zod").ZodInt;
+            maturedCount: import("zod").ZodInt;
+            verdict: import("zod").ZodEnum<{
+                unknown: "unknown";
+                met: "met";
+                missed: "missed";
+            }>;
+            withinTargetCount: import("zod").ZodInt;
+        }, import("zod/v4/core").$strip>>>;
         customerBlockedCount: import("zod").ZodInt;
         deliveredSampleCount: import("zod").ZodInt;
         freshness: import("zod").ZodObject<{
@@ -6594,6 +6822,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -6629,7 +6858,7 @@ export declare const OPERATIONS: readonly [{
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Lists every retained occurrence in the verified principal's project and environment, newest first by planned instant with the occurrence identifier breaking millisecond ties. Optional endpoint, schedule, half-open date-range and outcome filters may be combined; the endpoint is resolved through the schedules that belong to the same authority. The opaque cursor belongs to this operation and the exact normalized filters that issued it, so it cannot be replayed under another view. Every page publishes the authoritative earliest retained instant for the caller's effective plan. Each item is metadata only: callback payloads, destinations, response bodies and signing material have no field in the response.";
+    readonly description: "" | "Lists retained occurrences in the verified principal's project and environment one page at a time, newest first by planned instant with the occurrence identifier breaking millisecond ties; follow `nextCursor` until it is absent before counting or ranking. The `outcome` filter is applied after a bounded read, so a page can come back short, or empty, and still carry `nextCursor`: keep following it. Optional endpoint, schedule, half-open date-range and outcome filters may be combined; the endpoint is resolved through the schedules that belong to the same authority. The opaque cursor belongs to this operation and the exact normalized filters that issued it, so it cannot be replayed under another view. Every page publishes the authoritative earliest retained instant for the caller's effective plan. Each item carries its schedule's name as `scheduleName`, so a page of runs needs no schedule read per row. Each item is metadata only: callback payloads, destinations, response bodies and signing material have no field in the response.";
     readonly example: {
         data?: never;
         freshness?: never;
@@ -6641,6 +6870,7 @@ export declare const OPERATIONS: readonly [{
             id: string;
             plannedFor: string;
             schedule: string;
+            scheduleName: string;
             sequence: number;
             settledAt: string;
             state: string;
@@ -6703,6 +6933,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -6741,7 +6972,7 @@ export declare const OPERATIONS: readonly [{
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Reads one retained occurrence from the PostgreSQL authority that owns its schedule. Trusted first-outbound timing is optional for records that predate substantiation; when present, firstAttemptLatenessMs is signed and a negative value exposes an early-delivery defect rather than being clamped to zero. Timing eligibility states whether a customer restriction excluded the occurrence from the internal target cohort. An identifier outside the verified principal's organization, project or environment is indistinguishable from an absent occurrence.";
+    readonly description: "" | "Reads one retained occurrence from the PostgreSQL authority that owns its schedule. Trusted first-outbound timing is optional for records that predate substantiation; when present, firstAttemptLatenessMs is signed and a negative value exposes an early-delivery defect rather than being clamped to zero. Timing eligibility states whether a customer restriction excluded the occurrence from the internal target cohort. An identifier outside the verified principal's organization, project or environment is indistinguishable from an absent occurrence. timingPolicyVersion is timing-v2-service-bands when first-outbound evidence is recorded for a banded occurrence; legacy null-band occurrences retain their recorded policy (including payg-v1) and the 5,000ms/15,000ms thresholds.";
     readonly example: {
         freshness?: never;
         occurrence?: never;
@@ -6785,6 +7016,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -6816,7 +7048,7 @@ export declare const OPERATIONS: readonly [{
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Search all retained delivery attempts by actual startedAt in the required UTC interval [startedFrom, startedBefore), newest first with attempt ID breaking ties. Combine HTTP responseStatus, statusClass, attempt outcome or diagnostic, endpoint, schedule and exact host identifier/tag filters. The matched attempt outcome remains searchable after recovery; occurrence.state is its current outcome. Follow schedule and occurrence IDs to retained details and attempts.list for the complete retry chain. Only safe metadata is returned. Retention horizons describe normal plan history and attempt-detail limits; absence after expiry is not evidence that a delivery never happened. Unavailable queries fail explicitly. Cursors are bound to the verified authority and every selected filter.";
+    readonly description: "" | "Search retained delivery attempts one page at a time by actual startedAt in the required UTC interval [startedFrom, startedBefore), newest first with attempt ID breaking ties; follow `nextCursor` until it is absent before counting. The `outcome` and `diagnostic` filters are applied after a bounded read, so a page can come back short, or empty, and still carry `nextCursor`: keep following it. Combine HTTP responseStatus, statusClass, attempt outcome or diagnostic, endpoint, schedule and exact host identifier/tag filters. The matched attempt outcome remains searchable after recovery; occurrence.state is its current outcome. Follow schedule and occurrence IDs to retained details and attempts.list for the complete retry chain. Only safe metadata is returned. Retention horizons describe normal plan history and attempt-detail limits; absence after expiry is not evidence that a delivery never happened. Unavailable queries fail explicitly. Cursors are bound to the verified authority and every selected filter.";
     readonly example: {
         data?: never;
         freshness?: never;
@@ -6962,6 +7194,7 @@ export declare const OPERATIONS: readonly [{
                 id: import("zod").ZodString;
                 plannedFor: import("zod").ZodString;
                 schedule: import("zod").ZodString;
+                scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
                 sequence: import("zod").ZodNumber;
                 settledAt: import("zod").ZodOptional<import("zod").ZodString>;
                 state: import("zod").ZodEnum<{
@@ -7009,7 +7242,7 @@ export declare const OPERATIONS: readonly [{
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Lists the immutable attempts retained under one occurrence, ordered by start instant and attempt identifier so equal timestamps have a stable position. The PostgreSQL authority answers every page. Optional first-outbound fields carry trusted occurrence timing and its pinned policy; absence means unknown, never zero. Results expose only bounded outcome, response-status, duration, timing, diagnostic, remediation and redelivery-cause metadata; callback payloads, response bodies, destinations, signing material, secrets and transport traces are structurally absent.";
+    readonly description: "" | "Lists the immutable attempts retained under one occurrence, ordered by start instant and attempt identifier so equal timestamps have a stable position. The PostgreSQL authority answers every page. Optional first-outbound fields carry trusted occurrence timing and its pinned policy; absence means unknown, never zero. Results expose only bounded outcome, response-status, duration, timing, diagnostic, remediation and redelivery-cause metadata; callback payloads, response bodies, destinations, signing material, secrets and transport traces are structurally absent. timingPolicyVersion is timing-v2-service-bands when first-outbound evidence is recorded for a banded occurrence; legacy null-band occurrences retain their recorded policy (including payg-v1) and the 5,000ms/15,000ms thresholds.";
     readonly example: {
         data?: never;
         freshness?: never;
@@ -7122,6 +7355,12 @@ export declare const OPERATIONS: readonly [{
                 expired: "expired";
                 not_captured: "not_captured";
             }>>;
+            requestUnavailable: import("zod").ZodOptional<import("zod").ZodEnum<{
+                schedule_changed: "schedule_changed";
+                endpoint_changed: "endpoint_changed";
+                endpoint_deleted: "endpoint_deleted";
+                payload_deleted: "payload_deleted";
+            }>>;
             responseHeaders: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 value: import("zod").ZodString;
@@ -7180,7 +7419,7 @@ export declare const OPERATIONS: readonly [{
     readonly surfaces: readonly ["api", "mock"];
 }, {
     readonly creates: false;
-    readonly description: "" | "Reads one immutable delivery attempt from its occurrence's PostgreSQL authority. Ambiguous means the receiver may have acted and is never rewritten into certainty without durable result evidence. Optional first-outbound fields come only from trusted transport evidence and absence means unknown, never zero. The bounded response omits callback payloads, response bodies, destinations, signing material, secrets and raw transport failures by construction.";
+    readonly description: "" | "Reads one immutable delivery attempt from its occurrence's PostgreSQL authority. Ambiguous means the receiver may have acted and is never rewritten into certainty without durable result evidence. Optional first-outbound fields come only from trusted transport evidence and absence means unknown, never zero. The bounded response omits callback payloads, response bodies, destinations, signing material, secrets and raw transport failures by construction. timingPolicyVersion is timing-v2-service-bands when first-outbound evidence is recorded for a banded occurrence; legacy null-band occurrences retain their recorded policy (including payg-v1) and the 5,000ms/15,000ms thresholds.";
     readonly example: {
         attempt?: never;
         freshness?: never;
@@ -7286,6 +7525,12 @@ export declare const OPERATIONS: readonly [{
                 expired: "expired";
                 not_captured: "not_captured";
             }>>;
+            requestUnavailable: import("zod").ZodOptional<import("zod").ZodEnum<{
+                schedule_changed: "schedule_changed";
+                endpoint_changed: "endpoint_changed";
+                endpoint_deleted: "endpoint_deleted";
+                payload_deleted: "payload_deleted";
+            }>>;
             responseHeaders: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 value: import("zod").ZodString;
@@ -7451,6 +7696,12 @@ export declare const OPERATIONS: readonly [{
                 expired: "expired";
                 not_captured: "not_captured";
             }>>;
+            requestUnavailable: import("zod").ZodOptional<import("zod").ZodEnum<{
+                schedule_changed: "schedule_changed";
+                endpoint_changed: "endpoint_changed";
+                endpoint_deleted: "endpoint_deleted";
+                payload_deleted: "payload_deleted";
+            }>>;
             responseHeaders: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 value: import("zod").ZodString;
@@ -7606,8 +7857,9 @@ export declare const OPERATIONS: readonly [{
         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";
+            realtime: "realtime";
+            auto: "auto";
         }>>;
         lateness: import("zod").ZodOptional<import("zod").ZodObject<{
             maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -7649,6 +7901,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -7729,9 +7982,14 @@ export declare const OPERATIONS: readonly [{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
             latencyClass: import("zod").ZodEnum<{
-                realtime: "realtime";
                 bulk: "bulk";
+                realtime: "realtime";
             }>;
+            requestedLatencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bulk: "bulk";
+                realtime: "realtime";
+                auto: "auto";
+            }>>;
             lateness: import("zod").ZodObject<{
                 maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 policy: import("zod").ZodEnum<{
@@ -7829,6 +8087,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -7909,9 +8168,14 @@ export declare const OPERATIONS: readonly [{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
             latencyClass: import("zod").ZodEnum<{
-                realtime: "realtime";
                 bulk: "bulk";
+                realtime: "realtime";
             }>;
+            requestedLatencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bulk: "bulk";
+                realtime: "realtime";
+                auto: "auto";
+            }>>;
             lateness: import("zod").ZodObject<{
                 maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 policy: import("zod").ZodEnum<{
@@ -8004,6 +8268,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -8084,9 +8349,14 @@ export declare const OPERATIONS: readonly [{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
             latencyClass: import("zod").ZodEnum<{
-                realtime: "realtime";
                 bulk: "bulk";
+                realtime: "realtime";
             }>;
+            requestedLatencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bulk: "bulk";
+                realtime: "realtime";
+                auto: "auto";
+            }>>;
             lateness: import("zod").ZodObject<{
                 maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 policy: import("zod").ZodEnum<{
@@ -8180,6 +8450,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -8260,9 +8531,14 @@ export declare const OPERATIONS: readonly [{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
             latencyClass: import("zod").ZodEnum<{
-                realtime: "realtime";
                 bulk: "bulk";
+                realtime: "realtime";
             }>;
+            requestedLatencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bulk: "bulk";
+                realtime: "realtime";
+                auto: "auto";
+            }>>;
             lateness: import("zod").ZodObject<{
                 maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 policy: import("zod").ZodEnum<{
@@ -8357,6 +8633,7 @@ export declare const OPERATIONS: readonly [{
             id: import("zod").ZodString;
             plannedFor: import("zod").ZodString;
             schedule: import("zod").ZodString;
+            scheduleName: import("zod").ZodOptional<import("zod").ZodString>;
             sequence: import("zod").ZodNumber;
             settledAt: import("zod").ZodOptional<import("zod").ZodString>;
             state: import("zod").ZodEnum<{
@@ -8437,9 +8714,14 @@ export declare const OPERATIONS: readonly [{
             generation: import("zod").ZodNumber;
             id: import("zod").ZodString;
             latencyClass: import("zod").ZodEnum<{
-                realtime: "realtime";
                 bulk: "bulk";
+                realtime: "realtime";
             }>;
+            requestedLatencyClass: import("zod").ZodOptional<import("zod").ZodEnum<{
+                bulk: "bulk";
+                realtime: "realtime";
+                auto: "auto";
+            }>>;
             lateness: import("zod").ZodObject<{
                 maxStalenessSeconds: import("zod").ZodOptional<import("zod").ZodNumber>;
                 policy: import("zod").ZodEnum<{