@greatwait/contracts 0.1.0-alpha.5 → 0.1.0-alpha.7

package/README.md

@@ -4,7 +4,7 @@ The public contracts for [GreatWait](https://greatwait.dev): the schemas every
 response is parsed with, the stable refusal catalog, the operation registry, and
 the generated OpenAPI documents.
 
-> **Invited alpha.** This package publishes on the `alpha` dist-tag and has no
+> **Alpha.** This package publishes on the `alpha` dist-tag and has no
 > `latest`. Install it explicitly, and pin the exact version in anything you
 > care about.
 

package/dist/attempt-diagnostics.d.ts

@@ -0,0 +1,8 @@
+import type { Attempt, AttemptResponse } from "./scheduling.js";
+/** Render customer-controlled text without terminal escapes, controls or bidi overrides. */
+export declare function sanitizedDiagnosticText(value: string): string;
+export declare function responseBodySentence(state: AttemptResponse["bodyState"], noServerResponse?: boolean): string;
+export declare function requestCaptureSentence(state: Attempt["requestState"], inProgress?: boolean): string;
+export declare function attemptStatusGuidance(status: number | undefined): string | undefined;
+/** A safe text preview, independently of the exact retained/download bytes. */
+export declare function diagnosticBodyText(body: NonNullable<AttemptResponse["body"]>): string | undefined;

package/dist/attempt-diagnostics.js

@@ -0,0 +1,68 @@
+/** Render customer-controlled text without terminal escapes, controls or bidi overrides. */
+export function sanitizedDiagnosticText(value) {
+    return Array.from(value.replace(/\r\n/gu, "\n"), (c) => {
+        const n = c.codePointAt(0);
+        return c === "\n" ||
+            c === "\t" ||
+            c === "\u200C" ||
+            c === "\u200D" ||
+            c === "\uFEFF" ||
+            (!/\p{Cc}|\p{Cf}/u.test(c) && n !== 0x7f)
+            ? c
+            : "�";
+    }).join("");
+}
+export function responseBodySentence(state, noServerResponse = false) {
+    switch (state) {
+        case "empty":
+            return "The server answered with an empty body.";
+        case "expired":
+            return "The response has expired after 7 days.";
+        case "not_captured":
+            return noServerResponse
+                ? "No server response was received for this attempt."
+                : "The response body was not captured.";
+        case "captured":
+            return "What the server answered:";
+    }
+}
+export function requestCaptureSentence(state, inProgress = false) {
+    return state === "expired"
+        ? "The request body has expired. Request evidence is kept for at most 3 days and never beyond payload retention."
+        : inProgress
+            ? "The request is still in progress; sent-request evidence is not available yet."
+            : "The request was not captured.";
+}
+export function attemptStatusGuidance(status) {
+    if (status === 401 || status === 403)
+        return "Your server rejected the credentials we sent. Check the Authorization header on this endpoint.";
+    if (status === 404 || status === 410)
+        return "The server could not find this endpoint. Check the URL we sent.";
+    if (status === 405)
+        return "The server refused this HTTP method. Check the method we sent.";
+    if (status === 429)
+        return "The server asked us to slow down. Check its Retry-After header.";
+    if (status === 408)
+        return "The server timed out while receiving the request. Check its response and timeout settings.";
+    if (status !== undefined && status >= 500)
+        return "The server reported an error. Use its response to diagnose the failure.";
+    if (status !== undefined && status >= 300 && status < 400)
+        return "The server redirected the request. Call the final HTTPS URL directly; redirects are disabled.";
+    if (status !== undefined && status >= 400)
+        return "The server refused this request. Check its response against what we sent.";
+    return undefined;
+}
+/** A safe text preview, independently of the exact retained/download bytes. */
+export function diagnosticBodyText(body) {
+    if (body.encoding === "utf8")
+        return body.content;
+    const media = (body.contentType.split(";")[0] ?? "").trim().toLowerCase();
+    if (!/^(?:text\/[a-z0-9.+-]+|application\/(?:[a-z0-9.+-]+\+)?(?:json|xml)|application\/javascript)$/u.test(media))
+        return undefined;
+    try {
+        return new TextDecoder().decode(Uint8Array.from(atob(body.content), (c) => c.charCodeAt(0)));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/authority.d.ts

@@ -50,8 +50,9 @@ export type Authority = z.infer<typeof authoritySchema>;
  * client is permitted, and what the granting member's current role allows.
  * Nothing here can exceed a human's own access.
  */
-export declare const SCOPES: readonly ["credentials:administer", "billing:write", "credentials:read", "credentials:write", "endpoints:read", "endpoints:write", "forecast:read", "grants:read", "grants:write", "occurrences:read", "occurrences:redeliver", "projects:administer", "projects:read", "projects:write", "schedules:read", "schedules:write", "usage:read"];
+export declare const SCOPES: readonly ["members:manage", "credentials:administer", "billing:write", "credentials:read", "credentials:write", "endpoints:read", "endpoints:write", "forecast:read", "grants:read", "grants:write", "occurrences:read", "occurrences:redeliver", "projects:administer", "projects:read", "projects:write", "schedules:read", "schedules:write", "usage:read"];
 export declare const scopeSchema: import("zod").ZodEnum<{
+    "members:manage": "members:manage";
     "credentials:administer": "credentials:administer";
     "billing:write": "billing:write";
     "credentials:read": "credentials:read";
@@ -114,6 +115,7 @@ export declare const principalSchema: import("zod").ZodObject<{
         project: import("zod").ZodString;
     }, import("zod/v4/core").$strip>;
     scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+        "members:manage": "members:manage";
         "credentials:administer": "credentials:administer";
         "billing:write": "billing:write";
         "credentials:read": "credentials:read";
@@ -258,6 +260,7 @@ export declare const credentialContextSchema: import("zod").ZodObject<{
     }>;
     project: import("zod").ZodString;
     scopes: import("zod").ZodArray<import("zod").ZodEnum<{
+        "members:manage": "members:manage";
         "credentials:administer": "credentials:administer";
         "billing:write": "billing:write";
         "credentials:read": "credentials:read";

package/dist/authority.js

@@ -43,6 +43,7 @@ export const authoritySchema = z.object({
  * Nothing here can exceed a human's own access.
  */
 export const SCOPES = [
+    "members:manage",
     /**
      * Act on a credential somebody else issued.
      *

package/dist/billing.d.ts

@@ -253,16 +253,16 @@ export declare const billingPaymentOperationSchema: import("zod").ZodObject<{
     }, import("zod/v4/core").$strip>>;
     id: import("zod").ZodString;
     kind: import("zod").ZodEnum<{
-        manual: "manual";
         automatic: "automatic";
+        manual: "manual";
     }>;
     paymentUrl: import("zod").ZodOptional<import("zod").ZodString>;
     reason: import("zod").ZodOptional<import("zod").ZodString>;
     receiptUrl: import("zod").ZodOptional<import("zod").ZodString>;
     state: import("zod").ZodEnum<{
+        failed: "failed";
         pending: "pending";
         paid: "paid";
-        failed: "failed";
         "authentication-required": "authentication-required";
         "action-required": "action-required";
         canceled: "canceled";
@@ -393,16 +393,16 @@ export declare const billingFundingViewSchema: import("zod").ZodObject<{
         }, import("zod/v4/core").$strip>>;
         id: import("zod").ZodString;
         kind: import("zod").ZodEnum<{
-            manual: "manual";
             automatic: "automatic";
+            manual: "manual";
         }>;
         paymentUrl: import("zod").ZodOptional<import("zod").ZodString>;
         reason: import("zod").ZodOptional<import("zod").ZodString>;
         receiptUrl: import("zod").ZodOptional<import("zod").ZodString>;
         state: import("zod").ZodEnum<{
+            failed: "failed";
             pending: "pending";
             paid: "paid";
-            failed: "failed";
             "authentication-required": "authentication-required";
             "action-required": "action-required";
             canceled: "canceled";
@@ -427,7 +427,7 @@ export declare const billingFundingViewSchema: import("zod").ZodObject<{
         scale: import("zod").ZodLiteral<6>;
     }, import("zod/v4/core").$strip>;
 }, import("zod/v4/core").$strict>;
-export declare const BILLING_NOTICE_KINDS: readonly ["budget-warning", "budget-exhausted", "low-credit", "automatic-top-up-cap-reached", "funding-blocked", "payment-pending", "payment-succeeded", "payment-failed", "payment-authentication-required", "payment-outcome-unresolved", "service-restored"];
+export declare const BILLING_NOTICE_KINDS: readonly ["budget-warning", "budget-exhausted", "low-credit", "automatic-top-up-cap-reached", "funding-blocked", "payment-pending", "payment-succeeded", "payment-failed", "payment-authentication-required", "payment-outcome-unresolved", "service-restored", "schedule-auto-paused"];
 type BillingNoticeMoney = z.infer<typeof nonnegativeExactMoneySchema>;
 export interface BillingNotice {
     readonly amounts: {
@@ -450,7 +450,8 @@ export interface BillingNotice {
         readonly operation: string;
         readonly state: (typeof BILLING_PAYMENT_STATES)[number];
     } | null;
-    readonly recoveryPath: "#billing" | "#billing-funding" | "#billing-notification-settings";
+    /** A fixed billing anchor or a scoped schedule recovery route. */
+    readonly recoveryPath: string;
     readonly resolvedAt: string | null;
     readonly scope: {
         readonly kind: "organization";
@@ -493,11 +494,11 @@ export interface BillingNotificationSettingsUpdateRequest {
     readonly lowCreditThreshold?: z.infer<typeof exactCentMoneySchema> | null | undefined;
     readonly noncriticalEmail: boolean;
 }
-export declare const billingNoticeRecoveryPathSchema: import("zod").ZodEnum<{
+export declare const billingNoticeRecoveryPathSchema: import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
     "#billing": "#billing";
     "#billing-funding": "#billing-funding";
     "#billing-notification-settings": "#billing-notification-settings";
-}>;
+}>, import("zod").ZodString]>;
 export declare const billingNoticeSchema: z.ZodType<BillingNotice>;
 export declare const billingNoticePageSchema: z.ZodType<BillingNoticePage>;
 export declare const billingNotificationSettingsSchema: z.ZodType<BillingNotificationSettings>;
@@ -1118,16 +1119,16 @@ export declare const billingPaymentHistoryPageSchema: import("zod").ZodObject<{
         }, import("zod/v4/core").$strip>>;
         id: import("zod").ZodString;
         kind: import("zod").ZodEnum<{
-            manual: "manual";
             automatic: "automatic";
+            manual: "manual";
         }>;
         paymentUrl: import("zod").ZodOptional<import("zod").ZodString>;
         reason: import("zod").ZodOptional<import("zod").ZodString>;
         receiptUrl: import("zod").ZodOptional<import("zod").ZodString>;
         state: import("zod").ZodEnum<{
+            failed: "failed";
             pending: "pending";
             paid: "paid";
-            failed: "failed";
             "authentication-required": "authentication-required";
             "action-required": "action-required";
             canceled: "canceled";

package/dist/billing.js

@@ -406,11 +406,14 @@ export const BILLING_NOTICE_KINDS = [
     "payment-authentication-required",
     "payment-outcome-unresolved",
     "service-restored",
+    "schedule-auto-paused",
 ];
-export const billingNoticeRecoveryPathSchema = z.enum([
-    "#billing",
-    "#billing-funding",
-    "#billing-notification-settings",
+export const billingNoticeRecoveryPathSchema = z.union([
+    z.enum(["#billing", "#billing-funding", "#billing-notification-settings"]),
+    z
+        .string()
+        .max(1024)
+        .regex(/^\/o\/[A-Za-z0-9_%.-]+\/p\/proj_[0-9abcdefghjkmnpqrstvwxyz]{26}\/(?:live|test)\/schedules\/sch_[0-9abcdefghjkmnpqrstvwxyz]{26}$/u, "must be a scoped schedule recovery route"),
 ]);
 export const billingNoticeSchema = z
     .object({

package/dist/data-export.d.ts

@@ -58,6 +58,8 @@ export type DataExportPart = z.infer<typeof dataExportPartSchema>;
 /** Additive operation declarations, merged into the canonical registry by the API wiring. */
 export declare const DATA_EXPORT_OPERATIONS: readonly [import("./operations.js").OperationDefinition & {
     readonly id: "exports.create";
+} & {
+    readonly request: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
 }, import("./operations.js").OperationDefinition & {
     readonly id: "exports.read";
 }, import("./operations.js").OperationDefinition & {

package/dist/delivery.d.ts

@@ -21,6 +21,31 @@ export interface EncryptedSchedulePayload {
     readonly keyId: string;
     readonly nonce: string;
 }
+/** Encrypted custom HTTP settings, internal only; never a public read shape. */
+export type StoredHttpHeader = {
+    readonly name: string;
+    readonly secret: false;
+    readonly value: string;
+    readonly valueBytes: number;
+} | {
+    readonly name: string;
+    readonly secret: true;
+    readonly envelope: EncryptedSchedulePayload;
+    readonly valueBytes: number;
+    readonly ownerKind: "endpoint" | "schedule";
+    readonly ownerId: string;
+} | {
+    readonly name: string;
+    readonly suppressed: true;
+};
+export interface StoredHttpRequest {
+    readonly method: "POST" | "PUT" | "GET";
+    readonly bodyMode: "envelope" | "json" | "none";
+    readonly headers: readonly StoredHttpHeader[];
+    readonly encryptedTemplate?: EncryptedSchedulePayload;
+}
+export declare const HTTP_HEADER_AAD_VERSION: "greatwait.http-header.v1";
+export declare const HTTP_TEMPLATE_AAD_VERSION: "greatwait.http-template.v1";
 /**
  * One immutable delivery attempt, minted by the Scheduler Partition from its
  * verified authority. No member of this tuple comes from callback request
@@ -46,6 +71,7 @@ export interface CallbackAttemptDispatch {
     /** Monotonic partition fence for duplicate/late dispatch and report RPCs. */
     readonly dispatchEpoch: number;
     readonly encryptedPayloadEnvelope: EncryptedSchedulePayload;
+    readonly http?: StoredHttpRequest;
     readonly endpointId: EndpointId;
     readonly latencyClass: "realtime" | "bulk";
     /**
@@ -226,41 +252,17 @@ export declare function effectiveCompletionDeadlineMs(requestedMs: number | unde
 export declare const CALLBACK_ATTEMPT_DIAGNOSTICS: readonly ["completion_timed_out", "delivered", "duplicate_inflight", "endpoint_unavailable", "endpoint_unsafe", "http_refused", "http_retryable", "http_terminal", "identity_conflict", "network_ambiguous", "payload_unavailable", "rate_limited"];
 export type CallbackAttemptDiagnostic = (typeof CALLBACK_ATTEMPT_DIAGNOSTICS)[number];
 /**
- * Statuses where the receiver is refusing *this delivery, right now* rather
- * than objecting to the message it carries.
- *
- * **The line is whether resending the identical bytes could ever get a
- * different answer.** Every callback attempt re-sends the same signed envelope,
- * so a receiver that rejects the message itself — malformed, too large, wrong
- * media type, gone, refused for legal reasons — will reject it identically for
- * as long as the occurrence lives, and retrying is pure cost on the population
- * least likely to recover. A receiver that refuses *us* has a cause someone
- * fixes: an expired or rotated credential, a WAF rule that started matching, a
- * deploy window where the route is briefly absent.
- *
- * | Status | Why it is here |
- * | ------ | -------------- |
- * | 401    | credential expired, rotated, or not yet deployed |
- * | 402    | receiver's own service suspended, restored on payment |
- * | 403    | WAF or bot rule, revoked permission, IP block |
- * | 404    | route absent during a deploy or a partial rollout |
- * | 405    | method absent during a deploy or a partial rollout |
- * | 407    | an egress proxy in front of the receiver wants credentials |
- * | 421    | misdirected during a routing or certificate change |
- * | 423    | the target resource is temporarily locked |
- * | 424    | the receiver's own dependency failed |
- * | 425    | the receiver asked us not to risk a replay yet — literally "retry later" |
+ * Receiver refusals that retain the ordinary five-failure retry budget.
  *
- * **409 is deliberately not here**, though it is a refusal in the plain
- * reading. From a callback receiver a conflict overwhelmingly means "I already
- * have this delivery", which the identical retry cannot resolve and which is
- * the receiver's idempotency working rather than failing.
+ * W9-50 reverses FXO-1596 for 401/403/404/405: credentials, permissions,
+ * missing routes and unsupported methods need a customer change, so an
+ * automatic retry bills another attempt without fixing them. They now end
+ * the occurrence immediately; manual redelivery remains available.
  *
- * **An unrecognised 4xx is not here either.** RFC 7231 says an unknown 4xx must
- * be treated as a 400, so the default is terminal and this list is the whole of
- * the exception. Adding to it is a product decision, not a lookup.
+ * 402, 407, 421, 423, 424 and 425 retain the budget. 408, 429 and 5xx are
+ * retryable separately. Other responses outside 2xx are terminal.
  */
-export declare const CALLBACK_REFUSAL_STATUSES: readonly [401, 402, 403, 404, 405, 407, 421, 423, 424, 425];
+export declare const CALLBACK_REFUSAL_STATUSES: readonly [402, 407, 421, 423, 424, 425];
 /** Whether a receiver refused this delivery in a way that may recover. */
 export declare function isCallbackRefusalStatus(status: number): boolean;
 /** Stable outcome of the one network attempt an executor invocation may run. */
@@ -313,18 +315,17 @@ export declare const CALLBACK_RESPONSE_HEADER_MAX_BYTES = 256;
 /**
  * How much of a failed response body may be retained, in bytes.
  *
- * Four kibibytes of the *start* of the body, read as a bounded prefix and with
+ * Ten kibibytes of the *start* of any media type, read as a bounded prefix and with
  * the rest of the stream cancelled rather than buffered. It is enough for a
  * stack trace's first frames or a validation error list, which is what makes a
  * failing receiver diagnosable without turning this product into a log store.
  */
-export declare const CALLBACK_FAILURE_SNIPPET_MAX_BYTES = 4096;
+export declare const CALLBACK_FAILURE_SNIPPET_MAX_BYTES = 10240;
 /**
  * Media types whose body may be retained as a failure snippet.
  *
- * Text and JSON only. A binary body has nothing a person reads in its first
- * four kibibytes, and retaining one would mean storing an arbitrary fragment
- * of an arbitrary file because a receiver set a header.
+ * Legacy text detection, also used as a hint for decoding invalid UTF-8.
+ * Full failed-response capture accepts every media type.
  */
 export declare const CALLBACK_FAILURE_SNIPPET_CONTENT_TYPES: readonly ["application/json", "application/problem+json", "application/xml", "text/"];
 /** One retained response header, already bounded and lowercased by name. */
@@ -347,14 +348,16 @@ export interface CallbackFailureSnippet {
 /**
  * Bounded evidence about one HTTP response.
  *
- * Deliberately not "the response": there is no body for a success, no header
- * outside the allowlist, and no representation at all for a transport failure
- * that produced no response.
+ * Failed responses retain every header and bounded body before encryption.
+ * Success and pending responses keep only legacy diagnostic headers.
+ * The sent request is independent of whether a response arrived.
  */
 export interface CallbackResponseEvidence {
     readonly headers: readonly CallbackResponseHeader[];
     /** Absent for a success, a pending acknowledgement, and a non-text body. */
     readonly snippet?: CallbackFailureSnippet;
+    readonly response?: import("./scheduling.js").AttemptResponse;
+    readonly request?: import("./scheduling.js").AttemptRequest;
 }
 /**
  * What one network attempt did, including the answer that is not an outcome.

package/dist/delivery.js

@@ -7,6 +7,8 @@
  * decryption oracle.
  */
 export const SCHEDULE_PAYLOAD_AAD_VERSION = "greatwait.schedule-payload.v1";
+export const HTTP_HEADER_AAD_VERSION = "greatwait.http-header.v1";
+export const HTTP_TEMPLATE_AAD_VERSION = "greatwait.http-template.v1";
 /**
  * What a receiver says about work it acknowledged and then finished.
  *
@@ -206,42 +208,18 @@ export const CALLBACK_ATTEMPT_DIAGNOSTICS = [
     "rate_limited",
 ];
 /**
- * Statuses where the receiver is refusing *this delivery, right now* rather
- * than objecting to the message it carries.
+ * Receiver refusals that retain the ordinary five-failure retry budget.
  *
- * **The line is whether resending the identical bytes could ever get a
- * different answer.** Every callback attempt re-sends the same signed envelope,
- * so a receiver that rejects the message itself — malformed, too large, wrong
- * media type, gone, refused for legal reasons — will reject it identically for
- * as long as the occurrence lives, and retrying is pure cost on the population
- * least likely to recover. A receiver that refuses *us* has a cause someone
- * fixes: an expired or rotated credential, a WAF rule that started matching, a
- * deploy window where the route is briefly absent.
+ * W9-50 reverses FXO-1596 for 401/403/404/405: credentials, permissions,
+ * missing routes and unsupported methods need a customer change, so an
+ * automatic retry bills another attempt without fixing them. They now end
+ * the occurrence immediately; manual redelivery remains available.
  *
- * | Status | Why it is here |
- * | ------ | -------------- |
- * | 401    | credential expired, rotated, or not yet deployed |
- * | 402    | receiver's own service suspended, restored on payment |
- * | 403    | WAF or bot rule, revoked permission, IP block |
- * | 404    | route absent during a deploy or a partial rollout |
- * | 405    | method absent during a deploy or a partial rollout |
- * | 407    | an egress proxy in front of the receiver wants credentials |
- * | 421    | misdirected during a routing or certificate change |
- * | 423    | the target resource is temporarily locked |
- * | 424    | the receiver's own dependency failed |
- * | 425    | the receiver asked us not to risk a replay yet — literally "retry later" |
- *
- * **409 is deliberately not here**, though it is a refusal in the plain
- * reading. From a callback receiver a conflict overwhelmingly means "I already
- * have this delivery", which the identical retry cannot resolve and which is
- * the receiver's idempotency working rather than failing.
- *
- * **An unrecognised 4xx is not here either.** RFC 7231 says an unknown 4xx must
- * be treated as a 400, so the default is terminal and this list is the whole of
- * the exception. Adding to it is a product decision, not a lookup.
+ * 402, 407, 421, 423, 424 and 425 retain the budget. 408, 429 and 5xx are
+ * retryable separately. Other responses outside 2xx are terminal.
  */
 export const CALLBACK_REFUSAL_STATUSES = [
-    401, 402, 403, 404, 405, 407, 421, 423, 424, 425,
+    402, 407, 421, 423, 424, 425,
 ];
 /** Whether a receiver refused this delivery in a way that may recover. */
 export function isCallbackRefusalStatus(status) {
@@ -286,18 +264,17 @@ export const CALLBACK_RESPONSE_HEADER_MAX_BYTES = 256;
 /**
  * How much of a failed response body may be retained, in bytes.
  *
- * Four kibibytes of the *start* of the body, read as a bounded prefix and with
+ * Ten kibibytes of the *start* of any media type, read as a bounded prefix and with
  * the rest of the stream cancelled rather than buffered. It is enough for a
  * stack trace's first frames or a validation error list, which is what makes a
  * failing receiver diagnosable without turning this product into a log store.
  */
-export const CALLBACK_FAILURE_SNIPPET_MAX_BYTES = 4_096;
+export const CALLBACK_FAILURE_SNIPPET_MAX_BYTES = 10_240;
 /**
  * Media types whose body may be retained as a failure snippet.
  *
- * Text and JSON only. A binary body has nothing a person reads in its first
- * four kibibytes, and retaining one would mean storing an arbitrary fragment
- * of an arbitrary file because a receiver set a header.
+ * Legacy text detection, also used as a hint for decoding invalid UTF-8.
+ * Full failed-response capture accepts every media type.
  */
 export const CALLBACK_FAILURE_SNIPPET_CONTENT_TYPES = [
     "application/json",

package/dist/effective-limits.d.ts

@@ -8,26 +8,26 @@ export declare const effectiveCustomerLimitsSchema: import("zod").ZodObject<{
     }, import("zod/v4/core").$strict>;
     provenance: import("zod").ZodObject<{
         inlinePayloadBytes: import("zod").ZodEnum<{
-            organization: "organization";
             default: "default";
+            organization: "organization";
             global: "global";
             deployment: "deployment";
         }>;
         partitionKeyCeiling: import("zod").ZodOptional<import("zod").ZodEnum<{
-            organization: "organization";
             default: "default";
+            organization: "organization";
             global: "global";
             deployment: "deployment";
         }>>;
         forecastHorizonSeconds: import("zod").ZodEnum<{
-            organization: "organization";
             default: "default";
+            organization: "organization";
             global: "global";
             deployment: "deployment";
         }>;
         usageWindowDays: import("zod").ZodEnum<{
-            organization: "organization";
             default: "default";
+            organization: "organization";
             global: "global";
             deployment: "deployment";
         }>;