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

package/dist/organization-lifecycle.d.ts

@@ -29,6 +29,16 @@ export declare const ORGANIZATION_LIFECYCLE_OPERATIONS: readonly [import("./oper
     readonly id: "organizations.lifecycle";
 }, import("./operations.js").OperationDefinition & {
     readonly id: "organizations.close";
+} & {
+    readonly request: import("zod").ZodObject<{
+        expectedGeneration: import("zod").ZodNumber;
+        immediate: import("zod").ZodBoolean;
+        confirmation: import("zod").ZodLiteral<"delete organization">;
+    }, import("zod/v4/core").$strict>;
 }, import("./operations.js").OperationDefinition & {
     readonly id: "organizations.restore";
+} & {
+    readonly request: import("zod").ZodObject<{
+        expectedGeneration: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
 }];

package/dist/partition.d.ts

@@ -53,7 +53,7 @@ export declare const SINGLE_SHARD = "0";
  * produced by two constants drifting apart. The test-gap audit named exactly
  * that, and the fix is one declaration rather than a test comparing two.
  *
- * Thirty-two is one D1 batch's worth of work and a few kilobytes of response.
+ * Thirty-two is one control-plane batch's worth of work and a few kilobytes of response.
  * The caller comes back for the rest, and `RetainedProjections.pending` is how
  * it knows to.
  */
@@ -93,8 +93,8 @@ export declare const MAX_PARTITION_SHARDS = 8;
  * only under a precondition, and that is the most important thing to know about
  * it.** A schedule's shard is derived from its identifier. Before W2-06 that was
  * the only answer, so raising the count stranded every schedule already stored.
- * Now the shard a schedule was actually stored in is *recorded* in the D1
- * directory, and `resolveSchedule` falls back to it whenever the derived
+ * Now the shard a schedule was actually stored in is *recorded* in the
+ * control-plane directory, and `resolveSchedule` falls back to it whenever the derived
  * partition has nothing — so a schedule created under an older count keeps
  * working, because its route was written down rather than recomputed.
  *
@@ -295,7 +295,7 @@ export interface DrainProjectionsQuery {
  *
  * **Nothing is deleted here.** The intents stay until `settleProjections` says
  * the control plane has them, which is acceptance criterion 1: an intent
- * survives a drain whose D1 write never landed, and a partition that has never
+ * survives a drain whose control-plane write never landed, and a partition that has never
  * been initialized answers an empty drain rather than a refusal — a shard nobody
  * has written to owes the directory nothing.
  */
@@ -304,9 +304,10 @@ export type DrainProjectionsOutcome = PartitionRefused | RetainedProjections;
  * Retire the intents the control plane accepted, and postpone the rest.
  *
  * Both halves in one call rather than two, because a drain has exactly one of
- * these outcomes and the failing half must not need a healthy D1 to be recorded:
- * the deferral is what stops a control-plane outage from making every subsequent
- * request pay a D1 timeout for the same intent.
+ * these outcomes and the failing half must not need a healthy control plane
+ * to be recorded: the deferral is what stops a control-plane outage from
+ * making every subsequent request pay a control-plane timeout for the same
+ * intent.
  */
 export interface SettleProjectionsCommand {
     /** Intents the control plane has durably applied, or cannot route. */
@@ -470,7 +471,7 @@ export interface CreateScheduleCommand {
     readonly partitionKey?: string;
     /**
      * Authenticated encrypted customer JSON. The plaintext never crosses this
-     * seam and is never stored in a D1 projection.
+     * seam and is never stored in a control-plane projection.
      */
     readonly payloadEnvelope?: string;
     /** UTF-8 byte length of the plaintext JSON, before encryption. */
@@ -479,7 +480,7 @@ export interface CreateScheduleCommand {
      * The verified endpoint URL captured for durable host routing.
      *
      * This is internal metadata, not a public response field. The Host Executor
-     * re-reads the D1 endpoint row before signing and reroutes if the URL has
+     * re-reads the control-plane endpoint row before signing and reroutes if the URL has
      * changed. It does not resolve or revalidate the address: that boundary was
      * removed by FXO-1566 and FXO-1581, and this comment claimed it afterwards.
      */
@@ -700,6 +701,8 @@ export interface ForecastQuery {
     readonly authority: Authority;
     readonly bucketMs: number;
     readonly fromMs: number;
+    /** Omit named-key cells when the public caller only needs totals/classes. */
+    readonly includePartitionKeys?: boolean;
     readonly toMs: number;
 }
 /** One bucket, as one partition sees it. */
@@ -709,6 +712,8 @@ export interface ForecastPartitionBucket {
     readonly count: number;
     /** Occurrences here that are the next firing of their schedule. */
     readonly nextFireCount: number;
+    /** Named-key counts folded into the public remainder after exact ranking. */
+    readonly omittedPartitionKeyCount?: number;
     /**
      * Named customer keys and their counts, ascending by key.
      *
@@ -748,6 +753,9 @@ export type ForecastOutcome = PartitionRefused | {
      */
     readonly asOfMs?: number;
     readonly buckets: readonly ForecastPartitionBucket[];
+    /** Operator work budget that prevented a complete answer, never a count. */
+    readonly exhaustedBudget?: string;
+    readonly coverage?: import("./forecast.js").ForecastCoverage;
     /**
      * The instant this answer actually reached, when it is not the one asked
      * for.

package/dist/partition.js

@@ -51,7 +51,7 @@ export const SINGLE_SHARD = "0";
  * produced by two constants drifting apart. The test-gap audit named exactly
  * that, and the fix is one declaration rather than a test comparing two.
  *
- * Thirty-two is one D1 batch's worth of work and a few kilobytes of response.
+ * Thirty-two is one control-plane batch's worth of work and a few kilobytes of response.
  * The caller comes back for the rest, and `RetainedProjections.pending` is how
  * it knows to.
  */
@@ -110,8 +110,8 @@ function fnv1a32(input) {
  * only under a precondition, and that is the most important thing to know about
  * it.** A schedule's shard is derived from its identifier. Before W2-06 that was
  * the only answer, so raising the count stranded every schedule already stored.
- * Now the shard a schedule was actually stored in is *recorded* in the D1
- * directory, and `resolveSchedule` falls back to it whenever the derived
+ * Now the shard a schedule was actually stored in is *recorded* in the
+ * control-plane directory, and `resolveSchedule` falls back to it whenever the derived
  * partition has nothing — so a schedule created under an older count keeps
  * working, because its route was written down rather than recomputed.
  *

package/dist/policy.js

@@ -50,10 +50,13 @@ function allOperations() {
  * Clerk's and this product does not do it, so this is the whole of what `admin`
  * means here.
  */
-const MEMBER_SCOPES = SCOPES.filter((scope) => scope !== "billing:write" &&
+const MEMBER_SCOPES = SCOPES.filter((scope) => scope !== "members:manage" &&
+    scope !== "billing:write" &&
+    scope !== "credentials:administer" &&
+    scope !== "projects:administer");
+const BILLING_SCOPES = SCOPES.filter((scope) => scope !== "members:manage" &&
     scope !== "credentials:administer" &&
     scope !== "projects:administer");
-const BILLING_SCOPES = SCOPES.filter((scope) => scope !== "credentials:administer" && scope !== "projects:administer");
 export const ROLE_SCOPE_CEILINGS = {
     admin: SCOPES,
     billing: BILLING_SCOPES,

package/dist/problems.d.ts

@@ -12,12 +12,13 @@ import { z } from "./zod.js";
  * `code` is the contract. `title` and `detail` are prose and may change without
  * being a breaking change; clients must never branch on them.
  */
-export declare const PROBLEM_CATEGORIES: readonly ["authentication", "authorization", "conflict", "invalid-request", "not-found", "rate-limited", "unavailable"];
+export declare const PROBLEM_CATEGORIES: readonly ["authentication", "authorization", "conflict", "invalid-request", "not-configured", "not-found", "rate-limited", "unavailable"];
 export declare const problemCategorySchema: import("zod").ZodEnum<{
     authentication: "authentication";
     authorization: "authorization";
     conflict: "conflict";
     "invalid-request": "invalid-request";
+    "not-configured": "not-configured";
     "not-found": "not-found";
     "rate-limited": "rate-limited";
     unavailable: "unavailable";
@@ -32,6 +33,14 @@ export declare const PROBLEM_CODES: {
         readonly category: "authentication";
         readonly status: 401;
     };
+    readonly billing_not_ready: {
+        readonly category: "unavailable";
+        readonly status: 503;
+    };
+    readonly capability_not_configured: {
+        readonly category: "not-configured";
+        readonly status: 503;
+    };
     readonly credential_expired: {
         readonly category: "authentication";
         readonly status: 401;
@@ -96,6 +105,8 @@ export declare const PROBLEM_CODES: {
 export type ProblemCode = keyof typeof PROBLEM_CODES;
 export declare const problemCodeSchema: import("zod").ZodEnum<{
     authentication_required: "authentication_required";
+    billing_not_ready: "billing_not_ready";
+    capability_not_configured: "capability_not_configured";
     credential_expired: "credential_expired";
     credential_revoked: "credential_revoked";
     idempotency_key_reused: "idempotency_key_reused";
@@ -112,7 +123,17 @@ export declare const problemCodeSchema: import("zod").ZodEnum<{
     test_to_live_escalation: "test_to_live_escalation";
     version_conflict: "version_conflict";
 }>;
-/** Whether repeating the identical request could succeed later. */
+/**
+ * Whether repeating the identical request could succeed later.
+ *
+ * **Two 5xx categories, opposite answers, and that is the point.**
+ * `unavailable` is something that has gone wrong and will come back;
+ * `not-configured` is something that was never turned on and will not turn
+ * itself on. Reading the status alone cannot tell them apart, which is how a
+ * permanent refusal came to be published to customers as retryable — in the
+ * SDK's `retryable`, in the CLI's exit class, and as a "Try again" control the
+ * dashboard offered for a condition no amount of trying clears.
+ */
 export declare function isRetryable(code: ProblemCode): boolean;
 export declare const fieldErrorSchema: import("zod").ZodObject<{
     pointer: import("zod").ZodString;
@@ -122,6 +143,8 @@ export type FieldError = z.infer<typeof fieldErrorSchema>;
 export declare const problemSchema: import("zod").ZodObject<{
     code: import("zod").ZodEnum<{
         authentication_required: "authentication_required";
+        billing_not_ready: "billing_not_ready";
+        capability_not_configured: "capability_not_configured";
         credential_expired: "credential_expired";
         credential_revoked: "credential_revoked";
         idempotency_key_reused: "idempotency_key_reused";

package/dist/problems.js

@@ -17,6 +17,14 @@ export const PROBLEM_CATEGORIES = [
     "authorization",
     "conflict",
     "invalid-request",
+    // **A capability this deployment was never given, which is not an outage.**
+    // Separate from `unavailable` for one reason: `isRetryable` is a function of
+    // the category, and these two answer the retry question oppositely. An
+    // outage clears by itself and repeating is the right move; an unconfigured
+    // capability clears when somebody changes configuration and never otherwise,
+    // so telling a client "the identical request is safe to repeat" is false and
+    // it is false forever. Both are 5xx because the caller's request was fine.
+    "not-configured",
     "not-found",
     "rate-limited",
     "unavailable",
@@ -34,6 +42,36 @@ export const PROBLEM_CODES = {
     // now. One code for both would make a missed rotation window indistinguishable
     // from a security event, and the client's remedy differs — rotate again
     // versus find out who revoked it.
+    // **"Still being set up" is not "broken", and a first screen should not say
+    // the second when it means the first.** An organization's billing account row
+    // is written by a projection that runs every minute rather than synchronously
+    // at sign-up, so a member who creates their project immediately can read
+    // billing before the row exists. That used to answer `service_unavailable`,
+    // which the dashboard renders as "The service is not answering right now" —
+    // the sentence W9-06 blocked the invited cohort over, and the one a new member
+    // met on first contact.
+    //
+    // Deliberately still `unavailable`, and therefore still retryable: repeating
+    // the request is exactly the right move, and it succeeds within about a
+    // minute. What changes is what the reader is told, not what a client does.
+    billing_not_ready: { category: "unavailable", status: 503 },
+    // **The environment was never given this capability.** A configuration fact,
+    // not a fault and not a fluctuation: the Worker holds no provider, no secret
+    // or no binding for the thing being asked about, and it will hold none until
+    // somebody deploys different configuration.
+    //
+    // It exists because `service_unavailable` was carrying both meanings, and
+    // the retry answer differs between them. W9-06 blocked the invited cohort
+    // over billing panels that said "The service is not answering right now" for
+    // capabilities production had deliberately not turned on; W9-08 found the
+    // other half still live — the same refusal reaching a customer as
+    // `retryable`, and the CLI printing "The identical request is safe to
+    // repeat" about a condition no repetition can clear.
+    //
+    // Deliberately **not** `billing_not_ready`, which is the opposite case: that
+    // one is provisioning already in flight, finishes on its own within a
+    // minute, and is correctly retryable.
+    capability_not_configured: { category: "not-configured", status: 503 },
     credential_expired: { category: "authentication", status: 401 },
     credential_revoked: { category: "authentication", status: 401 },
     idempotency_key_reused: { category: "conflict", status: 409 },
@@ -61,7 +99,17 @@ export const PROBLEM_CODES = {
     version_conflict: { category: "conflict", status: 409 },
 };
 export const problemCodeSchema = z.enum(Object.keys(PROBLEM_CODES));
-/** Whether repeating the identical request could succeed later. */
+/**
+ * Whether repeating the identical request could succeed later.
+ *
+ * **Two 5xx categories, opposite answers, and that is the point.**
+ * `unavailable` is something that has gone wrong and will come back;
+ * `not-configured` is something that was never turned on and will not turn
+ * itself on. Reading the status alone cannot tell them apart, which is how a
+ * permanent refusal came to be published to customers as retryable — in the
+ * SDK's `retryable`, in the CLI's exit class, and as a "Try again" control the
+ * dashboard offered for a condition no amount of trying clears.
+ */
 export function isRetryable(code) {
     const category = PROBLEM_CODES[code].category;
     return category === "rate-limited" || category === "unavailable";

package/dist/protocol.d.ts

@@ -10,11 +10,11 @@ import type { FieldError } from "./problems.js";
  * scheduling book changes constantly. The cursor is opaque: clients pass back
  * exactly what they were given.
  */
-export declare const PAGE_SIZE: {
-    readonly default: 25;
-    readonly max: 100;
-    readonly min: 1;
-};
+export declare const PAGE_SIZE: Readonly<{
+    default: 25;
+    max: 100;
+    min: 1;
+}>;
 export declare const pageRequestSchema: import("zod").ZodObject<{
     cursor: import("zod").ZodOptional<import("zod").ZodString>;
     limit: import("zod").ZodDefault<import("zod").ZodNumber>;

package/dist/protocol.js

@@ -1,4 +1,5 @@
 import { z } from "./zod.js";
+import { PUBLIC_PAGE_SIZE } from "./configuration-bounds.js";
 import { endpointIdSchema, environmentIdSchema, organizationIdSchema, projectIdSchema, } from "./identifiers.js";
 import { timestampSchema } from "./time.js";
 /**
@@ -13,7 +14,7 @@ import { timestampSchema } from "./time.js";
  * scheduling book changes constantly. The cursor is opaque: clients pass back
  * exactly what they were given.
  */
-export const PAGE_SIZE = { default: 25, max: 100, min: 1 };
+export const PAGE_SIZE = PUBLIC_PAGE_SIZE;
 export const pageRequestSchema = z.object({
     cursor: z.string().min(1).optional(),
     limit: z

package/dist/scheduling-records.d.ts

@@ -1,5 +1,46 @@
 import { z } from "./zod.js";
 export declare const portableScheduleRecordSchema: import("zod").ZodObject<{
+    storedHttp: import("zod").ZodOptional<import("zod").ZodObject<{
+        method: import("zod").ZodEnum<{
+            POST: "POST";
+            PUT: "PUT";
+            GET: "GET";
+        }>;
+        bodyMode: import("zod").ZodEnum<{
+            envelope: "envelope";
+            json: "json";
+            none: "none";
+        }>;
+        headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+            valueBytes: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            envelope: import("zod").ZodObject<{
+                keyId: import("zod").ZodLiteral<"v1">;
+                nonce: import("zod").ZodString;
+                ciphertext: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            valueBytes: import("zod").ZodNumber;
+            ownerKind: import("zod").ZodEnum<{
+                endpoint: "endpoint";
+                schedule: "schedule";
+            }>;
+            ownerId: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>;
+        encryptedTemplate: import("zod").ZodOptional<import("zod").ZodObject<{
+            keyId: import("zod").ZodLiteral<"v1">;
+            nonce: import("zod").ZodString;
+            ciphertext: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>>;
+    httpTemplateRetentionDueAt: import("zod").ZodOptional<import("zod").ZodString>;
     authority: import("zod").ZodObject<{
         environment: import("zod").ZodString;
         environmentKind: import("zod").ZodEnum<{
@@ -10,6 +51,34 @@ export declare const portableScheduleRecordSchema: import("zod").ZodObject<{
         project: import("zod").ZodString;
     }, import("zod/v4/core").$strict>;
     retentionClass: import("zod").ZodString;
+    http: import("zod").ZodOptional<import("zod").ZodObject<{
+        method: import("zod").ZodEnum<{
+            POST: "POST";
+            PUT: "PUT";
+            GET: "GET";
+        }>;
+        body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            mode: import("zod").ZodLiteral<"envelope">;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            mode: import("zod").ZodLiteral<"none">;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            mode: import("zod").ZodLiteral<"json">;
+            value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+        }, import("zod/v4/core").$strict>], "mode">;
+        headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>;
+    }, import("zod/v4/core").$strict>>;
     archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
     data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
     createdAt: import("zod").ZodString;
@@ -129,7 +198,9 @@ export declare const portableOccurrenceRecordSchema: import("zod").ZodObject<{
 export type PortableOccurrenceRecord = z.infer<typeof portableOccurrenceRecordSchema>;
 export declare const portableAttemptRecordSchema: import("zod").ZodObject<{
     id: import("zod").ZodString;
+    localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
     occurrence: import("zod").ZodString;
+    rescues: import("zod").ZodOptional<import("zod").ZodInt>;
     remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
         none: "none";
         review_retry_policy: "review_retry_policy";
@@ -188,7 +259,49 @@ export declare const portableAttemptRecordSchema: import("zod").ZodObject<{
         network_ambiguous: "network_ambiguous";
         payload_unavailable: "payload_unavailable";
     }>>;
+    dispatchRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
     durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+    storedHttp: import("zod").ZodOptional<import("zod").ZodObject<{
+        method: import("zod").ZodEnum<{
+            POST: "POST";
+            PUT: "PUT";
+            GET: "GET";
+        }>;
+        bodyMode: import("zod").ZodEnum<{
+            envelope: "envelope";
+            json: "json";
+            none: "none";
+        }>;
+        headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+            valueBytes: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            envelope: import("zod").ZodObject<{
+                keyId: import("zod").ZodLiteral<"v1">;
+                nonce: import("zod").ZodString;
+                ciphertext: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            valueBytes: import("zod").ZodNumber;
+            ownerKind: import("zod").ZodEnum<{
+                endpoint: "endpoint";
+                schedule: "schedule";
+            }>;
+            ownerId: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>;
+        encryptedTemplate: import("zod").ZodOptional<import("zod").ZodObject<{
+            keyId: import("zod").ZodLiteral<"v1">;
+            nonce: import("zod").ZodString;
+            ciphertext: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>>;
+    httpPayloadRetentionDueAt: import("zod").ZodOptional<import("zod").ZodString>;
     authority: import("zod").ZodObject<{
         environment: import("zod").ZodString;
         environmentKind: import("zod").ZodEnum<{
@@ -229,7 +342,9 @@ export type PortableEncryptedPayloadRecord = z.infer<typeof portableEncryptedPay
 export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<{
     attempts: import("zod").ZodArray<import("zod").ZodObject<{
         id: import("zod").ZodString;
+        localReceiptRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
         occurrence: import("zod").ZodString;
+        rescues: import("zod").ZodOptional<import("zod").ZodInt>;
         remediation: import("zod").ZodOptional<import("zod").ZodEnum<{
             none: "none";
             review_retry_policy: "review_retry_policy";
@@ -288,7 +403,49 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
             network_ambiguous: "network_ambiguous";
             payload_unavailable: "payload_unavailable";
         }>>;
+        dispatchRecoveries: import("zod").ZodOptional<import("zod").ZodInt>;
         durationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+        storedHttp: import("zod").ZodOptional<import("zod").ZodObject<{
+            method: import("zod").ZodEnum<{
+                POST: "POST";
+                PUT: "PUT";
+                GET: "GET";
+            }>;
+            bodyMode: import("zod").ZodEnum<{
+                envelope: "envelope";
+                json: "json";
+                none: "none";
+            }>;
+            headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<false>;
+                value: import("zod").ZodString;
+                valueBytes: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<true>;
+                envelope: import("zod").ZodObject<{
+                    keyId: import("zod").ZodLiteral<"v1">;
+                    nonce: import("zod").ZodString;
+                    ciphertext: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                valueBytes: import("zod").ZodNumber;
+                ownerKind: import("zod").ZodEnum<{
+                    endpoint: "endpoint";
+                    schedule: "schedule";
+                }>;
+                ownerId: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                suppressed: import("zod").ZodLiteral<true>;
+            }, import("zod/v4/core").$strict>]>>;
+            encryptedTemplate: import("zod").ZodOptional<import("zod").ZodObject<{
+                keyId: import("zod").ZodLiteral<"v1">;
+                nonce: import("zod").ZodString;
+                ciphertext: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>>;
+        httpPayloadRetentionDueAt: import("zod").ZodOptional<import("zod").ZodString>;
         authority: import("zod").ZodObject<{
             environment: import("zod").ZodString;
             environmentKind: import("zod").ZodEnum<{
@@ -388,6 +545,47 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
         storedAt: import("zod").ZodString;
     }, import("zod/v4/core").$strict>>;
     schedule: import("zod").ZodObject<{
+        storedHttp: import("zod").ZodOptional<import("zod").ZodObject<{
+            method: import("zod").ZodEnum<{
+                POST: "POST";
+                PUT: "PUT";
+                GET: "GET";
+            }>;
+            bodyMode: import("zod").ZodEnum<{
+                envelope: "envelope";
+                json: "json";
+                none: "none";
+            }>;
+            headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<false>;
+                value: import("zod").ZodString;
+                valueBytes: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<true>;
+                envelope: import("zod").ZodObject<{
+                    keyId: import("zod").ZodLiteral<"v1">;
+                    nonce: import("zod").ZodString;
+                    ciphertext: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                valueBytes: import("zod").ZodNumber;
+                ownerKind: import("zod").ZodEnum<{
+                    endpoint: "endpoint";
+                    schedule: "schedule";
+                }>;
+                ownerId: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                suppressed: import("zod").ZodLiteral<true>;
+            }, import("zod/v4/core").$strict>]>>;
+            encryptedTemplate: import("zod").ZodOptional<import("zod").ZodObject<{
+                keyId: import("zod").ZodLiteral<"v1">;
+                nonce: import("zod").ZodString;
+                ciphertext: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>>;
+        httpTemplateRetentionDueAt: import("zod").ZodOptional<import("zod").ZodString>;
         authority: import("zod").ZodObject<{
             environment: import("zod").ZodString;
             environmentKind: import("zod").ZodEnum<{
@@ -398,6 +596,34 @@ export declare const portableSchedulingRecordSetSchema: import("zod").ZodObject<
             project: import("zod").ZodString;
         }, import("zod/v4/core").$strict>;
         retentionClass: import("zod").ZodString;
+        http: import("zod").ZodOptional<import("zod").ZodObject<{
+            method: import("zod").ZodEnum<{
+                POST: "POST";
+                PUT: "PUT";
+                GET: "GET";
+            }>;
+            body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"envelope">;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"none">;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                mode: import("zod").ZodLiteral<"json">;
+                value: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+            }, import("zod/v4/core").$strict>], "mode">;
+            headers: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<false>;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                secret: import("zod").ZodLiteral<true>;
+                configured: import("zod").ZodLiteral<true>;
+                value: import("zod").ZodOptional<import("zod").ZodNever>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                suppressed: import("zod").ZodLiteral<true>;
+            }, import("zod/v4/core").$strict>]>>;
+        }, import("zod/v4/core").$strict>>;
         archivedAt: import("zod").ZodOptional<import("zod").ZodString>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
         createdAt: import("zod").ZodString;

package/dist/scheduling-records.js

@@ -1,3 +1,4 @@
+import { storedHttpRequestSchema } from "./http-request.js";
 import { z } from "./zod.js";
 import { authoritySchema } from "./authority.js";
 import { SCHEDULE_PAYLOAD_AAD_VERSION } from "./delivery.js";
@@ -12,6 +13,8 @@ const retentionClassSchema = z
 export const portableScheduleRecordSchema = z
     .strictObject({
     ...scheduleSchema.shape,
+    storedHttp: storedHttpRequestSchema.optional(),
+    httpTemplateRetentionDueAt: timestampSchema.optional(),
     authority: portableAuthoritySchema,
     retentionClass: retentionClassSchema,
 })
@@ -92,6 +95,8 @@ export const portableOccurrenceRecordSchema = occurrenceSchema
 });
 export const portableAttemptRecordSchema = attemptSchema
     .safeExtend({
+    storedHttp: storedHttpRequestSchema.optional(),
+    httpPayloadRetentionDueAt: timestampSchema.optional(),
     authority: portableAuthoritySchema,
     dispatchEpoch: z.number().int().positive(),
     schedule: scheduleIdSchema,