@nightintelligence/cloudflare-workers-utils 0.35.0-patch1

package/dist/compliance-j3-tqeao.d.mts

@@ -0,0 +1,3616 @@
+import { URLSearchParams } from 'node:url';
+import { RequestInit, Headers, Response as Response$1, MockAgent } from 'undici';
+import { RouterConfig, AssetConfig } from '@cloudflare/workers-shared';
+
+interface FetchError {
+    code: number;
+    documentation_url?: string;
+    message: string;
+    error_chain?: FetchError[];
+    /**
+     * Optional structured error metadata returned alongside the message. The
+     * Cloudflare v4 envelope permits a `meta` object whose shape varies by
+     * endpoint; consumers are expected to validate the shape at use site
+     * before relying on any field.
+     *
+     * Known usage: declarative DO exports reconciliation returns `meta.details`
+     * as an array of per-class errors.
+     */
+    meta?: {
+        details?: unknown;
+    } & Record<string, unknown>;
+}
+
+/**
+ * `WRANGLER_C3_COMMAND` can override the command used by `wrangler init` when delegating to C3.
+ *
+ * By default this will use `create cloudflare`.
+ *
+ * To run against the beta release of C3 use:
+ *
+ * ```sh
+ * # Tell Wrangler to use the beta version of create-cloudflare
+ * WRANGLER_C3_COMMAND="create cloudflare@beta" npx wrangler init
+ * ```
+ *
+ * To test the integration between wrangler and C3 locally, use:
+ *
+ * ```sh
+ * # Ensure both Wrangler and C3 are built
+ * npm run build
+ * # Tell Wrangler to use the local version of create-cloudflare
+ * WRANGLER_C3_COMMAND="exec ./packages/create-cloudflare" npx wrangler init temp
+ * ```
+ *
+ * Note that you cannot use `WRANGLER_C3_COMMAND="create cloudflare@2"` if you are
+ * running Wrangler from inside the monorepo as the bin paths get messed up.
+ */
+declare const getC3CommandFromEnv: () => string;
+/** Whether `DO_NOT_TRACK` is set to a supported telemetry opt-out value. */
+declare function isDoNotTrackEnabled(): boolean;
+/**
+ * `WRANGLER_SEND_METRICS` controls whether we attempt to send metrics information to Sparrow.
+ * `DO_NOT_TRACK` takes precedence when it is set to an opt-out value.
+ */
+declare function getWranglerSendMetricsFromEnv(): boolean | undefined;
+/**
+ * `WRANGLER_NO_SKILLS_UPDATE_PROMPTS` suppresses the prompt that offers to
+ * update Cloudflare agent skills when they are out of date.
+ *
+ * Set to `"true"` to never be prompted for skills updates.
+ */
+declare const getNoSkillsUpdatePromptsFromEnv: () => boolean | undefined;
+/**
+ * `WRANGLER_SEND_ERROR_REPORTS` controls whether we attempt to send error reports to Sentry.
+ *
+ * Defaults to `false` to avoid noisy false-positive reports. Users can opt in
+ * by setting `WRANGLER_SEND_ERROR_REPORTS=true`.
+ */
+declare const getWranglerSendErrorReportsFromEnv: () => boolean;
+/**
+ * Set `WRANGLER_API_ENVIRONMENT` environment variable to "staging" to tell Wrangler to hit the staging APIs rather than production.
+ */
+declare const getCloudflareApiEnvironmentFromEnv: () => "production" | "staging";
+/**
+ * The compliance region to use for the API requests.
+ */
+type ComplianceConfig = Partial<Pick<Config, "compliance_region">>;
+/** Used for commands that explicitly do not support compliance regions other than "public" */
+declare const COMPLIANCE_REGION_CONFIG_PUBLIC: ComplianceConfig;
+/**
+ * Used for commands where there is no configuration available and
+ * we rely upon the CLOUDFLARE_COMPLIANCE_REGION environment variable
+ * to determine the compliance region.
+ */
+declare const COMPLIANCE_REGION_CONFIG_UNKNOWN: ComplianceConfig;
+/**
+ * Set `CLOUDFLARE_COMPLIANCE_REGION` environment variable to "fedramp_high"
+ * or set the `compliance_region` property in the Wrangler configuration
+ * to tell Wrangler to run in FedRAMP High compliance region mode, rather than "public" mode.
+ */
+declare const getCloudflareComplianceRegion: (complianceConfig: ComplianceConfig) => "public" | "fedramp_high";
+/**
+ * `CLOUDFLARE_API_BASE_URL` specifies the URL to the Cloudflare API.
+ *
+ * If this environment variable is not set, it will default to a URL computed from the
+ * Cloudflare compliance region and the API environment.
+ */
+declare const getCloudflareApiBaseUrl: (complianceConfig: ComplianceConfig) => string;
+/**
+ * Compute the subdomain for the compliance region.
+ */
+declare function getComplianceRegionSubdomain(complianceConfig: ComplianceConfig): string;
+/**
+ * `WRANGLER_LOG_SANITIZE` specifies whether we sanitize debug logs.
+ *
+ * By default we do, since debug logs could be added to GitHub issues and shouldn't include sensitive information.
+ */
+declare const getSanitizeLogs: () => boolean;
+/**
+ * `WRANGLER_OUTPUT_FILE_DIRECTORY` specifies a directory where we should write a file containing output data in ND-JSON format.
+ *
+ * If this is set a random file will be created in this directory, and certain Wrangler commands will write entries to this file.
+ * This is overridden by the `WRANGLER_OUTPUT_FILE_PATH` environment variable.
+ */
+declare const getOutputFileDirectoryFromEnv: () => string | undefined;
+/**
+ * `WRANGLER_OUTPUT_FILE_PATH` specifies a path to a file where we should write output data in ND-JSON format.
+ *
+ * If this is set certain Wrangler commands will write entries to this file.
+ * This overrides the `WRANGLER_OUTPUT_FILE_DIRECTORY` environment variable.
+ */
+declare const getOutputFilePathFromEnv: () => string | undefined;
+/**
+ * `WRANGLER_CI_MATCH_TAG` specifies a Worker tag
+ *
+ * If this is set, Wrangler will ensure the Worker being targeted has this tag
+ */
+declare const getCIMatchTag: () => string | undefined;
+/**
+ * `WRANGLER_CI_OVERRIDE_NAME` specifies a Worker name
+ *
+ * If this is set, Wrangler will override the Worker name with this one
+ */
+declare const getCIOverrideName: () => string | undefined;
+/**
+ * `WRANGLER_CI_OVERRIDE_NETWORK_MODE_HOST` specifies whether --network=host should be set
+ *
+ * If this is set to true, Wrangler will use the --network=host flag when calling out to docker to build container images
+ */
+declare const getCIOverrideNetworkModeHost: () => string | undefined;
+/**
+ * `WRANGLER_CI_GENERATE_PREVIEW_ALIAS` specifies whether to generate a preview alias during version upload
+ *
+ * If this is set to true, Wrangler will attempt to autogenerate the preview alias by using the branch
+ * name. If the branch name is too long and an alias cannot be created, a warning will be printed to the console.
+ */
+declare const getCIGeneratePreviewAlias: () => "true" | "false";
+/**
+ * `WORKERS_CI_BRANCH` is the branch name exposed by Workers CI
+ *
+ */
+declare const getWorkersCIBranchName: () => string | undefined;
+/**
+ * `WRANGLER_BUILD_CONDITIONS` specifies the "build conditions" to use when importing packages at build time.
+ *
+ * See https://nodejs.org/api/packages.html#conditional-exports
+ * and https://esbuild.github.io/api/#how-conditions-work.
+ *
+ * If this is set, Wrangler will configure esbuild to use this list of conditions.
+ * The format is a string of comma separated conditions.
+ */
+declare const getBuildConditionsFromEnv: () => string | undefined;
+/**
+ * `WRANGLER_BUILD_PLATFORM` specifies the "build platform" to use when importing packages at build time.
+ *
+ * See https://esbuild.github.io/api/#platform
+ * and https://esbuild.github.io/api/#how-conditions-work.
+ *
+ * If this is set, Wrangler will configure esbuild to use this platform.
+ */
+declare const getBuildPlatformFromEnv: () => string | undefined;
+/**
+ * `WRANGLER_REGISTRY_PATH` specifies the file based dev registry folder
+ */
+declare const getRegistryPath: () => string;
+/**
+ * `WRANGLER_D1_EXTRA_LOCATION_CHOICES` is an internal variable to let D1 team target their testing environments.
+ *
+ * External accounts cannot access testing environments, so should not set this variable.
+ */
+declare const getD1ExtraLocationChoices: () => string | undefined;
+
+declare const getSubdomainMixedStateCheckDisabled: () => boolean;
+/**
+/**
+ * `CLOUDFLARE_LOAD_DEV_VARS_FROM_DOT_ENV` specifies whether to load vars for local dev from `.env` files.
+ */
+declare const getCloudflareLoadDevVarsFromDotEnv: () => boolean;
+/**
+ * `CLOUDFLARE_INCLUDE_PROCESS_ENV` specifies whether to include the `process.env` in vars loaded from `.env` for local development.
+ */
+declare const getCloudflareIncludeProcessEnvFromEnv: () => boolean;
+declare const getTraceHeader: () => string | undefined;
+declare const getDisableConfigWatching: () => boolean;
+/**
+ * Hide the Wrangler version banner and command status (deprecated/experimental) warnings
+ */
+declare const getWranglerHideBanner: () => boolean;
+/**
+ * `CLOUDFLARE_ENV` specifies the currently selected Wrangler/Cloudflare environment.
+ */
+declare const getCloudflareEnv: () => string | undefined;
+/**
+ * `OPEN_NEXT_DEPLOY` is an environment variables that indicates that the current process is being
+ * run by the open-next deploy command
+ */
+declare const getOpenNextDeployFromEnv: () => string | undefined;
+/**
+ * `X_LOCAL_EXPLORER` enables the local explorer UI at /cdn-cgi/local/explorer.
+ */
+declare const getLocalExplorerEnabledFromEnv: () => boolean;
+/**
+ * `X_LOCAL_OBSERVABILITY` turns on local-dev observability capture. Both
+ * `wrangler dev` and the Vite plugin read it and pass it through as the one
+ * `unsafeObservability` Miniflare option, which makes core attach the trace
+ * collector to each user worker.
+ *
+ * Defaults to `true` so the Local Explorer's Observability tab captures traces
+ * and logs out of the box. Set `X_LOCAL_OBSERVABILITY=false` to opt out — for
+ * example if the extra per-worker services (collector + streaming tail) cause
+ * trouble in a multi-process dev-registry setup.
+ */
+declare const getLocalObservabilityEnabledFromEnv: () => boolean;
+/**
+ * `X_BROWSER_HEADFUL` opens the browser in headful (visible) mode when using the
+ * Browser Run API in local development.
+ *
+ * Set to "true" to enable:
+ *
+ * ```sh
+ * X_BROWSER_HEADFUL=true vite dev
+ * ```
+ *
+ * Note: when using `@cloudflare/playwright`, two Chrome windows may appear — the initial blank
+ * page and the one created by `browser.newPage()`. This is expected due to how Playwright handles
+ * browser contexts via CDP.
+ */
+declare const getBrowserRenderingHeadfulFromEnv: () => boolean;
+/**
+ * `CLOUDFLARE_CF_FETCH_ENABLED` controls whether Miniflare fetches the `cf.json` file
+ * containing request.cf properties from workers.cloudflare.com.
+ *
+ * - If set to "false", disables fetching and uses fallback data (no files created)
+ * - If set to "true" or not set, uses the default behavior (fetches and caches cf.json)
+ *
+ * This is particularly useful for non-JavaScript projects that don't want
+ * a node_modules directory created automatically.
+ *
+ * Example:
+ * ```sh
+ * # Disable cf fetching entirely
+ * CLOUDFLARE_CF_FETCH_ENABLED=false npx wrangler dev
+ * ```
+ */
+declare const getCfFetchEnabledFromEnv: () => boolean;
+/**
+ * `CLOUDFLARE_CF_FETCH_PATH` specifies a custom path for caching the cf.json file.
+ *
+ * - If set, uses the specified path instead of the default node_modules/.mf/cf.json
+ * - If not set, uses the default location (node_modules/.mf/cf.json)
+ *
+ * Example:
+ * ```sh
+ * # Use a custom cache location
+ * CLOUDFLARE_CF_FETCH_PATH=/tmp/cf-cache.json npx wrangler dev
+ * ```
+ */
+declare const getCfFetchPathFromEnv: () => string | undefined;
+/**
+ * `WRANGLER_CACHE_DIR` specifies a custom directory for Wrangler's cache files.
+ * This overrides the default `node_modules/.cache/wrangler` location.
+ * Useful for Yarn PnP or projects without node_modules.
+ */
+declare const getWranglerCacheDirFromEnv: () => string | undefined;
+/**
+ * `CLOUDFLARED_PATH` specifies a custom path to a cloudflared binary.
+ *
+ * If set, Wrangler will use this cloudflared binary instead of downloading one.
+ * The path must point to an existing executable file.
+ */
+declare const getCloudflaredPathFromEnv: () => string | undefined;
+
+declare const LOGGER_LEVELS: {
+    readonly none: -1;
+    readonly error: 0;
+    readonly warn: 1;
+    readonly info: 2;
+    readonly log: 3;
+    readonly debug: 4;
+};
+type LoggerLevel = keyof typeof LOGGER_LEVELS;
+type Logger = {
+    loggerLevel?: LoggerLevel;
+    debug: typeof console.debug;
+    debugWithSanitization?: (label: string, ...args: unknown[]) => void;
+    log: typeof console.log;
+    info: typeof console.info;
+    warn: typeof console.warn;
+    error: typeof console.error;
+    once?: {
+        info: typeof console.info;
+        log: typeof console.log;
+        warn: typeof console.warn;
+        error: typeof console.error;
+    };
+    console?<M extends Exclude<keyof Console, "Console">>(method: M, ...args: Parameters<Console[M]>): void;
+};
+
+type ApiCredentials = {
+    apiToken: string;
+} | {
+    authKey: string;
+    authEmail: string;
+};
+interface FetchResult<ResponseType = unknown> {
+    success: boolean;
+    result: ResponseType;
+    errors: FetchError[];
+    messages?: (string | {
+        code?: number;
+        message: string;
+    })[];
+    result_info?: unknown;
+}
+type FetchResultFetcher = <ResponseType>(complianceConfig: ComplianceConfig, resource: string, init?: RequestInit, queryParams?: URLSearchParams, abortSignal?: AbortSignal) => Promise<ResponseType>;
+type FetchListResultFetcher = <ResponseType>(complianceConfig: ComplianceConfig, resource: string, init?: RequestInit, queryParams?: URLSearchParams) => Promise<ResponseType[]>;
+type FetchPagedListResultFetcher = <ResponseType>(complianceConfig: ComplianceConfig, resource: string, init?: RequestInit, queryParams?: URLSearchParams) => Promise<ResponseType[]>;
+/**
+ *
+ * Note this requires its caller to handle credentials
+ * (need to call requireLoggedIn and requireApiToken)
+ */
+declare function performApiFetchBase(complianceConfig: ComplianceConfig, resource: string, init: RequestInit | undefined, userAgent: string, logger: Logger, queryParams?: URLSearchParams, abortSignal?: AbortSignal, credentials?: ApiCredentials): Promise<Response$1>;
+declare function fetchInternalBase<ResponseType>(complianceConfig: ComplianceConfig, resource: string, init: RequestInit | undefined, userAgent: string, logger: Logger, queryParams?: URLSearchParams, abortSignal?: AbortSignal, credentials?: ApiCredentials): Promise<{
+    response: ResponseType;
+    status: number;
+    retryAfterMs?: number;
+}>;
+declare function fetchResultBase<ResponseType>(complianceConfig: ComplianceConfig, resource: string, init: RequestInit | undefined, userAgent: string, logger: Logger, queryParams?: URLSearchParams, abortSignal?: AbortSignal, credentials?: ApiCredentials): Promise<ResponseType>;
+declare function fetchListResultBase<ResponseType>(complianceConfig: ComplianceConfig, resource: string, init: RequestInit | undefined, userAgent: string, logger: Logger, queryParams?: URLSearchParams, credentials?: ApiCredentials): Promise<ResponseType[]>;
+declare function truncate(text: string, maxLength: number): string;
+declare function isWAFBlockResponse(headers: Headers): boolean;
+/**
+ * Parses a `Retry-After` header value (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After)
+ * into milliseconds to wait before retrying, or `undefined` if absent/unparsable.
+ *
+ * Per the HTTP spec, `Retry-After` may either be a number of delay-seconds,
+ * or an HTTP-date after which the request may be retried.
+ */
+declare function parseRetryAfterValue(retryAfter: string | null | undefined): number | undefined;
+/** Same as {@link parseRetryAfterValue}, reading the value from a `Headers` object. */
+declare function parseRetryAfterMs(headers: Headers): number | undefined;
+declare function extractWAFBlockRayId(headers: Headers): string | undefined;
+declare function extractAccountTag(resource: string): string | undefined;
+interface PageResultInfo {
+    page: number;
+    per_page: number;
+    count: number;
+    total_count: number;
+}
+declare function hasMorePages(result_info: unknown): result_info is PageResultInfo;
+declare function renderError(err: FetchError | {
+    code?: number;
+    message?: string;
+    documentation_url?: string;
+}, level?: number): string;
+declare function addAuthorizationHeader(headers: Headers, auth: ApiCredentials, overrideExisting?: boolean): void;
+declare function throwFetchError(resource: string, response: FetchResult<unknown>, status: number, retryAfterMs?: number): never;
+/**
+ * Fetch a raw KV value from the Cloudflare API.
+ *
+ * This is special-cased because it's the only API endpoint that returns raw
+ * binary data instead of a JSON envelope.
+ *
+ * Note: callers must call encodeURIComponent on `key` before passing it.
+ */
+declare function fetchKVGetValueBase(complianceConfig: ComplianceConfig, accountId: string, namespaceId: string, key: string, userAgent: string, logger: Logger, credentials: ApiCredentials): Promise<ArrayBuffer>;
+type FetchKVGetValueFetcher = (complianceConfig: ComplianceConfig, accountId: string, namespaceId: string, key: string) => Promise<ArrayBuffer>;
+declare function hasCursor(result_info: unknown): result_info is {
+    cursor: string;
+};
+declare function maybeAddTraceHeader(headers: Headers): void;
+
+/**
+ * A symbol to inherit a binding from the deployed worker.
+ */
+declare const INHERIT_SYMBOL: unique symbol;
+declare const SERVICE_TAG_PREFIX = "cf:service=";
+declare const ENVIRONMENT_TAG_PREFIX = "cf:environment=";
+declare const PATH_TO_DEPLOY_CONFIG = ".wrangler/deploy/config.json";
+/**
+ * Config formats that use JSON parsing
+ */
+declare const JSON_CONFIG_FORMATS: readonly string[];
+
+/**
+ * The type of Worker
+ */
+type CfScriptFormat = "modules" | "service-worker";
+/**
+ * A module type.
+ */
+type CfModuleType = "esm" | "commonjs" | "compiled-wasm" | "text" | "buffer" | "python" | "python-requirement";
+/**
+ * An imported module.
+ */
+interface CfModule {
+    /**
+     * The module name.
+     *
+     * @example
+     * './src/index.js'
+     */
+    name: string;
+    /**
+     * The absolute path of the module on disk, or `undefined` if this is a
+     * virtual module. Used as the source URL for this module, so source maps are
+     * correctly resolved.
+     *
+     * @example
+     * '/path/to/src/index.js'
+     */
+    filePath: string | undefined;
+    /**
+     * The module content, usually JavaScript or WASM code.
+     *
+     * @example
+     * export default {
+     *   async fetch(request) {
+     *     return new Response('Ok')
+     *   }
+     * }
+     */
+    content: string | Buffer<ArrayBuffer>;
+    /**
+     * An optional sourcemap for this module if it's of a ESM or CJS type, this will only be present
+     * if we're deploying with sourcemaps enabled. Since we copy extra modules that aren't bundled
+     * we need to also copy the relevant sourcemaps into the final out directory.
+     */
+    sourceMap?: CfWorkerSourceMap;
+    /**
+     * The module type.
+     *
+     * If absent, will default to the main module's type.
+     */
+    type?: CfModuleType;
+}
+/**
+ * A map of variable names to values.
+ */
+interface CfVars {
+    [key: string]: string | Json;
+}
+/**
+ * A KV namespace.
+ */
+interface CfKvNamespace {
+    binding: string;
+    id?: string | typeof INHERIT_SYMBOL;
+    remote?: boolean;
+    raw?: boolean;
+}
+/**
+ * A binding to send email.
+ */
+type CfSendEmailBindings = {
+    name: string;
+    remote?: boolean;
+    allowed_sender_addresses?: string[];
+} & ({
+    destination_address: string;
+    allowed_destination_addresses?: never;
+} | {
+    destination_address?: never;
+    allowed_destination_addresses: string[];
+} | {
+    destination_address?: never;
+    allowed_destination_addresses?: never;
+});
+/**
+ * A binding to a wasm module (in service-worker format)
+ */
+interface CfWasmModuleBindings {
+    [key: string]: string | Uint8Array<ArrayBuffer>;
+}
+/**
+ * A binding to a text blob (in service-worker format)
+ */
+interface CfTextBlobBindings {
+    [key: string]: string;
+}
+/**
+ * A binding to a browser
+ */
+interface CfBrowserBinding {
+    binding: string;
+    raw?: boolean;
+    remote?: boolean;
+}
+/**
+ * A binding to the AI project
+ */
+interface CfAIBinding {
+    binding: string;
+    staging?: boolean;
+    remote?: boolean;
+    raw?: boolean;
+}
+/**
+ * A binding to Cloudflare Images
+ */
+interface CfImagesBinding {
+    binding: string;
+    raw?: boolean;
+    remote?: boolean;
+}
+/**
+ * A binding to Cloudflare Media Transformations
+ */
+interface CfMediaBinding {
+    binding: string;
+    remote?: boolean;
+}
+/**
+ * A binding to Cloudflare Stream
+ */
+interface CfStreamBinding {
+    binding: string;
+    remote?: boolean;
+}
+/**
+ * A binding to the Worker Version's metadata
+ */
+interface CfVersionMetadataBinding {
+    binding: string;
+}
+/**
+ * A binding to a data blob (in service-worker format)
+ */
+interface CfDataBlobBindings {
+    [key: string]: string | Uint8Array<ArrayBuffer>;
+}
+/**
+ * A Durable Object.
+ */
+interface CfDurableObject {
+    name: string;
+    class_name: string;
+    script_name?: string;
+    environment?: string;
+}
+interface CfWorkflow {
+    name: string;
+    class_name: string;
+    binding: string;
+    script_name?: string;
+    raw?: boolean;
+    limits?: {
+        steps?: number;
+    };
+    concurrency?: {
+        limit?: number;
+    };
+    schedules?: string | string[];
+}
+interface CfQueue {
+    binding: string;
+    queue_name?: string | typeof INHERIT_SYMBOL;
+    delivery_delay?: number;
+    remote?: boolean;
+    raw?: boolean;
+}
+interface CfR2Bucket {
+    binding: string;
+    bucket_name?: string | typeof INHERIT_SYMBOL;
+    jurisdiction?: string;
+    remote?: boolean;
+    raw?: boolean;
+    /** Settings that only apply to local development */
+    local_dev?: {
+        /** EXPERIMENTAL: credentials for the local S3-compatible endpoint */
+        experimental_s3_credentials?: LocalS3Credentials;
+    };
+}
+interface CfD1Database {
+    binding: string;
+    database_id?: string | typeof INHERIT_SYMBOL;
+    database_name?: string;
+    preview_database_id?: string;
+    database_internal_env?: string;
+    migrations_table?: string;
+    migrations_dir?: string;
+    migrations_pattern?: string;
+    remote?: boolean;
+    raw?: boolean;
+}
+interface CfVectorize {
+    binding: string;
+    index_name: string;
+    raw?: boolean;
+    remote?: boolean;
+}
+interface CfAISearchNamespace {
+    binding: string;
+    namespace: string | typeof INHERIT_SYMBOL;
+    remote?: boolean;
+}
+interface CfAISearch {
+    binding: string;
+    instance_name: string;
+    remote?: boolean;
+}
+interface CfWebSearch {
+    binding: string;
+    remote?: boolean;
+}
+interface CfAgentMemory {
+    binding: string;
+    namespace: string | typeof INHERIT_SYMBOL;
+    remote?: boolean;
+}
+interface CfSecretsStoreSecrets {
+    binding: string;
+    store_id: string;
+    secret_name: string;
+}
+interface CfArtifacts {
+    binding: string;
+    namespace: string;
+    remote?: boolean;
+}
+interface CfHelloWorld {
+    binding: string;
+    enable_timer?: boolean;
+}
+interface CfFlagship {
+    binding: string;
+    app_id?: string | typeof INHERIT_SYMBOL;
+    remote?: boolean;
+}
+interface CfWorkerLoader {
+    binding: string;
+}
+interface CfRateLimit {
+    name: string;
+    namespace_id: string;
+    simple: {
+        limit: number;
+        period: 10 | 60;
+    };
+}
+interface CfHyperdrive {
+    binding: string;
+    id: string;
+    localConnectionString?: string;
+}
+interface CfDevPluginCfg {
+    plugin: {
+        /**
+         * Package is the bare specifier of the package that exposes plugins to integrate into Miniflare via a named `plugins` export.
+         * @example "@cloudflare/my-external-miniflare-plugin"
+         */
+        package: string;
+        /**
+         * Plugin is the name of the plugin exposed by the package.
+         * @example "my-unsafe-plugin"
+         */
+        name: string;
+    };
+    /**
+     * dev-only options to pass to the plugin.
+     */
+    options?: Record<string, unknown>;
+}
+interface CfService {
+    binding: string;
+    service: string;
+    environment?: string;
+    entrypoint?: string;
+    props?: Record<string, unknown>;
+    remote?: boolean;
+    cross_account_grant?: string;
+    dev?: CfDevPluginCfg;
+}
+interface CfVpcService {
+    binding: string;
+    service_id: string;
+    remote?: boolean;
+}
+interface CfVpcNetwork {
+    binding: string;
+    tunnel_id?: string;
+    network_id?: string;
+    remote?: boolean;
+}
+interface CfAnalyticsEngineDataset {
+    binding: string;
+    dataset?: string;
+}
+interface CfDispatchNamespace {
+    binding: string;
+    namespace?: string | typeof INHERIT_SYMBOL;
+    outbound?: {
+        service: string;
+        environment?: string;
+        parameters?: string[];
+    };
+    remote?: boolean;
+}
+interface CfMTlsCertificate {
+    binding: string;
+    certificate_id: string;
+    remote?: boolean;
+}
+interface CfLogfwdr {
+    bindings: CfLogfwdrBinding[];
+}
+interface CfLogfwdrBinding {
+    name: string;
+    destination: string;
+}
+interface CfAssetsBinding {
+    binding: string;
+}
+interface CfPipeline {
+    binding: string;
+    stream?: string;
+    pipeline?: string;
+    remote?: boolean;
+}
+interface CfUnsafeBinding {
+    name: string;
+    type: string;
+    dev?: CfDevPluginCfg;
+}
+type CfUnsafeMetadata = Record<string, unknown>;
+type CfCapnp = {
+    base_path?: never;
+    source_schemas?: never;
+    compiled_schema: string;
+} | {
+    base_path: string;
+    source_schemas: string[];
+    compiled_schema?: never;
+};
+interface CfUnsafe {
+    bindings: CfUnsafeBinding[] | undefined;
+    metadata: CfUnsafeMetadata | undefined;
+    capnp: CfCapnp | undefined;
+}
+interface CfDurableObjectMigrations {
+    old_tag?: string;
+    new_tag: string;
+    steps: {
+        new_classes?: string[];
+        new_sqlite_classes?: string[];
+        renamed_classes?: {
+            from: string;
+            to: string;
+        }[];
+        deleted_classes?: string[];
+    }[];
+}
+/**
+ * The declarative `exports` map keyed by class name.
+ *
+ * Durable Objects can only be configured by `exports` or `migrations`, not both.
+ */
+type CfExports = Exports;
+type CfPlacement = {
+    mode: "smart";
+    hint?: string;
+} | {
+    mode?: "targeted";
+    region: string;
+} | {
+    mode?: "targeted";
+    host: string;
+} | {
+    mode?: "targeted";
+    hostname: string;
+};
+interface CfTailConsumer {
+    service: string;
+    environment?: string;
+}
+interface CfUserLimits {
+    cpu_ms?: number;
+    subrequests?: number;
+}
+/**
+ * Options for creating a `CfWorker`.
+ */
+interface CfWorkerInit {
+    /**
+     * The name of the worker.
+     */
+    name: string | undefined;
+    /**
+     * The entrypoint module.
+     */
+    main: CfModule;
+    /**
+     * The list of additional modules.
+     */
+    modules: CfModule[] | undefined;
+    /**
+     * The list of source maps to include on upload.
+     */
+    sourceMaps: CfWorkerSourceMap[] | undefined;
+    /**
+     * A container is linked to its Durable Object either by `class_name`, or by
+     * the Durable Object's `exports` entry naming the container by `name`.
+     */
+    containers: {
+        name?: string;
+        class_name?: string;
+    }[] | undefined;
+    migrations: CfDurableObjectMigrations | undefined;
+    /**
+     * Declarative exports configuration. Durable Object entries are sent instead
+     * of `migrations`.
+     */
+    exports: CfExports | undefined;
+    compatibility_date: string | undefined;
+    compatibility_flags: string[] | undefined;
+    keepVars: boolean | undefined;
+    keepSecrets: boolean | undefined;
+    keepBindings?: WorkerMetadata["keep_bindings"];
+    logpush: boolean | undefined;
+    placement: CfPlacement | undefined;
+    tail_consumers: CfTailConsumer[] | undefined;
+    streaming_tail_consumers?: CfTailConsumer[] | undefined;
+    limits: CfUserLimits | undefined;
+    annotations?: Record<string, string | undefined>;
+    keep_assets?: boolean | undefined;
+    assets: {
+        jwt: string;
+        routerConfig: RouterConfig;
+        assetConfig: AssetConfig;
+        run_worker_first?: string[] | boolean;
+        _redirects?: string;
+        _headers?: string;
+    } | undefined;
+    observability: Observability | undefined;
+    cache: CacheOptions | undefined;
+    /**
+     * The list of npm package dependencies collected from the project's package.json.
+     * Sent to the API for instrumentation and analytics purposes.
+     */
+    package_dependencies?: Array<{
+        name: string;
+        packageJsonVersion: string;
+        installedVersion: string;
+    }> | undefined;
+}
+interface CfWorkerContext {
+    env: string | undefined;
+    zone: string | undefined;
+    host: string | undefined;
+    routes: Route[] | undefined;
+    sendMetrics: boolean | undefined;
+}
+interface CfWorkerSourceMap {
+    /**
+     * The name of the source map.
+     *
+     * @example
+     * 'out.js.map'
+     */
+    name: string;
+    /**
+     * The content of the source map, which is a JSON object described by the v3
+     * spec.
+     *
+     * @example
+     * {
+     *   "version" : 3,
+     *   "file": "out.js",
+     *   "sourceRoot": "",
+     *   "sources": ["foo.js", "bar.js"],
+     *   "sourcesContent": [null, null],
+     *   "names": ["src", "maps", "are", "fun"],
+     *   "mappings": "A,AAAB;;ABCDE;"
+     * }
+     */
+    content: string | Buffer;
+}
+
+type Json = string | number | boolean | null | Json[] | {
+    [id: string]: Json;
+};
+type WorkerMetadataBinding = {
+    type: "inherit";
+    name: string;
+} | {
+    type: "plain_text";
+    name: string;
+    text: string;
+} | {
+    type: "secret_text";
+    name: string;
+    text: string;
+} | {
+    type: "json";
+    name: string;
+    json: Json;
+} | {
+    type: "wasm_module";
+    name: string;
+    part: string;
+} | {
+    type: "text_blob";
+    name: string;
+    part: string;
+} | {
+    type: "browser";
+    name: string;
+    raw?: boolean;
+} | {
+    type: "ai";
+    name: string;
+    staging?: boolean;
+    raw?: boolean;
+} | {
+    type: "images";
+    name: string;
+    raw?: boolean;
+} | {
+    type: "stream";
+    name: string;
+} | {
+    type: "version_metadata";
+    name: string;
+} | {
+    type: "data_blob";
+    name: string;
+    part: string;
+} | {
+    type: "ai_search_namespace";
+    name: string;
+    namespace: string;
+} | {
+    type: "ai_search";
+    name: string;
+    instance_name: string;
+} | {
+    type: "websearch";
+    name: string;
+} | {
+    type: "agent_memory";
+    name: string;
+    namespace: string;
+} | {
+    type: "kv_namespace";
+    name: string;
+    namespace_id: string;
+    raw?: boolean;
+} | {
+    type: "media";
+    name: string;
+} | {
+    type: "send_email";
+    name: string;
+    destination_address?: string;
+    allowed_destination_addresses?: string[];
+    allowed_sender_addresses?: string[];
+} | {
+    type: "durable_object_namespace";
+    name: string;
+    class_name: string;
+    script_name?: string;
+    environment?: string;
+    namespace_id?: string;
+} | {
+    type: "workflow";
+    name: string;
+    workflow_name: string;
+    class_name: string;
+    script_name?: string;
+    raw?: boolean;
+} | {
+    type: "queue";
+    name: string;
+    queue_name: string;
+    delivery_delay?: number;
+    raw?: boolean;
+} | {
+    type: "r2_bucket";
+    name: string;
+    bucket_name: string;
+    jurisdiction?: string;
+    raw?: boolean;
+} | {
+    type: "d1";
+    name: string;
+    id: string;
+    internalEnv?: string;
+    raw?: boolean;
+} | {
+    type: "vectorize";
+    name: string;
+    index_name: string;
+    internalEnv?: string;
+    raw?: boolean;
+} | {
+    type: "hyperdrive";
+    name: string;
+    id: string;
+} | {
+    type: "service";
+    name: string;
+    service: string;
+    environment?: string;
+    entrypoint?: string;
+    cross_account_grant?: string;
+} | {
+    type: "analytics_engine";
+    name: string;
+    dataset?: string;
+} | {
+    type: "dispatch_namespace";
+    name: string;
+    namespace: string;
+    outbound?: {
+        worker: {
+            service: string;
+            environment?: string;
+        };
+        params?: {
+            name: string;
+        }[];
+    };
+} | {
+    type: "mtls_certificate";
+    name: string;
+    certificate_id: string;
+} | {
+    type: "pipelines";
+    name: string;
+    stream?: string;
+    pipeline?: string;
+} | {
+    type: "secrets_store_secret";
+    name: string;
+    store_id: string;
+    secret_name: string;
+} | {
+    type: "artifacts";
+    name: string;
+    namespace: string;
+} | {
+    type: "unsafe_hello_world";
+    name: string;
+    enable_timer?: boolean;
+} | {
+    type: "flagship";
+    name: string;
+    app_id: string;
+} | {
+    type: "ratelimit";
+    name: string;
+    namespace_id: string;
+    simple: {
+        limit: number;
+        period: 10 | 60;
+    };
+} | {
+    type: "vpc_service";
+    name: string;
+    service_id: string;
+} | {
+    type: "vpc_network";
+    name: string;
+    tunnel_id?: string;
+    network_id?: string;
+} | {
+    type: "worker_loader";
+    name: string;
+} | {
+    type: "logfwdr";
+    name: string;
+    destination: string;
+} | {
+    type: "assets";
+    name: string;
+};
+type AssetConfigMetadata = {
+    html_handling?: AssetConfig["html_handling"];
+    not_found_handling?: AssetConfig["not_found_handling"];
+    run_worker_first?: boolean | string[];
+    _redirects?: string;
+    _headers?: string;
+};
+type AssetsOptions = {
+    directory: string;
+    binding?: string;
+    routerConfig: RouterConfig;
+    assetConfig: AssetConfig;
+    _redirects?: string;
+    _headers?: string;
+    run_worker_first?: boolean | string[];
+};
+/**
+ * The result of validating and resolving the assets directory, before the
+ * full {@link AssetsOptions} are resolved. Produced by the validation half of
+ * `getAssetsOptions` and consumed by `resolveAssetOptions`.
+ */
+type ValidatedAssetsOptions = {
+    directory: string;
+    binding?: string;
+    directoryExists: boolean;
+};
+/**
+ * Information about the assets that should be uploaded
+ */
+interface LegacyAssetPaths {
+    /**
+     * Absolute path to the root of the project.
+     *
+     * This is the directory containing wrangler.toml or cwd if no config.
+     */
+    baseDirectory: string;
+    /**
+     * The path to the assets directory, relative to the `baseDirectory`.
+     */
+    assetDirectory: string;
+    /**
+     * An array of patterns that match files that should be uploaded.
+     */
+    includePatterns: string[];
+    /**
+     * An array of patterns that match files that should not be uploaded.
+     */
+    excludePatterns: string[];
+}
+type WorkerMetadataPut = {
+    /** The name of the entry point module. Only exists when the worker is in the ES module format */
+    main_module?: string;
+    /** The name of the entry point module. Only exists when the worker is in the service-worker format */
+    body_part?: string;
+    compatibility_date?: string;
+    compatibility_flags?: string[];
+    usage_model?: "bundled" | "unbound";
+    migrations?: CfDurableObjectMigrations;
+    exports?: CfExports;
+    capnp_schema?: string;
+    bindings: WorkerMetadataBinding[];
+    keep_bindings?: (WorkerMetadataBinding["type"] | "secret_text" | "secret_key")[];
+    logpush?: boolean;
+    placement?: CfPlacement;
+    tail_consumers?: CfTailConsumer[];
+    streaming_tail_consumers?: CfTailConsumer[];
+    limits?: CfUserLimits;
+    assets?: {
+        jwt: string;
+        config?: AssetConfigMetadata;
+    };
+    observability?: Observability | undefined;
+    containers?: {
+        name?: string;
+        class_name?: string;
+    }[];
+    package_dependencies?: Array<{
+        name: string;
+        packageJsonVersion: string;
+        installedVersion: string;
+    }>;
+    [key: string]: unknown;
+};
+type WorkerMetadataVersionsPost = WorkerMetadataPut & {
+    annotations?: Record<string, string>;
+};
+type WorkerMetadata = WorkerMetadataPut | WorkerMetadataVersionsPost;
+/**
+ * Structured per-class entry returned by the declarative exports
+ * reconciliation flow.
+ *
+ * The same shape is used for both successful info entries (under
+ * `exports_reconciliation.info[]`) and blocking errors (under the v4 error
+ * envelope's `meta.details[]`). The `scenario` tag is the stable, machine-
+ * readable identifier of which reconciliation case produced the entry.
+ */
+type ExportsReconciliationEntryBase = {
+    class: string;
+    scenario: string;
+    message: string;
+    namespace_id?: string;
+};
+type ExportsReconciliationInfo = ExportsReconciliationEntryBase & {
+    /**
+     * Workers in the account that still bind to the source class name and must
+     * be redeployed before the tombstone is safe to remove.
+     */
+    referencing_scripts?: string[];
+};
+type ExportsReconciliationWarning = ExportsReconciliationEntryBase;
+type ExportsReconciliationErrorDetail = ExportsReconciliationEntryBase & {
+    suggestion?: string;
+    referencing_scripts?: string[];
+};
+type ExportsReconciliationRename = {
+    from: string;
+    to: string;
+};
+type ExportsReconciliationTransfer = {
+    class: string;
+    to: string;
+    phase: "committed";
+};
+type ExportsReconciliationTransferPending = {
+    class: string;
+    from: string;
+};
+/**
+ * The customer-visible summary of a successful exports reconciliation,
+ * embedded in the upload response under `exports_reconciliation`. All arrays
+ * are present, and are empty when there are no entries to report.
+ */
+type ExportsReconciliationResult = {
+    created: string[];
+    updated: string[];
+    deleted: string[];
+    renamed: ExportsReconciliationRename[];
+    transferred: ExportsReconciliationTransfer[];
+    transfer_pending: ExportsReconciliationTransferPending[];
+    warnings: ExportsReconciliationWarning[];
+    info: ExportsReconciliationInfo[];
+    removable_entries: string[];
+};
+type ServiceMetadataRes = {
+    id: string;
+    default_environment: {
+        environment: string;
+        created_on: string;
+        modified_on: string;
+        script: {
+            id: string;
+            tag: string;
+            tags: string[];
+            etag: string;
+            handlers: string[];
+            modified_on: string;
+            created_on: string;
+            migration_tag: string;
+            usage_model: "bundled" | "unbound";
+            limits: {
+                cpu_ms: number;
+                subrequests: number;
+            };
+            compatibility_date: string;
+            compatibility_flags: string[];
+            last_deployed_from?: "wrangler" | "dash" | "api";
+            placement_mode?: "smart";
+            tail_consumers?: TailConsumer[];
+            observability?: Observability;
+        };
+    };
+    created_on: string;
+    modified_on: string;
+    usage_model: "bundled" | "unbound";
+    environments: [
+        {
+            environment: string;
+            created_on: string;
+            modified_on: string;
+        }
+    ];
+};
+type ServiceFetch = (request: Request) => Promise<Response> | Response;
+type File<Contents = string, Path = string> = {
+    path: Path;
+} | {
+    contents: Contents;
+    path?: Path;
+};
+type BinaryFile = File<Uint8Array>;
+type QueueConsumer = NonNullable<Config["queues"]["consumers"]>[number];
+type Trigger = {
+    type: "workers.dev";
+} | {
+    type: "route";
+    pattern: string;
+} | ({
+    type: "route";
+} & ZoneIdRoute) | ({
+    type: "route";
+} & ZoneNameRoute) | ({
+    type: "route";
+} & CustomDomainRoute) | {
+    type: "cron";
+    cron: string;
+} | ({
+    type: "queue-consumer";
+} & Omit<QueueConsumer, "type">) | {
+    type: "connect";
+    protocol: "tcp";
+    port: number;
+    address?: string;
+};
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+type BindingOmit<T> = DistributiveOmit<T, "binding">;
+type NameOmit<T> = DistributiveOmit<T, "name">;
+type Binding = {
+    type: "plain_text";
+    value: string;
+    /**
+     * Hide this environment variable in output as it may be sensitive
+     * This is a @deprecated feature to support current Wrangler behaviour, and sensitive
+     * variables should be marked as `type: secret_text` in future
+     */
+    hidden?: boolean;
+} | {
+    type: "secret_text";
+    value: string;
+} | {
+    type: "json";
+    value: Json;
+} | ({
+    type: "kv_namespace";
+} & BindingOmit<CfKvNamespace>) | ({
+    type: "send_email";
+} & NameOmit<CfSendEmailBindings>) | {
+    type: "wasm_module";
+    source: BinaryFile;
+} | {
+    type: "text_blob";
+    source: File;
+} | ({
+    type: "browser";
+} & BindingOmit<CfBrowserBinding>) | ({
+    type: "ai";
+} & BindingOmit<CfAIBinding>) | ({
+    type: "images";
+} & BindingOmit<CfImagesBinding>) | ({
+    type: "stream";
+} & BindingOmit<CfStreamBinding>) | {
+    type: "version_metadata";
+} | {
+    type: "data_blob";
+    source: BinaryFile;
+} | ({
+    type: "durable_object_namespace";
+} & NameOmit<CfDurableObject>) | ({
+    type: "workflow";
+} & BindingOmit<CfWorkflow>) | ({
+    type: "queue";
+} & BindingOmit<CfQueue>) | ({
+    type: "r2_bucket";
+} & BindingOmit<CfR2Bucket>) | ({
+    type: "d1";
+} & BindingOmit<CfD1Database>) | ({
+    type: "vectorize";
+} & BindingOmit<CfVectorize>) | ({
+    type: "ai_search_namespace";
+} & BindingOmit<CfAISearchNamespace>) | ({
+    type: "ai_search";
+} & BindingOmit<CfAISearch>) | ({
+    type: "websearch";
+} & BindingOmit<CfWebSearch>) | ({
+    type: "agent_memory";
+} & BindingOmit<CfAgentMemory>) | ({
+    type: "hyperdrive";
+} & BindingOmit<CfHyperdrive>) | ({
+    type: "service";
+} & BindingOmit<CfService>) | {
+    type: "fetcher";
+    fetcher: ServiceFetch;
+} | ({
+    type: "analytics_engine";
+} & BindingOmit<CfAnalyticsEngineDataset>) | ({
+    type: "dispatch_namespace";
+} & BindingOmit<CfDispatchNamespace>) | ({
+    type: "mtls_certificate";
+} & BindingOmit<CfMTlsCertificate>) | ({
+    type: "pipeline";
+} & BindingOmit<CfPipeline>) | ({
+    type: "secrets_store_secret";
+} & BindingOmit<CfSecretsStoreSecrets>) | ({
+    type: "artifacts";
+} & BindingOmit<CfArtifacts>) | ({
+    type: "logfwdr";
+} & NameOmit<CfLogfwdrBinding>) | ({
+    type: "unsafe_hello_world";
+} & BindingOmit<CfHelloWorld>) | ({
+    type: "flagship";
+} & BindingOmit<CfFlagship>) | ({
+    type: "ratelimit";
+} & NameOmit<CfRateLimit>) | ({
+    type: "worker_loader";
+} & BindingOmit<CfWorkerLoader>) | ({
+    type: "vpc_service";
+} & BindingOmit<CfVpcService>) | ({
+    type: "vpc_network";
+} & BindingOmit<CfVpcNetwork>) | ({
+    type: "media";
+} & BindingOmit<CfMediaBinding>) | ({
+    type: `unsafe_${string}`;
+} & Omit<CfUnsafeBinding, "name" | "type">) | {
+    type: "assets";
+} | {
+    type: "inherit";
+};
+interface CfAccount {
+    /**
+     * An API token.
+     *
+     * @link https://api.cloudflare.com/#user-api-tokens-properties
+     */
+    apiToken: ApiCredentials;
+    /**
+     * An account ID.
+     */
+    accountId: string;
+}
+type HookValues = string | number | boolean | object | undefined | null;
+type Hook<T extends HookValues, Args extends unknown[] = []> = T | ((...args: Args) => T);
+type AsyncHook<T extends HookValues, Args extends unknown[] = []> = Hook<T, Args> | Hook<Promise<T>, Args>;
+type LogLevel = "debug" | "info" | "log" | "warn" | "error" | "none";
+type NodeJSCompatMode = "als" | "v1" | "v2" | null;
+interface StartDevWorkerInput {
+    /** The name of the worker. */
+    name?: string;
+    /**
+     * The javascript or typescript entry-point of the worker.
+     * This is the `main` property of a Wrangler configuration file.
+     */
+    entrypoint?: string;
+    /** The configuration path of the worker, or a normalized configuration object. */
+    config?: string | Config;
+    /** The compatibility date for the workerd runtime. */
+    compatibilityDate?: string;
+    /** The compatibility flags for the workerd runtime. */
+    compatibilityFlags?: string[];
+    /** Specify the compliance region mode of the Worker. */
+    complianceRegion?: Config["compliance_region"];
+    /** Configuration for Python modules. */
+    pythonModules?: {
+        /** A list of glob patterns to exclude files from the python_modules directory when bundling. */
+        exclude?: string[];
+    };
+    env?: string;
+    /**
+     * An array of paths to the .env files to load for this worker, relative to the project directory.
+     *
+     * If not specified, defaults to the standard `.env` files as given from Wrangler.
+     * The project directory is where the Wrangler configuration file is located or the current working directory otherwise.
+     */
+    envFiles?: string[];
+    /** The bindings available to the worker. The specified binding type will be exposed to the worker on the `env` object under the same key. */
+    bindings?: Record<string, Binding>;
+    /**
+     * Default bindings that can be overridden by config bindings.
+     * Useful for injecting environment-specific defaults like CF_PAGES variables.
+     */
+    defaultBindings?: Record<string, Extract<Binding, {
+        type: "plain_text";
+    }>>;
+    migrations?: DurableObjectMigration[];
+    exports?: Exports;
+    containers?: ContainerApp[];
+    /** The triggers which will cause the worker's exported default handlers to be called. */
+    triggers?: Trigger[];
+    tailConsumers?: CfTailConsumer[];
+    streamingTailConsumers?: CfTailConsumer[];
+    /** Cloudflare Access authentication configuration */
+    access?: Config["access"];
+    /**
+     * Whether Wrangler should send usage metrics to Cloudflare for this project.
+     *
+     * When defined this will override any user settings.
+     * Otherwise, Wrangler will use the user's preference.
+     */
+    sendMetrics?: boolean;
+    /** Options applying to the worker's build step. Applies to deploy and dev. */
+    build?: {
+        /** Whether the worker and its dependencies are bundled. Defaults to true. */
+        bundle?: boolean;
+        additionalModules?: CfModule[];
+        findAdditionalModules?: boolean;
+        processEntrypoint?: boolean;
+        /** Specifies types of modules matched by globs. */
+        moduleRules?: Rule[];
+        /** Replace global identifiers with constant expressions, e.g. { debug: 'true', version: '"1.0.0"' }. Only takes effect if bundle: true. */
+        define?: Record<string, string>;
+        /** Alias modules */
+        alias?: Record<string, string>;
+        /** Whether the bundled worker is minified. Only takes effect if bundle: true. */
+        minify?: boolean;
+        /** Whether to keep function names after JavaScript transpilations. */
+        keepNames?: boolean;
+        /** Options controlling a custom build step. */
+        custom?: {
+            /** Custom shell command to run before bundling. Runs even if bundle. */
+            command?: string;
+            /** The cwd to run the command in. */
+            workingDirectory?: string;
+            /** Filepath(s) to watch for changes. Upon changes, the command will be rerun. */
+            watch?: string | string[];
+        };
+        jsxFactory?: string;
+        jsxFragment?: string;
+        tsconfig?: string;
+        nodejsCompatMode?: Hook<NodeJSCompatMode, [Config]>;
+        moduleRoot?: string;
+    };
+    /** Options applying to the worker's development preview environment. */
+    dev?: {
+        /** Options applying to the worker's inspector server. False disables the inspector server. */
+        inspector?: {
+            hostname?: string;
+            port?: number;
+            secure?: boolean;
+        } | false;
+        /** Whether the worker runs on the edge or locally. */
+        remote?: boolean | "minimal";
+        /** Cloudflare Account credentials. Can be provided upfront or as a function which will be called only when required. */
+        auth?: AsyncHook<CfAccount, [Pick<Config, "account_id">]>;
+        /** Whether local storage (KV, Durable Objects, R2, D1, etc) is persisted. You can also specify the directory to persist data to. Set to `false` to disable persistence. */
+        persist?: string | false;
+        /** Controls which logs are logged. */
+        logLevel?: LogLevel;
+        /** Whether the worker server restarts upon source/config file changes. */
+        watch?: boolean;
+        /** Whether a script tag is inserted on text/html responses which will reload the page upon file changes. Defaults to false. */
+        liveReload?: boolean;
+        /** The local address to reach your worker. Applies to remote: true (remote mode) and remote: false (local mode). */
+        server?: {
+            hostname?: string;
+            port?: number;
+            secure?: boolean;
+            httpsKeyPath?: string;
+            httpsCertPath?: string;
+        };
+        /** Controls what request.url looks like inside the worker. */
+        origin?: {
+            hostname?: string;
+            secure?: boolean;
+        };
+        /** A hook for outbound fetch calls from within the worker. */
+        outboundService?: ServiceFetch;
+        /** An undici MockAgent to declaratively mock fetch calls to particular resources. */
+        mockFetch?: MockAgent;
+        testScheduled?: boolean;
+        /** Treat this as the primary worker in a multiworker setup (i.e. the first Worker in Miniflare's options) */
+        multiworkerPrimary?: boolean;
+        /** Whether to infer the local request origin from configured routes. */
+        inferOriginFromRoutes?: boolean;
+        /** Whether local requests should be matched against configured routes. */
+        routeRequestsByRoutes?: boolean;
+        containerBuildId?: string;
+        /** Whether to build and connect to containers during local dev. Requires Docker daemon to be running. Defaults to true. */
+        enableContainers?: boolean;
+        /** Path to the dev registry directory */
+        registry?: string;
+        /** Path to the docker executable. Defaults to 'docker' */
+        dockerPath?: string;
+        /** Options for the container engine */
+        containerEngine?: ContainerEngine;
+        /** Re-generate your worker types when your Wrangler configuration file changes */
+        generateTypes?: boolean;
+        /**
+         * Experimental: Use `cloudflare.config.ts` + optional `wrangler.config.ts`
+         * instead of `wrangler.json[c]` / `wrangler.toml`.
+         */
+        experimentalNewConfig?: boolean;
+        /** Tunnel configuration for this dev session. */
+        tunnel?: {
+            enabled: boolean;
+            name?: string;
+        };
+    };
+    legacy?: {
+        site?: Hook<Config["site"], [Config]>;
+    };
+    unsafe?: Omit<CfUnsafe, "bindings">;
+    assets?: string;
+    experimental?: Record<string, never>;
+}
+/**
+ * An entry point for the Worker.
+ *
+ * It consists not just of a `file`, but also of a `directory` that is used to resolve relative paths.
+ */
+type Entry = {
+    /** A worker's entrypoint */
+    file: string;
+    /** A worker's directory. Usually where the Wrangler configuration file is located */
+    projectRoot: string;
+    /** The path to the config file, if it exists. */
+    configPath: string | undefined;
+    /** Is this a module worker or a service worker? */
+    format: CfScriptFormat;
+    /** The directory that contains all of a `--no-bundle` worker's modules. Usually `${directory}/src`. Defaults to path.dirname(file) */
+    moduleRoot: string;
+    /**
+     * A worker's name
+     */
+    name?: string | undefined;
+    /** Export from a Worker's entrypoint */
+    exports: string[];
+};
+
+/**
+ * Wrangler configuration types. The JSDoc on these fields is also the source
+ * of truth for the equivalent fields in `@cloudflare/config`
+ * (`packages/config/src/types.ts` — `WorkerConfig` — and the binding option
+ * interfaces in `packages/config/src/config.ts`). When editing prose here,
+ * mirror the changes there.
+ */
+
+/**
+ * The `Environment` interface declares all the configuration fields that
+ * can be specified for an environment.
+ *
+ * This could be the top-level default environment, or a specific named environment.
+ */
+interface Environment extends EnvironmentInheritable, EnvironmentNonInheritable {
+}
+type SimpleRoute = string;
+/** AWS SigV4 credentials for miniflare's local S3-compatible endpoint */
+interface LocalS3Credentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+}
+type ZoneIdRoute = {
+    pattern: string;
+    zone_id: string;
+    custom_domain?: boolean;
+};
+type ZoneNameRoute = {
+    pattern: string;
+    zone_name: string;
+    custom_domain?: boolean;
+};
+type CustomDomainRoute = {
+    pattern: string;
+    custom_domain: boolean;
+    enabled?: boolean;
+    previews_enabled?: boolean;
+};
+type Route = SimpleRoute | ZoneIdRoute | ZoneNameRoute | CustomDomainRoute;
+/**
+ * Configuration in wrangler for Cloudchamber
+ */
+type CloudchamberConfig = {
+    image?: string;
+    location?: string;
+    instance_type?: "dev" | "basic" | "standard" | "lite" | "standard-1" | "standard-2" | "standard-3" | "standard-4";
+    vcpu?: number;
+    memory?: string;
+    ipv4?: boolean;
+};
+type UnsafeBinding = {
+    /**
+     * The name of the binding provided to the Worker
+     */
+    name: string;
+    /**
+     * The 'type' of the unsafe binding.
+     */
+    type: string;
+    dev?: {
+        plugin: {
+            /**
+             * Package is the bare specifier of the package that exposes plugins to integrate into Miniflare via a named `plugins` export.
+             * @example "@cloudflare/my-external-miniflare-plugin"
+             */
+            package: string;
+            /**
+             * Plugin is the name of the plugin exposed by the package.
+             * @example "MY_UNSAFE_PLUGIN"
+             */
+            name: string;
+        };
+        /**
+         * Optional mapping of unsafe bindings names to options provided for the plugin.
+         */
+        options?: Record<string, unknown>;
+    };
+    [key: string]: unknown;
+};
+/**
+ * Configuration for a container application
+ */
+type ContainerApp = {
+    /**
+     * Name of the application.
+     *
+     * This is also the identifier used to reference the container from a Durable
+     * Object's `exports` entry via its `container` field.
+     *
+     * @optional Defaults to `worker_name-class_name` if not specified. A name is
+     * required when `class_name` is not set, since there is no class name to
+     * derive the default from.
+     */
+    name?: string;
+    /**
+     * Number of application instances
+     * @deprecated
+     * @hidden
+     */
+    instances?: number;
+    /**
+     * Number of maximum application instances.
+     * @optional
+     */
+    max_instances?: number;
+    /**
+     * The path to a Dockerfile, or an image URI for the Cloudflare registry.
+     */
+    image: string;
+    /**
+     * Build context of the application.
+     * @optional - defaults to the directory of `image`.
+     */
+    image_build_context?: string;
+    /**
+     * Image variables available to the image at build-time only.
+     * For runtime env vars, refer to https://developers.cloudflare.com/containers/examples/env-vars-and-secrets/
+     * @optional
+     */
+    image_vars?: Record<string, string>;
+    /**
+     * The class name of the Durable Object the container is connected to.
+     *
+     * @optional Instead of naming the Durable Object here, you can reference this
+     * container from the Durable Object's `exports` entry via its `container`
+     * field. Exactly one of the two directions must be configured.
+     */
+    class_name?: string;
+    /**
+     * The scheduling policy of the application
+     * @optional
+     * @default "default"
+     */
+    scheduling_policy?: "default" | "moon" | "regional";
+    /**
+     * The instance type to be used for the container.
+     * Select from one of the following named instance types:
+     *  - lite: 1/16 vCPU, 256 MiB memory, and 2 GB disk
+     *  - basic: 1/4 vCPU, 1 GiB memory, and 4 GB disk
+     *  - standard-1: 1/2 vCPU, 4 GiB memory, and 8 GB disk
+     *  - standard-2: 1 vCPU, 6 GiB memory, and 12 GB disk
+     *  - standard-3: 2 vCPU, 8 GiB memory, and 16 GB disk
+     *  - standard-4: 4 vCPU, 12 GiB memory, and 20 GB disk
+     *  - dev: 1/16 vCPU, 256 MiB memory, and 2 GB disk (deprecated, use "lite" instead)
+     *  - standard: 1 vCPU, 4 GiB memory, and 4 GB disk (deprecated, use "standard-1" instead)
+     *
+     * Customers on an enterprise plan have the additional option to set custom limits.
+     *
+     * @optional
+     * @default "dev"
+     */
+    instance_type?: "dev" | "basic" | "standard" | "lite" | "standard-1" | "standard-2" | "standard-3" | "standard-4" | {
+        /** @defaults to 0.0625 (1/16 vCPU) */
+        vcpu?: number;
+        /** @defaults to 256 MiB */
+        memory_mib?: number;
+        /** @defaults to 2 GB */
+        disk_mb?: number;
+    };
+    ssh?: {
+        /**
+         * If enabled, those with write access to a container will be able to SSH into it through Wrangler.
+         * @default false
+         */
+        enabled: boolean;
+        /**
+         * Port that the SSH service is running on
+         * @defaults to 22
+         */
+        port?: number;
+    };
+    /**
+     * @deprecated Use `ssh` instead.
+     * @hidden
+     */
+    wrangler_ssh?: {
+        enabled: boolean;
+        port?: number;
+    };
+    /**
+     * SSH public keys to put in the container's authorized_keys file.
+     */
+    authorized_keys?: {
+        name: string;
+        public_key: string;
+    }[];
+    /**
+     * Trusted user CA keys to put in the container's trusted_user_ca_keys file.
+     */
+    trusted_user_ca_keys?: {
+        name?: string;
+        public_key: string;
+    }[];
+    /**
+     * @deprecated Use top level `containers` fields instead.
+     * `configuration.image` should be `image`
+     * limits should be set via `instance_type`
+     * @hidden
+     */
+    configuration?: {
+        image?: string;
+        labels?: {
+            name: string;
+            value: string;
+        }[];
+        secrets?: {
+            name: string;
+            type: "env";
+            secret: string;
+        }[];
+        disk?: {
+            size_mb: number;
+        };
+        vcpu?: number;
+        memory_mib?: number;
+    };
+    /**
+     * Scheduling constraints for container placement.
+     */
+    constraints?: {
+        /**
+         * Limit container placement to specific geographic regions.
+         */
+        regions?: ("ENAM" | "WNAM" | "EEUR" | "WEUR" | "APAC" | "SAM" | "ME" | "OC" | "AFR")[];
+        /**
+         * Restrict containers to compliance boundaries.
+         */
+        jurisdiction?: "eu" | "fedramp";
+        /**
+         * @hidden
+         */
+        cities?: string[];
+        /**
+         * @deprecated Use `tiers` instead
+         * @hidden
+         */
+        tier?: number;
+        /**
+         * @hidden
+         */
+        tiers?: number[];
+    };
+    /**
+     * Scheduling affinities
+     * @hidden
+     */
+    affinities?: {
+        colocation?: "datacenter";
+        hardware_generation?: "highest-overall-performance";
+    };
+    /**
+     * @deprecated use the `class_name` field instead.
+     * @hidden
+     */
+    durable_objects?: {
+        namespace_id: string;
+    };
+    /**
+     * Configures what percentage of instances should be updated at each step of a rollout.
+     * You can specify this as a single number, or an array of numbers.
+     *
+     * If this is a single number, each step will progress by that percentage.
+     * The options are 5, 10, 20, 25, 50 or 100.
+     *
+     * If this is an array, each step specifies the cumulative rollout progress.
+     * The final step must be 100.
+     *
+     * This can be overridden adhoc by deploying with the `--containers-rollout=immediate` flag,
+     * which will roll out to 100% of instances in one step.
+     *
+     * @optional
+     * @default [10,100]
+     * */
+    rollout_step_percentage?: number | number[];
+    /**
+     * How a rollout should be created. It supports the following modes:
+     *  - full_auto: The container application will be rolled out fully automatically.
+     *  - none: The container application won't have a roll out or update.
+     *  - manual: The container application will be rollout fully by manually actioning progress steps.
+     * @optional
+     * @default "full_auto"
+     * @hidden
+     */
+    rollout_kind?: "full_auto" | "none" | "full_manual";
+    /**
+     * Configures the grace period (in seconds) for active instances before being shutdown during a rollout.
+     * @optional
+     * @default 0
+     */
+    rollout_active_grace_period?: number;
+    /**
+     * Directly passed to the API without wrangler-side validation or transformation.
+     * @hidden
+     */
+    unsafe?: Record<string, unknown>;
+};
+/**
+ * Configuration in wrangler for Durable Object Migrations
+ */
+type DurableObjectMigration = {
+    /** A unique identifier for this migration. */
+    tag: string;
+    /** The new Durable Objects being defined. */
+    new_classes?: string[];
+    /** The new SQLite Durable Objects being defined. */
+    new_sqlite_classes?: string[];
+    /** The Durable Objects being renamed. */
+    renamed_classes?: {
+        from: string;
+        to: string;
+    }[];
+    /** The Durable Objects being removed. */
+    deleted_classes?: string[];
+};
+/**
+ * Storage backend for a declarative Durable Object export. See
+ * {@link DurableObjectExport}.
+ */
+type DurableObjectExportStorage = "sqlite" | "legacy-kv";
+/**
+ * A single declarative Durable Object export entry in the `exports` config
+ * map. `type` is reserved for the export kind. `state` carries the Durable
+ * Object lifecycle and defaults to `"created"` (live) when omitted.
+ *
+ * Mutually exclusive with {@link DurableObjectMigration} at the config-
+ * validation boundary.
+ *
+ *  - `created` (default, live): `storage` is required.
+ *  - `deleted` (tombstone): retire a provisioned namespace whose class has
+ *    been removed from code.
+ *  - `renamed` (tombstone): rewrite a provisioned namespace's class name to
+ *    `renamed_to`. The target name must also appear as a live (state
+ *    `"created"`) `durable-object` entry in the same map.
+ *  - `transferred` (tombstone): hand ownership of the namespace to another
+ *    script in the same account (`transferred_to`). Two-phase commit;
+ *    the target must first deploy an `expecting-transfer` entry naming this
+ *    script via `transfer_from`.
+ *  - `expecting-transfer` (live): receiving side of a two-phase transfer;
+ *    `storage` and `transfer_from` are both required.
+ *
+ * The live states may additionally attach a container via `container`, which
+ * names an entry in the top-level `containers` array. Tombstones cannot.
+ */
+type DurableObjectExport = {
+    type: "durable-object";
+    state?: "created";
+    storage: DurableObjectExportStorage;
+    /**
+     * Attach a container to this Durable Object. Must match the `name` of an
+     * entry in the top-level `containers` array, and requires
+     * `storage: "sqlite"`.
+     *
+     * @optional
+     */
+    container?: string;
+} | {
+    type: "durable-object";
+    state: "deleted";
+} | {
+    type: "durable-object";
+    state: "renamed";
+    renamed_to: string;
+} | {
+    type: "durable-object";
+    state: "transferred";
+    transferred_to: string;
+} | {
+    type: "durable-object";
+    state: "expecting-transfer";
+    storage: DurableObjectExportStorage;
+    transfer_from: string;
+    /**
+     * Attach a container to this Durable Object. Must match the `name` of an
+     * entry in the top-level `containers` array, and requires
+     * `storage: "sqlite"`.
+     *
+     * @optional
+     */
+    container?: string;
+};
+interface WorkerEntrypointExport {
+    type: "worker";
+    cache?: {
+        /** Whether cache is enabled for this entrypoint. */
+        enabled: boolean;
+    };
+}
+type ConfiguredExport = DurableObjectExport | WorkerEntrypointExport;
+/**
+ * The declarative `exports` map keyed by export name. Durable Object exports
+ * are mutually exclusive with `migrations` at the wrangler config layer.
+ */
+type Exports = Record<string, ConfiguredExport>;
+/**
+ * The `EnvironmentInheritable` interface declares all the configuration fields for an environment
+ * that can be inherited (and overridden) from the top-level environment.
+ */
+interface EnvironmentInheritable {
+    /**
+     * The name of your Worker. Alphanumeric + dashes only.
+     *
+     * @inheritable
+     */
+    name: string | undefined;
+    /**
+     * This is the ID of the account associated with your zone.
+     * You might have more than one account, so make sure to use
+     * the ID of the account associated with the zone/route you
+     * provide, if you provide one. It can also be specified through
+     * the CLOUDFLARE_ACCOUNT_ID environment variable.
+     *
+     * @inheritable
+     */
+    account_id: string | undefined;
+    /**
+     * A date in the form yyyy-mm-dd, which will be used to determine
+     * which version of the Workers runtime is used.
+     *
+     * More details at https://developers.cloudflare.com/workers/configuration/compatibility-dates
+     *
+     * @inheritable
+     */
+    compatibility_date: string | undefined;
+    /**
+     * A list of flags that enable features from upcoming features of
+     * the Workers runtime, usually used together with compatibility_date.
+     *
+     * More details at https://developers.cloudflare.com/workers/configuration/compatibility-flags/
+     *
+     * @default []
+     * @inheritable
+     */
+    compatibility_flags: string[];
+    /**
+     * The entrypoint/path to the JavaScript file that will be executed.
+     *
+     * @inheritable
+     */
+    main: string | undefined;
+    /**
+     * If true then Wrangler will traverse the file tree below `base_dir`;
+     * Any files that match `rules` will be included in the deployed Worker.
+     * Defaults to true if `no_bundle` is true, otherwise false.
+     *
+     * @inheritable
+     */
+    find_additional_modules: boolean | undefined;
+    /**
+     * Determines whether Wrangler will preserve bundled file names.
+     * Defaults to false.
+     * If left unset, files will be named using the pattern ${fileHash}-${basename},
+     * for example, `34de60b44167af5c5a709e62a4e20c4f18c9e3b6-favicon.ico`.
+     *
+     * @inheritable
+     */
+    preserve_file_names: boolean | undefined;
+    /**
+     * The directory in which module rules should be evaluated when including additional files into a Worker deployment.
+     * This defaults to the directory containing the `main` entry point of the Worker if not specified.
+     *
+     * @inheritable
+     */
+    base_dir: string | undefined;
+    /**
+     * Whether we use <name>.<subdomain>.workers.dev to
+     * test and deploy your Worker.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#workersdev
+     *
+     * @default true
+     * @breaking
+     * @inheritable
+     */
+    workers_dev: boolean | undefined;
+    /**
+     * Whether we use <version>-<name>.<subdomain>.workers.dev to
+     * serve Preview URLs for your Worker.
+     *
+     * @default false
+     * @inheritable
+     */
+    preview_urls: boolean | undefined;
+    /**
+     * A list of routes that your Worker should be published to.
+     * Only one of `routes` or `route` is required.
+     *
+     * Only required when workers_dev is false, and there's no scheduled Worker (see `triggers`)
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#types-of-routes
+     *
+     * @inheritable
+     */
+    routes: Route[] | undefined;
+    /**
+     * A route that your Worker should be published to. Literally
+     * the same as routes, but only one.
+     * Only one of `routes` or `route` is required.
+     *
+     * Only required when workers_dev is false, and there's no scheduled Worker
+     *
+     * @inheritable
+     */
+    route: Route | undefined;
+    /**
+     * Path to a custom tsconfig
+     *
+     * @inheritable
+     */
+    tsconfig: string | undefined;
+    /**
+     * The function to use to replace jsx syntax.
+     *
+     * @default "React.createElement"
+     * @inheritable
+     */
+    jsx_factory: string;
+    /**
+     * The function to use to replace jsx fragment syntax.
+     *
+     * @default "React.Fragment"
+     * @inheritable
+     */
+    jsx_fragment: string;
+    /**
+     * A list of migrations that should be uploaded with your Worker.
+     *
+     * These define changes in your Durable Object declarations.
+     *
+     * More details at https://developers.cloudflare.com/workers/learning/using-durable-objects#configuring-durable-object-classes-with-migrations
+     *
+     * @default []
+     * @inheritable
+     */
+    migrations: DurableObjectMigration[];
+    /**
+     * Declarative exports configuration — a map of class name to export configuration.
+     *
+     * The configuration of Durable Objects via `exports` is mutually exclusive with `migrations`.
+     *
+     * @default {}
+     * @inheritable
+     */
+    exports: Exports;
+    /**
+     * Definitions that trigger a Worker from a schedule or a Cloudflare event.
+     *
+     * More details about cron triggers: https://developers.cloudflare.com/workers/platform/cron-triggers
+     *
+     * More details about Artifacts events: https://developers.cloudflare.com/artifacts/guides/event-subscriptions/
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#triggers
+     *
+     * @default {crons:[]}
+     * @inheritable
+     */
+    triggers: {
+        crons?: string[];
+        events?: ArtifactsEventTrigger[];
+    };
+    /**
+     * Specify limits for runtime behavior.
+     * Only supported for the "standard" Usage Model
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#limits
+     *
+     * @inheritable
+     */
+    limits: UserLimits | undefined;
+    /**
+     * An ordered list of rules that define which modules to import,
+     * and what type to import them as. You will need to specify rules
+     * to use Text, Data, and CompiledWasm modules, or when you wish to
+     * have a .js file be treated as an ESModule instead of CommonJS.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#bundling
+     *
+     * @inheritable
+     */
+    rules: Rule[];
+    /**
+     * Configures a custom build step to be run by Wrangler when building your Worker.
+     *
+     * Refer to the [custom builds documentation](https://developers.cloudflare.com/workers/cli-wrangler/configuration#build)
+     * for more details.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#custom-builds
+     *
+     * @default {watch_dir:"./src"}
+     */
+    build: {
+        /** The command used to build your Worker. On Linux and macOS, the command is executed in the `sh` shell and the `cmd` shell for Windows. The `&&` and `||` shell operators may be used. */
+        command?: string;
+        /** The directory in which the command is executed. */
+        cwd?: string;
+        /** The directory to watch for changes while using wrangler dev, defaults to the current working directory */
+        watch_dir?: string | string[];
+    };
+    /**
+     * Skip internal build steps and directly deploy script
+     * @inheritable
+     */
+    no_bundle: boolean | undefined;
+    /**
+     * Minify the script before uploading.
+     * @inheritable
+     */
+    minify: boolean | undefined;
+    /**
+     * Set the `name` property to the original name for functions and classes renamed during minification.
+     *
+     * See https://esbuild.github.io/api/#keep-names
+     *
+     * @default true
+     * @inheritable
+     */
+    keep_names: boolean | undefined;
+    /**
+     * Designates this Worker as an internal-only "first-party" Worker.
+     *
+     * @inheritable
+     */
+    first_party_worker: boolean | undefined;
+    /**
+     * List of bindings that you will send to logfwdr
+     *
+     * @default {bindings:[]}
+     * @inheritable
+     */
+    logfwdr: {
+        bindings: {
+            /** The binding name used to refer to logfwdr */
+            name: string;
+            /** The destination for this logged message */
+            destination: string;
+        }[];
+    };
+    /**
+     * Send Trace Events from this Worker to Workers Logpush.
+     *
+     * This will not configure a corresponding Logpush job automatically.
+     *
+     * For more information about Workers Logpush, see:
+     * https://blog.cloudflare.com/logpush-for-workers/
+     *
+     * @inheritable
+     */
+    logpush: boolean | undefined;
+    /**
+     * Include source maps when uploading this worker.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#source-maps
+     *
+     * @inheritable
+     */
+    upload_source_maps: boolean | undefined;
+    /**
+     * Specify how the Worker should be located to minimize round-trip time.
+     *
+     * More details: https://developers.cloudflare.com/workers/platform/smart-placement/
+     *
+     * @inheritable
+     */
+    placement: {
+        mode: "off" | "smart";
+        hint?: string;
+    } | {
+        mode?: "targeted";
+        region: string;
+    } | {
+        mode?: "targeted";
+        host: string;
+    } | {
+        mode?: "targeted";
+        hostname: string;
+    } | undefined;
+    /**
+     * Specify the directory of static assets to deploy/serve
+     *
+     * More details at https://developers.cloudflare.com/workers/frameworks/
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#assets
+     *
+     * @inheritable
+     */
+    assets: Assets | undefined;
+    /**
+     * Specify the observability behavior of the Worker.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#observability
+     *
+     * @inheritable
+     */
+    observability: Observability | undefined;
+    /**
+     * Specify the Cloudflare Access authentication behavior of the Worker.
+     *
+     * @inheritable
+     */
+    access: Access | undefined;
+    /**
+     * Specify the cache behavior of the Worker.
+     *
+     * @inheritable
+     */
+    cache: CacheOptions | undefined;
+    /**
+     * Specify the compliance region mode of the Worker.
+     *
+     * Although if the user does not specify a compliance region, the default is `public`,
+     * it can be set to `undefined` in configuration to delegate to the CLOUDFLARE_COMPLIANCE_REGION environment variable.
+     */
+    compliance_region: "public" | "fedramp_high" | undefined;
+    /**
+     * Configuration for Python modules.
+     *
+     * @inheritable
+     */
+    python_modules: {
+        /**
+         * A list of glob patterns to exclude files from the python_modules directory when bundling.
+         *
+         * Patterns are relative to the python_modules directory and use glob syntax.
+         *
+         * @default ["**\*.pyc"]
+         */
+        exclude: string[];
+    };
+    /**
+     * Configuration for Worker Previews.
+     *
+     * Previews are branches of your Worker's main instance used to test features
+     * in development outside of production. This block defines the settings
+     * used when creating Preview deployments via `wrangler preview`.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#previews
+     *
+     * @inheritable
+     */
+    previews: PreviewsConfig | undefined;
+}
+type DurableObjectBindings = {
+    /** The name of the binding used to refer to the Durable Object */
+    name: string;
+    /** The exported class name of the Durable Object */
+    class_name: string;
+    /** The script where the Durable Object is defined (if it's external to this Worker) */
+    script_name?: string;
+    /** The service environment of the script_name to bind to */
+    environment?: string;
+}[];
+declare const ARTIFACTS_EVENT_TYPES: readonly ["cf.artifacts.repo.created", "cf.artifacts.repo.deleted", "cf.artifacts.repo.forked", "cf.artifacts.repo.imported", "cf.artifacts.repo.pushed", "cf.artifacts.repo.cloned", "cf.artifacts.repo.fetched", "cf.artifacts.repo.token.created", "cf.artifacts.repo.token.revoked"];
+type ArtifactsEventType = (typeof ARTIFACTS_EVENT_TYPES)[number];
+type ArtifactsEventTrigger = {
+    type: ArtifactsEventType;
+    filter?: {
+        namespace?: string;
+        repo_name?: string;
+    };
+    targets: {
+        type: "workflow";
+        workflow_name: string;
+    }[];
+};
+type WorkflowBinding = {
+    /** The name of the binding used to refer to the Workflow */
+    binding: string;
+    /** The name of the Workflow */
+    name: string;
+    /** The exported class name of the Workflow */
+    class_name: string;
+    /** The script where the Workflow is defined (if it's external to this Worker) */
+    script_name?: string;
+    /** Optional limits for the Workflow */
+    limits?: {
+        /** Maximum number of steps a Workflow instance can execute */
+        steps?: number;
+    };
+    /** Optional concurrency configuration for the Workflow */
+    concurrency?: {
+        /** Maximum number of Workflow instances that can run concurrently */
+        limit?: number;
+    };
+    /** Optional cron schedule(s) for automatically triggering workflow instances */
+    schedules?: string | string[];
+    /**
+     * Optional default retention for instances of this Workflow, applied when an instance does not
+     * set its own retention. Accepts milliseconds or a duration string such as `"3 days"`, and is
+     * validated by the Workflows API at deploy time.
+     */
+    default_retention?: {
+        /** How long to retain instances that completed successfully or were terminated */
+        success_retention?: number | string;
+        /** How long to retain errored instances */
+        error_retention?: number | string;
+    };
+};
+/**
+ * The `EnvironmentNonInheritable` interface declares all the configuration fields for an environment
+ * that cannot be inherited from the top-level environment, and must be defined specifically.
+ *
+ * If any of these fields are defined at the top-level then they should also be specifically defined
+ * for each named environment.
+ */
+interface EnvironmentNonInheritable {
+    /**
+     * A map of values to substitute when deploying your Worker.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    define: Record<string, string>;
+    /**
+     * A map of environment variables to set when deploying your Worker.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#environment-variables
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    vars: Record<string, string | Json>;
+    /**
+     * Secrets configuration.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#secrets-configuration-property
+     *
+     * @nonInheritable
+     */
+    secrets?: {
+        /**
+         * List of secret names that are required by your Worker.
+         * When defined, this property:
+         * - Replaces .dev.vars/.env/process.env inference for type generation
+         * - Enables local dev validation with warnings for missing secrets
+         */
+        required?: string[];
+    };
+    /**
+     * A list of durable objects that your Worker should be bound to.
+     *
+     * For more information about Durable Objects, see the documentation at
+     * https://developers.cloudflare.com/workers/learning/using-durable-objects
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#durable-objects
+     *
+     * @default {bindings:[]}
+     * @nonInheritable
+     */
+    durable_objects: {
+        bindings: DurableObjectBindings;
+    };
+    /**
+     * A list of workflows that your Worker should be bound to.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    workflows: WorkflowBinding[];
+    /**
+     * Cloudchamber configuration
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    cloudchamber: CloudchamberConfig;
+    /**
+     * Container related configuration
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    containers?: ContainerApp[];
+    /**
+     * These specify any Workers KV Namespaces you want to
+     * access from inside your Worker.
+     *
+     * To learn more about KV Namespaces,
+     * see the documentation at https://developers.cloudflare.com/workers/learning/how-kv-works
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#kv-namespaces
+     *
+     * @default []
+     * @nonInheritable
+     */
+    kv_namespaces: {
+        /** The binding name used to refer to the KV Namespace */
+        binding: string;
+        /** The ID of the KV namespace */
+        id?: string;
+        /** The ID of the KV namespace used during `wrangler dev` */
+        preview_id?: string;
+        /** Whether the KV namespace should be remote or not in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * These specify bindings to send email from inside your Worker.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#email-bindings
+     *
+     * @default []
+     * @nonInheritable
+     */
+    send_email: {
+        /** The binding name used to refer to the this binding */
+        name: string;
+        /** If this binding should be restricted to a specific verified address */
+        destination_address?: string;
+        /** If this binding should be restricted to a set of verified addresses */
+        allowed_destination_addresses?: string[];
+        /** If this binding should be restricted to a set of sender addresses */
+        allowed_sender_addresses?: string[];
+        /** Whether the binding should be remote or not in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies Queues that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#queues
+     *
+     * @default {consumers:[],producers:[]}
+     * @nonInheritable
+     */
+    queues: {
+        /** Producer bindings */
+        producers?: {
+            /** The binding name used to refer to the Queue in the Worker. */
+            binding: string;
+            /** The name of this Queue. */
+            queue?: string;
+            /** The number of seconds to wait before delivering a message */
+            delivery_delay?: number;
+            /** Whether the Queue producer should be remote or not in local development */
+            remote?: boolean;
+        }[];
+        /** Consumer configuration */
+        consumers?: {
+            /** The name of the queue from which this consumer should consume. */
+            queue: string;
+            /** The consumer type. Only "worker" is supported in wrangler config. Default is "worker". */
+            type?: "worker";
+            /** The maximum number of messages per batch */
+            max_batch_size?: number;
+            /** The maximum number of seconds to wait to fill a batch with messages. */
+            max_batch_timeout?: number;
+            /** The maximum number of retries for each message. */
+            max_retries?: number;
+            /** The queue to send messages that failed to be consumed. */
+            dead_letter_queue?: string;
+            /** The maximum number of concurrent consumer Worker invocations. Leaving this unset will allow your consumer to scale to the maximum concurrency needed to keep up with the message backlog. */
+            max_concurrency?: number | null;
+            /** The number of milliseconds to wait for pulled messages to become visible again */
+            visibility_timeout_ms?: number;
+            /** The number of seconds to wait before retrying a message */
+            retry_delay?: number;
+        }[];
+    };
+    /**
+     * Specifies raw sockets that this Worker should listen on.
+     * Each entry opens a listening socket on the
+     * given port that delivers incoming connections directly to the Worker's
+     * `connect(socket, env, ctx)` handler.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    connect: {
+        /** The transport protocol to listen for. */
+        protocol: "tcp";
+        /** The port to listen on. */
+        port: number;
+        /** The address to bind to. Defaults to `127.0.0.1`. */
+        address?: string;
+    }[];
+    /**
+     * Specifies R2 buckets that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#r2-buckets
+     *
+     * @default []
+     * @nonInheritable
+     */
+    r2_buckets: {
+        /** The binding name used to refer to the R2 bucket in the Worker. */
+        binding: string;
+        /** The name of this R2 bucket at the edge. */
+        bucket_name?: string;
+        /** The preview name of this R2 bucket at the edge. */
+        preview_bucket_name?: string;
+        /** The jurisdiction that the bucket exists in. Default if not present. */
+        jurisdiction?: string;
+        /** Whether the R2 bucket should be remote or not in local development */
+        remote?: boolean;
+        /** Settings that only apply to local development */
+        local_dev?: {
+            /**
+             * EXPERIMENTAL: AWS SigV4 credentials for the local S3-compatible
+             * endpoint. When set, the bucket is served at
+             * `/cdn-cgi/local/r2/s3/<bucket-name>` during local development.
+             * Ignored when the bucket runs remotely.
+             */
+            experimental_s3_credentials?: LocalS3Credentials;
+        };
+    }[];
+    /**
+     * Specifies D1 databases that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#d1-databases
+     *
+     * @default []
+     * @nonInheritable
+     */
+    d1_databases: {
+        /** The binding name used to refer to the D1 database in the Worker. */
+        binding: string;
+        /** The name of this D1 database. */
+        database_name?: string;
+        /** The UUID of this D1 database (not required). */
+        database_id?: string;
+        /** The UUID of this D1 database for Wrangler Dev (if specified). */
+        preview_database_id?: string;
+        /** The name of the migrations table for this D1 database (defaults to 'd1_migrations'). */
+        migrations_table?: string;
+        /** The path to the directory of migrations for this D1 database (defaults to './migrations'). */
+        migrations_dir?: string;
+        /**
+         * A glob pattern (relative to the Wrangler config file) used to discover
+         * migration files for this D1 database. Defaults to `${migrations_dir}/*.sql`
+         * if not specified.
+         *
+         * Use this to opt in to nested layouts such as `migrations/*\/migration.sql`
+         * (as produced by some ORMs).
+         *
+         * When `migrations_pattern` is set, `migrations_dir` must also be set, and
+         * `migrations_pattern` must start with `${migrations_dir}/`. This keeps the
+         * relationship between the two settings explicit and lets Wrangler record
+         * each migration's name in the migrations table as a path relative to
+         * `migrations_dir`.
+         */
+        migrations_pattern?: string;
+        /** Internal use only. */
+        database_internal_env?: string;
+        /** Whether the D1 database should be remote or not in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies Vectorize indexes that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#vectorize-indexes
+     *
+     * @default []
+     * @nonInheritable
+     */
+    vectorize: {
+        /** The binding name used to refer to the Vectorize index in the Worker. */
+        binding: string;
+        /** The name of the index. */
+        index_name: string;
+        /** Whether the Vectorize index should be remote or not in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies AI Search namespace bindings that are bound to this Worker environment.
+     * Each binding is scoped to a namespace and allows dynamic instance CRUD within it.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    ai_search_namespaces: {
+        /** The binding name used to refer to the AI Search namespace in the Worker. */
+        binding: string;
+        /** The user-chosen namespace name. Must exist in Cloudflare at deploy time. */
+        namespace: string;
+        /** Whether the AI Search namespace binding should be remote in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies AI Search instance bindings that are bound to this Worker environment.
+     * Each binding is bound directly to a single pre-existing instance within the "default" namespace.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    ai_search: {
+        /** The binding name used to refer to the AI Search instance in the Worker. */
+        binding: string;
+        /** The user-chosen instance name. Must exist in Cloudflare at deploy time. */
+        instance_name: string;
+        /** Whether the AI Search instance binding should be remote in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies Agent Memory namespace bindings that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    agent_memory: {
+        /** The binding name used to refer to the Agent Memory namespace in the Worker. */
+        binding: string;
+        /** The user-chosen namespace name. Must exist in Cloudflare at deploy time. */
+        namespace: string;
+        /** Whether the Agent Memory binding should be remote in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Cloudflare Web Search binding. There is exactly one shared web corpus, so the
+     * binding is zero-config -- only the variable name is required, declared as a
+     * single object (not an array).
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    websearch: {
+        /** The binding name used to refer to Web Search in the Worker. */
+        binding: string;
+        /** Whether the Web Search binding should be remote or not in local development */
+        remote?: boolean;
+    } | undefined;
+    /**
+     * Specifies Hyperdrive configs that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#hyperdrive
+     *
+     * @default []
+     * @nonInheritable
+     */
+    hyperdrive: {
+        /** The binding name used to refer to the project in the Worker. */
+        binding: string;
+        /** The id of the database. */
+        id: string;
+        /** The local database connection string for `wrangler dev` */
+        localConnectionString?: string;
+    }[];
+    /**
+     * Specifies service bindings (Worker-to-Worker) that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#service-bindings
+     *
+     * @default []
+     * @nonInheritable
+     */
+    services: {
+        /** The binding name used to refer to the bound service. */
+        binding: string;
+        /**
+         * The name of the service.
+         * To bind to a worker in a specific environment,
+         * you should use the format `<worker_name>-<environment_name>`.
+         */
+        service: string;
+        /**
+         * @hidden
+         * @deprecated you should use `service: <worker_name>-<environment_name>` instead.
+         * This refers to the deprecated concept of 'service environments'.
+         * The environment of the service (e.g. production, staging, etc).
+         */
+        environment?: string;
+        /** Optionally, the entrypoint (named export) of the service to bind to. */
+        entrypoint?: string;
+        /** Optional properties that will be made available to the service via ctx.props. */
+        props?: Record<string, unknown>;
+        /** Whether the service binding should be remote or not in local development */
+        remote?: boolean;
+    }[] | undefined;
+    /**
+     * Specifies analytics engine datasets that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#analytics-engine-datasets
+     *
+     * @default []
+     * @nonInheritable
+     */
+    analytics_engine_datasets: {
+        /** The binding name used to refer to the dataset in the Worker. */
+        binding: string;
+        /** The name of this dataset to write to. */
+        dataset?: string;
+    }[];
+    /**
+     * A browser that will be usable from the Worker.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#browser-rendering
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    browser: {
+        binding: string;
+        /** Whether the Browser binding should be remote or not in local development */
+        remote?: boolean;
+    } | undefined;
+    /**
+     * Binding to the AI project.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#workers-ai
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    ai: {
+        binding: string;
+        staging?: boolean;
+        /** Whether the AI binding should be remote or not in local development */
+        remote?: boolean;
+    } | undefined;
+    /**
+     * Binding to Cloudflare Images
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#images
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    images: {
+        binding: string;
+        /** Whether the Images binding should be remote or not in local development */
+        remote?: boolean;
+    } | undefined;
+    /**
+     * Binding to Cloudflare Media Transformations
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    media: {
+        binding: string;
+        /** Whether the Media binding should be remote or not */
+        remote?: boolean;
+    } | undefined;
+    /**
+     * Binding to Cloudflare Stream
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    stream: {
+        binding: string;
+        /** Whether the Stream binding should be remote or not in local development */
+        remote?: boolean;
+    } | undefined;
+    /**
+     * Binding to the Worker Version's metadata
+     */
+    version_metadata: {
+        binding: string;
+    } | undefined;
+    /**
+     * "Unsafe" tables for features that aren't directly supported by wrangler.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default {}
+     * @nonInheritable
+     */
+    unsafe: {
+        /**
+         * A set of bindings that should be put into a Worker's upload metadata without changes. These
+         * can be used to implement bindings for features that haven't released and aren't supported
+         * directly by wrangler or miniflare.
+         */
+        bindings?: UnsafeBinding[];
+        /**
+         * Arbitrary key/value pairs that will be included in the uploaded metadata.  Values specified
+         * here will always be applied to metadata last, so can add new or override existing fields.
+         */
+        metadata?: {
+            [key: string]: unknown;
+        };
+        /**
+         * Used for internal capnp uploads for the Workers runtime
+         */
+        capnp?: {
+            base_path: string;
+            source_schemas: string[];
+            compiled_schema?: never;
+        } | {
+            base_path?: never;
+            source_schemas?: never;
+            compiled_schema: string;
+        };
+    };
+    /**
+     * Specifies a list of mTLS certificates that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#mtls-certificates
+     *
+     * @default []
+     * @nonInheritable
+     */
+    mtls_certificates: {
+        /** The binding name used to refer to the certificate in the Worker */
+        binding: string;
+        /** The uuid of the uploaded mTLS certificate */
+        certificate_id: string;
+        /** Whether the mtls fetcher should be remote or not in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies a list of Tail Workers that are bound to this Worker environment
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    tail_consumers?: TailConsumer[];
+    /**
+     * Specifies a list of Streaming Tail Workers that are bound to this Worker environment
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    streaming_tail_consumers?: StreamingTailConsumer[];
+    /**
+     * Specifies namespace bindings that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#dispatch-namespace-bindings-workers-for-platforms
+     *
+     * @default []
+     * @nonInheritable
+     */
+    dispatch_namespaces: {
+        /** The binding name used to refer to the bound service. */
+        binding: string;
+        /** The namespace to bind to. */
+        namespace?: string;
+        /** Details about the outbound Worker which will handle outbound requests from your namespace */
+        outbound?: DispatchNamespaceOutbound;
+        /** Whether the Dispatch Namespace should be remote or not in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies list of Pipelines bound to this Worker environment
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    pipelines: {
+        /** The binding name used to refer to the bound service. */
+        binding: string;
+        /** Id of the Stream to bind */
+        stream?: string;
+        /**
+         * Id of the Stream to bind
+         * @deprecated Use `stream` instead.
+         */
+        pipeline?: string;
+        /** Whether the pipeline should be remote or not in local development */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies Secret Store bindings that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    secrets_store_secrets: {
+        /** The binding name used to refer to the bound service. */
+        binding: string;
+        /** Id of the secret store */
+        store_id: string;
+        /** Name of the secret */
+        secret_name: string;
+    }[];
+    /**
+     * Specifies Artifacts bindings that are bound to this Worker environment.
+     * Artifacts provides git-compatible file storage on Cloudflare Workers.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    artifacts: {
+        /** The binding name used to refer to the Artifacts instance. */
+        binding: string;
+        /** The namespace to use. */
+        namespace: string;
+        /** Whether to use the remote Artifacts service in local dev. */
+        remote?: boolean;
+    }[];
+    /**
+     * **DO NOT USE**. Hello World Binding Config to serve as an explanatory example.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    unsafe_hello_world: {
+        /** The binding name used to refer to the bound service. */
+        binding: string;
+        /** Whether the timer is enabled */
+        enable_timer?: boolean;
+    }[];
+    /**
+     * Specifies Flagship feature flag bindings that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    flagship: {
+        /** The binding name used to refer to the bound Flagship service. */
+        binding: string;
+        /** The Flagship app ID to bind to. */
+        app_id?: string;
+        /** Set to `true` to suppress the remote binding warning in local dev. Flagship bindings are always remote. */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies rate limit bindings that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    ratelimits: {
+        /** The binding name used to refer to the rate limiter in the Worker. */
+        name: string;
+        /** The namespace ID for this rate limiter. */
+        namespace_id: string;
+        /** Simple rate limiting configuration. */
+        simple: {
+            /** The maximum number of requests allowed in the time period. */
+            limit: number;
+            /** The time period in seconds (10 for ten seconds, 60 for one minute). */
+            period: 10 | 60;
+        };
+    }[];
+    /**
+     * Specifies Worker Loader bindings that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    worker_loaders: {
+        /** The binding name used to refer to the Worker Loader in the Worker. */
+        binding: string;
+    }[];
+    /**
+     * Specifies VPC services that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    vpc_services: {
+        /** The binding name used to refer to the VPC service in the Worker. */
+        binding: string;
+        /** The service ID of the VPC connectivity service. */
+        service_id: string;
+        /** Whether the VPC service is remote or not */
+        remote?: boolean;
+    }[];
+    /**
+     * Specifies VPC networks that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default []
+     * @nonInheritable
+     */
+    vpc_networks: ({
+        /** The binding name used to refer to the VPC network in the Worker. */
+        binding: string;
+        /** The tunnel ID of the Cloudflare Tunnel to route traffic through. Mutually exclusive with network_id. */
+        tunnel_id: string;
+        /** Whether the VPC network is remote or not */
+        remote?: boolean;
+    } | {
+        /** The binding name used to refer to the VPC network in the Worker. */
+        binding: string;
+        /** The network ID to route traffic through. Mutually exclusive with tunnel_id. */
+        network_id: string;
+        /** Whether the VPC network is remote or not */
+        remote?: boolean;
+    })[];
+}
+/**
+ * The raw environment configuration that we read from the config file.
+ *
+ * All the properties are optional, and will be replaced with defaults in the configuration that
+ * is used in the rest of the codebase.
+ */
+type RawEnvironment = Partial<Environment>;
+/**
+ * A bundling resolver rule, defining the modules type for paths that match the specified globs.
+ */
+type Rule = {
+    type: ConfigModuleRuleType;
+    globs: string[];
+    fallthrough?: boolean;
+};
+/**
+ * The possible types for a `Rule`.
+ */
+type ConfigModuleRuleType = "ESModule" | "CommonJS" | "CompiledWasm" | "Text" | "Data" | "PythonModule" | "PythonRequirement";
+type TailConsumer = {
+    /** The name of the service tail events will be forwarded to. */
+    service: string;
+    /** (Optional) The environment of the service. */
+    environment?: string;
+};
+type StreamingTailConsumer = {
+    /** The name of the service streaming tail events will be forwarded to. */
+    service: string;
+};
+interface DispatchNamespaceOutbound {
+    /** Name of the service handling the outbound requests */
+    service: string;
+    /** (Optional) Name of the environment handling the outbound requests. */
+    environment?: string;
+    /** (Optional) List of parameter names, for sending context from your dispatch Worker to the outbound handler */
+    parameters?: string[];
+}
+interface UserLimits {
+    /** Maximum allowed CPU time for a Worker's invocation in milliseconds */
+    cpu_ms?: number;
+    /** Maximum allowed number of fetch requests that a Worker's invocation can execute */
+    subrequests?: number;
+}
+type Assets = {
+    /** Absolute path to assets directory */
+    directory?: string;
+    /** Name of `env` binding property in the User Worker. */
+    binding?: string;
+    /** How to handle HTML requests. */
+    html_handling?: "auto-trailing-slash" | "force-trailing-slash" | "drop-trailing-slash" | "none";
+    /** How to handle requests that do not match an asset. */
+    not_found_handling?: "single-page-application" | "404-page" | "none";
+    /**
+     * Matches will be routed to the User Worker, and matches to negative rules will go to the Asset Worker.
+     *
+     * Can also be `true`, indicating that every request should be routed to the User Worker.
+     */
+    run_worker_first?: string[] | boolean;
+};
+interface Observability {
+    /** If observability is enabled for this Worker */
+    enabled?: boolean;
+    /** The sampling rate */
+    head_sampling_rate?: number;
+    /**
+     * Whether query strings are removed from request URLs in logs and traces.
+     *
+     * @default false
+     */
+    redact_query_string?: boolean;
+    logs?: {
+        enabled?: boolean;
+        /** The sampling rate */
+        head_sampling_rate?: number;
+        /** Set to false to disable invocation logs */
+        invocation_logs?: boolean;
+        /**
+         * If logs should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.
+         *
+         * @default true
+         */
+        persist?: boolean;
+        /**
+         * What destinations logs emitted from the Worker should be sent to.
+         *
+         * @default []
+         */
+        destinations?: string[];
+    };
+    traces?: {
+        enabled?: boolean;
+        /** The sampling rate */
+        head_sampling_rate?: number;
+        /**
+         * If traces should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.
+         *
+         * @default true
+         */
+        persist?: boolean;
+        /**
+         * What destinations traces emitted from the Worker should be sent to.
+         *
+         * @default []
+         */
+        destinations?: string[];
+    };
+}
+interface Access {
+    /** Local dev simulation of Cloudflare Access authentication */
+    dev?: {
+        /** The Access application audience tag (aud) */
+        aud: string;
+        /** Mock identity object returned by ctx.access.getIdentity() */
+        identity?: Record<string, unknown>;
+    };
+}
+interface CacheOptions {
+    /** If cache is enabled for this Worker */
+    enabled: boolean;
+    /** Whether cached assets may be reused across Worker versions. */
+    cross_version_cache?: boolean;
+}
+type DockerConfiguration = {
+    /** Socket used by miniflare to communicate with Docker */
+    socketPath: string;
+    /** Docker image name for the container egress interceptor sidecar */
+    containerEgressInterceptorImage?: string;
+};
+type ContainerEngine = {
+    localDocker: DockerConfiguration;
+} | string;
+/**
+ * Configuration for Worker Previews.
+ *
+ * This defines the settings used when creating Preview deployments.
+ * Previews are branches of your Worker's main instance used to test features
+ * during feature development outside of production.
+ *
+ * The `previews` block contains any intentionally divergent configuration intended solely for Previews, including:
+ * - All non-inheritable properties (environment variables and bindings like KV, D1, R2, etc.)
+ * - Select inheritable properties: `logpush`, `observability`, `limits`, `cache`
+ *
+ * @inheritable
+ */
+interface PreviewsConfig extends Partial<EnvironmentNonInheritable>, Partial<Pick<EnvironmentInheritable, "logpush" | "observability" | "limits" | "cache">> {
+}
+
+/**
+ * This is the static type definition for the configuration object.
+ *
+ * It reflects a normalized and validated version of the configuration that you can write in a Wrangler configuration file,
+ * and optionally augment with arguments passed directly to wrangler.
+ *
+ * For more information about the configuration object, see the
+ * documentation at https://developers.cloudflare.com/workers/cli-wrangler/configuration
+ *
+ * Notes:
+ *
+ * - Fields that are only specified in `ConfigFields` and not `Environment` can only appear
+ *   in the top level config and should not appear in any environments.
+ * - Fields that are specified in `PagesConfigFields` are only relevant for Pages projects
+ * - All top level fields in config and environments are optional in the Wrangler configuration file.
+ *
+ * Legend for the annotations:
+ *
+ * - `@breaking`: the deprecation/optionality is a breaking change from Wrangler v1.
+ * - `@todo`: there's more work to be done (with details attached).
+ */
+type Config = ComputedFields & ConfigFields<DevConfig> & PagesConfigFields & Environment;
+type RawConfig = Partial<ConfigFields<RawDevConfig>> & PagesConfigFields & RawEnvironment & EnvironmentMap & {
+    $schema?: string;
+};
+type RedirectedRawConfig = RawConfig & Partial<ComputedFields>;
+interface ComputedFields {
+    /** The path to the Wrangler configuration file (if any, and possibly redirected from the user Wrangler configuration) used to create this configuration. */
+    configPath: string | undefined;
+    /** The path to the user's Wrangler configuration file (if any), which may have been redirected to another file that used to create this configuration. */
+    userConfigPath: string | undefined;
+    /**
+     * The original top level name for the Worker in the raw configuration.
+     *
+     * When a raw configuration has been flattened to a single environment the worker name may have been replaced or transformed.
+     * It can be useful to know what the top-level name was before the flattening.
+     */
+    topLevelName: string | undefined;
+    /** A list of environment names declared in the raw configuration. */
+    definedEnvironments: string[] | undefined;
+    /** The name of the environment being targeted. */
+    targetEnvironment: string | undefined;
+}
+interface ConfigFields<Dev extends RawDevConfig> {
+    /**
+     * Whether Wrangler should send usage metrics to Cloudflare for this project.
+     *
+     * When defined this will override any user settings.
+     * Otherwise, Wrangler will use the user's preference.
+     */
+    send_metrics: boolean | undefined;
+    /**
+     * Configuration for npm package dependency instrumentation.
+     *
+     * Controls whether Wrangler should collect and send npm package dependency
+     * metadata when deploying or uploading a Worker version.
+     *
+     * When `enabled` is set to `false`, Wrangler will not include
+     * `package_dependencies` in the upload payload. Defaults to enabled when
+     * not specified.
+     *
+     * Note: This is considered build metadata, so managed separately from the
+     *       telemetry one and not disabled when
+     *       `send_metrics`/`WRANGLER_SEND_METRICS` is set to `false`
+     */
+    dependencies_instrumentation: {
+        /** Whether dependency instrumentation is enabled. Defaults to `true`. */
+        enabled: boolean;
+        /**
+         * An optional list of package name patterns to exclude from the
+         * collected dependency metadata.
+         *
+         * Each entry can be an exact package name (e.g. `"lodash"`) or a glob
+         * pattern using `*` as a wildcard (e.g. `"@internal/*"` to exclude all
+         * packages under the `@internal` scope).
+         */
+        exclude_packages?: string[];
+    } | undefined;
+    /**
+     * Options to configure the development server that your worker will use.
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#local-development-settings
+     */
+    dev: Dev;
+    /**
+     * The definition of a Worker Site, a feature that lets you upload
+     * static assets with your Worker.
+     *
+     * More details at https://developers.cloudflare.com/workers/platform/sites
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#workers-sites
+     */
+    site: {
+        /**
+         * The directory containing your static assets.
+         *
+         * It must be a path relative to your Wrangler configuration file.
+         * Example: bucket = "./public"
+         *
+         * If there is a `site` field then it must contain this `bucket` field.
+         */
+        bucket: string;
+        /**
+         * The location of your Worker script.
+         *
+         * @deprecated DO NOT use this (it's a holdover from Wrangler v1.x). Either use the top level `main` field, or pass the path to your entry file as a command line argument.
+         * @breaking
+         */
+        "entry-point"?: string;
+        /**
+         * An exclusive list of .gitignore-style patterns that match file
+         * or directory names from your bucket location. Only matched
+         * items will be uploaded. Example: include = ["upload_dir"]
+         *
+         * @optional
+         * @default []
+         */
+        include?: string[];
+        /**
+         * A list of .gitignore-style patterns that match files or
+         * directories in your bucket that should be excluded from
+         * uploads. Example: exclude = ["ignore_dir"]
+         *
+         * @optional
+         * @default []
+         */
+        exclude?: string[];
+    } | undefined;
+    /**
+     * A list of wasm modules that your worker should be bound to. This is
+     * the "legacy" way of binding to a wasm module. ES module workers should
+     * do proper module imports.
+     */
+    wasm_modules: {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * A list of text files that your worker should be bound to. This is
+     * the "legacy" way of binding to a text file. ES module workers should
+     * do proper module imports.
+     */
+    text_blobs: {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * A list of data files that your worker should be bound to. This is
+     * the "legacy" way of binding to a data file. ES module workers should
+     * do proper module imports.
+     */
+    data_blobs: {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * A map of module aliases. Lets you swap out a module for any others.
+     * Corresponds with esbuild's `alias` config
+     *
+     * For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#module-aliasing
+     */
+    alias: {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * By default, the Wrangler configuration file is the source of truth for your environment configuration, like a terraform file.
+     *
+     * If you change your vars in the dashboard, wrangler *will* override/delete them on its next deploy.
+     *
+     * If you want to keep your dashboard vars when wrangler deploys, set this field to true.
+     *
+     * @default false
+     * @nonInheritable
+     */
+    keep_vars?: boolean;
+    /**
+     * The inbound email addresses handled by the Worker being deployed.
+     *
+     * Each entry is a literal recipient address (e.g. `"support@example.com"`)
+     * or a `*@domain` catch-all (e.g. `"*@example.com"`). Every entry creates an
+     * Email Routing rule whose action routes mail to this Worker.
+     *
+     * This field is top-level only and applies to every environment of the
+     * Worker; it cannot be set under `env.*`.
+     *
+     * @nonInheritable
+     */
+    addresses?: string[];
+}
+interface PagesConfigFields {
+    /**
+     * The directory of static assets to serve.
+     *
+     * The presence of this field in a Wrangler configuration file indicates a Pages project,
+     * and will prompt the handling of the configuration file according to the
+     * Pages-specific validation rules.
+     */
+    pages_build_output_dir?: string;
+}
+interface DevConfig {
+    /**
+     * IP address for the local dev server to listen on,
+     *
+     * @default localhost
+     */
+    ip: string;
+    /**
+     * Port for the local dev server to listen on
+     *
+     * @default 8787
+     */
+    port: number | undefined;
+    /**
+     * Port for the local dev server's inspector to listen on
+     *
+     * @default 9229
+     */
+    inspector_port: number | undefined;
+    /**
+     * IP address for the local dev server's inspector to listen on
+     *
+     * @default 127.0.0.1
+     */
+    inspector_ip: string | undefined;
+    /**
+     * Protocol that local wrangler dev server listens to requests on.
+     *
+     * @default http
+     */
+    local_protocol: "http" | "https";
+    /**
+     * Protocol that wrangler dev forwards requests on
+     *
+     * Setting this to `http` is not currently implemented for remote mode.
+     * See https://github.com/cloudflare/workers-sdk/issues/583
+     *
+     * @default https
+     */
+    upstream_protocol: "https" | "http";
+    /**
+     * Host to forward requests to, defaults to the host of the first route of project
+     */
+    host: string | undefined;
+    /**
+     * When developing, whether to build and connect to containers. This requires a Docker daemon to be running.
+     * Defaults to `true`.
+     *
+     * @default true
+     */
+    enable_containers: boolean;
+    /**
+     * Either the Docker unix socket i.e. `unix:///var/run/docker.sock` or a full configuration.
+     * Note that windows is only supported via WSL at the moment
+     */
+    container_engine: ContainerEngine | undefined;
+    /**
+     * Re-generate your worker types when your Wrangler configuration file changes.
+     *
+     * @default false
+     */
+    generate_types: boolean;
+}
+type RawDevConfig = Partial<DevConfig>;
+interface EnvironmentMap {
+    /**
+     * The `env` section defines overrides for the configuration for different environments.
+     *
+     * All environment fields can be specified at the top level of the config indicating the default environment settings.
+     *
+     * - Some fields are inherited and overridable in each environment.
+     * - But some are not inherited and must be explicitly specified in every environment, if they are specified at the top level.
+     *
+     * For more information, see the documentation at https://developers.cloudflare.com/workers/cli-wrangler/configuration#environments
+     *
+     * @default {}
+     */
+    env?: {
+        [envName: string]: RawEnvironment;
+    };
+}
+declare const defaultWranglerConfig: Config;
+
+export { type CfModuleType as $, ARTIFACTS_EVENT_TYPES as A, type Binding as B, type ComputedFields as C, type DurableObjectExport as D, type Exports as E, type CfBrowserBinding as F, type CfCapnp as G, type CfD1Database as H, type CfDataBlobBindings as I, type CfDevPluginCfg as J, type CfDispatchNamespace as K, type Logger as L, type CfDurableObject as M, type CfDurableObjectMigrations as N, type CfExports as O, type CfFlagship as P, type CfHelloWorld as Q, type RawConfig as R, type CfHyperdrive as S, type CfImagesBinding as T, type CfKvNamespace as U, type CfLogfwdr as V, type WorkerEntrypointExport as W, type CfLogfwdrBinding as X, type CfMTlsCertificate as Y, type CfMediaBinding as Z, type CfModule as _, type RedirectedRawConfig as a, type LocalS3Credentials as a$, type CfPipeline as a0, type CfPlacement as a1, type CfQueue as a2, type CfR2Bucket as a3, type CfRateLimit as a4, type CfScriptFormat as a5, type CfSecretsStoreSecrets as a6, type CfSendEmailBindings as a7, type CfService as a8, type CfStreamBinding as a9, type DurableObjectExportStorage as aA, type DurableObjectMigration as aB, ENVIRONMENT_TAG_PREFIX as aC, type Entry as aD, type Environment as aE, type EnvironmentNonInheritable as aF, type ExportsReconciliationEntryBase as aG, type ExportsReconciliationErrorDetail as aH, type ExportsReconciliationInfo as aI, type ExportsReconciliationRename as aJ, type ExportsReconciliationResult as aK, type ExportsReconciliationTransfer as aL, type ExportsReconciliationTransferPending as aM, type ExportsReconciliationWarning as aN, type FetchKVGetValueFetcher as aO, type FetchListResultFetcher as aP, type FetchPagedListResultFetcher as aQ, type FetchResult as aR, type FetchResultFetcher as aS, type File as aT, type Hook as aU, type HookValues as aV, INHERIT_SYMBOL as aW, JSON_CONFIG_FORMATS as aX, type Json as aY, LOGGER_LEVELS as aZ, type LegacyAssetPaths as a_, type CfTextBlobBindings as aa, type CfUnsafe as ab, type CfUnsafeBinding as ac, type CfUserLimits as ad, type CfVars as ae, type CfVectorize as af, type CfVersionMetadataBinding as ag, type CfVpcNetwork as ah, type CfVpcService as ai, type CfWasmModuleBindings as aj, type CfWebSearch as ak, type CfWorkerContext as al, type CfWorkerInit as am, type CfWorkerLoader as an, type CfWorkerSourceMap as ao, type CfWorkflow as ap, type CloudchamberConfig as aq, type ComplianceConfig as ar, type ConfigFields as as, type ConfigModuleRuleType as at, type ConfiguredExport as au, type ContainerEngine as av, type CustomDomainRoute as aw, type DispatchNamespaceOutbound as ax, type DockerConfiguration as ay, type DurableObjectBindings as az, type Config as b, getWranglerSendErrorReportsFromEnv as b$, type LogLevel as b0, type LoggerLevel as b1, type NodeJSCompatMode as b2, type Observability as b3, PATH_TO_DEPLOY_CONFIG as b4, type PreviewsConfig as b5, type RawDevConfig as b6, type RawEnvironment as b7, type Rule as b8, SERVICE_TAG_PREFIX as b9, getCIOverrideName as bA, getCIOverrideNetworkModeHost as bB, getCfFetchEnabledFromEnv as bC, getCfFetchPathFromEnv as bD, getCloudflareApiBaseUrl as bE, getCloudflareApiEnvironmentFromEnv as bF, getCloudflareComplianceRegion as bG, getCloudflareEnv as bH, getCloudflareIncludeProcessEnvFromEnv as bI, getCloudflareLoadDevVarsFromDotEnv as bJ, getCloudflaredPathFromEnv as bK, getComplianceRegionSubdomain as bL, getD1ExtraLocationChoices as bM, getDisableConfigWatching as bN, getLocalExplorerEnabledFromEnv as bO, getLocalObservabilityEnabledFromEnv as bP, getNoSkillsUpdatePromptsFromEnv as bQ, getOpenNextDeployFromEnv as bR, getOutputFileDirectoryFromEnv as bS, getOutputFilePathFromEnv as bT, getRegistryPath as bU, getSanitizeLogs as bV, getSubdomainMixedStateCheckDisabled as bW, getTraceHeader as bX, getWorkersCIBranchName as bY, getWranglerCacheDirFromEnv as bZ, getWranglerHideBanner as b_, type ServiceFetch as ba, type ServiceMetadataRes as bb, type StartDevWorkerInput as bc, type StreamingTailConsumer as bd, type TailConsumer as be, type Trigger as bf, type UserLimits as bg, type ValidatedAssetsOptions as bh, type WorkerMetadata as bi, type WorkflowBinding as bj, type ZoneIdRoute as bk, type ZoneNameRoute as bl, addAuthorizationHeader as bm, defaultWranglerConfig as bn, extractAccountTag as bo, extractWAFBlockRayId as bp, fetchInternalBase as bq, fetchKVGetValueBase as br, fetchListResultBase as bs, fetchResultBase as bt, getBrowserRenderingHeadfulFromEnv as bu, getBuildConditionsFromEnv as bv, getBuildPlatformFromEnv as bw, getC3CommandFromEnv as bx, getCIGeneratePreviewAlias as by, getCIMatchTag as bz, type ContainerApp as c, getWranglerSendMetricsFromEnv as c0, hasCursor as c1, hasMorePages as c2, isDoNotTrackEnabled as c3, isWAFBlockResponse as c4, maybeAddTraceHeader as c5, parseRetryAfterMs as c6, parseRetryAfterValue as c7, performApiFetchBase as c8, renderError as c9, throwFetchError as ca, truncate as cb, type WorkerMetadataBinding as d, type CfTailConsumer as e, type Route as f, type Access as g, type ApiCredentials as h, type ArtifactsEventTrigger as i, type ArtifactsEventType as j, type AssetConfigMetadata as k, type Assets as l, type AssetsOptions as m, type AsyncHook as n, type BinaryFile as o, COMPLIANCE_REGION_CONFIG_PUBLIC as p, COMPLIANCE_REGION_CONFIG_UNKNOWN as q, type CacheOptions as r, type CfAIBinding as s, type CfAISearch as t, type CfAISearchNamespace as u, type CfAccount as v, type CfAgentMemory as w, type CfAnalyticsEngineDataset as x, type CfArtifacts as y, type CfAssetsBinding as z };