@greatwait/contracts 0.2.3 → 0.3.1

package/dist/operations.js

@@ -1,3 +1,5 @@
+import { projectAttemptPageSchema, projectAttemptSearchRequestSchema, } from "./attempt-search.js";
+import { BULK_API_OPERATIONS } from "./bulk-operations.js";
 import { effectiveCustomerLimitsSchema } from "./effective-limits.js";
 import { z } from "./zod.js";
 import { MEMBER_OPERATIONS } from "./members.js";
@@ -545,6 +547,7 @@ export const OPERATIONS = [
         surfaces: ["api", "mock"],
     },
     ...DATA_EXPORT_OPERATIONS,
+    ...BULK_API_OPERATIONS,
     ...MEMBER_OPERATIONS,
     ...PROJECT_NOTIFICATION_OPERATIONS,
     ...ORGANIZATION_LIFECYCLE_OPERATIONS,
@@ -3622,6 +3625,70 @@ export const OPERATIONS = [
             : "Read an occurrence",
         surfaces: ["api", "mock"],
     },
+    {
+        creates: false,
+        description: globalThis.GREATWAIT_RUNTIME_CONTRACTS_ONLY
+            ? ""
+            : "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.",
+        example: globalThis.GREATWAIT_RUNTIME_WITHOUT_EXAMPLES
+            ? {}
+            : {
+                data: [
+                    {
+                        attempt: {
+                            id: "att_01h8xyz9k2m4n6p8r0t2v4w6y8",
+                            attemptNumber: 1,
+                            occurrence: "occ_01h8xyz9k2m4n6p8r0t2v4w6y8",
+                            startedAt: "2026-07-28T15:00:00.000Z",
+                            classifiedAt: "2026-07-28T15:00:00.071Z",
+                            state: "retryable_failure",
+                            responseStatus: 503,
+                            durationMs: 71,
+                            diagnostic: "http_retryable",
+                            remediation: "review_retry_policy",
+                            trigger: { kind: "automatic" },
+                        },
+                        occurrence: {
+                            id: "occ_01h8xyz9k2m4n6p8r0t2v4w6y8",
+                            schedule: "sch_01h8xyz9k2m4n6p8r0t2v4w6y8",
+                            generation: 1,
+                            sequence: 1,
+                            attemptCount: 2,
+                            plannedFor: "2026-07-28T14:50:00.000Z",
+                            settledAt: "2026-07-28T15:00:04.000Z",
+                            state: "succeeded",
+                        },
+                        schedule: {
+                            id: "sch_01h8xyz9k2m4n6p8r0t2v4w6y8",
+                            name: "Recovered delivery",
+                        },
+                    },
+                ],
+                freshness: { kind: "authoritative" },
+                retention: {
+                    from: "2026-07-21T15:00:00.000Z",
+                    detailsFrom: "2026-07-21T15:00:00.000Z",
+                },
+            },
+        id: "attempts.search",
+        idempotent: true,
+        mcp: { destructive: false, kind: "tool", openWorld: false },
+        method: "GET",
+        mutates: false,
+        path: "/v1/attempts",
+        principals: ["api-credential", "oauth", "session"],
+        problems: ["invalid_request"],
+        query: projectAttemptSearchRequestSchema,
+        response: globalThis.GREATWAIT_API_REQUEST_REGISTRY
+            ? API_UNUSED_RESPONSE_SCHEMA
+            : projectAttemptPageSchema,
+        scopes: ["occurrences:read"],
+        sessionAuthority: "headers",
+        summary: globalThis.GREATWAIT_API_REQUEST_REGISTRY
+            ? ""
+            : "Search delivery attempts by actual time",
+        surfaces: ["api", "mock"],
+    },
     {
         creates: false,
         description: globalThis.GREATWAIT_RUNTIME_CONTRACTS_ONLY

package/dist/protocol.d.ts

@@ -54,14 +54,28 @@ export type ScheduleOrder = (typeof SCHEDULE_ORDERS)[number];
 export declare const scheduleListRequestSchema: import("zod").ZodObject<{
     cursor: import("zod").ZodOptional<import("zod").ZodString>;
     limit: import("zod").ZodDefault<import("zod").ZodNumber>;
-    external_identifier: import("zod").ZodOptional<import("zod").ZodString>;
-    tag: import("zod").ZodOptional<import("zod").ZodString>;
-    dueBefore: import("zod").ZodOptional<import("zod").ZodString>;
-    endpoint: import("zod").ZodOptional<import("zod").ZodString>;
     order: import("zod").ZodDefault<import("zod").ZodEnum<{
-        created: "created";
         due: "due";
+        created: "created";
     }>>;
+    external_identifier: import("zod").ZodOptional<import("zod").ZodString>;
+    tag: import("zod").ZodOptional<import("zod").ZodString>;
+    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+        cancelled: "cancelled";
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+    }>>;
+    recurrence: import("zod").ZodOptional<import("zod").ZodEnum<{
+        at: "at";
+        every: "every";
+        cron: "cron";
+    }>>;
+    endpoint: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<"none">]>>;
+    text: import("zod").ZodOptional<import("zod").ZodString>;
+    schedule: import("zod").ZodOptional<import("zod").ZodString>;
+    dueAfter: import("zod").ZodOptional<import("zod").ZodString>;
+    dueBefore: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>;
 export type ScheduleListRequest = z.infer<typeof scheduleListRequestSchema>;
 /**

package/dist/protocol.js

@@ -1,7 +1,7 @@
 import { z } from "./zod.js";
-import { externalIdentifierSchema, scheduleTagSchema, } from "./host-correlation.js";
+import { scheduleSelectionSchema } from "./schedule-selection.js";
 import { PUBLIC_PAGE_SIZE } from "./configuration-bounds.js";
-import { endpointIdSchema, environmentIdSchema, organizationIdSchema, projectIdSchema, } from "./identifiers.js";
+import { environmentIdSchema, organizationIdSchema, projectIdSchema, } from "./identifiers.js";
 import { timestampSchema } from "./time.js";
 /**
  * Request and collection mechanics: paging, optimistic concurrency, and
@@ -16,7 +16,7 @@ import { timestampSchema } from "./time.js";
  * exactly what they were given.
  */
 export const PAGE_SIZE = PUBLIC_PAGE_SIZE;
-export const pageRequestSchema = z.object({
+export const pageRequestSchema = /* @__PURE__ */ (() => z.object({
     cursor: z.string().min(1).optional(),
     limit: z
         .number()
@@ -24,7 +24,7 @@ export const pageRequestSchema = z.object({
         .min(PAGE_SIZE.min)
         .max(PAGE_SIZE.max)
         .default(PAGE_SIZE.default),
-});
+}))();
 /**
  * A schedules listing: the page, and optionally one endpoint to keep to.
  *
@@ -55,13 +55,10 @@ export const SCHEDULE_ORDERS = ["created", "due"];
  * a schedule with nothing on the books matches no `dueBefore`, because it has
  * no instant to compare and inventing one either way would be a guess.
  */
-export const scheduleListRequestSchema = pageRequestSchema.extend({
-    external_identifier: externalIdentifierSchema.optional(),
-    tag: scheduleTagSchema.optional(),
-    dueBefore: timestampSchema.optional(),
-    endpoint: endpointIdSchema.optional(),
+export const scheduleListRequestSchema = /* @__PURE__ */ (() => pageRequestSchema.extend({
+    ...scheduleSelectionSchema.shape,
     order: z.enum(SCHEDULE_ORDERS).default("created"),
-});
+}))();
 /**
  * Which end of a history a page walks from.
  *
@@ -73,9 +70,9 @@ export const scheduleListRequestSchema = pageRequestSchema.extend({
  */
 export const HISTORY_ORDERS = ["oldest", "newest"];
 /** A page request over a history, which may be walked from either end. */
-export const historyPageRequestSchema = pageRequestSchema.extend({
+export const historyPageRequestSchema = /* @__PURE__ */ (() => pageRequestSchema.extend({
     order: z.enum(HISTORY_ORDERS).default("oldest"),
-});
+}))();
 /**
  * A page of results.
  *
@@ -85,14 +82,14 @@ export const historyPageRequestSchema = pageRequestSchema.extend({
  * stale data as fact. `authoritative` means the answer came from the owning
  * partition; `projected` means it may lag and carries the age.
  */
-export const freshnessSchema = z.discriminatedUnion("kind", [
+export const freshnessSchema = /* @__PURE__ */ (() => z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("authoritative") }),
     z.object({
         asOf: timestampSchema,
         kind: z.literal("projected"),
         lagSeconds: z.number().int().nonnegative(),
     }),
-]);
+]))();
 /**
  * The `projected` arm alone, for a response that is never authoritative.
  *
@@ -103,11 +100,11 @@ export const freshnessSchema = z.discriminatedUnion("kind", [
  * taken, were unreachable without narrowing that no consumer could justify.
  * Naming the narrower shape moves the claim into the type.
  */
-export const projectedFreshnessSchema = z.object({
+export const projectedFreshnessSchema = /* @__PURE__ */ (() => z.object({
     asOf: timestampSchema,
     kind: z.literal("projected"),
     lagSeconds: z.number().int().nonnegative(),
-});
+}))();
 export function pageSchema(item) {
     return z.object({
         data: z.array(item),
@@ -160,7 +157,17 @@ function authorityFingerprint(authority) {
     return hash.toString(16).padStart(8, "0");
 }
 function base64UrlEncode(value) {
-    return btoa(value)
+    // Cursor JSON can include Unicode filter values. Escape UTF-16 units outside
+    // Latin-1 before btoa; JSON.parse restores them, including surrogate pairs.
+    // Keep the existing decoder so previously issued Latin-1 cursors still work.
+    const encodable = value
+        .split("")
+        .map((unit) => {
+        const code = unit.charCodeAt(0);
+        return code > 255 ? `\\u${code.toString(16).padStart(4, "0")}` : unit;
+    })
+        .join("");
+    return btoa(encodable)
         .replace(/\+/gu, "-")
         .replace(/\//gu, "_")
         .replace(/=+$/u, "");
@@ -330,7 +337,7 @@ function parseListing(query, schema) {
  * `version_conflict` rather than silently overwriting — a cancel racing a
  * replace must not resolve by luck.
  */
-export const versionSchema = z.number().int().positive();
+export const versionSchema = /* @__PURE__ */ (() => z.number().int().positive())();
 /**
  * A strong entity tag over a version: a quoted decimal, and nothing else.
  *
@@ -376,10 +383,10 @@ export function fromETag(etag) {
  * refinement is the extra strictness the OpenAPI preamble already discloses
  * that a described schema does not capture.
  */
-export const etagSchema = z
+export const etagSchema = /* @__PURE__ */ (() => z
     .string()
     .regex(ETAG_PATTERN, ETAG_MESSAGE)
-    .refine((value) => fromETag(value) !== undefined, ETAG_MESSAGE);
+    .refine((value) => fromETag(value) !== undefined, ETAG_MESSAGE))();
 /* -------------------------------------------------------------------------- */
 /* Idempotency                                                                */
 /* -------------------------------------------------------------------------- */
@@ -393,11 +400,11 @@ export const etagSchema = z
  * silent second write — that distinction is the whole point, and the legacy
  * scheduler had no equivalent.
  */
-export const idempotencyKeySchema = z
+export const idempotencyKeySchema = /* @__PURE__ */ (() => z
     .string()
     .min(16, "must be at least 16 characters so keys do not collide by accident")
     .max(255)
-    .regex(/^[\x20-\x7e]+$/u, "must be printable ASCII");
+    .regex(/^[\x20-\x7e]+$/u, "must be printable ASCII"))();
 /**
  * The scope a key was used in. Carried on the receipt rather than assumed,
  * because an implementation that keys its receipt store on the idempotency key
@@ -405,13 +412,13 @@ export const idempotencyKeySchema = z
  * send the same key. The scope is part of the record so that mistake cannot be
  * made silently.
  */
-export const idempotencyScopeSchema = z.object({
+export const idempotencyScopeSchema = /* @__PURE__ */ (() => z.object({
     environment: environmentIdSchema,
     operation: z.string().min(1),
     organization: organizationIdSchema,
     project: projectIdSchema,
-});
-export const idempotencyReceiptSchema = z.object({
+}))();
+export const idempotencyReceiptSchema = /* @__PURE__ */ (() => z.object({
     /**
      * Hash of the canonical request the key was first used with. Canonical
      * means: the operation name, then the request body serialized with object
@@ -424,7 +431,7 @@ export const idempotencyReceiptSchema = z.object({
     replayed: z.boolean(),
     scope: idempotencyScopeSchema,
     storedAt: timestampSchema,
-});
+}))();
 /**
  * The canonical form of a request, as the receipt's `requestFingerprint`
  * describes it: the operation name, then the body with object keys sorted and
@@ -528,9 +535,9 @@ export const CONCURRENCY_HEADERS = {
     ifMatch: "If-Match",
     replayed: "Idempotency-Replayed",
 };
-export const idempotencyRequestHeaderSchema = z.object({
+export const idempotencyRequestHeaderSchema = /* @__PURE__ */ (() => z.object({
     [CONCURRENCY_HEADERS.idempotencyKey]: idempotencyKeySchema.optional(),
-});
+}))();
 /**
  * A write for which idempotency is mandatory, rather than an optional
  * protection a caller may opt into.
@@ -540,12 +547,12 @@ export const idempotencyRequestHeaderSchema = z.object({
  * `idempotencyRequestHeaderSchema` lets schedule creation retain its published
  * optional behavior without weakening the redelivery promise.
  */
-export const requiredIdempotencyRequestHeaderSchema = z.object({
+export const requiredIdempotencyRequestHeaderSchema = /* @__PURE__ */ (() => z.object({
     [CONCURRENCY_HEADERS.idempotencyKey]: idempotencyKeySchema,
-});
-export const conditionalRequestHeaderSchema = z.object({
+}))();
+export const conditionalRequestHeaderSchema = /* @__PURE__ */ (() => z.object({
     [CONCURRENCY_HEADERS.ifMatch]: etagSchema.optional(),
-});
+}))();
 /**
  * A conditional write that refuses an unversioned request.
  *
@@ -554,18 +561,18 @@ export const conditionalRequestHeaderSchema = z.object({
  * silently accepting a missing precondition would let a stale General page
  * overwrite a newer decision.
  */
-export const requiredConditionalRequestHeaderSchema = z.object({
+export const requiredConditionalRequestHeaderSchema = /* @__PURE__ */ (() => z.object({
     [CONCURRENCY_HEADERS.ifMatch]: etagSchema,
-});
+}))();
 /**
  * Required rather than optional, deliberately: an operation that declares this
  * promises the header on every success, and a client that has to test for its
  * presence before making a conditional write will write the untested branch
  * wrong.
  */
-export const versionResponseHeaderSchema = z.object({
+export const versionResponseHeaderSchema = /* @__PURE__ */ (() => z.object({
     [CONCURRENCY_HEADERS.etag]: etagSchema,
-});
+}))();
 /**
  * What a replayed write answers with, on top of the version.
  *
@@ -581,11 +588,11 @@ export const versionResponseHeaderSchema = z.object({
  * header is the ordinary case, and a client that has to read a header to learn
  * nothing happened is a client that will not read it.
  */
-export const replayedResponseHeaderSchema = z.object({
+export const replayedResponseHeaderSchema = /* @__PURE__ */ (() => z.object({
     [CONCURRENCY_HEADERS.etag]: etagSchema,
     [CONCURRENCY_HEADERS.replayed]: z.literal("true").optional(),
-});
+}))();
 /** Replay marker for an idempotent create whose result has no ETag. */
-export const idempotencyReplayResponseHeaderSchema = z.object({
+export const idempotencyReplayResponseHeaderSchema = /* @__PURE__ */ (() => z.object({
     [CONCURRENCY_HEADERS.replayed]: z.literal("true").optional(),
-});
+}))();

package/dist/schedule-selection.d.ts

@@ -0,0 +1,28 @@
+import { z } from "./zod.js";
+/** Shared schedule predicates. Every populated field intersects before paging. */
+export declare const scheduleSelectionSchema: import("zod").ZodObject<{
+    external_identifier: import("zod").ZodOptional<import("zod").ZodString>;
+    tag: import("zod").ZodOptional<import("zod").ZodString>;
+    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+        cancelled: "cancelled";
+        active: "active";
+        paused: "paused";
+        completed: "completed";
+    }>>;
+    recurrence: import("zod").ZodOptional<import("zod").ZodEnum<{
+        at: "at";
+        every: "every";
+        cron: "cron";
+    }>>;
+    endpoint: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodLiteral<"none">]>>;
+    text: import("zod").ZodOptional<import("zod").ZodString>;
+    schedule: import("zod").ZodOptional<import("zod").ZodString>;
+    dueAfter: import("zod").ZodOptional<import("zod").ZodString>;
+    dueBefore: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+export type ScheduleSelection = z.infer<typeof scheduleSelectionSchema>;
+export type NormalizedScheduleSelection = {
+    readonly [Key in keyof ScheduleSelection]?: Exclude<ScheduleSelection[Key], undefined>;
+};
+/** Canonical predicate shape for lists, cursor bindings and bulk selections. */
+export declare function normalizeScheduleSelection(selection: ScheduleSelection): NormalizedScheduleSelection;

package/dist/schedule-selection.js

@@ -0,0 +1,48 @@
+import { z } from "./zod.js";
+import { endpointIdSchema, scheduleIdSchema } from "./identifiers.js";
+import { externalIdentifierSchema, scheduleTagSchema, } from "./host-correlation.js";
+import { timestampSchema } from "./time.js";
+/** Shared schedule predicates. Every populated field intersects before paging. */
+export const scheduleSelectionSchema = /* @__PURE__ */ (() => z.object({
+    external_identifier: externalIdentifierSchema.optional(),
+    tag: scheduleTagSchema.optional(),
+    status: z.enum(["active", "paused", "cancelled", "completed"]).optional(),
+    recurrence: z.enum(["at", "every", "cron"]).optional(),
+    endpoint: z.union([endpointIdSchema, z.literal("none")]).optional(),
+    text: z
+        .string()
+        .max(256)
+        .refine((value) => !value.includes("\u0000"), "must not contain NUL characters")
+        .optional()
+        .describe("Case-insensitive literal substring of schedule name, endpoint address or schedule identifier."),
+    schedule: scheduleIdSchema.optional(),
+    dueAfter: timestampSchema.optional(),
+    dueBefore: timestampSchema.optional(),
+}))();
+/** Canonical predicate shape for lists, cursor bindings and bulk selections. */
+export function normalizeScheduleSelection(selection) {
+    const text = selection.text?.trim();
+    return {
+        ...(selection.external_identifier === undefined
+            ? {}
+            : { external_identifier: selection.external_identifier }),
+        ...(selection.tag === undefined ? {} : { tag: selection.tag }),
+        ...(selection.status === undefined ? {} : { status: selection.status }),
+        ...(selection.recurrence === undefined
+            ? {}
+            : { recurrence: selection.recurrence }),
+        ...(selection.endpoint === undefined
+            ? {}
+            : { endpoint: selection.endpoint }),
+        ...(text === undefined || text === "" ? {} : { text }),
+        ...(selection.schedule === undefined
+            ? {}
+            : { schedule: selection.schedule }),
+        ...(selection.dueAfter === undefined
+            ? {}
+            : { dueAfter: selection.dueAfter }),
+        ...(selection.dueBefore === undefined
+            ? {}
+            : { dueBefore: selection.dueBefore }),
+    };
+}

package/dist/scheduling-records.d.ts

@@ -7,9 +7,9 @@ export declare const portableScheduleRecordSchema: import("zod").ZodObject<{
             GET: "GET";
         }>;
         bodyMode: import("zod").ZodEnum<{
+            none: "none";
             envelope: "envelope";
             json: "json";
-            none: "none";
         }>;
         headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -132,9 +132,9 @@ export declare const portableScheduleRecordSchema: import("zod").ZodObject<{
         timeZone: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
     }, import("zod/v4/core").$strip>], "kind">;
     status: import("zod").ZodEnum<{
-        paused: "paused";
-        active: "active";
         cancelled: "cancelled";
+        active: "active";
+        paused: "paused";
         completed: "completed";
     }>;
     updatedAt: import("zod").ZodString;
@@ -172,14 +172,14 @@ export declare const portableOccurrenceRecordSchema: import("zod").ZodObject<{
     sequence: import("zod").ZodNumber;
     settledAt: import("zod").ZodOptional<import("zod").ZodString>;
     state: import("zod").ZodEnum<{
-        succeeded: "succeeded";
-        ambiguous: "ambiguous";
-        due: "due";
-        cancelled: "cancelled";
         planned: "planned";
+        due: "due";
         dispatching: "dispatching";
         retry_wait: "retry_wait";
+        ambiguous: "ambiguous";
+        succeeded: "succeeded";
         terminal_failed: "terminal_failed";
+        cancelled: "cancelled";
         skipped_stale: "skipped_stale";
     }>;
     firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
@@ -240,8 +240,8 @@ export declare const portableAttemptRecordSchema: import("zod").ZodObject<{
         body: import("zod").ZodOptional<import("zod").ZodObject<{
             contentType: import("zod").ZodString;
             encoding: import("zod").ZodEnum<{
-                utf8: "utf8";
                 base64: "base64";
+                utf8: "utf8";
             }>;
             content: import("zod").ZodString;
             capturedBytes: import("zod").ZodInt;
@@ -276,8 +276,8 @@ export declare const portableAttemptRecordSchema: import("zod").ZodObject<{
     responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
     startedAt: import("zod").ZodString;
     state: import("zod").ZodOptional<import("zod").ZodEnum<{
-        succeeded: "succeeded";
         ambiguous: "ambiguous";
+        succeeded: "succeeded";
         retryable_failure: "retryable_failure";
         terminal_failure: "terminal_failure";
     }>>;
@@ -322,9 +322,9 @@ export declare const portableAttemptRecordSchema: import("zod").ZodObject<{
             GET: "GET";
         }>;
         bodyMode: import("zod").ZodEnum<{
+            none: "none";
             envelope: "envelope";
             json: "json";
-            none: "none";
         }>;
         headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -428,8 +428,8 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
             body: import("zod").ZodOptional<import("zod").ZodObject<{
                 contentType: import("zod").ZodString;
                 encoding: import("zod").ZodEnum<{
-                    utf8: "utf8";
                     base64: "base64";
+                    utf8: "utf8";
                 }>;
                 content: import("zod").ZodString;
                 capturedBytes: import("zod").ZodInt;
@@ -464,8 +464,8 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
         responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
         startedAt: import("zod").ZodString;
         state: import("zod").ZodOptional<import("zod").ZodEnum<{
-            succeeded: "succeeded";
             ambiguous: "ambiguous";
+            succeeded: "succeeded";
             retryable_failure: "retryable_failure";
             terminal_failure: "terminal_failure";
         }>>;
@@ -510,9 +510,9 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
                 GET: "GET";
             }>;
             bodyMode: import("zod").ZodEnum<{
+                none: "none";
                 envelope: "envelope";
                 json: "json";
-                none: "none";
             }>;
             headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
                 name: import("zod").ZodString;
@@ -565,14 +565,14 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
         sequence: import("zod").ZodNumber;
         settledAt: import("zod").ZodOptional<import("zod").ZodString>;
         state: import("zod").ZodEnum<{
-            succeeded: "succeeded";
-            ambiguous: "ambiguous";
-            due: "due";
-            cancelled: "cancelled";
             planned: "planned";
+            due: "due";
             dispatching: "dispatching";
             retry_wait: "retry_wait";
+            ambiguous: "ambiguous";
+            succeeded: "succeeded";
             terminal_failed: "terminal_failed";
+            cancelled: "cancelled";
             skipped_stale: "skipped_stale";
         }>;
         firstAttemptLatenessMs: import("zod").ZodOptional<import("zod").ZodInt>;
@@ -650,9 +650,9 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
                 GET: "GET";
             }>;
             bodyMode: import("zod").ZodEnum<{
+                none: "none";
                 envelope: "envelope";
                 json: "json";
-                none: "none";
             }>;
             headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
                 name: import("zod").ZodString;
@@ -775,9 +775,9 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
             timeZone: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
         }, import("zod/v4/core").$strip>], "kind">;
         status: import("zod").ZodEnum<{
-            paused: "paused";
-            active: "active";
             cancelled: "cancelled";
+            active: "active";
+            paused: "paused";
             completed: "completed";
         }>;
         updatedAt: import("zod").ZodString;