@greatwait/contracts 0.3.0 → 0.3.1

package/dist/http-request.js

@@ -31,7 +31,7 @@ export function reservedHttpHeaderReason(name) {
         return "reserved for transport";
     return undefined;
 }
-export const httpHeaderNameSchema = z
+export const httpHeaderNameSchema = /* @__PURE__ */ (() => z
     .string()
     .min(1)
     .superRefine((name, ctx) => {
@@ -48,8 +48,8 @@ export const httpHeaderNameSchema = z
     const reason = reservedHttpHeaderReason(name);
     if (reason !== undefined)
         ctx.addIssue({ code: "custom", message: `${name}: ${reason}` });
-});
-export const httpHeaderValueSchema = z.string().superRefine((value, ctx) => {
+}))();
+export const httpHeaderValueSchema = /* @__PURE__ */ (() => z.string().superRefine((value, ctx) => {
     if (Array.from(value).some((character) => {
         const point = character.codePointAt(0);
         return point < 32 || (point >= 127 && point <= 159) || point > 255;
@@ -64,8 +64,8 @@ export const httpHeaderValueSchema = z.string().superRefine((value, ctx) => {
             code: "custom",
             message: "header value exceeds 8192 bytes",
         });
-});
-export const headerChangeSchema = z.discriminatedUnion("action", [
+}))();
+export const headerChangeSchema = /* @__PURE__ */ (() => z.discriminatedUnion("action", [
     z
         .object({
         action: z.literal("set"),
@@ -74,15 +74,17 @@ export const headerChangeSchema = z.discriminatedUnion("action", [
         secret: z.boolean().optional(),
     })
         .strict(),
-    z.object({ action: z.literal("keep"), name: httpHeaderNameSchema }).strict(),
+    z
+        .object({ action: z.literal("keep"), name: httpHeaderNameSchema })
+        .strict(),
     z
         .object({ action: z.literal("remove"), name: httpHeaderNameSchema })
         .strict(),
     z
         .object({ action: z.literal("suppress"), name: httpHeaderNameSchema })
         .strict(),
-]);
-export const headerChangesSchema = z
+]))();
+export const headerChangesSchema = /* @__PURE__ */ (() => z
     .array(headerChangeSchema)
     .max(HTTP_HEADER_BOUNDS.count * 2)
     .superRefine((rows, ctx) => {
@@ -113,8 +115,8 @@ export const headerChangesSchema = z
             code: "custom",
             message: "headers exceed 16384 total bytes",
         });
-});
-export const endpointHeaderChangesSchema = headerChangesSchema.superRefine((rows, ctx) => {
+}))();
+export const endpointHeaderChangesSchema = /* @__PURE__ */ (() => headerChangesSchema.superRefine((rows, ctx) => {
     rows.forEach((row, index) => {
         if (row.action === "suppress")
             ctx.addIssue({
@@ -123,8 +125,8 @@ export const endpointHeaderChangesSchema = headerChangesSchema.superRefine((rows
                 message: "only a schedule can suppress an inherited header",
             });
     });
-});
-export const publicHttpHeaderSchema = z.union([
+}))();
+export const publicHttpHeaderSchema = /* @__PURE__ */ (() => z.union([
     z
         .object({
         name: httpHeaderNameSchema,
@@ -144,8 +146,8 @@ export const publicHttpHeaderSchema = z.union([
     z
         .object({ name: httpHeaderNameSchema, suppressed: z.literal(true) })
         .strict(),
-]);
-export const httpRequestSchema = z
+]))();
+export const httpRequestSchema = /* @__PURE__ */ (() => z
     .object({
     method: z.enum(HTTP_METHODS).optional(),
     body: z
@@ -164,8 +166,8 @@ export const httpRequestSchema = z
             path: ["body"],
             message: "GET must be bodyless; omit body",
         });
-});
-export const publicHttpRequestSchema = z
+}))();
+export const publicHttpRequestSchema = /* @__PURE__ */ (() => z
     .object({
     method: z.enum(HTTP_METHODS),
     body: z.discriminatedUnion("mode", [
@@ -177,9 +179,9 @@ export const publicHttpRequestSchema = z
     ]),
     headers: z.array(publicHttpHeaderSchema),
 })
-    .strict();
+    .strict())();
 /** Internal portability schema: ciphertext remains sealed across backend exports. */
-const sealedHttpValueSchema = z
+const sealedHttpValueSchema = /* @__PURE__ */ (() => z
     .object({
     keyId: z.literal("v1"),
     nonce: z.string().regex(/^[A-Za-z0-9_-]{16}$/u),
@@ -189,7 +191,7 @@ const sealedHttpValueSchema = z
         .max(100000)
         .regex(/^[A-Za-z0-9_-]+$/u),
 })
-    .strict();
+    .strict())();
 function decodedCipherBytes(value) {
     try {
         const padding = "=".repeat((4 - (value.length % 4)) % 4);
@@ -204,7 +206,7 @@ function decodedCipherBytes(value) {
         return undefined;
     }
 }
-export const storedHttpHeaderSchema = z
+export const storedHttpHeaderSchema = /* @__PURE__ */ (() => z
     .union([
     z
         .object({
@@ -253,8 +255,8 @@ export const storedHttpHeaderSchema = z
             path: ["valueBytes"],
             message: "header byte count must match value",
         });
-});
-export const storedHttpRequestSchema = z
+}))();
+export const storedHttpRequestSchema = /* @__PURE__ */ (() => z
     .object({
     method: z.enum(HTTP_METHODS),
     bodyMode: z.enum(["envelope", "json", "none"]),
@@ -302,4 +304,4 @@ export const storedHttpRequestSchema = z
             path: ["headers"],
             message: "stored headers exceed 16384 total bytes",
         });
-});
+}))();

package/dist/identifiers.js

@@ -65,31 +65,31 @@ export function idPattern(resource) {
     return new RegExp(`^${ID_PREFIXES[resource]}_${SUFFIX}$`, "u");
 }
 /** Any well-formed public identifier, whatever it names. */
-export const ANY_ID_PATTERN = new RegExp(`^(?:${Object.values(ID_PREFIXES).join("|")})_${SUFFIX}$`, "u");
+export const ANY_ID_PATTERN = /* @__PURE__ */ (() => new RegExp(`^(?:${Object.values(ID_PREFIXES).join("|")})_${SUFFIX}$`, "u"))();
 export function idSchema(resource) {
     return z
         .string()
         .regex(idPattern(resource), `must be a ${resource} identifier: "${ID_PREFIXES[resource]}_" followed by 26 Crockford base32 characters`);
 }
-export const apiCredentialIdSchema = idSchema("apiCredential");
-export const apiCredentialEventIdSchema = idSchema("apiCredentialEvent");
-export const authorizationRequestIdSchema = idSchema("authorizationRequest");
-export const callbackSigningKeyIdSchema = idSchema("callbackSigningKey");
-export const oauthClientIdSchema = idSchema("oauthClient");
-export const oauthGrantIdSchema = idSchema("oauthGrant");
-export const oauthGrantEventIdSchema = idSchema("oauthGrantEvent");
-export const scheduleIdSchema = idSchema("schedule");
-export const occurrenceIdSchema = idSchema("occurrence");
-export const bulkJobIdSchema = idSchema("bulkJob");
-export const attemptIdSchema = idSchema("attempt");
-export const deliveryIdSchema = idSchema("delivery");
-export const endpointIdSchema = idSchema("endpoint");
-export const organizationIdSchema = idSchema("organization");
-export const projectIdSchema = idSchema("project");
-export const environmentIdSchema = idSchema("environment");
-export const eventIdSchema = idSchema("event");
-export const testSinkIdSchema = idSchema("testSink");
-export const testSinkDeliveryIdSchema = idSchema("testSinkDelivery");
+export const apiCredentialIdSchema = /* @__PURE__ */ (() => idSchema("apiCredential"))();
+export const apiCredentialEventIdSchema = /* @__PURE__ */ (() => idSchema("apiCredentialEvent"))();
+export const authorizationRequestIdSchema = /* @__PURE__ */ (() => idSchema("authorizationRequest"))();
+export const callbackSigningKeyIdSchema = /* @__PURE__ */ (() => idSchema("callbackSigningKey"))();
+export const oauthClientIdSchema = /* @__PURE__ */ (() => idSchema("oauthClient"))();
+export const oauthGrantIdSchema = /* @__PURE__ */ (() => idSchema("oauthGrant"))();
+export const oauthGrantEventIdSchema = /* @__PURE__ */ (() => idSchema("oauthGrantEvent"))();
+export const scheduleIdSchema = /* @__PURE__ */ (() => idSchema("schedule"))();
+export const occurrenceIdSchema = /* @__PURE__ */ (() => idSchema("occurrence"))();
+export const bulkJobIdSchema = /* @__PURE__ */ (() => idSchema("bulkJob"))();
+export const attemptIdSchema = /* @__PURE__ */ (() => idSchema("attempt"))();
+export const deliveryIdSchema = /* @__PURE__ */ (() => idSchema("delivery"))();
+export const endpointIdSchema = /* @__PURE__ */ (() => idSchema("endpoint"))();
+export const organizationIdSchema = /* @__PURE__ */ (() => idSchema("organization"))();
+export const projectIdSchema = /* @__PURE__ */ (() => idSchema("project"))();
+export const environmentIdSchema = /* @__PURE__ */ (() => idSchema("environment"))();
+export const eventIdSchema = /* @__PURE__ */ (() => idSchema("event"))();
+export const testSinkIdSchema = /* @__PURE__ */ (() => idSchema("testSink"))();
+export const testSinkDeliveryIdSchema = /* @__PURE__ */ (() => idSchema("testSinkDelivery"))();
 /**
  * The alphabet the pattern above accepts, in order.
  *

package/dist/operational-config.js

@@ -85,7 +85,7 @@ export const OPERATIONAL_TIMING = Object.freeze({
     forecastRefreshMaximumMs: 300_000,
     forecastCoverageSlackMs: 120_000,
 });
-export const OPERATIONAL_TIMING_ENFORCEMENT = Object.freeze({
+export const OPERATIONAL_TIMING_ENFORCEMENT = /* @__PURE__ */ (() => Object.freeze({
     forecastRefreshFloorMs: [
         "packages/contracts/src/forecast.ts#OPERATIONAL_TIMING.forecastRefreshFloorMs",
         "packages/scheduling/src/partition-forecast.ts#OPERATIONAL_TIMING.forecastRefreshFloorMs",
@@ -160,7 +160,6 @@ export const OPERATIONAL_TIMING_ENFORCEMENT = Object.freeze({
     ],
     hostFullRetryMs: [
         "packages/application/src/dialer.ts#DEFAULT_HOST_FULL_RETRY_MS",
-        "packages/postgres-scheduling/src/postgres-repository.ts#CLAIM_SEND_HOST_FULL_RETRY_MS",
     ],
     deliveryRetryBaseMs: [
         "packages/application/src/schedule-series.ts#RETRY_BASE_MS",
@@ -217,7 +216,9 @@ export const OPERATIONAL_TIMING_ENFORCEMENT = Object.freeze({
         "apps/api/src/detached-signal.ts#TIMER_SIGNAL_RETRY_DELAYS_MS",
     ],
     dispatchWarmHorizonMs: ["apps/api/src/worker.ts#DISPATCH_WARM_HORIZON_MS"],
-    sdkAutoRetryCount: ["packages/api-client/src/client.ts#SDK_AUTO_RETRY_LIMIT"],
+    sdkAutoRetryCount: [
+        "packages/api-client/src/client.ts#SDK_AUTO_RETRY_LIMIT",
+    ],
     sdkAutoRetryBaseMs: [
         "packages/api-client/src/client.ts#SDK_AUTO_RETRY_BASE_DELAY_MS",
     ],
@@ -322,9 +323,9 @@ export const OPERATIONAL_TIMING_ENFORCEMENT = Object.freeze({
     projectBillingConflictRetryCount: [
         "packages/application/src/project-billing.ts#OPERATIONAL_TIMING.projectBillingConflictRetryCount",
     ],
-});
+}))();
 /** Catalog metadata derives its defaults from the numeric owner above. */
-export const OPERATIONAL_TIMING_CATALOG = Object.freeze(Object.keys(OPERATIONAL_TIMING).map((key) => Object.freeze({
+export const OPERATIONAL_TIMING_CATALOG = /* @__PURE__ */ (() => Object.freeze(Object.keys(OPERATIONAL_TIMING).map((key) => Object.freeze({
     key: `operational.${key}`,
     default: OPERATIONAL_TIMING[key],
     unit: key.endsWith("Seconds")
@@ -338,4 +339,4 @@ export const OPERATIONAL_TIMING_CATALOG = Object.freeze(Object.keys(OPERATIONAL_
     changeProcedure: "Reviewed deployment; preserve callback, retry, funding and receipt compatibility",
     rationale: "Retain the existing measured or copied operating policy; the enforcement owner documents its evidence",
     enforcement: OPERATIONAL_TIMING_ENFORCEMENT[key],
-})));
+}))))();

package/dist/protocol.js

@@ -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,10 +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({
+export const scheduleListRequestSchema = /* @__PURE__ */ (() => pageRequestSchema.extend({
     ...scheduleSelectionSchema.shape,
     order: z.enum(SCHEDULE_ORDERS).default("created"),
-});
+}))();
 /**
  * Which end of a history a page walks from.
  *
@@ -70,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.
  *
@@ -82,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.
  *
@@ -100,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),
@@ -337,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.
  *
@@ -383,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                                                                */
 /* -------------------------------------------------------------------------- */
@@ -400,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
@@ -412,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
@@ -431,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
@@ -535,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.
@@ -547,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.
  *
@@ -561,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.
  *
@@ -588,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.js

@@ -3,7 +3,7 @@ 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 = z.object({
+export const scheduleSelectionSchema = /* @__PURE__ */ (() => z.object({
     external_identifier: externalIdentifierSchema.optional(),
     tag: scheduleTagSchema.optional(),
     status: z.enum(["active", "paused", "cancelled", "completed"]).optional(),
@@ -18,7 +18,7 @@ export const scheduleSelectionSchema = z.object({
     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();

package/dist/scheduling.d.ts

@@ -1065,6 +1065,51 @@ export declare const attemptRequestSchema: import("zod").ZodObject<{
     body: import("zod").ZodString;
 }, import("zod/v4/core").$strip>;
 export type AttemptRequest = z.infer<typeof attemptRequestSchema>;
+/** Shared validators for attempt search summaries and full attempt details. */
+export declare const attemptSearchSummaryShape: {
+    attemptNumber: import("zod").ZodNumber;
+    classifiedAt: import("zod").ZodOptional<import("zod").ZodString>;
+    diagnostic: import("zod").ZodOptional<import("zod").ZodEnum<{
+        rate_limited: "rate_limited";
+        completion_timed_out: "completion_timed_out";
+        delivered: "delivered";
+        duplicate_inflight: "duplicate_inflight";
+        endpoint_unavailable: "endpoint_unavailable";
+        endpoint_unsafe: "endpoint_unsafe";
+        http_refused: "http_refused";
+        http_retryable: "http_retryable";
+        http_terminal: "http_terminal";
+        identity_conflict: "identity_conflict";
+        network_ambiguous: "network_ambiguous";
+        payload_unavailable: "payload_unavailable";
+    }>>;
+    durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+    id: import("zod").ZodString;
+    occurrence: import("zod").ZodString;
+    remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
+        none: "none";
+        review_retry_policy: "review_retry_policy";
+        inspect_receiver: "inspect_receiver";
+        review_endpoint: "review_endpoint";
+        replace_payload: "replace_payload";
+        contact_support: "contact_support";
+        review_before_redelivery: "review_before_redelivery";
+    }>>;
+    responseStatus: import("zod").ZodOptional<import("zod").ZodNumber>;
+    startedAt: import("zod").ZodString;
+    state: import("zod").ZodOptional<import("zod").ZodEnum<{
+        ambiguous: "ambiguous";
+        succeeded: "succeeded";
+        retryable_failure: "retryable_failure";
+        terminal_failure: "terminal_failure";
+    }>>;
+    trigger: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"automatic">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"redelivery">;
+        sourceAttemptId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>], "kind">;
+};
 export declare const attemptSchema: import("zod").ZodObject<{
     id: import("zod").ZodString;
     localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;