@distilled.cloud/cloudflare 0.0.0-john

package/lib/services/workers-for-platforms.js

@@ -0,0 +1,2121 @@
+/**
+ * Cloudflare WORKERS-FOR-PLATFORMS API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service workers-for-platforms
+ */
+import * as stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import * as API from "../client/api.js";
+import * as T from "../traits.js";
+import {} from "../errors.js";
+import { UploadableSchema } from "../schemas.js";
+export const GetDispatchNamespaceRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}",
+}));
+export const GetDispatchNamespaceResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    createdBy: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedBy: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    namespaceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    namespaceName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    scriptCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    trustedWorkers: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    createdBy: "created_by",
+    createdOn: "created_on",
+    modifiedBy: "modified_by",
+    modifiedOn: "modified_on",
+    namespaceId: "namespace_id",
+    namespaceName: "namespace_name",
+    scriptCount: "script_count",
+    trustedWorkers: "trusted_workers",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getDispatchNamespace = API.make(() => ({
+    input: GetDispatchNamespaceRequest,
+    output: GetDispatchNamespaceResponse,
+    errors: [],
+}));
+export const ListDispatchNamespacesRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces",
+}));
+export const ListDispatchNamespacesResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Struct({
+        createdBy: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        modifiedBy: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        namespaceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        namespaceName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        scriptCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        trustedWorkers: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    }).pipe(Schema.encodeKeys({
+        createdBy: "created_by",
+        createdOn: "created_on",
+        modifiedBy: "modified_by",
+        modifiedOn: "modified_on",
+        namespaceId: "namespace_id",
+        namespaceName: "namespace_name",
+        scriptCount: "script_count",
+        trustedWorkers: "trusted_workers",
+    }))),
+});
+export const listDispatchNamespaces = API.makePaginated(() => ({
+    input: ListDispatchNamespacesRequest,
+    output: ListDispatchNamespacesResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const CreateDispatchNamespaceRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.optional(Schema.String),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces",
+}));
+export const CreateDispatchNamespaceResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    createdBy: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedBy: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    namespaceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    namespaceName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    scriptCount: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    trustedWorkers: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    createdBy: "created_by",
+    createdOn: "created_on",
+    modifiedBy: "modified_by",
+    modifiedOn: "modified_on",
+    namespaceId: "namespace_id",
+    namespaceName: "namespace_name",
+    scriptCount: "script_count",
+    trustedWorkers: "trusted_workers",
+}))
+    .pipe(T.ResponsePath("result"));
+export const createDispatchNamespace = API.make(() => ({
+    input: CreateDispatchNamespaceRequest,
+    output: CreateDispatchNamespaceResponse,
+    errors: [],
+}));
+export const DeleteDispatchNamespaceRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}",
+}));
+export const DeleteDispatchNamespaceResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result"));
+export const deleteDispatchNamespace = API.make(() => ({
+    input: DeleteDispatchNamespaceRequest,
+    output: DeleteDispatchNamespaceResponse,
+    errors: [],
+}));
+export const GetDispatchNamespaceScriptRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}",
+}));
+export const GetDispatchNamespaceScriptResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    dispatchNamespace: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    script: Schema.optional(Schema.Union([Schema.Unknown, Schema.Null])),
+})
+    .pipe(Schema.encodeKeys({
+    createdOn: "created_on",
+    dispatchNamespace: "dispatch_namespace",
+    modifiedOn: "modified_on",
+    script: "script",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getDispatchNamespaceScript = API.make(() => ({
+    input: GetDispatchNamespaceScriptRequest,
+    output: GetDispatchNamespaceScriptResponse,
+    errors: [],
+}));
+export const PutDispatchNamespaceScriptRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    metadata: Schema.Struct({
+        assets: Schema.optional(Schema.Struct({
+            config: Schema.optional(Schema.Struct({
+                headers: Schema.optional(Schema.String),
+                redirects: Schema.optional(Schema.String),
+                htmlHandling: Schema.optional(Schema.Literals([
+                    "auto-trailing-slash",
+                    "force-trailing-slash",
+                    "drop-trailing-slash",
+                    "none",
+                ])),
+                notFoundHandling: Schema.optional(Schema.Literals([
+                    "none",
+                    "404-page",
+                    "single-page-application",
+                ])),
+                runWorkerFirst: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Boolean])),
+                serveDirectly: Schema.optional(Schema.Boolean),
+            }).pipe(Schema.encodeKeys({
+                headers: "_headers",
+                redirects: "_redirects",
+                htmlHandling: "html_handling",
+                notFoundHandling: "not_found_handling",
+                runWorkerFirst: "run_worker_first",
+                serveDirectly: "serve_directly",
+            }))),
+            jwt: Schema.optional(Schema.String),
+        })),
+        bindings: Schema.optional(Schema.Array(Schema.Union([
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("ai"),
+            }),
+            Schema.Struct({
+                dataset: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("analytics_engine"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("assets"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("browser"),
+            }),
+            Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("d1"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("data_blob"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                namespace: Schema.String,
+                type: Schema.Literal("dispatch_namespace"),
+                outbound: Schema.optional(Schema.Struct({
+                    params: Schema.optional(Schema.Array(Schema.String)),
+                    worker: Schema.optional(Schema.Struct({
+                        environment: Schema.optional(Schema.String),
+                        service: Schema.optional(Schema.String),
+                    })),
+                })),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("durable_object_namespace"),
+                className: Schema.optional(Schema.String),
+                environment: Schema.optional(Schema.String),
+                namespaceId: Schema.optional(Schema.String),
+                scriptName: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                className: "class_name",
+                environment: "environment",
+                namespaceId: "namespace_id",
+                scriptName: "script_name",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("hyperdrive"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("inherit"),
+                oldName: Schema.optional(Schema.String),
+                versionId: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                oldName: "old_name",
+                versionId: "version_id",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("images"),
+            }),
+            Schema.Struct({
+                json: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("json"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                namespaceId: Schema.String,
+                type: Schema.Literal("kv_namespace"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                namespaceId: "namespace_id",
+                type: "type",
+            })),
+            Schema.Struct({
+                certificateId: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("mtls_certificate"),
+            }).pipe(Schema.encodeKeys({
+                certificateId: "certificate_id",
+                name: "name",
+                type: "type",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                text: Schema.String,
+                type: Schema.Literal("plain_text"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                pipeline: Schema.String,
+                type: Schema.Literal("pipelines"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                queueName: Schema.String,
+                type: Schema.Literal("queue"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                queueName: "queue_name",
+                type: "type",
+            })),
+            Schema.Struct({
+                bucketName: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("r2_bucket"),
+                jurisdiction: Schema.optional(Schema.Literals(["eu", "fedramp"])),
+            }).pipe(Schema.encodeKeys({
+                bucketName: "bucket_name",
+                name: "name",
+                type: "type",
+                jurisdiction: "jurisdiction",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                text: Schema.String,
+                type: Schema.Literal("secret_text"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("send_email"),
+                allowedDestinationAddresses: Schema.optional(Schema.Array(Schema.String)),
+                allowedSenderAddresses: Schema.optional(Schema.Array(Schema.String)),
+                destinationAddress: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                allowedDestinationAddresses: "allowed_destination_addresses",
+                allowedSenderAddresses: "allowed_sender_addresses",
+                destinationAddress: "destination_address",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                service: Schema.String,
+                type: Schema.Literal("service"),
+                environment: Schema.optional(Schema.String),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("text_blob"),
+            }),
+            Schema.Struct({
+                indexName: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("vectorize"),
+            }).pipe(Schema.encodeKeys({
+                indexName: "index_name",
+                name: "name",
+                type: "type",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("version_metadata"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                secretName: Schema.String,
+                storeId: Schema.String,
+                type: Schema.Literal("secrets_store_secret"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                secretName: "secret_name",
+                storeId: "store_id",
+                type: "type",
+            })),
+            Schema.Struct({
+                algorithm: Schema.Unknown,
+                format: Schema.Literals(["raw", "pkcs8", "spki", "jwk"]),
+                name: Schema.String,
+                type: Schema.Literal("secret_key"),
+                usages: Schema.Array(Schema.Literals([
+                    "encrypt",
+                    "decrypt",
+                    "sign",
+                    "verify",
+                    "deriveKey",
+                    "deriveBits",
+                    "wrapKey",
+                    "unwrapKey",
+                ])),
+                keyBase64: Schema.optional(Schema.String),
+                keyJwk: Schema.optional(Schema.Unknown),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                format: "format",
+                name: "name",
+                type: "type",
+                usages: "usages",
+                keyBase64: "key_base64",
+                keyJwk: "key_jwk",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("workflow"),
+                workflowName: Schema.String,
+                className: Schema.optional(Schema.String),
+                scriptName: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                workflowName: "workflow_name",
+                className: "class_name",
+                scriptName: "script_name",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("wasm_module"),
+            }),
+        ]))),
+        bodyPart: Schema.optional(Schema.String),
+        compatibilityDate: Schema.optional(Schema.String),
+        compatibilityFlags: Schema.optional(Schema.Array(Schema.String)),
+        keepAssets: Schema.optional(Schema.Boolean),
+        keepBindings: Schema.optional(Schema.Array(Schema.String)),
+        limits: Schema.optional(Schema.Struct({
+            cpuMs: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({ cpuMs: "cpu_ms" }))),
+        logpush: Schema.optional(Schema.Boolean),
+        mainModule: Schema.optional(Schema.String),
+        migrations: Schema.optional(Schema.Union([
+            Schema.Unknown,
+            Schema.Struct({
+                newTag: Schema.optional(Schema.String),
+                oldTag: Schema.optional(Schema.String),
+                steps: Schema.optional(Schema.Array(Schema.Unknown)),
+            }).pipe(Schema.encodeKeys({
+                newTag: "new_tag",
+                oldTag: "old_tag",
+                steps: "steps",
+            })),
+        ])),
+        observability: Schema.optional(Schema.Struct({
+            enabled: Schema.Boolean,
+            headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            logs: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    enabled: Schema.Boolean,
+                    invocationLogs: Schema.Boolean,
+                    destinations: Schema.optional(Schema.Array(Schema.String)),
+                    headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    persist: Schema.optional(Schema.Boolean),
+                }).pipe(Schema.encodeKeys({
+                    enabled: "enabled",
+                    invocationLogs: "invocation_logs",
+                    destinations: "destinations",
+                    headSamplingRate: "head_sampling_rate",
+                    persist: "persist",
+                })),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            enabled: "enabled",
+            headSamplingRate: "head_sampling_rate",
+            logs: "logs",
+        }))),
+        placement: Schema.optional(Schema.Union([
+            Schema.Struct({
+                mode: Schema.Literal("smart"),
+            }),
+            Schema.Struct({
+                region: Schema.String,
+            }),
+            Schema.Struct({
+                hostname: Schema.String,
+            }),
+            Schema.Struct({
+                host: Schema.String,
+            }),
+        ])),
+        tags: Schema.optional(Schema.Array(Schema.String)),
+        tailConsumers: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+        usageModel: Schema.optional(Schema.Literals(["standard", "bundled", "unbound"])),
+    }).pipe(Schema.encodeKeys({
+        assets: "assets",
+        bindings: "bindings",
+        bodyPart: "body_part",
+        compatibilityDate: "compatibility_date",
+        compatibilityFlags: "compatibility_flags",
+        keepAssets: "keep_assets",
+        keepBindings: "keep_bindings",
+        limits: "limits",
+        logpush: "logpush",
+        mainModule: "main_module",
+        migrations: "migrations",
+        observability: "observability",
+        placement: "placement",
+        tags: "tags",
+        tailConsumers: "tail_consumers",
+        usageModel: "usage_model",
+    })),
+    files: Schema.optional(Schema.Array(UploadableSchema.pipe(T.HttpFormDataFile()))),
+}).pipe(T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}",
+    contentType: "multipart",
+}));
+export const PutDispatchNamespaceScriptResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    startupTimeMs: Schema.Number,
+    id: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    compatibilityDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    compatibilityFlags: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    entryPoint: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    etag: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    handlers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    hasAssets: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    hasModules: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    lastDeployedFrom: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    logpush: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    migrationTag: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    namedHandlers: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Struct({
+            handlers: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+            name: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        })),
+        Schema.Null,
+    ])),
+    observability: Schema.optional(Schema.Union([
+        Schema.Struct({
+            enabled: Schema.Boolean,
+            headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            logs: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    enabled: Schema.Boolean,
+                    invocationLogs: Schema.Boolean,
+                    destinations: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    persist: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    enabled: "enabled",
+                    invocationLogs: "invocation_logs",
+                    destinations: "destinations",
+                    headSamplingRate: "head_sampling_rate",
+                    persist: "persist",
+                })),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            enabled: "enabled",
+            headSamplingRate: "head_sampling_rate",
+            logs: "logs",
+        })),
+        Schema.Null,
+    ])),
+    placement: Schema.optional(Schema.Union([
+        Schema.Union([
+            Schema.Struct({
+                mode: Schema.Literal("smart"),
+                lastAnalyzedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                status: Schema.optional(Schema.Union([
+                    Schema.Literals([
+                        "SUCCESS",
+                        "UNSUPPORTED_APPLICATION",
+                        "INSUFFICIENT_INVOCATIONS",
+                    ]),
+                    Schema.Null,
+                ])),
+            }).pipe(Schema.encodeKeys({
+                mode: "mode",
+                lastAnalyzedAt: "last_analyzed_at",
+                status: "status",
+            })),
+            Schema.Struct({
+                region: Schema.String,
+                lastAnalyzedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                status: Schema.optional(Schema.Union([
+                    Schema.Literals([
+                        "SUCCESS",
+                        "UNSUPPORTED_APPLICATION",
+                        "INSUFFICIENT_INVOCATIONS",
+                    ]),
+                    Schema.Null,
+                ])),
+            }).pipe(Schema.encodeKeys({
+                region: "region",
+                lastAnalyzedAt: "last_analyzed_at",
+                status: "status",
+            })),
+            Schema.Struct({
+                hostname: Schema.String,
+                lastAnalyzedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                status: Schema.optional(Schema.Union([
+                    Schema.Literals([
+                        "SUCCESS",
+                        "UNSUPPORTED_APPLICATION",
+                        "INSUFFICIENT_INVOCATIONS",
+                    ]),
+                    Schema.Null,
+                ])),
+            }).pipe(Schema.encodeKeys({
+                hostname: "hostname",
+                lastAnalyzedAt: "last_analyzed_at",
+                status: "status",
+            })),
+            Schema.Struct({
+                host: Schema.String,
+                lastAnalyzedAt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                status: Schema.optional(Schema.Union([
+                    Schema.Literals([
+                        "SUCCESS",
+                        "UNSUPPORTED_APPLICATION",
+                        "INSUFFICIENT_INVOCATIONS",
+                    ]),
+                    Schema.Null,
+                ])),
+            }).pipe(Schema.encodeKeys({
+                host: "host",
+                lastAnalyzedAt: "last_analyzed_at",
+                status: "status",
+            })),
+        ]),
+        Schema.Null,
+    ])),
+    placementMode: Schema.optional(Schema.Union([Schema.Literal("smart"), Schema.Null])),
+    placementStatus: Schema.optional(Schema.Union([
+        Schema.Literals([
+            "SUCCESS",
+            "UNSUPPORTED_APPLICATION",
+            "INSUFFICIENT_INVOCATIONS",
+        ]),
+        Schema.Null,
+    ])),
+    tag: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    tags: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    tailConsumers: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+    usageModel: Schema.optional(Schema.Union([
+        Schema.Literals(["standard", "bundled", "unbound"]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    startupTimeMs: "startup_time_ms",
+    id: "id",
+    compatibilityDate: "compatibility_date",
+    compatibilityFlags: "compatibility_flags",
+    createdOn: "created_on",
+    entryPoint: "entry_point",
+    etag: "etag",
+    handlers: "handlers",
+    hasAssets: "has_assets",
+    hasModules: "has_modules",
+    lastDeployedFrom: "last_deployed_from",
+    logpush: "logpush",
+    migrationTag: "migration_tag",
+    modifiedOn: "modified_on",
+    namedHandlers: "named_handlers",
+    observability: "observability",
+    placement: "placement",
+    placementMode: "placement_mode",
+    placementStatus: "placement_status",
+    tag: "tag",
+    tags: "tags",
+    tailConsumers: "tail_consumers",
+    usageModel: "usage_model",
+}))
+    .pipe(T.ResponsePath("result"));
+export const putDispatchNamespaceScript = API.make(() => ({
+    input: PutDispatchNamespaceScriptRequest,
+    output: PutDispatchNamespaceScriptResponse,
+    errors: [],
+}));
+export const DeleteDispatchNamespaceScriptRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    force: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("force")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}",
+}));
+export const DeleteDispatchNamespaceScriptResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result"));
+export const deleteDispatchNamespaceScript = API.make(() => ({
+    input: DeleteDispatchNamespaceScriptRequest,
+    output: DeleteDispatchNamespaceScriptResponse,
+    errors: [],
+}));
+export const CreateDispatchNamespaceScriptAssetUploadRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    manifest: Schema.Struct({}),
+}).pipe(T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/assets-upload-session",
+}));
+export const CreateDispatchNamespaceScriptAssetUploadResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    buckets: Schema.optional(Schema.Union([Schema.Array(Schema.Array(Schema.String)), Schema.Null])),
+    jwt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(T.ResponsePath("result"));
+export const createDispatchNamespaceScriptAssetUpload = API.make(() => ({
+    input: CreateDispatchNamespaceScriptAssetUploadRequest,
+    output: CreateDispatchNamespaceScriptAssetUploadResponse,
+    errors: [],
+}));
+export const GetDispatchNamespaceScriptBindingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/bindings",
+}));
+export const GetDispatchNamespaceScriptBindingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Union([
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("ai"),
+        }),
+        Schema.Struct({
+            dataset: Schema.String,
+            name: Schema.String,
+            type: Schema.Literal("analytics_engine"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("assets"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("browser"),
+        }),
+        Schema.Struct({
+            id: Schema.String,
+            name: Schema.String,
+            type: Schema.Literal("d1"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            part: Schema.String,
+            type: Schema.Literal("data_blob"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            namespace: Schema.String,
+            type: Schema.Literal("dispatch_namespace"),
+            outbound: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    params: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    worker: Schema.optional(Schema.Union([
+                        Schema.Struct({
+                            environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            service: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                        }),
+                        Schema.Null,
+                    ])),
+                }),
+                Schema.Null,
+            ])),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("durable_object_namespace"),
+            className: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            namespaceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            scriptName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            name: "name",
+            type: "type",
+            className: "class_name",
+            environment: "environment",
+            namespaceId: "namespace_id",
+            scriptName: "script_name",
+        })),
+        Schema.Struct({
+            id: Schema.String,
+            name: Schema.String,
+            type: Schema.Literal("hyperdrive"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("inherit"),
+            oldName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            versionId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            name: "name",
+            type: "type",
+            oldName: "old_name",
+            versionId: "version_id",
+        })),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("images"),
+        }),
+        Schema.Struct({
+            json: Schema.String,
+            name: Schema.String,
+            type: Schema.Literal("json"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            namespaceId: Schema.String,
+            type: Schema.Literal("kv_namespace"),
+        }).pipe(Schema.encodeKeys({
+            name: "name",
+            namespaceId: "namespace_id",
+            type: "type",
+        })),
+        Schema.Struct({
+            certificateId: Schema.String,
+            name: Schema.String,
+            type: Schema.Literal("mtls_certificate"),
+        }).pipe(Schema.encodeKeys({
+            certificateId: "certificate_id",
+            name: "name",
+            type: "type",
+        })),
+        Schema.Struct({
+            name: Schema.String,
+            text: Schema.String,
+            type: Schema.Literal("plain_text"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            pipeline: Schema.String,
+            type: Schema.Literal("pipelines"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            queueName: Schema.String,
+            type: Schema.Literal("queue"),
+        }).pipe(Schema.encodeKeys({
+            name: "name",
+            queueName: "queue_name",
+            type: "type",
+        })),
+        Schema.Struct({
+            bucketName: Schema.String,
+            name: Schema.String,
+            type: Schema.Literal("r2_bucket"),
+            jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["eu", "fedramp"]), Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            bucketName: "bucket_name",
+            name: "name",
+            type: "type",
+            jurisdiction: "jurisdiction",
+        })),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("secret_text"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("send_email"),
+            allowedDestinationAddresses: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+            allowedSenderAddresses: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+            destinationAddress: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            name: "name",
+            type: "type",
+            allowedDestinationAddresses: "allowed_destination_addresses",
+            allowedSenderAddresses: "allowed_sender_addresses",
+            destinationAddress: "destination_address",
+        })),
+        Schema.Struct({
+            name: Schema.String,
+            service: Schema.String,
+            type: Schema.Literal("service"),
+            environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            part: Schema.String,
+            type: Schema.Literal("text_blob"),
+        }),
+        Schema.Struct({
+            indexName: Schema.String,
+            name: Schema.String,
+            type: Schema.Literal("vectorize"),
+        }).pipe(Schema.encodeKeys({
+            indexName: "index_name",
+            name: "name",
+            type: "type",
+        })),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("version_metadata"),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            secretName: Schema.String,
+            storeId: Schema.String,
+            type: Schema.Literal("secrets_store_secret"),
+        }).pipe(Schema.encodeKeys({
+            name: "name",
+            secretName: "secret_name",
+            storeId: "store_id",
+            type: "type",
+        })),
+        Schema.Struct({
+            algorithm: Schema.Unknown,
+            format: Schema.Literals(["raw", "pkcs8", "spki", "jwk"]),
+            name: Schema.String,
+            type: Schema.Literal("secret_key"),
+            usages: Schema.Array(Schema.Literals([
+                "encrypt",
+                "decrypt",
+                "sign",
+                "verify",
+                "deriveKey",
+                "deriveBits",
+                "wrapKey",
+                "unwrapKey",
+            ])),
+        }),
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("workflow"),
+            workflowName: Schema.String,
+            className: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            scriptName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+        }).pipe(Schema.encodeKeys({
+            name: "name",
+            type: "type",
+            workflowName: "workflow_name",
+            className: "class_name",
+            scriptName: "script_name",
+        })),
+        Schema.Struct({
+            name: Schema.String,
+            part: Schema.String,
+            type: Schema.Literal("wasm_module"),
+        }),
+    ])),
+});
+export const getDispatchNamespaceScriptBinding = API.makePaginated(() => ({
+    input: GetDispatchNamespaceScriptBindingRequest,
+    output: GetDispatchNamespaceScriptBindingResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const GetDispatchNamespaceScriptContentRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/content",
+}));
+export const GetDispatchNamespaceScriptContentResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export const getDispatchNamespaceScriptContent = API.make(() => ({
+    input: GetDispatchNamespaceScriptContentRequest,
+    output: GetDispatchNamespaceScriptContentResponse,
+    errors: [],
+}));
+export const PutDispatchNamespaceScriptContentRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    cfworkerbodypart: Schema.optional(Schema.String).pipe(T.HttpHeader("CF-WORKER-BODY-PART")),
+    cfworkermainmodulepart: Schema.optional(Schema.String).pipe(T.HttpHeader("CF-WORKER-MAIN-MODULE-PART")),
+    metadata: Schema.Unknown,
+    files: Schema.optional(Schema.Array(UploadableSchema.pipe(T.HttpFormDataFile()))),
+}).pipe(T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/content",
+    contentType: "multipart",
+}));
+export const PutDispatchNamespaceScriptContentResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown;
+export const putDispatchNamespaceScriptContent = API.make(() => ({
+    input: PutDispatchNamespaceScriptContentRequest,
+    output: PutDispatchNamespaceScriptContentResponse,
+    errors: [],
+}));
+export const GetDispatchNamespaceScriptSecretRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    secretName: Schema.String.pipe(T.HttpPath("secretName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    urlEncoded: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("url_encoded")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/secrets/{secretName}",
+}));
+export const GetDispatchNamespaceScriptSecretResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.Struct({
+        name: Schema.String,
+        type: Schema.Literal("secret_text"),
+    }),
+    Schema.Struct({
+        algorithm: Schema.Unknown,
+        format: Schema.Literals(["raw", "pkcs8", "spki", "jwk"]),
+        name: Schema.String,
+        type: Schema.Literal("secret_key"),
+        usages: Schema.Array(Schema.Literals([
+            "encrypt",
+            "decrypt",
+            "sign",
+            "verify",
+            "deriveKey",
+            "deriveBits",
+            "wrapKey",
+            "unwrapKey",
+        ])),
+    }),
+]).pipe(T.ResponsePath("result"));
+export const getDispatchNamespaceScriptSecret = API.make(() => ({
+    input: GetDispatchNamespaceScriptSecretRequest,
+    output: GetDispatchNamespaceScriptSecretResponse,
+    errors: [],
+}));
+export const ListDispatchNamespaceScriptSecretsRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/secrets",
+}));
+export const ListDispatchNamespaceScriptSecretsResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.Union([
+        Schema.Struct({
+            name: Schema.String,
+            type: Schema.Literal("secret_text"),
+        }),
+        Schema.Struct({
+            algorithm: Schema.Unknown,
+            format: Schema.Literals(["raw", "pkcs8", "spki", "jwk"]),
+            name: Schema.String,
+            type: Schema.Literal("secret_key"),
+            usages: Schema.Array(Schema.Literals([
+                "encrypt",
+                "decrypt",
+                "sign",
+                "verify",
+                "deriveKey",
+                "deriveBits",
+                "wrapKey",
+                "unwrapKey",
+            ])),
+        }),
+    ])),
+});
+export const listDispatchNamespaceScriptSecrets = API.makePaginated(() => ({
+    input: ListDispatchNamespaceScriptSecretsRequest,
+    output: ListDispatchNamespaceScriptSecretsResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const PutDispatchNamespaceScriptSecretRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    name: Schema.String,
+    text: Schema.String,
+    type: Schema.Literal("secret_text"),
+}).pipe(T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/secrets",
+}));
+export const PutDispatchNamespaceScriptSecretResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Union([
+    Schema.Struct({
+        name: Schema.String,
+        type: Schema.Literal("secret_text"),
+    }),
+    Schema.Struct({
+        algorithm: Schema.Unknown,
+        format: Schema.Literals(["raw", "pkcs8", "spki", "jwk"]),
+        name: Schema.String,
+        type: Schema.Literal("secret_key"),
+        usages: Schema.Array(Schema.Literals([
+            "encrypt",
+            "decrypt",
+            "sign",
+            "verify",
+            "deriveKey",
+            "deriveBits",
+            "wrapKey",
+            "unwrapKey",
+        ])),
+    }),
+]).pipe(T.ResponsePath("result"));
+export const putDispatchNamespaceScriptSecret = API.make(() => ({
+    input: PutDispatchNamespaceScriptSecretRequest,
+    output: PutDispatchNamespaceScriptSecretResponse,
+    errors: [],
+}));
+export const DeleteDispatchNamespaceScriptSecretRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    secretName: Schema.String.pipe(T.HttpPath("secretName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    urlEncoded: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("url_encoded")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/secrets/{secretName}",
+}));
+export const DeleteDispatchNamespaceScriptSecretResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result"));
+export const deleteDispatchNamespaceScriptSecret = API.make(() => ({
+    input: DeleteDispatchNamespaceScriptSecretRequest,
+    output: DeleteDispatchNamespaceScriptSecretResponse,
+    errors: [],
+}));
+export const GetDispatchNamespaceScriptSettingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/settings",
+}));
+export const GetDispatchNamespaceScriptSettingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    bindings: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Union([
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("ai"),
+            }),
+            Schema.Struct({
+                dataset: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("analytics_engine"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("assets"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("browser"),
+            }),
+            Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("d1"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("data_blob"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                namespace: Schema.String,
+                type: Schema.Literal("dispatch_namespace"),
+                outbound: Schema.optional(Schema.Union([
+                    Schema.Struct({
+                        params: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                        worker: Schema.optional(Schema.Union([
+                            Schema.Struct({
+                                environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                                service: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            }),
+                            Schema.Null,
+                        ])),
+                    }),
+                    Schema.Null,
+                ])),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("durable_object_namespace"),
+                className: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                namespaceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                scriptName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                className: "class_name",
+                environment: "environment",
+                namespaceId: "namespace_id",
+                scriptName: "script_name",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("hyperdrive"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("inherit"),
+                oldName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                versionId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                oldName: "old_name",
+                versionId: "version_id",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("images"),
+            }),
+            Schema.Struct({
+                json: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("json"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                namespaceId: Schema.String,
+                type: Schema.Literal("kv_namespace"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                namespaceId: "namespace_id",
+                type: "type",
+            })),
+            Schema.Struct({
+                certificateId: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("mtls_certificate"),
+            }).pipe(Schema.encodeKeys({
+                certificateId: "certificate_id",
+                name: "name",
+                type: "type",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                text: Schema.String,
+                type: Schema.Literal("plain_text"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                pipeline: Schema.String,
+                type: Schema.Literal("pipelines"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                queueName: Schema.String,
+                type: Schema.Literal("queue"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                queueName: "queue_name",
+                type: "type",
+            })),
+            Schema.Struct({
+                bucketName: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("r2_bucket"),
+                jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["eu", "fedramp"]), Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                bucketName: "bucket_name",
+                name: "name",
+                type: "type",
+                jurisdiction: "jurisdiction",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("secret_text"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("send_email"),
+                allowedDestinationAddresses: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                allowedSenderAddresses: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                destinationAddress: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                allowedDestinationAddresses: "allowed_destination_addresses",
+                allowedSenderAddresses: "allowed_sender_addresses",
+                destinationAddress: "destination_address",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                service: Schema.String,
+                type: Schema.Literal("service"),
+                environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("text_blob"),
+            }),
+            Schema.Struct({
+                indexName: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("vectorize"),
+            }).pipe(Schema.encodeKeys({
+                indexName: "index_name",
+                name: "name",
+                type: "type",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("version_metadata"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                secretName: Schema.String,
+                storeId: Schema.String,
+                type: Schema.Literal("secrets_store_secret"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                secretName: "secret_name",
+                storeId: "store_id",
+                type: "type",
+            })),
+            Schema.Struct({
+                algorithm: Schema.Unknown,
+                format: Schema.Literals(["raw", "pkcs8", "spki", "jwk"]),
+                name: Schema.String,
+                type: Schema.Literal("secret_key"),
+                usages: Schema.Array(Schema.Literals([
+                    "encrypt",
+                    "decrypt",
+                    "sign",
+                    "verify",
+                    "deriveKey",
+                    "deriveBits",
+                    "wrapKey",
+                    "unwrapKey",
+                ])),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("workflow"),
+                workflowName: Schema.String,
+                className: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                scriptName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                workflowName: "workflow_name",
+                className: "class_name",
+                scriptName: "script_name",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("wasm_module"),
+            }),
+        ])),
+        Schema.Null,
+    ])),
+    compatibilityDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    compatibilityFlags: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    limits: Schema.optional(Schema.Union([
+        Schema.Struct({
+            cpuMs: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ cpuMs: "cpu_ms" })),
+        Schema.Null,
+    ])),
+    logpush: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    observability: Schema.optional(Schema.Union([
+        Schema.Struct({
+            enabled: Schema.Boolean,
+            headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            logs: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    enabled: Schema.Boolean,
+                    invocationLogs: Schema.Boolean,
+                    destinations: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    persist: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    enabled: "enabled",
+                    invocationLogs: "invocation_logs",
+                    destinations: "destinations",
+                    headSamplingRate: "head_sampling_rate",
+                    persist: "persist",
+                })),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            enabled: "enabled",
+            headSamplingRate: "head_sampling_rate",
+            logs: "logs",
+        })),
+        Schema.Null,
+    ])),
+    placement: Schema.optional(Schema.Union([
+        Schema.Union([
+            Schema.Struct({
+                mode: Schema.Literal("smart"),
+            }),
+            Schema.Struct({
+                region: Schema.String,
+            }),
+            Schema.Struct({
+                hostname: Schema.String,
+            }),
+            Schema.Struct({
+                host: Schema.String,
+            }),
+        ]),
+        Schema.Null,
+    ])),
+    tags: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    tailConsumers: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+    usageModel: Schema.optional(Schema.Union([
+        Schema.Literals(["standard", "bundled", "unbound"]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    bindings: "bindings",
+    compatibilityDate: "compatibility_date",
+    compatibilityFlags: "compatibility_flags",
+    limits: "limits",
+    logpush: "logpush",
+    observability: "observability",
+    placement: "placement",
+    tags: "tags",
+    tailConsumers: "tail_consumers",
+    usageModel: "usage_model",
+}))
+    .pipe(T.ResponsePath("result"));
+export const getDispatchNamespaceScriptSetting = API.make(() => ({
+    input: GetDispatchNamespaceScriptSettingRequest,
+    output: GetDispatchNamespaceScriptSettingResponse,
+    errors: [],
+}));
+export const PatchDispatchNamespaceScriptSettingRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    settings: Schema.optional(Schema.Struct({
+        bindings: Schema.optional(Schema.Array(Schema.Union([
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("ai"),
+            }),
+            Schema.Struct({
+                dataset: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("analytics_engine"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("assets"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("browser"),
+            }),
+            Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("d1"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("data_blob"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                namespace: Schema.String,
+                type: Schema.Literal("dispatch_namespace"),
+                outbound: Schema.optional(Schema.Struct({
+                    params: Schema.optional(Schema.Array(Schema.String)),
+                    worker: Schema.optional(Schema.Struct({
+                        environment: Schema.optional(Schema.String),
+                        service: Schema.optional(Schema.String),
+                    })),
+                })),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("durable_object_namespace"),
+                className: Schema.optional(Schema.String),
+                environment: Schema.optional(Schema.String),
+                namespaceId: Schema.optional(Schema.String),
+                scriptName: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                className: "class_name",
+                environment: "environment",
+                namespaceId: "namespace_id",
+                scriptName: "script_name",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("hyperdrive"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("inherit"),
+                oldName: Schema.optional(Schema.String),
+                versionId: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                oldName: "old_name",
+                versionId: "version_id",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("images"),
+            }),
+            Schema.Struct({
+                json: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("json"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                namespaceId: Schema.String,
+                type: Schema.Literal("kv_namespace"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                namespaceId: "namespace_id",
+                type: "type",
+            })),
+            Schema.Struct({
+                certificateId: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("mtls_certificate"),
+            }).pipe(Schema.encodeKeys({
+                certificateId: "certificate_id",
+                name: "name",
+                type: "type",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                text: Schema.String,
+                type: Schema.Literal("plain_text"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                pipeline: Schema.String,
+                type: Schema.Literal("pipelines"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                queueName: Schema.String,
+                type: Schema.Literal("queue"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                queueName: "queue_name",
+                type: "type",
+            })),
+            Schema.Struct({
+                bucketName: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("r2_bucket"),
+                jurisdiction: Schema.optional(Schema.Literals(["eu", "fedramp"])),
+            }).pipe(Schema.encodeKeys({
+                bucketName: "bucket_name",
+                name: "name",
+                type: "type",
+                jurisdiction: "jurisdiction",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                text: Schema.String,
+                type: Schema.Literal("secret_text"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("send_email"),
+                allowedDestinationAddresses: Schema.optional(Schema.Array(Schema.String)),
+                allowedSenderAddresses: Schema.optional(Schema.Array(Schema.String)),
+                destinationAddress: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                allowedDestinationAddresses: "allowed_destination_addresses",
+                allowedSenderAddresses: "allowed_sender_addresses",
+                destinationAddress: "destination_address",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                service: Schema.String,
+                type: Schema.Literal("service"),
+                environment: Schema.optional(Schema.String),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("text_blob"),
+            }),
+            Schema.Struct({
+                indexName: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("vectorize"),
+            }).pipe(Schema.encodeKeys({
+                indexName: "index_name",
+                name: "name",
+                type: "type",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("version_metadata"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                secretName: Schema.String,
+                storeId: Schema.String,
+                type: Schema.Literal("secrets_store_secret"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                secretName: "secret_name",
+                storeId: "store_id",
+                type: "type",
+            })),
+            Schema.Struct({
+                algorithm: Schema.Unknown,
+                format: Schema.Literals(["raw", "pkcs8", "spki", "jwk"]),
+                name: Schema.String,
+                type: Schema.Literal("secret_key"),
+                usages: Schema.Array(Schema.Literals([
+                    "encrypt",
+                    "decrypt",
+                    "sign",
+                    "verify",
+                    "deriveKey",
+                    "deriveBits",
+                    "wrapKey",
+                    "unwrapKey",
+                ])),
+                keyBase64: Schema.optional(Schema.String),
+                keyJwk: Schema.optional(Schema.Unknown),
+            }).pipe(Schema.encodeKeys({
+                algorithm: "algorithm",
+                format: "format",
+                name: "name",
+                type: "type",
+                usages: "usages",
+                keyBase64: "key_base64",
+                keyJwk: "key_jwk",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("workflow"),
+                workflowName: Schema.String,
+                className: Schema.optional(Schema.String),
+                scriptName: Schema.optional(Schema.String),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                workflowName: "workflow_name",
+                className: "class_name",
+                scriptName: "script_name",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("wasm_module"),
+            }),
+        ]))),
+        compatibilityDate: Schema.optional(Schema.String),
+        compatibilityFlags: Schema.optional(Schema.Array(Schema.String)),
+        limits: Schema.optional(Schema.Struct({
+            cpuMs: Schema.optional(Schema.Number),
+        }).pipe(Schema.encodeKeys({ cpuMs: "cpu_ms" }))),
+        logpush: Schema.optional(Schema.Boolean),
+        migrations: Schema.optional(Schema.Union([
+            Schema.Unknown,
+            Schema.Struct({
+                newTag: Schema.optional(Schema.String),
+                oldTag: Schema.optional(Schema.String),
+                steps: Schema.optional(Schema.Array(Schema.Unknown)),
+            }).pipe(Schema.encodeKeys({
+                newTag: "new_tag",
+                oldTag: "old_tag",
+                steps: "steps",
+            })),
+        ])),
+        observability: Schema.optional(Schema.Struct({
+            enabled: Schema.Boolean,
+            headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            logs: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    enabled: Schema.Boolean,
+                    invocationLogs: Schema.Boolean,
+                    destinations: Schema.optional(Schema.Array(Schema.String)),
+                    headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    persist: Schema.optional(Schema.Boolean),
+                }).pipe(Schema.encodeKeys({
+                    enabled: "enabled",
+                    invocationLogs: "invocation_logs",
+                    destinations: "destinations",
+                    headSamplingRate: "head_sampling_rate",
+                    persist: "persist",
+                })),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            enabled: "enabled",
+            headSamplingRate: "head_sampling_rate",
+            logs: "logs",
+        }))),
+        placement: Schema.optional(Schema.Union([
+            Schema.Struct({
+                mode: Schema.Literal("smart"),
+            }),
+            Schema.Struct({
+                region: Schema.String,
+            }),
+            Schema.Struct({
+                hostname: Schema.String,
+            }),
+            Schema.Struct({
+                host: Schema.String,
+            }),
+        ])),
+        tags: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+        tailConsumers: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+        usageModel: Schema.optional(Schema.Literals(["standard", "bundled", "unbound"])),
+    }).pipe(Schema.encodeKeys({
+        bindings: "bindings",
+        compatibilityDate: "compatibility_date",
+        compatibilityFlags: "compatibility_flags",
+        limits: "limits",
+        logpush: "logpush",
+        migrations: "migrations",
+        observability: "observability",
+        placement: "placement",
+        tags: "tags",
+        tailConsumers: "tail_consumers",
+        usageModel: "usage_model",
+    }))),
+}).pipe(T.Http({
+    method: "PATCH",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/settings",
+    contentType: "multipart",
+}));
+export const PatchDispatchNamespaceScriptSettingResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    bindings: Schema.optional(Schema.Union([
+        Schema.Array(Schema.Union([
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("ai"),
+            }),
+            Schema.Struct({
+                dataset: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("analytics_engine"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("assets"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("browser"),
+            }),
+            Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("d1"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("data_blob"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                namespace: Schema.String,
+                type: Schema.Literal("dispatch_namespace"),
+                outbound: Schema.optional(Schema.Union([
+                    Schema.Struct({
+                        params: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                        worker: Schema.optional(Schema.Union([
+                            Schema.Struct({
+                                environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                                service: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                            }),
+                            Schema.Null,
+                        ])),
+                    }),
+                    Schema.Null,
+                ])),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("durable_object_namespace"),
+                className: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                namespaceId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                scriptName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                className: "class_name",
+                environment: "environment",
+                namespaceId: "namespace_id",
+                scriptName: "script_name",
+            })),
+            Schema.Struct({
+                id: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("hyperdrive"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("inherit"),
+                oldName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                versionId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                oldName: "old_name",
+                versionId: "version_id",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("images"),
+            }),
+            Schema.Struct({
+                json: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("json"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                namespaceId: Schema.String,
+                type: Schema.Literal("kv_namespace"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                namespaceId: "namespace_id",
+                type: "type",
+            })),
+            Schema.Struct({
+                certificateId: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("mtls_certificate"),
+            }).pipe(Schema.encodeKeys({
+                certificateId: "certificate_id",
+                name: "name",
+                type: "type",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                text: Schema.String,
+                type: Schema.Literal("plain_text"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                pipeline: Schema.String,
+                type: Schema.Literal("pipelines"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                queueName: Schema.String,
+                type: Schema.Literal("queue"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                queueName: "queue_name",
+                type: "type",
+            })),
+            Schema.Struct({
+                bucketName: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("r2_bucket"),
+                jurisdiction: Schema.optional(Schema.Union([Schema.Literals(["eu", "fedramp"]), Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                bucketName: "bucket_name",
+                name: "name",
+                type: "type",
+                jurisdiction: "jurisdiction",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("secret_text"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("send_email"),
+                allowedDestinationAddresses: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                allowedSenderAddresses: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                destinationAddress: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                allowedDestinationAddresses: "allowed_destination_addresses",
+                allowedSenderAddresses: "allowed_sender_addresses",
+                destinationAddress: "destination_address",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                service: Schema.String,
+                type: Schema.Literal("service"),
+                environment: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("text_blob"),
+            }),
+            Schema.Struct({
+                indexName: Schema.String,
+                name: Schema.String,
+                type: Schema.Literal("vectorize"),
+            }).pipe(Schema.encodeKeys({
+                indexName: "index_name",
+                name: "name",
+                type: "type",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("version_metadata"),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                secretName: Schema.String,
+                storeId: Schema.String,
+                type: Schema.Literal("secrets_store_secret"),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                secretName: "secret_name",
+                storeId: "store_id",
+                type: "type",
+            })),
+            Schema.Struct({
+                algorithm: Schema.Unknown,
+                format: Schema.Literals(["raw", "pkcs8", "spki", "jwk"]),
+                name: Schema.String,
+                type: Schema.Literal("secret_key"),
+                usages: Schema.Array(Schema.Literals([
+                    "encrypt",
+                    "decrypt",
+                    "sign",
+                    "verify",
+                    "deriveKey",
+                    "deriveBits",
+                    "wrapKey",
+                    "unwrapKey",
+                ])),
+            }),
+            Schema.Struct({
+                name: Schema.String,
+                type: Schema.Literal("workflow"),
+                workflowName: Schema.String,
+                className: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+                scriptName: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+            }).pipe(Schema.encodeKeys({
+                name: "name",
+                type: "type",
+                workflowName: "workflow_name",
+                className: "class_name",
+                scriptName: "script_name",
+            })),
+            Schema.Struct({
+                name: Schema.String,
+                part: Schema.String,
+                type: Schema.Literal("wasm_module"),
+            }),
+        ])),
+        Schema.Null,
+    ])),
+    compatibilityDate: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+    compatibilityFlags: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    limits: Schema.optional(Schema.Union([
+        Schema.Struct({
+            cpuMs: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+        }).pipe(Schema.encodeKeys({ cpuMs: "cpu_ms" })),
+        Schema.Null,
+    ])),
+    logpush: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+    observability: Schema.optional(Schema.Union([
+        Schema.Struct({
+            enabled: Schema.Boolean,
+            headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            logs: Schema.optional(Schema.Union([
+                Schema.Struct({
+                    enabled: Schema.Boolean,
+                    invocationLogs: Schema.Boolean,
+                    destinations: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+                    headSamplingRate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+                    persist: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
+                }).pipe(Schema.encodeKeys({
+                    enabled: "enabled",
+                    invocationLogs: "invocation_logs",
+                    destinations: "destinations",
+                    headSamplingRate: "head_sampling_rate",
+                    persist: "persist",
+                })),
+                Schema.Null,
+            ])),
+        }).pipe(Schema.encodeKeys({
+            enabled: "enabled",
+            headSamplingRate: "head_sampling_rate",
+            logs: "logs",
+        })),
+        Schema.Null,
+    ])),
+    placement: Schema.optional(Schema.Union([
+        Schema.Union([
+            Schema.Struct({
+                mode: Schema.Literal("smart"),
+            }),
+            Schema.Struct({
+                region: Schema.String,
+            }),
+            Schema.Struct({
+                hostname: Schema.String,
+            }),
+            Schema.Struct({
+                host: Schema.String,
+            }),
+        ]),
+        Schema.Null,
+    ])),
+    tags: Schema.optional(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+    tailConsumers: Schema.optional(Schema.Union([Schema.Array(Schema.Unknown), Schema.Null])),
+    usageModel: Schema.optional(Schema.Union([
+        Schema.Literals(["standard", "bundled", "unbound"]),
+        Schema.Null,
+    ])),
+})
+    .pipe(Schema.encodeKeys({
+    bindings: "bindings",
+    compatibilityDate: "compatibility_date",
+    compatibilityFlags: "compatibility_flags",
+    limits: "limits",
+    logpush: "logpush",
+    observability: "observability",
+    placement: "placement",
+    tags: "tags",
+    tailConsumers: "tail_consumers",
+    usageModel: "usage_model",
+}))
+    .pipe(T.ResponsePath("result"));
+export const patchDispatchNamespaceScriptSetting = API.make(() => ({
+    input: PatchDispatchNamespaceScriptSettingRequest,
+    output: PatchDispatchNamespaceScriptSettingResponse,
+    errors: [],
+}));
+export const ListDispatchNamespaceScriptTagsRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/tags",
+}));
+export const ListDispatchNamespaceScriptTagsResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.String),
+});
+export const listDispatchNamespaceScriptTags = API.makePaginated(() => ({
+    input: ListDispatchNamespaceScriptTagsRequest,
+    output: ListDispatchNamespaceScriptTagsResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const PutDispatchNamespaceScriptTagRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    body: Schema.Union([Schema.Array(Schema.String), Schema.Null]).pipe(T.HttpBody()),
+}).pipe(T.Http({
+    method: "PUT",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/tags",
+}));
+export const PutDispatchNamespaceScriptTagResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    result: Schema.Array(Schema.String),
+});
+export const putDispatchNamespaceScriptTag = API.makePaginated(() => ({
+    input: PutDispatchNamespaceScriptTagRequest,
+    output: PutDispatchNamespaceScriptTagResponse,
+    errors: [],
+    pagination: {
+        mode: "single",
+        items: "result",
+    },
+}));
+export const DeleteDispatchNamespaceScriptTagRequest = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    dispatchNamespace: Schema.String.pipe(T.HttpPath("dispatchNamespace")),
+    scriptName: Schema.String.pipe(T.HttpPath("scriptName")),
+    tag: Schema.String.pipe(T.HttpPath("tag")),
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/workers/dispatch/namespaces/{dispatchNamespace}/scripts/{scriptName}/tags/{tag}",
+}));
+export const DeleteDispatchNamespaceScriptTagResponse = 
+/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result"));
+export const deleteDispatchNamespaceScriptTag = API.make(() => ({
+    input: DeleteDispatchNamespaceScriptTagRequest,
+    output: DeleteDispatchNamespaceScriptTagResponse,
+    errors: [],
+}));
+//# sourceMappingURL=workers-for-platforms.js.map