import type { Abortable } from 'node:events';
import type { AbortSignal as AbortSignal_2 } from '@cloudflare/workers-types/experimental';
import type { AssetConfig } from '@cloudflare/workers-shared';
import type { Blob as Blob_2 } from '@cloudflare/workers-types/experimental';
import { Blob as Blob_3 } from 'node:buffer';
import { BodyInit as BodyInit_2 } from 'undici';
import type { CacheStorage as CacheStorage_2 } from '@cloudflare/workers-types/experimental';
import { cspotcodeSourceMapSupport } from '@cspotcode/source-map-support';
import type { D1Database as D1Database_2 } from '@cloudflare/workers-types/experimental';
import type { DurableObjectNamespace as DurableObjectNamespace_2 } from '@cloudflare/workers-types/experimental';
import type { Fetcher as Fetcher_2 } from '@cloudflare/workers-types/experimental';
import type { File as File_2 } from '@cloudflare/workers-types/experimental';
import type { Flagship as Flagship_2 } from '@cloudflare/workers-types/experimental';
import { FormData as FormData_2 } from 'undici';
import { Headers as Headers_2 } from 'undici';
import type { Headers as Headers_3 } from '@cloudflare/workers-types/experimental';
import { HeadersInit as HeadersInit_2 } from 'undici';
import type * as http from 'node:http';
import type { default as http_2 } from 'node:http';
import type { ImagesBinding as ImagesBinding_2 } from '@cloudflare/workers-types/experimental';
import type { IncomingRequestCfProperties as IncomingRequestCfProperties_2 } from '@cloudflare/workers-types/experimental';
import type { KVNamespace as KVNamespace_2 } from '@cloudflare/workers-types/experimental';
import type { KVNamespaceListKey as KVNamespaceListKey_2 } from '@cloudflare/workers-types/experimental';
import net from 'node:net';
import NodeWebSocket from 'ws';
import { Plugin as Plugin_2 } from './shared';
import { Process } from '@puppeteer/browsers';
import type { Queue as Queue_2 } from '@cloudflare/workers-types/experimental';
import type { R2Bucket as R2Bucket_2 } from '@cloudflare/workers-types/experimental';
import type { ReadableStream as ReadableStream_2 } from '@cloudflare/workers-types/experimental';
import { ReadableStream as ReadableStream_3 } from 'node:stream/web';
import { ReferrerPolicy } from 'undici';
import { Request as Request_3 } from 'undici';
import type { Request as Request_4 } from '@cloudflare/workers-types/experimental';
import { RequestCache } from 'undici';
import { RequestCredentials } from 'undici';
import { RequestDestination } from 'undici';
import { RequestDuplex } from 'undici';
import type { RequestInfo as RequestInfo_3 } from 'undici';
import type { RequestInit as RequestInit_3 } from 'undici';
import type { RequestInit as RequestInit_4 } from '@cloudflare/workers-types/experimental';
import type { RequestInitCfProperties as RequestInitCfProperties_2 } from '@cloudflare/workers-types/experimental';
import { RequestMode } from 'undici';
import { RequestRedirect } from 'undici';
import { Response as Response_3 } from 'undici';
import type { Response as Response_4 } from '@cloudflare/workers-types/experimental';
import type { ResponseInit as ResponseInit_3 } from 'undici';
import { ResponseRedirectStatus } from 'undici';
import { ResponseType } from 'undici';
import type { RouterConfig } from '@cloudflare/workers-shared';
import { SendEmailBinding } from '@cloudflare/config';
import { ServiceDesignator as ServiceDesignator_2 } from '../..';
import type { ServiceWorkerGlobalScope as ServiceWorkerGlobalScope_2 } from '@cloudflare/workers-types/experimental';
import type { SqlStorage as SqlStorage_2 } from '@cloudflare/workers-types';
import type { SqlStorageValue as SqlStorageValue_2 } from '@cloudflare/workers-types';
import type { StreamBinding as StreamBinding_2 } from '@cloudflare/workers-types/experimental';
import type { Transform } from 'node:stream';
import * as undici from 'undici';
import { UnsafeBindingSchema } from '@cloudflare/config';
import { URL as URL_2 } from 'url';
import { VpcNetworkBinding } from '@cloudflare/config';
import { z } from 'zod';

export declare class __MiniflareFunctionWrapper {
    constructor(fnWithProps: ((...args: unknown[]) => unknown) & {
        [key: string | symbol]: unknown;
    });
}

export declare const AGENT_MEMORY_PLUGIN: Plugin;

export declare const AGENT_MEMORY_PLUGIN_NAME = "agent-memory";

export declare const AI_PLUGIN: Plugin;

export declare const AI_PLUGIN_NAME = "ai";

export declare const AI_SEARCH_PLUGIN: Plugin;

export declare const AI_SEARCH_PLUGIN_NAME = "ai-search";

export declare const ANALYTICS_ENGINE_PLUGIN: Plugin;

export declare const ANALYTICS_ENGINE_PLUGIN_NAME = "analytics-engine";

export declare type AnyHeaders = http_2.IncomingHttpHeaders | string[];

export declare const ARTIFACTS_PLUGIN: Plugin;

export declare const ARTIFACTS_PLUGIN_NAME = "artifacts";

export declare type AssetReverseMap = {
    [pathHash: string]: {
        filePath: string;
        contentType: string | null;
    };
};

export declare const ASSETS_PLUGIN: Plugin;

export declare type Awaitable<T> = T | Promise<T>;

export declare function base64Decode(encoded: string): string;

export declare function base64Encode(value: string): string;

export declare interface BaseCondition {
    attribute: string;
    operator: Operator;
    value: unknown;
}

export { BodyInit_2 as BodyInit }

export declare const BROWSER_RENDERING_PLUGIN: Plugin;

export declare const BROWSER_RENDERING_PLUGIN_NAME = "browser-rendering";

/**
 * The Asset Manifest and Asset Reverse Map are used to map a request path to an asset.
 * 1. Hash path of request
 * 2. Use this path hash to find the manifest entry
 * 3. Get content hash from manifest entry
 * 4a. In prod, use content hash to get asset from KV
 * 4b. In dev, we fake out the KV store and use the file system instead.
 * 	   Use content hash to get file path from asset reverse map.
 */
export declare const buildAssetManifest: (dir: string) => Promise<{
    encodedAssetManifest: Uint8Array<ArrayBuffer>;
    assetsReverseMap: AssetReverseMap;
}>;

export declare function buildObjectEntryProps(id: string): Record<string, unknown>;

/**
 * Builds a client-reachable URL for a local server given host, port, and
 * secure flag. Handles IPv6 bracketing and wildcard-address normalization
 * so the resulting string is always a valid URL.
 */
export declare function buildPublicUrl(options: {
    hostname?: string;
    port: number;
    secure?: boolean;
}): string;

export declare function buildRemoteProxyProps(remoteProxyConnectionString: RemoteProxyConnectionString | undefined, binding: string): {
    json: string;
};

export declare const CACHE_PLUGIN: Plugin;

export declare const CACHE_PLUGIN_NAME = "cache";

export declare const CacheHeaders: {
    readonly NAMESPACE: "cf-cache-namespace";
    readonly STATUS: "cf-cache-status";
};

declare class CloseEvent_2 extends Event {
    readonly code: number;
    readonly reason: string;
    readonly wasClean: boolean;
    constructor(type: "close", init?: {
        code?: number;
        reason?: string;
        wasClean?: boolean;
    });
}
export { CloseEvent_2 as CloseEvent }

export declare interface CompiledModuleRule {
    type: V4ModuleRuleType;
    include: ReturnType<typeof globsToRegExps>;
}

export declare function compileModuleRules(rules: V4ModuleRule[]): CompiledModuleRule[];

export declare type Condition = BaseCondition | LogicalCondition;

export declare interface Config {
    services?: Service_2[];
    sockets?: Socket_2[];
    v8Flags?: string[];
    extensions?: Extension[];
    autogates?: string[];
    structuredLogging?: boolean;
}

export declare type ContainerPrivileges = Worker_DurableObjectNamespace_ContainerOptions_ContainerPrivileges | undefined;

/** Caches privilege detection for the current container engine. */
export declare class ContainerPrivilegesCache {
    #private;
    /** Clears cached privileges when Miniflare selects a different engine. */
    setEngine(containerEngine: Worker_ContainerEngine): void;
    /** Returns the privilege decision cached for the selected engine. */
    get(containerEngine: Worker_ContainerEngine): Promise<ContainerPrivileges>;
}

export declare function convertV4MiniflareOptions(options: V4MiniflareOptions): MiniflareOptions;

export declare const CORE_PLUGIN: Plugin;

export declare const CORE_PLUGIN_NAME = "core";

export declare const CoreBindings: {
    readonly SERVICE_LOOPBACK: "MINIFLARE_LOOPBACK";
    readonly SERVICE_USER_ROUTE_PREFIX: "MINIFLARE_USER_ROUTE_";
    readonly SERVICE_USER_FALLBACK: "MINIFLARE_USER_FALLBACK";
    readonly TEXT_CUSTOM_SERVICE: "MINIFLARE_CUSTOM_SERVICE";
    readonly IMAGES_BINDING_SERVICE: "MINIFLARE_IMAGES_BINDING_SERVICE";
    readonly IMAGES_FETCH_SERVICE: "MINIFLARE_IMAGES_FETCH_SERVICE";
    readonly TEXT_UPSTREAM_URL: "MINIFLARE_UPSTREAM_URL";
    readonly JSON_CF_BLOB: "CF_BLOB";
    readonly JSON_ROUTES: "MINIFLARE_ROUTES";
    readonly JSON_LOG_LEVEL: "MINIFLARE_LOG_LEVEL";
    readonly DURABLE_OBJECT_NAMESPACE_PROXY: "MINIFLARE_PROXY";
    readonly DATA_PROXY_SECRET: "MINIFLARE_PROXY_SECRET";
    readonly DATA_PROXY_SHARED_SECRET: "MINIFLARE_PROXY_SHARED_SECRET";
    readonly TRIGGER_HANDLERS: "TRIGGER_HANDLERS";
    readonly LOG_REQUESTS: "LOG_REQUESTS";
    readonly STRIP_DISABLE_PRETTY_ERROR: "STRIP_DISABLE_PRETTY_ERROR";
    readonly SERVICE_LOCAL_EXPLORER: "MINIFLARE_LOCAL_EXPLORER";
    readonly EXPLORER_DISK: "MINIFLARE_EXPLORER_DISK";
    readonly JSON_LOCAL_EXPLORER_BINDING_MAP: "LOCAL_EXPLORER_BINDING_MAP";
    readonly JSON_LOCAL_EXPLORER_WORKER_NAMES: "LOCAL_EXPLORER_WORKER_NAMES";
    readonly JSON_EXPLORER_WORKER_OPTS: "MINIFLARE_EXPLORER_WORKER_OPTS";
    readonly SERVICE_CACHE: "MINIFLARE_CACHE";
    readonly SERVICE_DEV_CONTROL: "MINIFLARE_DEV_CONTROL";
    readonly SERVICE_DEV_REGISTRY_PROXY: "MINIFLARE_DEV_REGISTRY_PROXY";
    readonly JSON_TELEMETRY_CONFIG: "MINIFLARE_TELEMETRY_CONFIG";
    readonly DEV_REGISTRY_DEBUG_PORT: "DEV_REGISTRY_DEBUG_PORT";
    readonly DEV_REGISTRY_INSTANCE_ID: "DEV_REGISTRY_INSTANCE_ID";
    readonly SERVICE_STREAM: "MINIFLARE_STREAM";
    readonly SERVICE_IMAGES_DELIVERY: "MINIFLARE_IMAGES_DELIVERY";
    readonly SERVICE_D1: "MINIFLARE_D1";
    readonly SERVICE_KV: "MINIFLARE_KV";
    readonly SERVICE_R2: "MINIFLARE_R2";
    readonly SERVICE_R2_PUBLIC: "MINIFLARE_R2_PUBLIC";
    readonly SERVICE_R2_S3: "MINIFLARE_R2_S3";
    readonly SERVICE_OBSERVABILITY_COLLECTOR: "MINIFLARE_OBSERVABILITY_COLLECTOR";
    readonly JSON_ACCESS_BLOB_PREFIX: "MINIFLARE_ACCESS_BLOB_";
    readonly TEXT_FALLBACK_WORKER_NAME: "MINIFLARE_FALLBACK_WORKER_NAME";
    readonly SERVICE_EMAIL_STORE: "MINIFLARE_EMAIL_STORE";
    readonly SERVICE_EXPLORER_USER_WORKER_PREFIX: "MINIFLARE_EXPLORER_USER_WORKER_";
};

export declare const CoreHeaders: {
    readonly CUSTOM_FETCH_SERVICE: "MF-Custom-Fetch-Service";
    readonly CUSTOM_NODE_SERVICE: "MF-Custom-Node-Service";
    readonly ORIGINAL_URL: "MF-Original-URL";
    /**
     * Stores the original hostname when using the `upstream` option.
     * When requests are proxied to an upstream, the `Host` header is rewritten
     * to match the upstream. This header preserves the original hostname
     * so Workers can access it if needed.
     */
    readonly ORIGINAL_HOSTNAME: "MF-Original-Hostname";
    readonly PROXY_SHARED_SECRET: "MF-Proxy-Shared-Secret";
    readonly DISABLE_PRETTY_ERROR: "MF-Disable-Pretty-Error";
    readonly ERROR_STACK: "MF-Experimental-Error-Stack";
    /**
     * The serialised error, URI-encoded. `workerd` drops response bodies for
     * `HEAD` requests, so the body alone cannot carry the error out of the user
     * Worker. Producers set this in addition to the body; consumers fall back to
     * it whenever the body is unavailable.
     */
    readonly ERROR_STACK_PAYLOAD: "MF-Experimental-Error-Stack-Payload";
    readonly ROUTE_OVERRIDE: "MF-Route-Override";
    readonly CF_BLOB: "MF-CF-Blob";
    readonly ACCESS_BLOB: "MF-Access-Blob";
    /** Used by the Vite plugin to pass through the original `sec-fetch-mode` header */
    readonly SEC_FETCH_MODE: "MF-Sec-Fetch-Mode";
    readonly OP_SECRET: "MF-Op-Secret";
    readonly OP: "MF-Op";
    readonly OP_TARGET: "MF-Op-Target";
    readonly OP_KEY: "MF-Op-Key";
    readonly OP_SYNC: "MF-Op-Sync";
    readonly OP_STRINGIFIED_SIZE: "MF-Op-Stringified-Size";
    readonly OP_RESULT_TYPE: "MF-Op-Result-Type";
    readonly OP_ORIGINAL_URL: "MF-Op-Original-URL";
};

/**
 * Reserved paths for internal Miniflare endpoints.
 *
 * Paths under `/cdn-cgi/local/` are reserved by Cloudflare's network
 * and won't conflict with user routes. Paths under `/__cf_local/` live
 * outside `/cdn-cgi/` so they remain reachable over tunnels.
 */
export declare const CorePaths: {
    /** Magic proxy used by getPlatformProxy */
    readonly PLATFORM_PROXY: "/cdn-cgi/local/platform-proxy";
    /** Trigger scheduled event handlers */
    readonly SCHEDULED: "/cdn-cgi/local/scheduled";
    /** Trigger email event handlers */
    readonly EMAIL: "/cdn-cgi/local/email";
    /** Local explorer UI and API */
    readonly EXPLORER: "/cdn-cgi/local/explorer";
    /** Stream video serving endpoint (outside /cdn-cgi/ for tunnel access) */
    readonly STREAM_VIDEO: "/__cf_local/stream";
    /** Local image delivery endpoint (outside /cdn-cgi/ for tunnel access) */
    readonly IMAGE_DELIVERY: "/__cf_local/imagedelivery";
    /** Local Direct Creator Upload completion endpoint (outside /cdn-cgi/ for tunnel access) */
    readonly IMAGE_UPLOAD: "/__cf_local/imageupload";
    /** Public R2 bucket object serving endpoint */
    readonly R2_PUBLIC: "/cdn-cgi/local/r2/public";
    /** S3-compatible API endpoint for local R2 buckets */
    readonly R2_S3: "/cdn-cgi/local/r2/s3";
};

export declare function coupleWebSocket(ws: NodeWebSocket, pair: WebSocket_2): Promise<void>;

export declare function createHTTPReducers(impl: PlatformImpl<unknown>): ReducersRevivers;

export declare function createHTTPRevivers<RS>(impl: PlatformImpl<RS>): ReducersRevivers;

export declare const D1_PLUGIN: Plugin;

export declare const D1_PLUGIN_NAME = "d1";

/**
 * Recovers the serialised error a Worker put in `ERROR_STACK_PAYLOAD`, for the
 * cases where the response body carrying it has been dropped (`HEAD` requests).
 * Returns `null` when the header is absent or malformed, so callers can fall
 * back rather than surfacing a decoding failure as the Worker's error.
 */
export declare function decodeErrorPayload(response: {
    headers: {
        get(name: string): string | null;
    };
}): string | null;

export declare function decodeSitesKey(key: string): string;

export declare class DeferredPromise<T> extends Promise<T> {
    readonly resolve: DeferredPromiseResolve<T>;
    readonly reject: DeferredPromiseReject;
    constructor(executor?: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void);
}

export declare type DeferredPromiseReject = (reason?: any) => void;

export declare type DeferredPromiseResolve<T> = (value: T | PromiseLike<T>) => void;

export declare function deserialiseRegExps(matcher: SerialisableMatcherRegExps): MatcherRegExps;

export declare function deserialiseSiteRegExps(siteRegExps: SerialisableSiteMatcherRegExps): SiteMatcherRegExps;

export declare type DevConfig = z.input<typeof DevConfigSchema>;

export declare const DevConfigSchema: z.ZodObject<{
    rootPath: z.ZodDefault<z.ZodString>;
    cacheAPI: z.ZodDefault<z.ZodBoolean>;
    outboundService: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
        type: z.ZodLiteral<"fetcher">;
        handler: z.ZodCustom<(request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>, (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"node-handler">;
        handler: z.ZodCustom<(req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>, (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"worker">;
        worker: z.ZodString;
        exportName: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        dev: z.ZodOptional<z.ZodObject<{
            remote: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strict>>;
    }, z.core.$strict>], "type">>;
    remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    unsafeInspectorProxy: z.ZodOptional<z.ZodBoolean>;
    unsafeDirectSockets: z.ZodOptional<z.ZodArray<z.ZodObject<{
        host: z.ZodOptional<z.ZodString>;
        port: z.ZodOptional<z.ZodNumber>;
        serviceName: z.ZodOptional<z.ZodString>;
        entrypoint: z.ZodOptional<z.ZodString>;
        proxy: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>>;
    unsafeOverrideFetchWorker: z.ZodOptional<z.ZodString>;
    unsafeEvalBinding: z.ZodOptional<z.ZodString>;
    useModuleFallbackService: z.ZodOptional<z.ZodBoolean>;
    unsafeRegisterWorker: z.ZodDefault<z.ZodBoolean>;
    unsafeEphemeralDurableObjects: z.ZodOptional<z.ZodBoolean>;
    stripCfConnectingIp: z.ZodDefault<z.ZodBoolean>;
    zone: z.ZodOptional<z.ZodString>;
    access: z.ZodOptional<z.ZodObject<{
        aud: z.ZodString;
        identity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strict>>;
}, z.core.$strict>;

export declare interface DiskDirectory {
    path?: string;
    writable?: boolean;
    allowDotfiles?: boolean;
}

export declare const DISPATCH_NAMESPACE_PLUGIN: Plugin;

export declare const DISPATCH_NAMESPACE_PLUGIN_NAME = "dispatch-namespace";

/** Selects the Worker TCP trigger used by `Miniflare#dispatchConnect()`. */
export declare interface DispatchConnectOptions {
    /** Defaults to the entrypoint Worker. */
    workerName?: string;
    /** The configured trigger port, including `0` for an OS-assigned port. */
    port?: number;
}

export declare type DispatchFetch = (input: RequestInfo_2, init?: RequestInit_2<Partial<IncomingRequestCfProperties_2>>) => Promise<Response_2>;

/**
 * Dispatcher created for each `dispatchFetch()` call. Ensures request origin
 * in Worker matches that passed to `dispatchFetch()`, not the address the
 * `workerd` server is listening on. Handles cases where `fetch()` redirects to
 * same origin and different external origins.
 */
export declare class DispatchFetchDispatcher extends undici.Dispatcher {
    private readonly globalDispatcher;
    private readonly runtimeDispatcher;
    private readonly actualRuntimeOrigin;
    private readonly userRuntimeOrigin;
    private readonly cfBlobJson?;
    /**
     * @param globalDispatcher 		Dispatcher to use for all non-runtime requests
     * 												 		(rejects unauthorised certificates)
     * @param runtimeDispatcher 	Dispatcher to use for runtime requests
     * 														(permits unauthorised certificates)
     * @param actualRuntimeOrigin	Origin to send all runtime requests to
     * @param userRuntimeOrigin 	Origin to treat as runtime request
     * 														(initial URL passed by user to `dispatchFetch()`)
     * @param cfBlob							`request.cf` blob override for runtime requests
     */
    constructor(globalDispatcher: undici.Dispatcher, runtimeDispatcher: undici.Dispatcher, actualRuntimeOrigin: string, userRuntimeOrigin: string, cfBlob?: IncomingRequestCfProperties_2);
    addHeaders(headers: undici.Headers, path: string): void;
    dispatch(options: undici.Dispatcher.DispatchOptions, handler: undici.Dispatcher.DispatchHandler): boolean;
    close(): Promise<void>;
    close(callback: () => void): void;
    destroy(): Promise<void>;
    destroy(err: Error | null): Promise<void>;
    destroy(callback: () => void): void;
    destroy(err: Error | null, callback: () => void): void;
    get isMockActive(): boolean;
}

export declare type DOContainerOptions = z.infer<typeof DOContainerOptionsSchema>;

export declare const DOContainerOptionsSchema: z.ZodObject<{
    imageName: z.ZodString;
}, z.core.$strip>;

export declare const DURABLE_OBJECTS_PLUGIN: Plugin;

export declare const DURABLE_OBJECTS_PLUGIN_NAME = "do";

export declare const DURABLE_OBJECTS_STORAGE_SERVICE_NAME = "do:storage";

export declare type DurableObjectClassNames = Map<string, Map<string, {
    enableSql?: boolean;
    unsafeUniqueKey?: UnsafeUniqueKey;
    unsafePreventEviction?: boolean;
    container?: DOContainerOptions;
}>>;

export declare type DurableObjectEvictionOptions = DurableObjectIdentifier & {
    webSockets?: "close" | "hibernate";
};

export declare type DurableObjectIdentifier = {
    name: string;
    id?: never;
} | {
    id: string;
    name?: never;
};

export declare type DurableObjectStorageHandle = {
    exec<Row extends Record<string, SqlStorageValue_2> = Record<string, SqlStorageValue_2>>(...args: Parameters<SqlStorage_2["exec"]>): Promise<Row[]>;
};

export declare type DurableObjectStorageOptions = DurableObjectIdentifier;

export declare const EMAIL_PLUGIN: Plugin;

export declare const EMAIL_PLUGIN_NAME = "email";

export declare type EmailHandlerEvent = {
    type: "received" | "reject" | "unhandled";
    timestamp: string;
} | {
    type: "forward" | "reply";
    timestamp: string;
    messageId: string;
};

export declare interface EmailHandlerForward {
    messageId: string;
    recipient: string;
    headers: [string, string][];
}

export declare interface EmailHandlerReply {
    messageId: string;
    sender: string;
    raw: string;
    rawBase64?: string;
}

export declare interface EmailHandlerResult {
    outcome: "ok" | "exception";
    rejectReason?: string;
    forwards: EmailHandlerForward[];
    replies: EmailHandlerReply[];
    events: EmailHandlerEvent[];
}

/* Excluded from this release type: _enableControlEndpoints */

export declare function encodeSitesKey(key: string): string;

export declare type ErrorCode = "FLAG_NOT_FOUND" | "PARSE_ERROR" | "TYPE_MISMATCH" | "GENERAL";

declare class ErrorEvent_2 extends Event {
    readonly error: Error | null;
    constructor(type: "error", init?: {
        error?: Error;
    });
}
export { ErrorEvent_2 as ErrorEvent }

export declare type EvaluationContext = Record<string, unknown>;

export declare interface EvaluationDetails<T> {
    flagKey: string;
    value: T;
    variant: string;
    reason: EvaluationReason;
    errorCode?: ErrorCode;
    errorMessage?: string;
}

export declare type EvaluationReason = "TARGETING_MATCH" | "DEFAULT" | "DISABLED" | "SPLIT" | "ERROR";

export declare interface Extension {
    modules?: Extension_Module[];
}

export declare interface Extension_Module {
    name?: string;
    internal?: boolean;
    esModule?: string;
}

export declare type ExternalServer = {
    address?: string;
} & ({
    http: HttpOptions;
} | {
    https: ExternalServer_Https;
} | {
    tcp: ExternalServer_Tcp;
});

export declare interface ExternalServer_Https {
    options?: HttpOptions;
    tlsOptions?: TlsOptions_2;
    certificateHost?: string;
}

export declare interface ExternalServer_Tcp {
    tlsOptions?: TlsOptions_2;
    certificateHost?: string;
}

export declare function extractObjectEntryId(propsJson: string | undefined): string | undefined;

declare function fetch_2(input: RequestInfo_2, init?: RequestInit_2 | Request_2): Promise<Response_2>;
export { fetch_2 as fetch }

export declare interface Flag extends FlagInput {
    type: FlagType;
    updated_at: string;
}

export declare interface FlagChanges {
    description?: string | null;
    enabled?: boolean;
    default_variation?: string;
    variations?: Record<string, unknown>;
    rules?: Rule[];
}

export declare interface FlagInput {
    key: string;
    description?: string | null;
    enabled: boolean;
    default_variation: string;
    variations: Record<string, unknown>;
    rules: Rule[];
}

export declare const FLAGSHIP_PLUGIN: Plugin;

export declare const FLAGSHIP_PLUGIN_NAME = "flagship";

export declare interface FlagshipAdmin {
    listFlags(): Promise<Flag[]>;
    getFlag(flagKey: string): Promise<Flag>;
    getAccountTag(): Promise<string | null>;
    setAccountTag(accountTag: string): Promise<void>;
    createFlag(input: FlagInput): Promise<Flag>;
    updateFlag(flagKey: string, input: FlagInput): Promise<Flag>;
    patchFlag(flagKey: string, changes: FlagChanges): Promise<Flag>;
    putFlag(input: FlagInput): Promise<Flag>;
    putFlags(inputs: FlagInput[], accountTag: string): Promise<void>;
    deleteFlag(flagKey: string): Promise<void>;
    evaluateFlag(flagKey: string, context?: EvaluationContext): Promise<EvaluationDetails<FlagValue>>;
}

export declare type FlagType = "boolean" | "string" | "number" | "json";

export declare type FlagValue = boolean | string | number | Record<string, unknown> | unknown[];

/**
 * Format an error into a string, including the error cause if available.
 *
 * @example
 * ```
 * Error: Something went wrong
 *    at Object.<anonymous> (/path/to/file.js:10:15)
 * Caused by: Error: Another error
 *   at Object.<anonymous> (/path/to/another-file.js:5:10)
 * ```
 */
export declare function formatError(error: Error): string;

export { FormData_2 as FormData }

export declare function getAccessibleHosts(ipv4Only?: boolean): string[];

export declare function getAssetsBindingsNames(assetsKVBindingName?: string, assetsManifestBindingName?: string): {
    readonly ASSETS_KV_NAMESPACE: string;
    readonly ASSETS_MANIFEST: string;
};

export declare function getCacheServiceName(workerIndex: number): string;

/**
 * Utility to get the name for a raw socket listener implementing a worker's `connect` handler.
 *
 * @param workerIndex Index of the worker the listener belongs to
 * @param protocol Protocol the listener accepts connections for
 * @param port Port the listener accepts connections for
 * @returns the name for the socket
 */
export declare function getConnectSocketName(workerIndex: number, protocol: "tcp" | "udp", port: number): string;

/**
 * Get the default path for the dev registry.
 * This is used by both Wrangler and the Vite plugin to ensure they use the same path.
 */
export declare function getDefaultDevRegistryPath(): string;

export declare function getDirectSocketName(workerIndex: number, entrypoint: string): string;

/**
 * Returns the key workerd uses to identify a Durable Object class.
 *
 * @param className Durable Object class name.
 * @param workerName Worker containing the class.
 * @param unsafeUniqueKey Explicit key override.
 */
export declare function getDurableObjectUniqueKey(className: string, workerName: string | undefined, unsafeUniqueKey: UnsafeUniqueKey | undefined): string | undefined;

export declare function getEmailPathsToClean(resourceTmpPath: string | undefined, tmpPath: string): {
    sessionDir: string;
    parentDir: string;
} | undefined;

export declare function getEntrySocketHttpOptions(coreOpts: ParsedInstanceOptions): Promise<{
    http: HttpOptions;
} | {
    https: Socket_Https;
}>;

/**
 * Returns the entries of `config.env` whose binding `type` matches `type`,
 * typed as the matching binding variant. The record key is the binding name.
 */
export declare function getEnvBindingsOfType<T extends string>(config: ParsedMiniflareWorkerConfig, type: T): [name: string, binding: Extract<MiniflareBinding, {
    type: T;
}>][];

/**
 * Returns the entries of `config.exports` whose `type` matches `type`. The
 * record key is the export name.
 */
export declare function getExportsOfType<T extends string>(config: ParsedMiniflareWorkerConfig, type: T): [name: string, exported: Extract<MiniflareExport, {
    type: T;
}>][];

export declare function getFlagshipService(appId: string, sharedOptions: Pick<ParsedInstanceOptions, "resourcePersistencePath" | "unsafeEnableSharedStorage">): ServiceDesignator_2;

export declare function getFreshSourceMapSupport(): cspotcodeSourceMapSupport;

export declare function getGlobalServices({ sharedOptions, allWorkerRoutes, fallbackWorkerName, tmpPath, log, proxyBindings, durableObjectClassNames, allWorkerOpts, }: GlobalServicesOptions): Service_2[];

export declare function getImagesBindingServiceName(name: string): string;

/**
 * Normalizes a hostname for use in a client-reachable URL.
 *
 * - Maps wildcard/listen-all addresses to `127.0.0.1`.
 * - Brackets IPv6 addresses (e.g. `::1` -> `[::1]`, `fe80::1` -> `[fe80::1]`).
 * - Leaves hostnames and IPv4 addresses unchanged.
 */
export declare function getLocallyAccessibleHost(host: string): string;

export declare function getMiniflareObjectBindings(): Worker_Binding[];

/**
 * Computes the Node.js compatibility mode we are running.
 *
 * The `nodejs_compat`/`nodejs_compat_v2` resolution itself is shared with the
 * rest of the tooling, in `resolveNodejsCompat()`.
 *
 * @param compatibilityDate The compatibility date
 * @param compatibilityFlags The compatibility flags
 * @returns the mode and flags to indicate specific configuration for validating.
 */
export declare function getNodeCompat(compatibilityDate: string | undefined, // Default to some arbitrary old date
compatibilityFlags: string[]): {
    mode: NodeJSCompatMode;
    isNodejsCompatEnabled: boolean;
    isNodejsCompatV2Enabled: boolean;
    hasNodejsAlsFlag: boolean;
    hasNodejsCompatFlag: boolean;
    hasNoNodejsCompatFlag: boolean;
    hasNodejsCompatV2Flag: boolean;
    hasNoNodejsCompatV2Flag: boolean;
    hasExperimentalNodejsCompatV2Flag: boolean;
};

export declare function getPersistPath(pluginName: string, tmpPath: string, resourcePersistencePath: string | undefined): string;

export declare function getQueueServiceName(queueId: string): string;

export declare function getR2PublicService(allWorkerOpts: ParsedWorkerOptions[], sharedOptions: Pick<ParsedInstanceOptions, "resourcePersistencePath" | "unsafeEnableSharedStorage">): Service_2 | undefined;

export declare function getR2S3Service(allWorkerOpts: ParsedWorkerOptions[], sharedOptions: Pick<ParsedInstanceOptions, "resourcePersistencePath" | "unsafeEnableSharedStorage">): Service_2 | undefined;

/**
 * Resolves the remote proxy connection string for a binding. A binding is
 * proxied remotely iff `binding.dev.remote === true` _and_
 * `dev.remoteProxyConnectionString` is set (mirroring wrangler's model).
 */
export declare function getRemoteProxyConnectionString(binding: {
    dev?: {
        remote?: boolean;
    };
}, dev: ParsedDevConfig | undefined): RemoteProxyConnectionString | undefined;

export declare function getStorageScope(resourcePersistencePath: string | undefined): string | undefined;

export declare function getStorageService(localServiceName: string, props: Record<string, unknown>, sharedOptions: Pick<ParsedInstanceOptions, "resourcePersistencePath" | "unsafeEnableSharedStorage">, options?: {
    entrypoint?: string;
    rpcProperties?: string[];
}): ServiceDesignator;

export declare function getStreamService(sharedOptions: Pick<ParsedInstanceOptions, "resourcePersistencePath" | "unsafeEnableSharedStorage">): ServiceDesignator_2;

/**
 * Returns the entries of `config.triggers` whose `type` matches `type`.
 */
export declare function getTriggersOfType<T extends string>(config: ParsedMiniflareWorkerConfig, type: T): Extract<MiniflareTrigger, {
    type: T;
}>[];

/**
 * Utility to get the name for a service implementing a user binding
 *
 * @param scope Scope of the service (this usually is the plugin name)
 * @param identifier Identifier to use for the service
 * @param remoteProxyConnectionString Optional remote proxy connection string (in case the service connects to a remote resource)
 * @returns the name for the service
 */
export declare function getUserBindingServiceName(scope: string, identifier: string, remoteProxyConnectionString?: RemoteProxyConnectionString): string;

/**
 * Read the worker registry from the specified path.
 *
 * Skips stale workers that haven't sent a heartbeat within their stale window,
 * and removes their files from disk.
 */
export declare function getWorkerRegistry(registryPath: string): WorkerRegistry;

export declare interface GlobalServicesOptions {
    sharedOptions: ParsedInstanceOptions;
    allWorkerRoutes: Map<string, string[]>;
    fallbackWorkerName: string | undefined;
    tmpPath: string;
    log: Log;
    /** All user workerd-native bindings, used for Miniflare's magic proxy and the local explorer worker */
    proxyBindings: Worker_Binding[];
    /** Pass Durable Object configuration for the explorer worker (has more info than proxyBindings)*/
    durableObjectClassNames: DurableObjectClassNames;
    /** All worker options for building per-worker resource bindings */
    allWorkerOpts?: ParsedWorkerOptions[];
}

export declare function globsToRegExps(globs?: string[], { endAnchor }?: {
    endAnchor?: boolean;
}): MatcherRegExps;

export declare const HEADER_QUEUE_NAME = "MF-Queue-Name";

export { Headers_2 as Headers }

export { HeadersInit_2 as HeadersInit }

export declare const HELLO_WORLD_PLUGIN: Plugin;

export declare const HELLO_WORLD_PLUGIN_NAME = "hello-world";

export declare const HOST_CAPNP_CONNECT = "miniflare-unsafe-internal-capnp-connect";

export declare interface HttpOptions {
    style?: HttpOptions_Style;
    forwardedProtoHeader?: string;
    cfBlobHeader?: string;
    injectRequestHeaders?: HttpOptions_Header[];
    injectResponseHeaders?: HttpOptions_Header[];
    capnpConnectHost?: string;
}

export declare interface HttpOptions_Header {
    name?: string;
    value?: string;
}

export declare const HttpOptions_Style: {
    /**
     * Normal HTTP. The request line contains only the path, and the separate `Host` header
     * specifies the hostname.
     *
     */
    readonly HOST: 0;
    /**
     * HTTP proxy protocol. The request line contains a full URL instead of a path. No `Host`
     * header is required. This is the protocol used by HTTP forward proxies. This allows you to
     * implement such a proxy as a Worker.
     *
     */
    readonly PROXY: 1;
};

export declare type HttpOptions_Style = (typeof HttpOptions_Style)[keyof typeof HttpOptions_Style];

export declare const HYPERDRIVE_PLUGIN: Plugin;

export declare const HYPERDRIVE_PLUGIN_NAME = "hyperdrive";

export declare interface HyperdriveProxyConfig {
    name: string;
    targetHost: string;
    targetPort: string;
    scheme: string;
    sslmode: string;
    sslrootcert?: string;
}

/**
 * HyperdriveProxyController establishes TLS-enabled connections between workerd
 * and external Postgres/MySQL databases. Supports PostgreSQL sslmode options
 * ('require', 'prefer', 'disable', 'verify-full', 'verify-ca') by proxying
 * each Hyperdrive binding through a randomly assigned local port.
 */
export declare class HyperdriveProxyController {
    #private;
    log?: Log;
    /**
     * Creates a proxy server for a Hyperdrive binding.
     *
     * @param config - The configuration for the proxy server.
     * @returns A promise that resolves to the port number of the proxy server.
     */
    createProxyServer(config: HyperdriveProxyConfig): Promise<number>;
    /** Disposes of the proxy servers when shutting down the worker.*/
    dispose(): void;
}

export declare const HyperdriveSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodURL, z.ZodCustom<URL_2, URL_2>]>, z.ZodTransform<URL_2, string | URL_2>>;

export declare const IMAGES_PLUGIN: Plugin;

export declare const IMAGES_PLUGIN_NAME = "images";

export declare interface InclusiveRange {
    start: number;
    end: number;
}

/* Excluded from this release type: _initialiseInstanceRegistry */

export declare type InstanceOptions = z.input<typeof InstanceOptionsSchema>;

export declare const InstanceOptionsSchema: z.ZodObject<{
    host: z.ZodOptional<z.ZodString>;
    port: z.ZodOptional<z.ZodNumber>;
    https: z.ZodOptional<z.ZodBoolean>;
    httpsKey: z.ZodOptional<z.ZodString>;
    httpsCert: z.ZodOptional<z.ZodString>;
    inspectorPort: z.ZodOptional<z.ZodNumber>;
    inspectorHost: z.ZodOptional<z.ZodString>;
    verbose: z.ZodOptional<z.ZodBoolean>;
    log: z.ZodOptional<z.ZodCustom<Log, Log>>;
    handleStructuredLogs: z.ZodOptional<z.ZodCustom<(log: WorkerdStructuredLog) => void, (log: WorkerdStructuredLog) => void>>;
    handleUncaughtError: z.ZodOptional<z.ZodCustom<(error: Error) => void, (error: Error) => void>>;
    upstream: z.ZodOptional<z.ZodString>;
    cf: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
    logRequests: z.ZodDefault<z.ZodBoolean>;
    stripDisablePrettyError: z.ZodDefault<z.ZodBoolean>;
    resourcePersistencePath: z.ZodOptional<z.ZodString>;
    isolatedResourcePersistencePath: z.ZodOptional<z.ZodString>;
    resourceTmpPath: z.ZodOptional<z.ZodString>;
    unsafeEnableSharedStorage: z.ZodOptional<z.ZodBoolean>;
    containerEngine: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        localDocker: z.ZodObject<{
            socketPath: z.ZodString;
            containerEgressInterceptorImage: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>;
    }, z.core.$strict>]>>;
    telemetry: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        deviceId: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    publicUrl: z.ZodOptional<z.ZodURL>;
    unsafeDevRegistryPath: z.ZodOptional<z.ZodString>;
    unsafeHandleDevRegistryUpdate: z.ZodOptional<z.ZodCustom<(registry: WorkerRegistry) => void, (registry: WorkerRegistry) => void>>;
    unsafeHandleRuntimeRestart: z.ZodOptional<z.ZodCustom<() => Awaitable<void>, () => Awaitable<void>>>;
    unsafeProxySharedSecret: z.ZodOptional<z.ZodString>;
    unsafeModuleFallbackService: z.ZodOptional<z.ZodCustom<(request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>, (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>>>;
    unsafeTriggerHandlers: z.ZodOptional<z.ZodBoolean>;
    unsafeRuntimeEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    unsafeLocalExplorer: z.ZodOptional<z.ZodBoolean>;
    unsafeObservability: z.ZodOptional<z.ZodBoolean>;
    unsafeInspectDurableObjects: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strict>;

/**
 * Used by the local explorer worker.
 * The method name injected into wrapped Durable Objects for SQLite introspection.
 */
export declare const INTROSPECT_SQLITE_METHOD = "__miniflare_introspectSqlite";

/* Excluded from this release type: _isCyclic */

export declare function isDurableObjectStub(targetName: string): targetName is "DurableObject" | "WorkerRpc";

export declare function isFetcherFetch(targetName: string, key: string): boolean;

export declare const isFileNotFoundError: (e: unknown) => boolean;

export declare function isHeadersLike(value: unknown): value is Headers_3;

/**
 * See #createMediaProxy() comment for why this is special
 */
export declare function isImagesInput(targetName: string, key: string): boolean;

export declare function isR2ObjectWriteHttpMetadata(targetName: string, key: string): boolean;

export declare function isSitesRequest(request: {
    url: string;
}): boolean;

export declare type Json = Literal | {
    [key: string]: Json;
} | Json[];

export declare interface JsonError {
    message?: string;
    name?: string;
    stack?: string;
    cause?: JsonError;
}

export declare const JsonSchema: z.ZodType<Json>;

declare const kAccepted: unique symbol;

declare const kCf: unique symbol;

declare const kClose: unique symbol;

declare const kClosedIncoming: unique symbol;

declare const kClosedOutgoing: unique symbol;

declare const kCoupled: unique symbol;

export declare const kCurrentWorker: unique symbol;

declare const kError: unique symbol;

export declare type KeyTypes<T> = T extends Set<infer Keys> ? Keys : never;

export declare const kInspectorSocket: unique symbol;

export declare type KnownKeys<T> = {
    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
};

declare const kPair: unique symbol;

declare const kSend: unique symbol;

export declare const kUnsafeEphemeralUniqueKey: unique symbol;

declare const kUnsafeEphemeralUniqueKey_2: unique symbol;

export declare const KV_LOCAL_ENTRY_SERVICE_NAME = "kv:ns:entry";

export declare const KV_NAMESPACE_OBJECT_CLASS_NAME = "KVNamespaceObject";

export declare const KV_PLUGIN: Plugin;

export declare const KV_PLUGIN_NAME = "kv";

export declare const KVHeaders: {
    readonly EXPIRATION: "CF-Expiration";
    readonly METADATA: "CF-KV-Metadata";
};

export declare const KVLimits: {
    readonly MIN_CACHE_TTL_SECONDS: 30;
    readonly MIN_EXPIRATION_TTL_SECONDS: 60;
    readonly MAX_LIST_KEYS: 1000;
    readonly MAX_KEY_SIZE_BYTES: 512;
    readonly MAX_VALUE_SIZE_BYTES: number;
    readonly MAX_VALUE_SIZE_TEST_BYTES: 1024;
    readonly MAX_METADATA_SIZE_BYTES: 1024;
    readonly MAX_BULK_SIZE_BYTES: number;
};

export declare const kVoid: unique symbol;

export declare const KVParams: {
    readonly URL_ENCODED: "urlencoded";
    readonly CACHE_TTL: "cache_ttl";
    readonly EXPIRATION: "expiration";
    readonly EXPIRATION_TTL: "expiration_ttl";
    readonly LIST_LIMIT: "key_count_limit";
    readonly LIST_PREFIX: "prefix";
    readonly LIST_CURSOR: "cursor";
};

declare const kWebSocket: unique symbol;

export declare function launchBrowser({ browserVersion, headful, log, tmpPath, }: {
    browserVersion: string;
    headful?: boolean;
    log: Log;
    tmpPath: string;
}): Promise<{
    sessionId: `${string}-${string}-${string}-${string}-${string}`;
    browserProcess: Process;
    startTime: number;
    wsEndpoint: string;
}>;

export declare type LegacyConfig = z.input<typeof LegacyConfigSchema>;

export declare const LegacyConfigSchema: z.ZodObject<{
    serviceWorkerScript: z.ZodOptional<z.ZodString>;
    serviceWorkerScriptPath: z.ZodOptional<z.ZodString>;
    wasmBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
    textBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    dataBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
    sitePath: z.ZodOptional<z.ZodString>;
    siteInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
    siteExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strict>;

export declare type LegacyWorkerOptions = KnownKeys<V4WorkerOptionsShape> & V4SourceOptions;

export declare type Literal = z.infer<typeof LiteralSchema>;

export declare const LiteralSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;

/**
 * loadExternalPlugins will take a packageName, and attempt to load additional
 * external plugins to add to Miniflare's default ones
 */
export declare function loadExternalPlugins(packageName: string): Promise<Record<string, Plugin>>;

export declare class Log {
    #private;
    readonly level: LogLevel;
    constructor(level?: LogLevel, opts?: LogOptions);
    protected log(message: string): void;
    static unstable_registerBeforeLogHook(callback: (() => void) | undefined): void;
    static unstable_registerAfterLogHook(callback: (() => void) | undefined): void;
    logWithLevel(level: LogLevel, message: string): void;
    logReady(message: string): void;
    error(message: Error): void;
    warn(message: string): void;
    info(message: string): void;
    debug(message: string): void;
    verbose(message: string): void;
}

export declare interface LogicalCondition {
    logical_operator: "AND" | "OR";
    clauses: Condition[];
}

export declare enum LogLevel {
    NONE = 0,
    ERROR = 1,
    WARN = 2,
    INFO = 3,
    DEBUG = 4,
    VERBOSE = 5
}

export declare interface LogOptions {
    prefix?: string;
    suffix?: string;
}

export declare type ManifestEntry = {
    pathHash: Uint8Array;
    contentHash: Uint8Array;
};

export declare interface MatcherRegExps {
    include: RegExp[];
    exclude: RegExp[];
}

export declare function matchRoutes(routes: WorkerRoute[], url: URL): string | null;

export declare const MAX_BULK_GET_KEYS = 100;

export declare function maybeApply<From, To>(f: (value: From) => To, maybeValue: From | undefined): To | undefined;

export declare function maybeParseURL(url: string | undefined): URL | undefined;

export declare const MEDIA_PLUGIN: Plugin;

export declare const MEDIA_PLUGIN_NAME = "media";

/**
 * Merges all of `b`'s properties into `a`. Only merges 1 level deep, i.e.
 * `kvNamespaces` will be fully-merged, but `durableObject` object-designators
 * will be overwritten.
 */
export declare function mergeWorkerOptions(a: Partial<LegacyWorkerOptions>, b: Partial<LegacyWorkerOptions>): Partial<LegacyWorkerOptions>;

declare class MessageEvent_2 extends Event {
    readonly data: string | ArrayBuffer | Uint8Array<ArrayBuffer>;
    constructor(type: "message", init: {
        data: string | ArrayBuffer | Uint8Array<ArrayBuffer>;
    });
}
export { MessageEvent_2 as MessageEvent }

export declare class Miniflare {
    #private;
    publicUrl?: string;
    constructor(opts: MiniflareOptions);
    get ready(): Promise<URL>;
    getCf(): Promise<Record<string, any>>;
    getInspectorURL(): Promise<URL>;
    unsafeGetDirectURL(workerName?: string, entrypoint?: string): Promise<URL>;
    setOptions(opts: MiniflareOptions): Promise<void>;
    dispatchFetch: DispatchFetch;
    /**
     * Opens a TCP connection to a Worker's connect trigger.
     *
     * @param options Worker and trigger selection options
     * @returns A connected Node.js socket
     */
    dispatchConnect: (options?: DispatchConnectOptions) => Promise<net.Socket>;
    /* Excluded from this release type: _getProxyClient */
    getBindings<Env = Record<string, unknown>>(workerName?: string): Promise<Env>;
    getWorker(workerName?: string): Promise<ReplaceWorkersTypes<Fetcher_2>>;
    /**
     * Returns remote storage access for a Durable Object instance.
     *
     * Calling `exec()` runs SQL inside the target Durable Object and returns all
     * rows. It may start the object if it is not already active.
     */
    unsafeGetDurableObjectStorage(scriptName: string, className: string, options: DurableObjectStorageOptions): Promise<DurableObjectStorageHandle>;
    getCaches(): Promise<ReplaceWorkersTypes<CacheStorage_2>>;
    /**
     * Purges all entries from the cache.
     *
     * This is useful during development when cached assets need to be cleared
     * without restarting the Miniflare instance.
     *
     * @param cacheName - Optional name of specific cache to purge. If not provided,
     *                    purges the default cache.
     * @returns A promise that resolves with the number of entries purged.
     */
    purgeCache(cacheName?: string): Promise<number>;
    getD1Database(bindingName: string, workerName?: string): Promise<D1Database_2>;
    getDurableObjectNamespace(bindingName: string, workerName?: string): Promise<ReplaceWorkersTypes<DurableObjectNamespace_2>>;
    unsafeEvictDurableObject(scriptName: string, className: string, options: DurableObjectEvictionOptions): Promise<void>;
    listDurableObjectIds(classNameOrBindingName: string, workerName?: string): Promise<string[]>;
    getKVNamespace(bindingName: string, workerName?: string): Promise<ReplaceWorkersTypes<KVNamespace_2>>;
    getSecretsStoreSecretAPI(bindingName: string, workerName?: string): Promise<() => SecretsStoreSecretAdmin>;
    getSecretsStoreSecret(bindingName: string, workerName?: string): Promise<ReplaceWorkersTypes<KVNamespace_2>>;
    getQueueProducer<Body = unknown>(bindingName: string, workerName?: string): Promise<Queue_2<Body>>;
    getR2Bucket(bindingName: string, workerName?: string): Promise<ReplaceWorkersTypes<R2Bucket_2>>;
    getImagesBinding(bindingName: string, workerName?: string): Promise<ReplaceWorkersTypes<ImagesBinding_2>>;
    getHelloWorldBinding(bindingName: string, workerName?: string): Promise<{
        get: () => Promise<{
            value: string;
            ms?: number;
        }>;
        set: (value: string) => Promise<void>;
    }>;
    getFlagshipBinding(bindingName: string, workerName?: string): Promise<Flagship_2>;
    getFlagshipBindingAPI(bindingName: string, workerName?: string): Promise<() => FlagshipAdmin>;
    getStreamBinding(bindingName: string, workerName?: string): Promise<StreamBinding_2>;
    /* Excluded from this release type: _getInternalDurableObjectNamespace */
    dispose(): Promise<void>;
}

/** A single parsed `config.env` binding (known, miniflare-extended, or unsafe). */
export declare type MiniflareBinding = z.output<typeof ParsedMiniflareKnownBindingSchema> | z.output<typeof UnsafeBindingSchema>;

export declare class MiniflareCoreError extends MiniflareError<MiniflareCoreErrorCode> {
}

export declare type MiniflareCoreErrorCode = KeyTypes<typeof USER_ERROR_CODES> | KeyTypes<typeof SYSTEM_ERROR_CODES>;

/** A parsed binding to workerd's builtin `disk` service. */
export declare type MiniflareDiskServiceBinding = Extract<MiniflareBinding, {
    type: "disk";
}>;

/**
 * Extends live DO exports with miniflare-internal fields:
 * - `unsafeUniqueKey` — custom unique key for DO namespace identity
 * - `unsafePreventEviction` — prevents the DO from being evicted
 * - `container` — container config for container-attached DOs
 */
export declare const MiniflareDurableObjectExportSchema: z.ZodObject<{
    type: z.ZodLiteral<"durable-object">;
    state: z.ZodOptional<z.ZodLiteral<"created">>;
    storage: z.ZodEnum<{
        sqlite: "sqlite";
        "legacy-kv": "legacy-kv";
    }>;
    unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
    unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
    container: z.ZodOptional<z.ZodCustom<{
        imageName: string;
    }, {
        imageName: string;
    }>>;
}, z.core.$strict>;

export declare class MiniflareError<Code extends string = string> extends Error {
    readonly code: Code;
    readonly cause?: Error | undefined;
    constructor(code: Code, message?: string, cause?: Error | undefined);
    isUserError(): boolean;
    isSystemError(): boolean;
}

/** A single parsed `config.exports` entry. */
export declare type MiniflareExport = NonNullable<ParsedMiniflareWorkerConfig["exports"]>[string];

/** A parsed binding to workerd's builtin `external` service. */
export declare type MiniflareExternalServiceBinding = Extract<MiniflareBinding, {
    type: "external";
}>;

/** A parsed function-backed `fetcher` service binding. */
export declare type MiniflareFetcherBinding = Extract<MiniflareBinding, {
    type: "fetcher";
}>;

/** A parsed binding to workerd's builtin `network` service. */
export declare type MiniflareNetworkServiceBinding = Extract<MiniflareBinding, {
    type: "network";
}>;

/** A parsed Node.js http-style `node-handler` service binding. */
export declare type MiniflareNodeHandlerBinding = Extract<MiniflareBinding, {
    type: "node-handler";
}>;

export declare type MiniflareOptions = z.input<typeof MiniflareOptionsSchema>;

export declare const MiniflareOptionsSchema: z.ZodPipe<z.ZodObject<{
    host: z.ZodOptional<z.ZodString>;
    port: z.ZodOptional<z.ZodNumber>;
    https: z.ZodOptional<z.ZodBoolean>;
    httpsKey: z.ZodOptional<z.ZodString>;
    httpsCert: z.ZodOptional<z.ZodString>;
    inspectorPort: z.ZodOptional<z.ZodNumber>;
    inspectorHost: z.ZodOptional<z.ZodString>;
    verbose: z.ZodOptional<z.ZodBoolean>;
    log: z.ZodOptional<z.ZodCustom<Log, Log>>;
    handleStructuredLogs: z.ZodOptional<z.ZodCustom<(log: WorkerdStructuredLog) => void, (log: WorkerdStructuredLog) => void>>;
    handleUncaughtError: z.ZodOptional<z.ZodCustom<(error: Error) => void, (error: Error) => void>>;
    upstream: z.ZodOptional<z.ZodString>;
    cf: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
    logRequests: z.ZodDefault<z.ZodBoolean>;
    stripDisablePrettyError: z.ZodDefault<z.ZodBoolean>;
    resourcePersistencePath: z.ZodOptional<z.ZodString>;
    isolatedResourcePersistencePath: z.ZodOptional<z.ZodString>;
    resourceTmpPath: z.ZodOptional<z.ZodString>;
    unsafeEnableSharedStorage: z.ZodOptional<z.ZodBoolean>;
    containerEngine: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        localDocker: z.ZodObject<{
            socketPath: z.ZodString;
            containerEgressInterceptorImage: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>;
    }, z.core.$strict>]>>;
    telemetry: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        deviceId: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
    publicUrl: z.ZodOptional<z.ZodURL>;
    unsafeDevRegistryPath: z.ZodOptional<z.ZodString>;
    unsafeHandleDevRegistryUpdate: z.ZodOptional<z.ZodCustom<(registry: WorkerRegistry) => void, (registry: WorkerRegistry) => void>>;
    unsafeHandleRuntimeRestart: z.ZodOptional<z.ZodCustom<() => Awaitable<void>, () => Awaitable<void>>>;
    unsafeProxySharedSecret: z.ZodOptional<z.ZodString>;
    unsafeModuleFallbackService: z.ZodOptional<z.ZodCustom<(request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>, (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>>>;
    unsafeTriggerHandlers: z.ZodOptional<z.ZodBoolean>;
    unsafeRuntimeEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    unsafeLocalExplorer: z.ZodOptional<z.ZodBoolean>;
    unsafeObservability: z.ZodOptional<z.ZodBoolean>;
    unsafeInspectDurableObjects: z.ZodOptional<z.ZodBoolean>;
    workers: z.ZodArray<z.ZodObject<{
        config: z.ZodPipe<z.ZodObject<{
            name: z.ZodString;
            type: z.ZodLiteral<"worker">;
            cache: z.ZodOptional<z.ZodObject<{
                enabled: z.ZodBoolean;
                crossVersionCache: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strict>>;
            compatibilityDate: z.ZodString;
            compatibilityFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
            domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
            triggers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                type: z.ZodLiteral<"email">;
                addresses: z.ZodArray<z.ZodString>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"fetch">;
                pattern: z.ZodString;
                zone: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"queue">;
                name: z.ZodString;
                deadLetterQueue: z.ZodOptional<z.ZodString>;
                maxBatchSize: z.ZodOptional<z.ZodNumber>;
                maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                maxRetries: z.ZodOptional<z.ZodNumber>;
                retryDelay: z.ZodOptional<z.ZodNumber>;
                visibilityTimeoutMs: z.ZodOptional<z.ZodNumber>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"scheduled">;
                schedule: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"connect">;
                protocol: z.ZodEnum<{
                    tcp: "tcp";
                }>;
                port: z.ZodNumber;
                address: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>], "type">>>;
            placement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                mode: z.ZodEnum<{
                    off: "off";
                    smart: "smart";
                }>;
                hint: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
                region: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
                host: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
                hostname: z.ZodString;
            }, z.core.$strict>]>>;
            limits: z.ZodOptional<z.ZodObject<{
                cpuMs: z.ZodOptional<z.ZodNumber>;
                subrequests: z.ZodOptional<z.ZodNumber>;
            }, z.core.$strict>>;
            logpush: z.ZodOptional<z.ZodBoolean>;
            observability: z.ZodOptional<z.ZodObject<{
                enabled: z.ZodOptional<z.ZodBoolean>;
                headSamplingRate: z.ZodOptional<z.ZodNumber>;
                redactQueryString: z.ZodOptional<z.ZodBoolean>;
                logs: z.ZodOptional<z.ZodObject<{
                    enabled: z.ZodOptional<z.ZodBoolean>;
                    headSamplingRate: z.ZodOptional<z.ZodNumber>;
                    invocationLogs: z.ZodOptional<z.ZodBoolean>;
                    persist: z.ZodOptional<z.ZodBoolean>;
                    destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
                }, z.core.$strict>>;
                traces: z.ZodOptional<z.ZodObject<{
                    enabled: z.ZodOptional<z.ZodBoolean>;
                    headSamplingRate: z.ZodOptional<z.ZodNumber>;
                    persist: z.ZodOptional<z.ZodBoolean>;
                    destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
                }, z.core.$strict>>;
            }, z.core.$strict>>;
            workersDev: z.ZodOptional<z.ZodBoolean>;
            previewUrls: z.ZodOptional<z.ZodBoolean>;
            firstPartyWorker: z.ZodOptional<z.ZodBoolean>;
            unsafe: z.ZodOptional<z.ZodObject<{
                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                capnp: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                    basePath: z.ZodString;
                    sourceSchemas: z.ZodArray<z.ZodString>;
                    compiledSchema: z.ZodOptional<z.ZodNever>;
                }, z.core.$strict>, z.ZodObject<{
                    basePath: z.ZodOptional<z.ZodNever>;
                    sourceSchemas: z.ZodOptional<z.ZodNever>;
                    compiledSchema: z.ZodString;
                }, z.core.$strict>]>>;
            }, z.core.$strict>>;
            manifest: z.ZodOptional<z.ZodObject<{
                mainModule: z.ZodString;
                modulesRoot: z.ZodDefault<z.ZodString>;
                modules: z.ZodRecord<z.ZodString, z.ZodObject<{
                    type: z.ZodEnum<{
                        json: "json";
                        text: "text";
                        esm: "esm";
                        cjs: "cjs";
                        python: "python";
                        "python-requirement": "python-requirement";
                        wasm: "wasm";
                        data: "data";
                        sourcemap: "sourcemap";
                    }>;
                    contents: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
                }, z.core.$strict>>;
            }, z.core.$strict>>;
            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<{
                type: "external";
                address: string;
                http?: {
                    capnpConnectHost: string;
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                https?: {
                    options?: {
                        capnpConnectHost: string;
                        style?: 0 | 1 | undefined;
                        forwardedProtoHeader?: string | undefined;
                        cfBlobHeader?: string | undefined;
                        injectRequestHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                        injectResponseHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                    } | undefined;
                    tlsOptions?: {
                        keypair?: {
                            privateKey?: string | undefined;
                            certificateChain?: string | undefined;
                        } | undefined;
                        requireClientCerts?: boolean | undefined;
                        trustBrowserCas?: boolean | undefined;
                        trustedCertificates?: string[] | undefined;
                        minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                        cipherList?: string | undefined;
                    } | undefined;
                    certificateHost?: string | undefined;
                } | undefined;
            } | ({
                type: "send-email";
                destinationAddress?: string | undefined;
                allowedDestinationAddresses?: string[] | undefined;
                allowedSenderAddresses?: string[] | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & SendEmailBinding) | ({
                type: "vpc-network";
                tunnelId?: string | undefined;
                networkId?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & VpcNetworkBinding) | {
                type: "browser";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
                headful?: boolean | undefined;
            } | {
                type: "hyperdrive";
                id: string;
                dev: {
                    connectionString: string;
                };
            } | {
                type: "worker";
                worker: string | typeof kCurrentWorker;
                exportName?: string | undefined;
                props?: Record<string, unknown> | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "fetcher";
                handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
            } | {
                type: "node-handler";
                handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
            } | {
                type: "network";
                allow?: string[] | undefined;
                deny?: string[] | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
            } | {
                type: "disk";
                path: string;
                writable?: boolean | undefined;
            } | {
                type: "hello-world";
                enable_timer?: boolean | undefined;
            } | {
                type: "workflow";
                name: string;
                worker: string;
                exportName: string;
                limits?: {
                    steps?: number | undefined;
                } | undefined;
            } | {
                type: "agent-memory";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search-namespace";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "analytics-engine-dataset";
                name?: string | undefined;
            } | {
                type: "artifacts";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "assets";
            } | {
                type: "d1";
                name?: string | undefined;
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "dispatch-namespace";
                namespace?: string | undefined;
                outbound?: {
                    worker: string;
                    parameters?: string[] | undefined;
                } | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "durable-object";
                worker: string;
                exportName: string;
            } | {
                type: "flagship";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "images";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "json";
                value: z.core.util.JSONType;
            } | {
                type: "kv";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "logfwdr";
                destination: string;
            } | {
                type: "media";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "mtls-certificate";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "pipeline";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "queue";
                name?: string | undefined;
                deliveryDelay?: number | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "rate-limit";
                namespace: string;
                simple: {
                    limit: number;
                    period: 60 | 10;
                };
            } | {
                type: "r2";
                name?: string | undefined;
                jurisdiction?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                    experimentalS3Credentials?: {
                        accessKeyId: string;
                        secretAccessKey: string;
                    } | undefined;
                } | undefined;
            } | {
                type: "secret";
            } | {
                type: "secrets-store-secret";
                storeId: string;
                secretName: string;
            } | {
                type: "stream";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "text";
                value: string;
            } | {
                type: "vectorize";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "version-metadata";
            } | {
                type: "vpc-service";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "web-search";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "worker-loader";
            } | {
                [x: string]: unknown;
                type: `unsafe:${string}`;
                dev?: {
                    plugin: {
                        package: string;
                        name: string;
                    };
                    options?: Record<string, unknown> | undefined;
                } | undefined;
            }, {
                type: "external";
                address: string;
                http?: {
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                https?: {
                    options?: {
                        style?: 0 | 1 | undefined;
                        forwardedProtoHeader?: string | undefined;
                        cfBlobHeader?: string | undefined;
                        injectRequestHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                        injectResponseHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                    } | undefined;
                    tlsOptions?: {
                        keypair?: {
                            privateKey?: string | undefined;
                            certificateChain?: string | undefined;
                        } | undefined;
                        requireClientCerts?: boolean | undefined;
                        trustBrowserCas?: boolean | undefined;
                        trustedCertificates?: string[] | undefined;
                        minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                        cipherList?: string | undefined;
                    } | undefined;
                    certificateHost?: string | undefined;
                } | undefined;
            } | ({
                type: "send-email";
                destinationAddress?: string | undefined;
                allowedDestinationAddresses?: string[] | undefined;
                allowedSenderAddresses?: string[] | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & {
                type: "send-email";
                destinationAddress?: string | undefined;
                allowedDestinationAddresses?: string[] | undefined;
                allowedSenderAddresses?: string[] | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            }) | ({
                type: "vpc-network";
                tunnelId?: string | undefined;
                networkId?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & {
                type: "vpc-network";
                tunnelId?: string | undefined;
                networkId?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            }) | {
                type: "browser";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
                headful?: boolean | undefined;
            } | {
                type: "hyperdrive";
                id: string;
                dev: {
                    connectionString: string;
                };
            } | {
                type: "worker";
                worker: string | typeof kCurrentWorker;
                exportName?: string | undefined;
                props?: Record<string, unknown> | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "fetcher";
                handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
            } | {
                type: "node-handler";
                handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
            } | {
                type: "network";
                allow?: string[] | undefined;
                deny?: string[] | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
            } | {
                type: "disk";
                path: string;
                writable?: boolean | undefined;
            } | {
                type: "hello-world";
                enable_timer?: boolean | undefined;
            } | {
                type: "workflow";
                name: string;
                worker: string;
                exportName: string;
                limits?: {
                    steps?: number | undefined;
                } | undefined;
            } | {
                type: "agent-memory";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search-namespace";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "analytics-engine-dataset";
                name?: string | undefined;
            } | {
                type: "artifacts";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "assets";
            } | {
                type: "d1";
                name?: string | undefined;
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "dispatch-namespace";
                namespace?: string | undefined;
                outbound?: {
                    worker: string;
                    parameters?: string[] | undefined;
                } | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "durable-object";
                worker: string;
                exportName: string;
            } | {
                type: "flagship";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "images";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "json";
                value: z.core.util.JSONType;
            } | {
                type: "kv";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "logfwdr";
                destination: string;
            } | {
                type: "media";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "mtls-certificate";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "pipeline";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "queue";
                name?: string | undefined;
                deliveryDelay?: number | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "rate-limit";
                namespace: string;
                simple: {
                    limit: number;
                    period: 60 | 10;
                };
            } | {
                type: "r2";
                name?: string | undefined;
                jurisdiction?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                    experimentalS3Credentials?: {
                        accessKeyId: string;
                        secretAccessKey: string;
                    } | undefined;
                } | undefined;
            } | {
                type: "secret";
            } | {
                type: "secrets-store-secret";
                storeId: string;
                secretName: string;
            } | {
                type: "stream";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "text";
                value: string;
            } | {
                type: "vectorize";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "version-metadata";
            } | {
                type: "vpc-service";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "web-search";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "worker-loader";
            } | {
                [x: string]: unknown;
                type: `unsafe:${string}`;
                dev?: {
                    plugin: {
                        package: string;
                        name: string;
                    };
                    options?: Record<string, unknown> | undefined;
                } | undefined;
            }, z.core.$ZodTypeInternals<{
                type: "external";
                address: string;
                http?: {
                    capnpConnectHost: string;
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                https?: {
                    options?: {
                        capnpConnectHost: string;
                        style?: 0 | 1 | undefined;
                        forwardedProtoHeader?: string | undefined;
                        cfBlobHeader?: string | undefined;
                        injectRequestHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                        injectResponseHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                    } | undefined;
                    tlsOptions?: {
                        keypair?: {
                            privateKey?: string | undefined;
                            certificateChain?: string | undefined;
                        } | undefined;
                        requireClientCerts?: boolean | undefined;
                        trustBrowserCas?: boolean | undefined;
                        trustedCertificates?: string[] | undefined;
                        minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                        cipherList?: string | undefined;
                    } | undefined;
                    certificateHost?: string | undefined;
                } | undefined;
            } | ({
                type: "send-email";
                destinationAddress?: string | undefined;
                allowedDestinationAddresses?: string[] | undefined;
                allowedSenderAddresses?: string[] | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & SendEmailBinding) | ({
                type: "vpc-network";
                tunnelId?: string | undefined;
                networkId?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & VpcNetworkBinding) | {
                type: "browser";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
                headful?: boolean | undefined;
            } | {
                type: "hyperdrive";
                id: string;
                dev: {
                    connectionString: string;
                };
            } | {
                type: "worker";
                worker: string | typeof kCurrentWorker;
                exportName?: string | undefined;
                props?: Record<string, unknown> | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "fetcher";
                handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
            } | {
                type: "node-handler";
                handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
            } | {
                type: "network";
                allow?: string[] | undefined;
                deny?: string[] | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
            } | {
                type: "disk";
                path: string;
                writable?: boolean | undefined;
            } | {
                type: "hello-world";
                enable_timer?: boolean | undefined;
            } | {
                type: "workflow";
                name: string;
                worker: string;
                exportName: string;
                limits?: {
                    steps?: number | undefined;
                } | undefined;
            } | {
                type: "agent-memory";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search-namespace";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "analytics-engine-dataset";
                name?: string | undefined;
            } | {
                type: "artifacts";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "assets";
            } | {
                type: "d1";
                name?: string | undefined;
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "dispatch-namespace";
                namespace?: string | undefined;
                outbound?: {
                    worker: string;
                    parameters?: string[] | undefined;
                } | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "durable-object";
                worker: string;
                exportName: string;
            } | {
                type: "flagship";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "images";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "json";
                value: z.core.util.JSONType;
            } | {
                type: "kv";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "logfwdr";
                destination: string;
            } | {
                type: "media";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "mtls-certificate";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "pipeline";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "queue";
                name?: string | undefined;
                deliveryDelay?: number | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "rate-limit";
                namespace: string;
                simple: {
                    limit: number;
                    period: 60 | 10;
                };
            } | {
                type: "r2";
                name?: string | undefined;
                jurisdiction?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                    experimentalS3Credentials?: {
                        accessKeyId: string;
                        secretAccessKey: string;
                    } | undefined;
                } | undefined;
            } | {
                type: "secret";
            } | {
                type: "secrets-store-secret";
                storeId: string;
                secretName: string;
            } | {
                type: "stream";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "text";
                value: string;
            } | {
                type: "vectorize";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "version-metadata";
            } | {
                type: "vpc-service";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "web-search";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "worker-loader";
            } | {
                [x: string]: unknown;
                type: `unsafe:${string}`;
                dev?: {
                    plugin: {
                        package: string;
                        name: string;
                    };
                    options?: Record<string, unknown> | undefined;
                } | undefined;
            }, {
                type: "external";
                address: string;
                http?: {
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                https?: {
                    options?: {
                        style?: 0 | 1 | undefined;
                        forwardedProtoHeader?: string | undefined;
                        cfBlobHeader?: string | undefined;
                        injectRequestHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                        injectResponseHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                    } | undefined;
                    tlsOptions?: {
                        keypair?: {
                            privateKey?: string | undefined;
                            certificateChain?: string | undefined;
                        } | undefined;
                        requireClientCerts?: boolean | undefined;
                        trustBrowserCas?: boolean | undefined;
                        trustedCertificates?: string[] | undefined;
                        minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                        cipherList?: string | undefined;
                    } | undefined;
                    certificateHost?: string | undefined;
                } | undefined;
            } | ({
                type: "send-email";
                destinationAddress?: string | undefined;
                allowedDestinationAddresses?: string[] | undefined;
                allowedSenderAddresses?: string[] | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & {
                type: "send-email";
                destinationAddress?: string | undefined;
                allowedDestinationAddresses?: string[] | undefined;
                allowedSenderAddresses?: string[] | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            }) | ({
                type: "vpc-network";
                tunnelId?: string | undefined;
                networkId?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & {
                type: "vpc-network";
                tunnelId?: string | undefined;
                networkId?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            }) | {
                type: "browser";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
                headful?: boolean | undefined;
            } | {
                type: "hyperdrive";
                id: string;
                dev: {
                    connectionString: string;
                };
            } | {
                type: "worker";
                worker: string | typeof kCurrentWorker;
                exportName?: string | undefined;
                props?: Record<string, unknown> | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "fetcher";
                handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
            } | {
                type: "node-handler";
                handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
            } | {
                type: "network";
                allow?: string[] | undefined;
                deny?: string[] | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
            } | {
                type: "disk";
                path: string;
                writable?: boolean | undefined;
            } | {
                type: "hello-world";
                enable_timer?: boolean | undefined;
            } | {
                type: "workflow";
                name: string;
                worker: string;
                exportName: string;
                limits?: {
                    steps?: number | undefined;
                } | undefined;
            } | {
                type: "agent-memory";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search-namespace";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "analytics-engine-dataset";
                name?: string | undefined;
            } | {
                type: "artifacts";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "assets";
            } | {
                type: "d1";
                name?: string | undefined;
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "dispatch-namespace";
                namespace?: string | undefined;
                outbound?: {
                    worker: string;
                    parameters?: string[] | undefined;
                } | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "durable-object";
                worker: string;
                exportName: string;
            } | {
                type: "flagship";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "images";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "json";
                value: z.core.util.JSONType;
            } | {
                type: "kv";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "logfwdr";
                destination: string;
            } | {
                type: "media";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "mtls-certificate";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "pipeline";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "queue";
                name?: string | undefined;
                deliveryDelay?: number | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "rate-limit";
                namespace: string;
                simple: {
                    limit: number;
                    period: 60 | 10;
                };
            } | {
                type: "r2";
                name?: string | undefined;
                jurisdiction?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                    experimentalS3Credentials?: {
                        accessKeyId: string;
                        secretAccessKey: string;
                    } | undefined;
                } | undefined;
            } | {
                type: "secret";
            } | {
                type: "secrets-store-secret";
                storeId: string;
                secretName: string;
            } | {
                type: "stream";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "text";
                value: string;
            } | {
                type: "vectorize";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "version-metadata";
            } | {
                type: "vpc-service";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "web-search";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "worker-loader";
            } | {
                [x: string]: unknown;
                type: `unsafe:${string}`;
                dev?: {
                    plugin: {
                        package: string;
                        name: string;
                    };
                    options?: Record<string, unknown> | undefined;
                } | undefined;
            }>>>>;
            exports: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
                type: z.ZodLiteral<"durable-object">;
                state: z.ZodOptional<z.ZodLiteral<"created">>;
                storage: z.ZodEnum<{
                    sqlite: "sqlite";
                    "legacy-kv": "legacy-kv";
                }>;
                unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
                unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
                container: z.ZodOptional<z.ZodCustom<{
                    imageName: string;
                }, {
                    imageName: string;
                }>>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"durable-object">;
                state: z.ZodLiteral<"deleted">;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"durable-object">;
                state: z.ZodLiteral<"renamed">;
                renamedTo: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"durable-object">;
                state: z.ZodLiteral<"transferred">;
                transferredTo: z.ZodString;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"durable-object">;
                state: z.ZodLiteral<"expecting-transfer">;
                storage: z.ZodEnum<{
                    sqlite: "sqlite";
                    "legacy-kv": "legacy-kv";
                }>;
                transferFrom: z.ZodString;
                unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
                unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
                container: z.ZodOptional<z.ZodCustom<{
                    imageName: string;
                }, {
                    imageName: string;
                }>>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"worker">;
                cache: z.ZodOptional<z.ZodObject<{
                    enabled: z.ZodBoolean;
                }, z.core.$strict>>;
            }, z.core.$strict>]>>, z.ZodTransform<Record<string, {
                type: "durable-object";
                storage: "sqlite" | "legacy-kv";
                state?: "created" | undefined;
                unsafeUniqueKey?: UnsafeUniqueKey | undefined;
                unsafePreventEviction?: boolean | undefined;
                container?: {
                    imageName: string;
                } | undefined;
            } | {
                type: "durable-object";
                state: "expecting-transfer";
                storage: "sqlite" | "legacy-kv";
                transferFrom: string;
                unsafeUniqueKey?: UnsafeUniqueKey | undefined;
                unsafePreventEviction?: boolean | undefined;
                container?: {
                    imageName: string;
                } | undefined;
            } | {
                type: "worker";
                cache?: {
                    enabled: boolean;
                } | undefined;
            }>, Record<string, {
                type: "durable-object";
                storage: "sqlite" | "legacy-kv";
                state?: "created" | undefined;
                unsafeUniqueKey?: UnsafeUniqueKey | undefined;
                unsafePreventEviction?: boolean | undefined;
                container?: {
                    imageName: string;
                } | undefined;
            } | {
                type: "durable-object";
                state: "deleted";
            } | {
                type: "durable-object";
                state: "renamed";
                renamedTo: string;
            } | {
                type: "durable-object";
                state: "transferred";
                transferredTo: string;
            } | {
                type: "durable-object";
                state: "expecting-transfer";
                storage: "sqlite" | "legacy-kv";
                transferFrom: string;
                unsafeUniqueKey?: UnsafeUniqueKey | undefined;
                unsafePreventEviction?: boolean | undefined;
                container?: {
                    imageName: string;
                } | undefined;
            } | {
                type: "worker";
                cache?: {
                    enabled: boolean;
                } | undefined;
            }>>>>;
            assets: z.ZodOptional<z.ZodObject<{
                htmlHandling: z.ZodOptional<z.ZodEnum<{
                    "auto-trailing-slash": "auto-trailing-slash";
                    "drop-trailing-slash": "drop-trailing-slash";
                    "force-trailing-slash": "force-trailing-slash";
                    none: "none";
                }>>;
                notFoundHandling: z.ZodOptional<z.ZodEnum<{
                    none: "none";
                    "single-page-application": "single-page-application";
                    "404-page": "404-page";
                }>>;
                runWorkerFirst: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodBoolean]>>;
                directory: z.ZodString;
                hasUserWorker: z.ZodDefault<z.ZodBoolean>;
            }, z.core.$strict>>;
            tailConsumers: z.ZodOptional<z.ZodArray<z.ZodObject<{
                worker: z.ZodString;
                streaming: z.ZodOptional<z.ZodBoolean>;
                entrypoint: z.ZodOptional<z.ZodString>;
                props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, z.core.$strict>>>;
        }, z.core.$strict>, z.ZodTransform<ParsedMiniflareWorkerConfig, {
            name: string;
            type: "worker";
            compatibilityDate: string;
            cache?: {
                enabled: boolean;
                crossVersionCache?: boolean | undefined;
            } | undefined;
            compatibilityFlags?: string[] | undefined;
            domains?: string[] | undefined;
            triggers?: ({
                type: "email";
                addresses: string[];
            } | {
                type: "fetch";
                pattern: string;
                zone?: string | undefined;
            } | {
                type: "queue";
                name: string;
                deadLetterQueue?: string | undefined;
                maxBatchSize?: number | undefined;
                maxBatchTimeout?: number | undefined;
                maxConcurrency?: number | null | undefined;
                maxRetries?: number | undefined;
                retryDelay?: number | undefined;
                visibilityTimeoutMs?: number | undefined;
            } | {
                type: "scheduled";
                schedule: string;
            } | {
                type: "connect";
                protocol: "tcp";
                port: number;
                address?: string | undefined;
            })[] | undefined;
            placement?: {
                mode: "off" | "smart";
                hint?: string | undefined;
            } | {
                region: string;
                mode?: "targeted" | undefined;
            } | {
                host: string;
                mode?: "targeted" | undefined;
            } | {
                hostname: string;
                mode?: "targeted" | undefined;
            } | undefined;
            limits?: {
                cpuMs?: number | undefined;
                subrequests?: number | undefined;
            } | undefined;
            logpush?: boolean | undefined;
            observability?: {
                enabled?: boolean | undefined;
                headSamplingRate?: number | undefined;
                redactQueryString?: boolean | undefined;
                logs?: {
                    enabled?: boolean | undefined;
                    headSamplingRate?: number | undefined;
                    invocationLogs?: boolean | undefined;
                    persist?: boolean | undefined;
                    destinations?: string[] | undefined;
                } | undefined;
                traces?: {
                    enabled?: boolean | undefined;
                    headSamplingRate?: number | undefined;
                    persist?: boolean | undefined;
                    destinations?: string[] | undefined;
                } | undefined;
            } | undefined;
            workersDev?: boolean | undefined;
            previewUrls?: boolean | undefined;
            firstPartyWorker?: boolean | undefined;
            unsafe?: {
                metadata?: Record<string, unknown> | undefined;
                capnp?: {
                    basePath: string;
                    sourceSchemas: string[];
                    compiledSchema?: undefined;
                } | {
                    compiledSchema: string;
                    basePath?: undefined;
                    sourceSchemas?: undefined;
                } | undefined;
            } | undefined;
            manifest?: {
                mainModule: string;
                modulesRoot: string;
                modules: Record<string, {
                    type: "text" | "json" | "esm" | "cjs" | "python" | "python-requirement" | "wasm" | "data" | "sourcemap";
                    contents: string | Uint8Array<ArrayBuffer>;
                }>;
            } | undefined;
            env?: Record<string, {
                type: "external";
                address: string;
                http?: {
                    capnpConnectHost: string;
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                https?: {
                    options?: {
                        capnpConnectHost: string;
                        style?: 0 | 1 | undefined;
                        forwardedProtoHeader?: string | undefined;
                        cfBlobHeader?: string | undefined;
                        injectRequestHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                        injectResponseHeaders?: {
                            name: string;
                            value?: string | undefined;
                        }[] | undefined;
                    } | undefined;
                    tlsOptions?: {
                        keypair?: {
                            privateKey?: string | undefined;
                            certificateChain?: string | undefined;
                        } | undefined;
                        requireClientCerts?: boolean | undefined;
                        trustBrowserCas?: boolean | undefined;
                        trustedCertificates?: string[] | undefined;
                        minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                        cipherList?: string | undefined;
                    } | undefined;
                    certificateHost?: string | undefined;
                } | undefined;
            } | ({
                type: "send-email";
                destinationAddress?: string | undefined;
                allowedDestinationAddresses?: string[] | undefined;
                allowedSenderAddresses?: string[] | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & SendEmailBinding) | ({
                type: "vpc-network";
                tunnelId?: string | undefined;
                networkId?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } & VpcNetworkBinding) | {
                type: "browser";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
                headful?: boolean | undefined;
            } | {
                type: "hyperdrive";
                id: string;
                dev: {
                    connectionString: string;
                };
            } | {
                type: "worker";
                worker: string | typeof kCurrentWorker;
                exportName?: string | undefined;
                props?: Record<string, unknown> | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "fetcher";
                handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
            } | {
                type: "node-handler";
                handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
            } | {
                type: "network";
                allow?: string[] | undefined;
                deny?: string[] | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
            } | {
                type: "disk";
                path: string;
                writable?: boolean | undefined;
            } | {
                type: "hello-world";
                enable_timer?: boolean | undefined;
            } | {
                type: "workflow";
                name: string;
                worker: string;
                exportName: string;
                limits?: {
                    steps?: number | undefined;
                } | undefined;
            } | {
                type: "agent-memory";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "ai-search-namespace";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "analytics-engine-dataset";
                name?: string | undefined;
            } | {
                type: "artifacts";
                namespace: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "assets";
            } | {
                type: "d1";
                name?: string | undefined;
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "dispatch-namespace";
                namespace?: string | undefined;
                outbound?: {
                    worker: string;
                    parameters?: string[] | undefined;
                } | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "durable-object";
                worker: string;
                exportName: string;
            } | {
                type: "flagship";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "images";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "json";
                value: z.core.util.JSONType;
            } | {
                type: "kv";
                id?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "logfwdr";
                destination: string;
            } | {
                type: "media";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "mtls-certificate";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "pipeline";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "queue";
                name?: string | undefined;
                deliveryDelay?: number | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "rate-limit";
                namespace: string;
                simple: {
                    limit: number;
                    period: 60 | 10;
                };
            } | {
                type: "r2";
                name?: string | undefined;
                jurisdiction?: string | undefined;
                dev?: {
                    remote?: boolean | undefined;
                    experimentalS3Credentials?: {
                        accessKeyId: string;
                        secretAccessKey: string;
                    } | undefined;
                } | undefined;
            } | {
                type: "secret";
            } | {
                type: "secrets-store-secret";
                storeId: string;
                secretName: string;
            } | {
                type: "stream";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "text";
                value: string;
            } | {
                type: "vectorize";
                name: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "version-metadata";
            } | {
                type: "vpc-service";
                id: string;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "web-search";
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "worker-loader";
            } | {
                [x: string]: unknown;
                type: `unsafe:${string}`;
                dev?: {
                    plugin: {
                        package: string;
                        name: string;
                    };
                    options?: Record<string, unknown> | undefined;
                } | undefined;
            }> | undefined;
            exports?: Record<string, {
                type: "durable-object";
                storage: "sqlite" | "legacy-kv";
                state?: "created" | undefined;
                unsafeUniqueKey?: UnsafeUniqueKey | undefined;
                unsafePreventEviction?: boolean | undefined;
                container?: {
                    imageName: string;
                } | undefined;
            } | {
                type: "durable-object";
                state: "expecting-transfer";
                storage: "sqlite" | "legacy-kv";
                transferFrom: string;
                unsafeUniqueKey?: UnsafeUniqueKey | undefined;
                unsafePreventEviction?: boolean | undefined;
                container?: {
                    imageName: string;
                } | undefined;
            } | {
                type: "worker";
                cache?: {
                    enabled: boolean;
                } | undefined;
            }> | undefined;
            assets?: {
                directory: string;
                hasUserWorker: boolean;
                htmlHandling?: "auto-trailing-slash" | "force-trailing-slash" | "drop-trailing-slash" | "none" | undefined;
                notFoundHandling?: "none" | "single-page-application" | "404-page" | undefined;
                runWorkerFirst?: boolean | string[] | undefined;
            } | undefined;
            tailConsumers?: {
                worker: string;
                streaming?: boolean | undefined;
                entrypoint?: string | undefined;
                props?: Record<string, unknown> | undefined;
            }[] | undefined;
        }>>;
        legacy: z.ZodOptional<z.ZodObject<{
            serviceWorkerScript: z.ZodOptional<z.ZodString>;
            serviceWorkerScriptPath: z.ZodOptional<z.ZodString>;
            wasmBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
            textBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            dataBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
            sitePath: z.ZodOptional<z.ZodString>;
            siteInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
            siteExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
        dev: z.ZodDefault<z.ZodObject<{
            rootPath: z.ZodDefault<z.ZodString>;
            cacheAPI: z.ZodDefault<z.ZodBoolean>;
            outboundService: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                type: z.ZodLiteral<"fetcher">;
                handler: z.ZodCustom<(request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>, (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"node-handler">;
                handler: z.ZodCustom<(req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>, (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>>;
            }, z.core.$strict>, z.ZodObject<{
                type: z.ZodLiteral<"worker">;
                worker: z.ZodString;
                exportName: z.ZodOptional<z.ZodString>;
                props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                dev: z.ZodOptional<z.ZodObject<{
                    remote: z.ZodOptional<z.ZodBoolean>;
                }, z.core.$strict>>;
            }, z.core.$strict>], "type">>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
            unsafeInspectorProxy: z.ZodOptional<z.ZodBoolean>;
            unsafeDirectSockets: z.ZodOptional<z.ZodArray<z.ZodObject<{
                host: z.ZodOptional<z.ZodString>;
                port: z.ZodOptional<z.ZodNumber>;
                serviceName: z.ZodOptional<z.ZodString>;
                entrypoint: z.ZodOptional<z.ZodString>;
                proxy: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strict>>>;
            unsafeOverrideFetchWorker: z.ZodOptional<z.ZodString>;
            unsafeEvalBinding: z.ZodOptional<z.ZodString>;
            useModuleFallbackService: z.ZodOptional<z.ZodBoolean>;
            unsafeRegisterWorker: z.ZodDefault<z.ZodBoolean>;
            unsafeEphemeralDurableObjects: z.ZodOptional<z.ZodBoolean>;
            stripCfConnectingIp: z.ZodDefault<z.ZodBoolean>;
            zone: z.ZodOptional<z.ZodString>;
            access: z.ZodOptional<z.ZodObject<{
                aud: z.ZodString;
                identity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
}, z.core.$strict>, z.ZodTransform<{
    isolatedResourcePersistencePath: string | undefined;
    logRequests: boolean;
    stripDisablePrettyError: boolean;
    telemetry: {
        enabled: boolean;
        deviceId?: string | undefined;
    };
    workers: {
        config: ParsedMiniflareWorkerConfig;
        dev: {
            rootPath: string;
            cacheAPI: boolean;
            unsafeRegisterWorker: boolean;
            stripCfConnectingIp: boolean;
            outboundService?: {
                type: "worker";
                worker: string;
                exportName?: string | undefined;
                props?: Record<string, unknown> | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "fetcher";
                handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
            } | {
                type: "node-handler";
                handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
            } | undefined;
            remoteProxyConnectionString?: RemoteProxyConnectionString | undefined;
            unsafeInspectorProxy?: boolean | undefined;
            unsafeDirectSockets?: {
                host?: string | undefined;
                port?: number | undefined;
                serviceName?: string | undefined;
                entrypoint?: string | undefined;
                proxy?: boolean | undefined;
            }[] | undefined;
            unsafeOverrideFetchWorker?: string | undefined;
            unsafeEvalBinding?: string | undefined;
            useModuleFallbackService?: boolean | undefined;
            unsafeEphemeralDurableObjects?: boolean | undefined;
            zone?: string | undefined;
            access?: {
                aud: string;
                identity?: Record<string, unknown> | undefined;
            } | undefined;
        };
        legacy?: {
            serviceWorkerScript?: string | undefined;
            serviceWorkerScriptPath?: string | undefined;
            wasmBindings?: Record<string, string | Uint8Array<ArrayBuffer>> | undefined;
            textBlobBindings?: Record<string, string> | undefined;
            dataBlobBindings?: Record<string, string | Uint8Array<ArrayBuffer>> | undefined;
            sitePath?: string | undefined;
            siteInclude?: string[] | undefined;
            siteExclude?: string[] | undefined;
        } | undefined;
    }[];
    host?: string | undefined;
    port?: number | undefined;
    https?: boolean | undefined;
    httpsKey?: string | undefined;
    httpsCert?: string | undefined;
    inspectorPort?: number | undefined;
    inspectorHost?: string | undefined;
    verbose?: boolean | undefined;
    log?: Log | undefined;
    handleStructuredLogs?: ((log: WorkerdStructuredLog) => void) | undefined;
    handleUncaughtError?: ((error: Error) => void) | undefined;
    upstream?: string | undefined;
    cf?: string | boolean | Record<string, any> | undefined;
    resourcePersistencePath?: string | undefined;
    resourceTmpPath?: string | undefined;
    unsafeEnableSharedStorage?: boolean | undefined;
    containerEngine?: string | {
        localDocker: {
            socketPath: string;
            containerEgressInterceptorImage?: string | undefined;
        };
    } | undefined;
    publicUrl?: string | undefined;
    unsafeDevRegistryPath?: string | undefined;
    unsafeHandleDevRegistryUpdate?: ((registry: WorkerRegistry) => void) | undefined;
    unsafeHandleRuntimeRestart?: (() => Awaitable<void>) | undefined;
    unsafeProxySharedSecret?: string | undefined;
    unsafeModuleFallbackService?: ((request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>) | undefined;
    unsafeTriggerHandlers?: boolean | undefined;
    unsafeRuntimeEnv?: Record<string, string> | undefined;
    unsafeLocalExplorer?: boolean | undefined;
    unsafeObservability?: boolean | undefined;
    unsafeInspectDurableObjects?: boolean | undefined;
}, {
    logRequests: boolean;
    stripDisablePrettyError: boolean;
    telemetry: {
        enabled: boolean;
        deviceId?: string | undefined;
    };
    workers: {
        config: ParsedMiniflareWorkerConfig;
        dev: {
            rootPath: string;
            cacheAPI: boolean;
            unsafeRegisterWorker: boolean;
            stripCfConnectingIp: boolean;
            outboundService?: {
                type: "worker";
                worker: string;
                exportName?: string | undefined;
                props?: Record<string, unknown> | undefined;
                dev?: {
                    remote?: boolean | undefined;
                } | undefined;
            } | {
                type: "fetcher";
                handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
            } | {
                type: "node-handler";
                handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
            } | undefined;
            remoteProxyConnectionString?: RemoteProxyConnectionString | undefined;
            unsafeInspectorProxy?: boolean | undefined;
            unsafeDirectSockets?: {
                host?: string | undefined;
                port?: number | undefined;
                serviceName?: string | undefined;
                entrypoint?: string | undefined;
                proxy?: boolean | undefined;
            }[] | undefined;
            unsafeOverrideFetchWorker?: string | undefined;
            unsafeEvalBinding?: string | undefined;
            useModuleFallbackService?: boolean | undefined;
            unsafeEphemeralDurableObjects?: boolean | undefined;
            zone?: string | undefined;
            access?: {
                aud: string;
                identity?: Record<string, unknown> | undefined;
            } | undefined;
        };
        legacy?: {
            serviceWorkerScript?: string | undefined;
            serviceWorkerScriptPath?: string | undefined;
            wasmBindings?: Record<string, string | Uint8Array<ArrayBuffer>> | undefined;
            textBlobBindings?: Record<string, string> | undefined;
            dataBlobBindings?: Record<string, string | Uint8Array<ArrayBuffer>> | undefined;
            sitePath?: string | undefined;
            siteInclude?: string[] | undefined;
            siteExclude?: string[] | undefined;
        } | undefined;
    }[];
    host?: string | undefined;
    port?: number | undefined;
    https?: boolean | undefined;
    httpsKey?: string | undefined;
    httpsCert?: string | undefined;
    inspectorPort?: number | undefined;
    inspectorHost?: string | undefined;
    verbose?: boolean | undefined;
    log?: Log | undefined;
    handleStructuredLogs?: ((log: WorkerdStructuredLog) => void) | undefined;
    handleUncaughtError?: ((error: Error) => void) | undefined;
    upstream?: string | undefined;
    cf?: string | boolean | Record<string, any> | undefined;
    resourcePersistencePath?: string | undefined;
    isolatedResourcePersistencePath?: string | undefined;
    resourceTmpPath?: string | undefined;
    unsafeEnableSharedStorage?: boolean | undefined;
    containerEngine?: string | {
        localDocker: {
            socketPath: string;
            containerEgressInterceptorImage?: string | undefined;
        };
    } | undefined;
    publicUrl?: string | undefined;
    unsafeDevRegistryPath?: string | undefined;
    unsafeHandleDevRegistryUpdate?: ((registry: WorkerRegistry) => void) | undefined;
    unsafeHandleRuntimeRestart?: (() => Awaitable<void>) | undefined;
    unsafeProxySharedSecret?: string | undefined;
    unsafeModuleFallbackService?: ((request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>) | undefined;
    unsafeTriggerHandlers?: boolean | undefined;
    unsafeRuntimeEnv?: Record<string, string> | undefined;
    unsafeLocalExplorer?: boolean | undefined;
    unsafeObservability?: boolean | undefined;
    unsafeInspectDurableObjects?: boolean | undefined;
}>>;

/**
 * Any service-binding variant: a `worker`/`fetcher`/`node-handler` custom
 * service, or a `network`/`external`/`disk` workerd builtin service.
 */
export declare type MiniflareServiceBinding = MiniflareWorkerBinding | MiniflareFetcherBinding | MiniflareNodeHandlerBinding | MiniflareNetworkServiceBinding | MiniflareExternalServiceBinding | MiniflareDiskServiceBinding;

/** A single parsed `config.triggers` entry. */
export declare type MiniflareTrigger = NonNullable<ParsedMiniflareWorkerConfig["triggers"]>[number];

/** A parsed `worker` (service) binding, extended with `kCurrentWorker` support. */
export declare type MiniflareWorkerBinding = Extract<MiniflareBinding, {
    type: "worker";
}>;

export declare type MiniflareWorkerConfig = z.input<typeof MiniflareWorkerConfigSchema>;

export declare const MiniflareWorkerConfigBaseSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"worker">;
    cache: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodBoolean;
        crossVersionCache: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    compatibilityDate: z.ZodString;
    compatibilityFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
    triggers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        type: z.ZodLiteral<"email">;
        addresses: z.ZodArray<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"fetch">;
        pattern: z.ZodString;
        zone: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"queue">;
        name: z.ZodString;
        deadLetterQueue: z.ZodOptional<z.ZodString>;
        maxBatchSize: z.ZodOptional<z.ZodNumber>;
        maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
        maxConcurrency: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        maxRetries: z.ZodOptional<z.ZodNumber>;
        retryDelay: z.ZodOptional<z.ZodNumber>;
        visibilityTimeoutMs: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"scheduled">;
        schedule: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"connect">;
        protocol: z.ZodEnum<{
            tcp: "tcp";
        }>;
        port: z.ZodNumber;
        address: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>], "type">>>;
    placement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
        mode: z.ZodEnum<{
            off: "off";
            smart: "smart";
        }>;
        hint: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
        region: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
        host: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
        hostname: z.ZodString;
    }, z.core.$strict>]>>;
    limits: z.ZodOptional<z.ZodObject<{
        cpuMs: z.ZodOptional<z.ZodNumber>;
        subrequests: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strict>>;
    logpush: z.ZodOptional<z.ZodBoolean>;
    observability: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodOptional<z.ZodBoolean>;
        headSamplingRate: z.ZodOptional<z.ZodNumber>;
        redactQueryString: z.ZodOptional<z.ZodBoolean>;
        logs: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodOptional<z.ZodBoolean>;
            headSamplingRate: z.ZodOptional<z.ZodNumber>;
            invocationLogs: z.ZodOptional<z.ZodBoolean>;
            persist: z.ZodOptional<z.ZodBoolean>;
            destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
        traces: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodOptional<z.ZodBoolean>;
            headSamplingRate: z.ZodOptional<z.ZodNumber>;
            persist: z.ZodOptional<z.ZodBoolean>;
            destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    workersDev: z.ZodOptional<z.ZodBoolean>;
    previewUrls: z.ZodOptional<z.ZodBoolean>;
    firstPartyWorker: z.ZodOptional<z.ZodBoolean>;
    unsafe: z.ZodOptional<z.ZodObject<{
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        capnp: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
            basePath: z.ZodString;
            sourceSchemas: z.ZodArray<z.ZodString>;
            compiledSchema: z.ZodOptional<z.ZodNever>;
        }, z.core.$strict>, z.ZodObject<{
            basePath: z.ZodOptional<z.ZodNever>;
            sourceSchemas: z.ZodOptional<z.ZodNever>;
            compiledSchema: z.ZodString;
        }, z.core.$strict>]>>;
    }, z.core.$strict>>;
    manifest: z.ZodOptional<z.ZodObject<{
        mainModule: z.ZodString;
        modulesRoot: z.ZodDefault<z.ZodString>;
        modules: z.ZodRecord<z.ZodString, z.ZodObject<{
            type: z.ZodEnum<{
                json: "json";
                text: "text";
                esm: "esm";
                cjs: "cjs";
                python: "python";
                "python-requirement": "python-requirement";
                wasm: "wasm";
                data: "data";
                sourcemap: "sourcemap";
            }>;
            contents: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<{
        type: "external";
        address: string;
        http?: {
            capnpConnectHost: string;
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                capnpConnectHost: string;
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & SendEmailBinding) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & VpcNetworkBinding) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }, {
        type: "external";
        address: string;
        http?: {
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & {
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    }) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & {
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    }) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }, z.core.$ZodTypeInternals<{
        type: "external";
        address: string;
        http?: {
            capnpConnectHost: string;
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                capnpConnectHost: string;
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & SendEmailBinding) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & VpcNetworkBinding) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }, {
        type: "external";
        address: string;
        http?: {
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & {
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    }) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & {
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    }) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }>>>>;
    exports: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodOptional<z.ZodLiteral<"created">>;
        storage: z.ZodEnum<{
            sqlite: "sqlite";
            "legacy-kv": "legacy-kv";
        }>;
        unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
        unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
        container: z.ZodOptional<z.ZodCustom<{
            imageName: string;
        }, {
            imageName: string;
        }>>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodLiteral<"deleted">;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodLiteral<"renamed">;
        renamedTo: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodLiteral<"transferred">;
        transferredTo: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodLiteral<"expecting-transfer">;
        storage: z.ZodEnum<{
            sqlite: "sqlite";
            "legacy-kv": "legacy-kv";
        }>;
        transferFrom: z.ZodString;
        unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
        unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
        container: z.ZodOptional<z.ZodCustom<{
            imageName: string;
        }, {
            imageName: string;
        }>>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"worker">;
        cache: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodBoolean;
        }, z.core.$strict>>;
    }, z.core.$strict>]>>, z.ZodTransform<Record<string, {
        type: "durable-object";
        storage: "sqlite" | "legacy-kv";
        state?: "created" | undefined;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "durable-object";
        state: "expecting-transfer";
        storage: "sqlite" | "legacy-kv";
        transferFrom: string;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "worker";
        cache?: {
            enabled: boolean;
        } | undefined;
    }>, Record<string, {
        type: "durable-object";
        storage: "sqlite" | "legacy-kv";
        state?: "created" | undefined;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "durable-object";
        state: "deleted";
    } | {
        type: "durable-object";
        state: "renamed";
        renamedTo: string;
    } | {
        type: "durable-object";
        state: "transferred";
        transferredTo: string;
    } | {
        type: "durable-object";
        state: "expecting-transfer";
        storage: "sqlite" | "legacy-kv";
        transferFrom: string;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "worker";
        cache?: {
            enabled: boolean;
        } | undefined;
    }>>>>;
    assets: z.ZodOptional<z.ZodObject<{
        htmlHandling: z.ZodOptional<z.ZodEnum<{
            "auto-trailing-slash": "auto-trailing-slash";
            "drop-trailing-slash": "drop-trailing-slash";
            "force-trailing-slash": "force-trailing-slash";
            none: "none";
        }>>;
        notFoundHandling: z.ZodOptional<z.ZodEnum<{
            none: "none";
            "single-page-application": "single-page-application";
            "404-page": "404-page";
        }>>;
        runWorkerFirst: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodBoolean]>>;
        directory: z.ZodString;
        hasUserWorker: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strict>>;
    tailConsumers: z.ZodOptional<z.ZodArray<z.ZodObject<{
        worker: z.ZodString;
        streaming: z.ZodOptional<z.ZodBoolean>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strict>>>;
}, z.core.$strict>;

export declare const MiniflareWorkerConfigSchema: z.ZodPipe<z.ZodObject<{
    name: z.ZodString;
    type: z.ZodLiteral<"worker">;
    cache: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodBoolean;
        crossVersionCache: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    compatibilityDate: z.ZodString;
    compatibilityFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
    triggers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
        type: z.ZodLiteral<"email">;
        addresses: z.ZodArray<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"fetch">;
        pattern: z.ZodString;
        zone: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"queue">;
        name: z.ZodString;
        deadLetterQueue: z.ZodOptional<z.ZodString>;
        maxBatchSize: z.ZodOptional<z.ZodNumber>;
        maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
        maxConcurrency: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        maxRetries: z.ZodOptional<z.ZodNumber>;
        retryDelay: z.ZodOptional<z.ZodNumber>;
        visibilityTimeoutMs: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"scheduled">;
        schedule: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"connect">;
        protocol: z.ZodEnum<{
            tcp: "tcp";
        }>;
        port: z.ZodNumber;
        address: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>], "type">>>;
    placement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
        mode: z.ZodEnum<{
            off: "off";
            smart: "smart";
        }>;
        hint: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
        region: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
        host: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
        hostname: z.ZodString;
    }, z.core.$strict>]>>;
    limits: z.ZodOptional<z.ZodObject<{
        cpuMs: z.ZodOptional<z.ZodNumber>;
        subrequests: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strict>>;
    logpush: z.ZodOptional<z.ZodBoolean>;
    observability: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodOptional<z.ZodBoolean>;
        headSamplingRate: z.ZodOptional<z.ZodNumber>;
        redactQueryString: z.ZodOptional<z.ZodBoolean>;
        logs: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodOptional<z.ZodBoolean>;
            headSamplingRate: z.ZodOptional<z.ZodNumber>;
            invocationLogs: z.ZodOptional<z.ZodBoolean>;
            persist: z.ZodOptional<z.ZodBoolean>;
            destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
        traces: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodOptional<z.ZodBoolean>;
            headSamplingRate: z.ZodOptional<z.ZodNumber>;
            persist: z.ZodOptional<z.ZodBoolean>;
            destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    workersDev: z.ZodOptional<z.ZodBoolean>;
    previewUrls: z.ZodOptional<z.ZodBoolean>;
    firstPartyWorker: z.ZodOptional<z.ZodBoolean>;
    unsafe: z.ZodOptional<z.ZodObject<{
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        capnp: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
            basePath: z.ZodString;
            sourceSchemas: z.ZodArray<z.ZodString>;
            compiledSchema: z.ZodOptional<z.ZodNever>;
        }, z.core.$strict>, z.ZodObject<{
            basePath: z.ZodOptional<z.ZodNever>;
            sourceSchemas: z.ZodOptional<z.ZodNever>;
            compiledSchema: z.ZodString;
        }, z.core.$strict>]>>;
    }, z.core.$strict>>;
    manifest: z.ZodOptional<z.ZodObject<{
        mainModule: z.ZodString;
        modulesRoot: z.ZodDefault<z.ZodString>;
        modules: z.ZodRecord<z.ZodString, z.ZodObject<{
            type: z.ZodEnum<{
                json: "json";
                text: "text";
                esm: "esm";
                cjs: "cjs";
                python: "python";
                "python-requirement": "python-requirement";
                wasm: "wasm";
                data: "data";
                sourcemap: "sourcemap";
            }>;
            contents: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<{
        type: "external";
        address: string;
        http?: {
            capnpConnectHost: string;
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                capnpConnectHost: string;
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & SendEmailBinding) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & VpcNetworkBinding) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }, {
        type: "external";
        address: string;
        http?: {
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & {
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    }) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & {
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    }) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }, z.core.$ZodTypeInternals<{
        type: "external";
        address: string;
        http?: {
            capnpConnectHost: string;
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                capnpConnectHost: string;
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & SendEmailBinding) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & VpcNetworkBinding) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }, {
        type: "external";
        address: string;
        http?: {
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & {
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    }) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & {
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    }) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }>>>>;
    exports: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodOptional<z.ZodLiteral<"created">>;
        storage: z.ZodEnum<{
            sqlite: "sqlite";
            "legacy-kv": "legacy-kv";
        }>;
        unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
        unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
        container: z.ZodOptional<z.ZodCustom<{
            imageName: string;
        }, {
            imageName: string;
        }>>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodLiteral<"deleted">;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodLiteral<"renamed">;
        renamedTo: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodLiteral<"transferred">;
        transferredTo: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"durable-object">;
        state: z.ZodLiteral<"expecting-transfer">;
        storage: z.ZodEnum<{
            sqlite: "sqlite";
            "legacy-kv": "legacy-kv";
        }>;
        transferFrom: z.ZodString;
        unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
        unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
        container: z.ZodOptional<z.ZodCustom<{
            imageName: string;
        }, {
            imageName: string;
        }>>;
    }, z.core.$strict>, z.ZodObject<{
        type: z.ZodLiteral<"worker">;
        cache: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodBoolean;
        }, z.core.$strict>>;
    }, z.core.$strict>]>>, z.ZodTransform<Record<string, {
        type: "durable-object";
        storage: "sqlite" | "legacy-kv";
        state?: "created" | undefined;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "durable-object";
        state: "expecting-transfer";
        storage: "sqlite" | "legacy-kv";
        transferFrom: string;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "worker";
        cache?: {
            enabled: boolean;
        } | undefined;
    }>, Record<string, {
        type: "durable-object";
        storage: "sqlite" | "legacy-kv";
        state?: "created" | undefined;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "durable-object";
        state: "deleted";
    } | {
        type: "durable-object";
        state: "renamed";
        renamedTo: string;
    } | {
        type: "durable-object";
        state: "transferred";
        transferredTo: string;
    } | {
        type: "durable-object";
        state: "expecting-transfer";
        storage: "sqlite" | "legacy-kv";
        transferFrom: string;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "worker";
        cache?: {
            enabled: boolean;
        } | undefined;
    }>>>>;
    assets: z.ZodOptional<z.ZodObject<{
        htmlHandling: z.ZodOptional<z.ZodEnum<{
            "auto-trailing-slash": "auto-trailing-slash";
            "drop-trailing-slash": "drop-trailing-slash";
            "force-trailing-slash": "force-trailing-slash";
            none: "none";
        }>>;
        notFoundHandling: z.ZodOptional<z.ZodEnum<{
            none: "none";
            "single-page-application": "single-page-application";
            "404-page": "404-page";
        }>>;
        runWorkerFirst: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodBoolean]>>;
        directory: z.ZodString;
        hasUserWorker: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strict>>;
    tailConsumers: z.ZodOptional<z.ZodArray<z.ZodObject<{
        worker: z.ZodString;
        streaming: z.ZodOptional<z.ZodBoolean>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strict>>>;
}, z.core.$strict>, z.ZodTransform<ParsedMiniflareWorkerConfig, {
    name: string;
    type: "worker";
    compatibilityDate: string;
    cache?: {
        enabled: boolean;
        crossVersionCache?: boolean | undefined;
    } | undefined;
    compatibilityFlags?: string[] | undefined;
    domains?: string[] | undefined;
    triggers?: ({
        type: "email";
        addresses: string[];
    } | {
        type: "fetch";
        pattern: string;
        zone?: string | undefined;
    } | {
        type: "queue";
        name: string;
        deadLetterQueue?: string | undefined;
        maxBatchSize?: number | undefined;
        maxBatchTimeout?: number | undefined;
        maxConcurrency?: number | null | undefined;
        maxRetries?: number | undefined;
        retryDelay?: number | undefined;
        visibilityTimeoutMs?: number | undefined;
    } | {
        type: "scheduled";
        schedule: string;
    } | {
        type: "connect";
        protocol: "tcp";
        port: number;
        address?: string | undefined;
    })[] | undefined;
    placement?: {
        mode: "off" | "smart";
        hint?: string | undefined;
    } | {
        region: string;
        mode?: "targeted" | undefined;
    } | {
        host: string;
        mode?: "targeted" | undefined;
    } | {
        hostname: string;
        mode?: "targeted" | undefined;
    } | undefined;
    limits?: {
        cpuMs?: number | undefined;
        subrequests?: number | undefined;
    } | undefined;
    logpush?: boolean | undefined;
    observability?: {
        enabled?: boolean | undefined;
        headSamplingRate?: number | undefined;
        redactQueryString?: boolean | undefined;
        logs?: {
            enabled?: boolean | undefined;
            headSamplingRate?: number | undefined;
            invocationLogs?: boolean | undefined;
            persist?: boolean | undefined;
            destinations?: string[] | undefined;
        } | undefined;
        traces?: {
            enabled?: boolean | undefined;
            headSamplingRate?: number | undefined;
            persist?: boolean | undefined;
            destinations?: string[] | undefined;
        } | undefined;
    } | undefined;
    workersDev?: boolean | undefined;
    previewUrls?: boolean | undefined;
    firstPartyWorker?: boolean | undefined;
    unsafe?: {
        metadata?: Record<string, unknown> | undefined;
        capnp?: {
            basePath: string;
            sourceSchemas: string[];
            compiledSchema?: undefined;
        } | {
            compiledSchema: string;
            basePath?: undefined;
            sourceSchemas?: undefined;
        } | undefined;
    } | undefined;
    manifest?: {
        mainModule: string;
        modulesRoot: string;
        modules: Record<string, {
            type: "text" | "json" | "esm" | "cjs" | "python" | "python-requirement" | "wasm" | "data" | "sourcemap";
            contents: string | Uint8Array<ArrayBuffer>;
        }>;
    } | undefined;
    env?: Record<string, {
        type: "external";
        address: string;
        http?: {
            capnpConnectHost: string;
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        } | undefined;
        https?: {
            options?: {
                capnpConnectHost: string;
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
            certificateHost?: string | undefined;
        } | undefined;
    } | ({
        type: "send-email";
        destinationAddress?: string | undefined;
        allowedDestinationAddresses?: string[] | undefined;
        allowedSenderAddresses?: string[] | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & SendEmailBinding) | ({
        type: "vpc-network";
        tunnelId?: string | undefined;
        networkId?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } & VpcNetworkBinding) | {
        type: "browser";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
        headful?: boolean | undefined;
    } | {
        type: "hyperdrive";
        id: string;
        dev: {
            connectionString: string;
        };
    } | {
        type: "worker";
        worker: string | typeof kCurrentWorker;
        exportName?: string | undefined;
        props?: Record<string, unknown> | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "fetcher";
        handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
    } | {
        type: "node-handler";
        handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
    } | {
        type: "network";
        allow?: string[] | undefined;
        deny?: string[] | undefined;
        tlsOptions?: {
            keypair?: {
                privateKey?: string | undefined;
                certificateChain?: string | undefined;
            } | undefined;
            requireClientCerts?: boolean | undefined;
            trustBrowserCas?: boolean | undefined;
            trustedCertificates?: string[] | undefined;
            minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
            cipherList?: string | undefined;
        } | undefined;
    } | {
        type: "disk";
        path: string;
        writable?: boolean | undefined;
    } | {
        type: "hello-world";
        enable_timer?: boolean | undefined;
    } | {
        type: "workflow";
        name: string;
        worker: string;
        exportName: string;
        limits?: {
            steps?: number | undefined;
        } | undefined;
    } | {
        type: "agent-memory";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "ai-search-namespace";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "analytics-engine-dataset";
        name?: string | undefined;
    } | {
        type: "artifacts";
        namespace: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "assets";
    } | {
        type: "d1";
        name?: string | undefined;
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "dispatch-namespace";
        namespace?: string | undefined;
        outbound?: {
            worker: string;
            parameters?: string[] | undefined;
        } | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "durable-object";
        worker: string;
        exportName: string;
    } | {
        type: "flagship";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "images";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "json";
        value: z.core.util.JSONType;
    } | {
        type: "kv";
        id?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "logfwdr";
        destination: string;
    } | {
        type: "media";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "mtls-certificate";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "pipeline";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "queue";
        name?: string | undefined;
        deliveryDelay?: number | undefined;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "rate-limit";
        namespace: string;
        simple: {
            limit: number;
            period: 60 | 10;
        };
    } | {
        type: "r2";
        name?: string | undefined;
        jurisdiction?: string | undefined;
        dev?: {
            remote?: boolean | undefined;
            experimentalS3Credentials?: {
                accessKeyId: string;
                secretAccessKey: string;
            } | undefined;
        } | undefined;
    } | {
        type: "secret";
    } | {
        type: "secrets-store-secret";
        storeId: string;
        secretName: string;
    } | {
        type: "stream";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "text";
        value: string;
    } | {
        type: "vectorize";
        name: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "version-metadata";
    } | {
        type: "vpc-service";
        id: string;
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "web-search";
        dev?: {
            remote?: boolean | undefined;
        } | undefined;
    } | {
        type: "worker-loader";
    } | {
        [x: string]: unknown;
        type: `unsafe:${string}`;
        dev?: {
            plugin: {
                package: string;
                name: string;
            };
            options?: Record<string, unknown> | undefined;
        } | undefined;
    }> | undefined;
    exports?: Record<string, {
        type: "durable-object";
        storage: "sqlite" | "legacy-kv";
        state?: "created" | undefined;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "durable-object";
        state: "expecting-transfer";
        storage: "sqlite" | "legacy-kv";
        transferFrom: string;
        unsafeUniqueKey?: UnsafeUniqueKey | undefined;
        unsafePreventEviction?: boolean | undefined;
        container?: {
            imageName: string;
        } | undefined;
    } | {
        type: "worker";
        cache?: {
            enabled: boolean;
        } | undefined;
    }> | undefined;
    assets?: {
        directory: string;
        hasUserWorker: boolean;
        htmlHandling?: "auto-trailing-slash" | "force-trailing-slash" | "drop-trailing-slash" | "none" | undefined;
        notFoundHandling?: "none" | "single-page-application" | "404-page" | undefined;
        runWorkerFirst?: boolean | string[] | undefined;
    } | undefined;
    tailConsumers?: {
        worker: string;
        streaming?: boolean | undefined;
        entrypoint?: string | undefined;
        props?: Record<string, unknown> | undefined;
    }[] | undefined;
}>>;

export declare const MTLS_PLUGIN: Plugin;

export declare const MTLS_PLUGIN_NAME = "mtls";

export declare class Mutex {
    private locked;
    private resolveQueue;
    private drainQueue;
    private lock;
    private unlock;
    get hasWaiting(): boolean;
    runWith<T>(closure: () => Awaitable<T>): Promise<T>;
    drained(): Promise<void>;
}

export declare function namespaceEntries<Entry extends {
    id: string;
    remoteProxyConnectionString?: RemoteProxyConnectionString;
} = {
    id: string;
    remoteProxyConnectionString?: RemoteProxyConnectionString;
}>(namespaces?: Record<string, string | Entry> | string[]): [bindingName: string, entry: Entry][];

export declare interface Network {
    allow?: string[];
    deny?: string[];
    tlsOptions?: TlsOptions_2;
}

export declare const NODE_PLATFORM_IMPL: PlatformImpl<ReadableStream_3>;

/**
 * We can provide Node.js compatibility in a number of different modes:
 * - "als": this mode tells the workerd runtime to enable only the Async Local Storage builtin library (accessible via `node:async_hooks`).
 * - "v1" - this mode tells the workerd runtime to enable some Node.js builtin libraries (accessible only via `node:...` imports) but no globals.
 * - "v2" - this mode tells the workerd runtime to enable more Node.js builtin libraries (accessible both with and without the `node:` prefix)
 *   and also some Node.js globals such as `Buffer`; it also turns on additional compile-time polyfills for those that are not provided by the runtime.
 *  - null - no Node.js compatibility.
 */
export declare type NodeJSCompatMode = "als" | "v1" | "v2" | null;

export declare class NoOpLog extends Log {
    constructor();
    protected log(): void;
    error(_message: Error): void;
}

export declare function objectEntryWorker(durableObjectNamespace: Worker_Binding_DurableObjectNamespaceDesignator, namespace?: string): Worker;

export declare type Operator = "equals" | "not_equals" | "greater_than" | "less_than" | "greater_than_or_equals" | "less_than_or_equals" | "contains" | "starts_with" | "ends_with" | "in" | "not_in";

export declare type OverloadReplaceWorkersTypes<T> = T extends (...args: any[]) => any ? UnionToIntersection<ReplaceWorkersTypes<OverloadUnion<T>>> : ReplaceWorkersTypes<T>;

export declare type OverloadUnion<T extends (...args: any[]) => any> = Parameters<T> extends [] ? T : OverloadUnion14<T>;

export declare type OverloadUnion10<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
    (...args: infer P7): infer R7;
    (...args: infer P8): infer R8;
    (...args: infer P9): infer R9;
    (...args: infer P10): infer R10;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) | ((...args: P7) => R7) | ((...args: P8) => R8) | ((...args: P9) => R9) | ((...args: P10) => R10) : OverloadUnion9<T>;

export declare type OverloadUnion11<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
    (...args: infer P7): infer R7;
    (...args: infer P8): infer R8;
    (...args: infer P9): infer R9;
    (...args: infer P10): infer R10;
    (...args: infer P11): infer R11;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) | ((...args: P7) => R7) | ((...args: P8) => R8) | ((...args: P9) => R9) | ((...args: P10) => R10) | ((...args: P11) => R11) : OverloadUnion10<T>;

export declare type OverloadUnion12<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
    (...args: infer P7): infer R7;
    (...args: infer P8): infer R8;
    (...args: infer P9): infer R9;
    (...args: infer P10): infer R10;
    (...args: infer P11): infer R11;
    (...args: infer P12): infer R12;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) | ((...args: P7) => R7) | ((...args: P8) => R8) | ((...args: P9) => R9) | ((...args: P10) => R10) | ((...args: P11) => R11) | ((...args: P12) => R12) : OverloadUnion11<T>;

export declare type OverloadUnion13<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
    (...args: infer P7): infer R7;
    (...args: infer P8): infer R8;
    (...args: infer P9): infer R9;
    (...args: infer P10): infer R10;
    (...args: infer P11): infer R11;
    (...args: infer P12): infer R12;
    (...args: infer P13): infer R13;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) | ((...args: P7) => R7) | ((...args: P8) => R8) | ((...args: P9) => R9) | ((...args: P10) => R10) | ((...args: P11) => R11) | ((...args: P12) => R12) | ((...args: P13) => R13) : OverloadUnion12<T>;

export declare type OverloadUnion14<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
    (...args: infer P7): infer R7;
    (...args: infer P8): infer R8;
    (...args: infer P9): infer R9;
    (...args: infer P10): infer R10;
    (...args: infer P11): infer R11;
    (...args: infer P12): infer R12;
    (...args: infer P13): infer R13;
    (...args: infer P14): infer R14;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) | ((...args: P7) => R7) | ((...args: P8) => R8) | ((...args: P9) => R9) | ((...args: P10) => R10) | ((...args: P11) => R11) | ((...args: P12) => R12) | ((...args: P13) => R13) | ((...args: P14) => R14) : OverloadUnion13<T>;

export declare type OverloadUnion2<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) : T;

export declare type OverloadUnion3<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) : OverloadUnion2<T>;

export declare type OverloadUnion4<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) : OverloadUnion3<T>;

export declare type OverloadUnion5<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) : OverloadUnion4<T>;

export declare type OverloadUnion6<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) : OverloadUnion5<T>;

export declare type OverloadUnion7<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
    (...args: infer P7): infer R7;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) | ((...args: P7) => R7) : OverloadUnion6<T>;

export declare type OverloadUnion8<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
    (...args: infer P7): infer R7;
    (...args: infer P8): infer R8;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) | ((...args: P7) => R7) | ((...args: P8) => R8) : OverloadUnion7<T>;

export declare type OverloadUnion9<T> = T extends {
    (...args: infer P1): infer R1;
    (...args: infer P2): infer R2;
    (...args: infer P3): infer R3;
    (...args: infer P4): infer R4;
    (...args: infer P5): infer R5;
    (...args: infer P6): infer R6;
    (...args: infer P7): infer R7;
    (...args: infer P8): infer R8;
    (...args: infer P9): infer R9;
} ? ((...args: P1) => R1) | ((...args: P2) => R2) | ((...args: P3) => R3) | ((...args: P4) => R4) | ((...args: P5) => R5) | ((...args: P6) => R6) | ((...args: P7) => R7) | ((...args: P8) => R8) | ((...args: P9) => R9) : OverloadUnion8<T>;

export declare type ParsedDevConfig = NonNullable<ParsedWorkerOptions["dev"]>;

/**
 * The fully-parsed instance-wide (shared) options, as passed to plugin methods.
 */
export declare type ParsedInstanceOptions = z.output<typeof InstanceOptionsSchema>;

export declare type ParsedLegacyConfig = NonNullable<ParsedWorkerOptions["legacy"]>;

export declare const ParsedMiniflareKnownBindingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    type: z.ZodLiteral<"kv">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    id: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    type: z.ZodLiteral<"d1">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    id: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"flagship">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    id: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"r2">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
        experimentalS3Credentials: z.ZodOptional<z.ZodObject<{
            accessKeyId: z.ZodString;
            secretAccessKey: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strict>>;
    jurisdiction: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"analytics-engine-dataset">;
    name: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    type: z.ZodLiteral<"queue">;
    deliveryDelay: z.ZodOptional<z.ZodNumber>;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    name: z.ZodString;
}, z.core.$strict>, ...(z.ZodObject<{
    type: z.ZodLiteral<"browser">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    headful: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"hyperdrive">;
    id: z.ZodString;
    dev: z.ZodObject<{
        connectionString: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"worker">;
    exportName: z.ZodOptional<z.ZodString>;
    props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
    worker: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"fetcher">;
    handler: z.ZodCustom<(request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>, (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"node-handler">;
    handler: z.ZodCustom<(req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>, (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"external">;
    address: z.ZodString;
    http: z.ZodOptional<z.ZodPipe<z.ZodObject<{
        style: z.ZodOptional<z.ZodEnum<{
            readonly HOST: 0;
            readonly PROXY: 1;
        }>>;
        forwardedProtoHeader: z.ZodOptional<z.ZodString>;
        cfBlobHeader: z.ZodOptional<z.ZodString>;
        injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            value: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
        injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            value: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
    }, z.core.$strict>, z.ZodTransform<{
        capnpConnectHost: string;
        style?: 0 | 1 | undefined;
        forwardedProtoHeader?: string | undefined;
        cfBlobHeader?: string | undefined;
        injectRequestHeaders?: {
            name: string;
            value?: string | undefined;
        }[] | undefined;
        injectResponseHeaders?: {
            name: string;
            value?: string | undefined;
        }[] | undefined;
    }, {
        style?: 0 | 1 | undefined;
        forwardedProtoHeader?: string | undefined;
        cfBlobHeader?: string | undefined;
        injectRequestHeaders?: {
            name: string;
            value?: string | undefined;
        }[] | undefined;
        injectResponseHeaders?: {
            name: string;
            value?: string | undefined;
        }[] | undefined;
    }>>>;
    https: z.ZodOptional<z.ZodObject<{
        options: z.ZodOptional<z.ZodPipe<z.ZodObject<{
            style: z.ZodOptional<z.ZodEnum<{
                readonly HOST: 0;
                readonly PROXY: 1;
            }>>;
            forwardedProtoHeader: z.ZodOptional<z.ZodString>;
            cfBlobHeader: z.ZodOptional<z.ZodString>;
            injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                value: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
            injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                value: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>>;
        }, z.core.$strict>, z.ZodTransform<{
            capnpConnectHost: string;
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        }, {
            style?: 0 | 1 | undefined;
            forwardedProtoHeader?: string | undefined;
            cfBlobHeader?: string | undefined;
            injectRequestHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
            injectResponseHeaders?: {
                name: string;
                value?: string | undefined;
            }[] | undefined;
        }>>>;
        tlsOptions: z.ZodOptional<z.ZodObject<{
            keypair: z.ZodOptional<z.ZodObject<{
                privateKey: z.ZodOptional<z.ZodString>;
                certificateChain: z.ZodOptional<z.ZodString>;
            }, z.core.$strict>>;
            requireClientCerts: z.ZodOptional<z.ZodBoolean>;
            trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
            trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
            minVersion: z.ZodOptional<z.ZodEnum<{
                readonly GOOD_DEFAULT: 0;
                readonly SSL3: 1;
                readonly TLS1DOT0: 2;
                readonly TLS1DOT1: 3;
                readonly TLS1DOT2: 4;
                readonly TLS1DOT3: 5;
            }>>;
            cipherList: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        certificateHost: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"network">;
    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
    deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
    tlsOptions: z.ZodOptional<z.ZodObject<{
        keypair: z.ZodOptional<z.ZodObject<{
            privateKey: z.ZodOptional<z.ZodString>;
            certificateChain: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>;
        requireClientCerts: z.ZodOptional<z.ZodBoolean>;
        trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
        trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
        minVersion: z.ZodOptional<z.ZodEnum<{
            readonly GOOD_DEFAULT: 0;
            readonly SSL3: 1;
            readonly TLS1DOT0: 2;
            readonly TLS1DOT1: 3;
            readonly TLS1DOT2: 4;
            readonly TLS1DOT3: 5;
        }>>;
        cipherList: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"disk">;
    path: z.ZodString;
    writable: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"hello-world">;
    enable_timer: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"workflow">;
    name: z.ZodString;
    worker: z.ZodString;
    exportName: z.ZodString;
    limits: z.ZodOptional<z.ZodObject<{
        steps: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"agent-memory">;
    namespace: z.ZodString;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"ai">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"ai-search">;
    name: z.ZodString;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"ai-search-namespace">;
    namespace: z.ZodString;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"artifacts">;
    namespace: z.ZodString;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"assets">;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"dispatch-namespace">;
    namespace: z.ZodOptional<z.ZodString>;
    outbound: z.ZodOptional<z.ZodObject<{
        worker: z.ZodString;
        parameters: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strict>>;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"durable-object">;
    worker: z.ZodString;
    exportName: z.ZodString;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"images">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"json">;
    value: z.ZodJSONSchema;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"logfwdr">;
    destination: z.ZodString;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"media">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"mtls-certificate">;
    id: z.ZodString;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"pipeline">;
    name: z.ZodString;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"rate-limit">;
    namespace: z.ZodString;
    simple: z.ZodObject<{
        limit: z.ZodNumber;
        period: z.ZodUnion<readonly [z.ZodLiteral<10>, z.ZodLiteral<60>]>;
    }, z.core.$strict>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"secret">;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"secrets-store-secret">;
    storeId: z.ZodString;
    secretName: z.ZodString;
}, z.core.$strict> | (z.ZodObject<{
    type: z.ZodLiteral<"send-email">;
    destinationAddress: z.ZodOptional<z.ZodString>;
    allowedDestinationAddresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
    allowedSenderAddresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> & z.ZodType<SendEmailBinding, {
    type: "send-email";
    destinationAddress?: string | undefined;
    allowedDestinationAddresses?: string[] | undefined;
    allowedSenderAddresses?: string[] | undefined;
    dev?: {
        remote?: boolean | undefined;
    } | undefined;
}, z.core.$ZodTypeInternals<SendEmailBinding, {
    type: "send-email";
    destinationAddress?: string | undefined;
    allowedDestinationAddresses?: string[] | undefined;
    allowedSenderAddresses?: string[] | undefined;
    dev?: {
        remote?: boolean | undefined;
    } | undefined;
}>>) | z.ZodObject<{
    type: z.ZodLiteral<"stream">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"text">;
    value: z.ZodString;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"vectorize">;
    name: z.ZodString;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"version-metadata">;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"vpc-service">;
    id: z.ZodString;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | (z.ZodObject<{
    type: z.ZodLiteral<"vpc-network">;
    tunnelId: z.ZodOptional<z.ZodString>;
    networkId: z.ZodOptional<z.ZodString>;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> & z.ZodType<VpcNetworkBinding, {
    type: "vpc-network";
    tunnelId?: string | undefined;
    networkId?: string | undefined;
    dev?: {
        remote?: boolean | undefined;
    } | undefined;
}, z.core.$ZodTypeInternals<VpcNetworkBinding, {
    type: "vpc-network";
    tunnelId?: string | undefined;
    networkId?: string | undefined;
    dev?: {
        remote?: boolean | undefined;
    } | undefined;
}>>) | z.ZodObject<{
    type: z.ZodLiteral<"web-search">;
    dev: z.ZodOptional<z.ZodObject<{
        remote: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strict>>;
}, z.core.$strict> | z.ZodObject<{
    type: z.ZodLiteral<"worker-loader">;
}, z.core.$strict>)[]], "type">;

export declare type ParsedMiniflareWorkerConfig = Omit<z.output<typeof MiniflareWorkerConfigBaseSchema>, "env"> & {
    env?: Record<string, MiniflareBinding>;
};

/** Discriminated union of both protocol versions */
export declare type ParsedModuleFallbackRequest = V1ModuleFallbackRequest | V2ModuleFallbackRequest;

/**
 * A single fully-parsed worker's options, as passed to plugin methods.
 */
export declare type ParsedWorkerOptions = z.output<typeof WorkerOptionsSchema>;

/**
 * Parses a module fallback service request into a protocol-specific format.
 * Automatically detects V1 vs V2 protocol based on HTTP method.
 *
 * @param request - The incoming Request object
 * @returns Parsed request data, or null if the request is malformed
 */
export declare function parseModuleFallbackRequest(request: Request_2): Promise<ParsedModuleFallbackRequest | null>;

/**
 * Parses an HTTP `Range` header (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range),
 * returning either:
 * - `undefined` indicating the range is unsatisfiable
 * - An empty array indicating the entire response should be returned
 * - A non-empty array of inclusive ranges of the response to return
 */
export declare function parseRanges(rangeHeader: string, length: number): InclusiveRange[] | undefined;

export declare function parseRoutes(allRoutes: Map<string, string[]>): WorkerRoute[];

export declare function parseWithReadableStreams<RS>(impl: PlatformImpl<RS>, stringified: StringifiedWithStream<RS>, revivers: ReducersRevivers): unknown;

export declare function parseWithRootPath<Z extends z.ZodType>(newRootPath: string, schema: Z, data: unknown, options?: {
    path?: (string | number)[];
}): z.infer<Z>;

export declare const PathSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;

export declare enum PeriodType {
    TENSECONDS = 10,
    MINUTE = 60
}

export declare const PIPELINE_PLUGIN: Plugin;

export declare const PIPELINES_PLUGIN_NAME = "pipelines";

export declare interface PlatformImpl<RS> {
    Blob: typeof Blob_2;
    File: typeof File_2;
    Headers: typeof Headers_3;
    Request: typeof Request_4;
    Response: typeof Response_4;
    isReadableStream(value: unknown): value is RS;
    bufferReadableStream(stream: RS): Promise<ArrayBuffer>;
    unbufferReadableStream(buffer: ArrayBuffer): RS;
}

/**
 * Every plugin receives the full parsed per-worker `WorkerOptions` and filters
 * its own bindings out of `options.config.env` / `options.config.exports` /
 * `options.config.triggers` (plus `options.legacy` / `options.dev`).
 */
export declare interface Plugin {
    bindingTypeDescription?: string;
    getBindings(options: ParsedWorkerOptions, sharedOptions: ParsedInstanceOptions, workerIndex: number): Awaitable<Worker_Binding[] | void>;
    getNodeBindings(options: ParsedWorkerOptions): Awaitable<Record<string, unknown>>;
    getServices(options: PluginServicesOptions): Awaitable<Service_2[] | ServicesExtensions | void>;
    getExtensions?(options: {
        options: ParsedWorkerOptions[];
    }): Awaitable<Extension[]>;
}

export declare const PLUGIN_ENTRIES: [keyof Plugins, ValueOf<Plugins>][];

export declare const PLUGINS: {
    core: Plugin_2;
    cache: Plugin_2;
    d1: Plugin_2;
    do: Plugin_2;
    kv: Plugin_2;
    queues: Plugin_2;
    r2: Plugin_2;
    hyperdrive: Plugin_2;
    ratelimit: Plugin_2;
    assets: Plugin_2;
    workflows: Plugin_2;
    pipelines: Plugin_2;
    "secrets-store": Plugin_2;
    email: Plugin_2;
    "analytics-engine": Plugin_2;
    ai: Plugin_2;
    "agent-memory": Plugin_2;
    "ai-search": Plugin_2;
    websearch: Plugin_2;
    "browser-rendering": Plugin_2;
    "dispatch-namespace": Plugin_2;
    images: Plugin_2;
    stream: Plugin_2;
    vectorize: Plugin_2;
    "vpc-networks": Plugin_2;
    "vpc-services": Plugin_2;
    mtls: Plugin_2;
    "hello-world": Plugin_2;
    flagship: Plugin_2;
    artifacts: Plugin_2;
    "worker-loader": Plugin_2;
    media: Plugin_2;
    "version-metadata": Plugin_2;
};

export declare type Plugins = typeof PLUGINS;

export declare interface PluginServicesOptions {
    log: Log;
    options: ParsedWorkerOptions;
    sharedOptions: ParsedInstanceOptions;
    workerBindings: Worker_Binding[];
    workerIndex: number;
    additionalModules: Worker_Module[];
    tmpPath: string;
    workerNames: string[];
    loopbackHost: string;
    loopbackPort: number;
    durableObjectClassNames: DurableObjectClassNames;
    unsafeEphemeralDurableObjects: boolean;
    queueProducers: QueueProducers;
    queueConsumers: QueueConsumers;
    devRegistryEnabled: boolean;
    containerPrivilegesCache: ContainerPrivilegesCache;
    hyperdriveProxyController: HyperdriveProxyController;
}

export declare const POSTGRES_SSL_REQUEST_PACKET: Buffer<ArrayBuffer>;

export declare function prefixError(prefix: string, e: any): Error;

export declare function prefixStream(prefix: Uint8Array, stream: ReadableStream_3<Uint8Array>): ReadableStream_3<Uint8Array>;

/**
 * Processes a stack trace by applying a custom frame transformer.
 * The transformer receives each frame line and its location (file:line:column);
 * if it returns null, that frame is dropped; otherwise its return value replaces the line.
 */
export declare function processStackTrace(stack: string, transformFrame: (line: string, location: string) => string | null): string;

export declare const ProxyAddresses: {
    readonly GLOBAL: 0;
    readonly ENV: 1;
    readonly USER_START: 2;
};

export declare class ProxyClient {
    #private;
    constructor(runtimeEntryURL: URL, dispatchFetch: DispatchFetch);
    get global(): ServiceWorkerGlobalScope_2;
    get env(): Record<string, unknown>;
    poisonProxies(): void;
    setRuntimeEntryURL(runtimeEntryURL: URL): void;
    dispose(): Promise<void>;
}

export declare class ProxyNodeBinding {
    proxyOverrideHandler?: ProxyHandler<any> | undefined;
    constructor(proxyOverrideHandler?: ProxyHandler<any> | undefined);
}

export declare const ProxyOps: {
    readonly GET: "GET";
    readonly GET_OWN_DESCRIPTOR: "GET_OWN_DESCRIPTOR";
    readonly GET_OWN_KEYS: "GET_OWN_KEYS";
    readonly CALL: "CALL";
    readonly FREE: "FREE";
};

export declare const QueueBindings: {
    readonly SERVICE_WORKER_PREFIX: "MINIFLARE_WORKER_";
    readonly MAYBE_JSON_QUEUE_PRODUCERS: "MINIFLARE_QUEUE_PRODUCERS";
    readonly MAYBE_JSON_QUEUE_CONSUMERS: "MINIFLARE_QUEUE_CONSUMERS";
    readonly MAYBE_SERVICE_QUEUE_PROXY: "MINIFLARE_QUEUE_PROXY";
};

export declare type QueueConsumer = z.infer<typeof QueueConsumerSchema>;

export declare const QueueConsumerOptionsSchema: z.ZodObject<{
    maxBatchSize: z.ZodOptional<z.ZodNumber>;
    maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
    maxRetries: z.ZodOptional<z.ZodNumber>;
    deadLetterQueue: z.ZodOptional<z.ZodString>;
    retryDelay: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;

export declare type QueueConsumers = Map<string, z.infer<typeof QueueConsumerSchema>>;

export declare const QueueConsumerSchema: z.ZodIntersection<z.ZodObject<{
    maxBatchSize: z.ZodOptional<z.ZodNumber>;
    maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
    maxRetries: z.ZodOptional<z.ZodNumber>;
    deadLetterQueue: z.ZodOptional<z.ZodString>;
    retryDelay: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    workerName: z.ZodString;
}, z.core.$strip>>;

export declare const QueueConsumersSchema: z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodObject<{
    maxBatchSize: z.ZodOptional<z.ZodNumber>;
    maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
    maxRetries: z.ZodOptional<z.ZodNumber>;
    deadLetterQueue: z.ZodOptional<z.ZodString>;
    retryDelay: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    workerName: z.ZodString;
}, z.core.$strip>>>;

declare type QueueContentType_2 = z.infer<typeof QueueContentTypeSchema>;
export { QueueContentType_2 as QueueContentType }

export declare const QueueContentTypeSchema: z.ZodDefault<z.ZodEnum<{
    text: "text";
    json: "json";
    bytes: "bytes";
    v8: "v8";
}>>;

export declare type QueueIncomingMessage = z.infer<typeof QueueIncomingMessageSchema>;

export declare const QueueIncomingMessageSchema: z.ZodObject<{
    contentType: z.ZodDefault<z.ZodEnum<{
        text: "text";
        json: "json";
        bytes: "bytes";
        v8: "v8";
    }>>;
    delaySecs: z.ZodOptional<z.ZodNumber>;
    body: z.ZodPipe<z.ZodString, z.ZodTransform<Buffer<ArrayBuffer>, string>>;
    id: z.ZodOptional<z.ZodString>;
    timestamp: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;

export declare type QueueMessageDelay = z.infer<typeof QueueMessageDelaySchema>;

export declare const QueueMessageDelaySchema: z.ZodOptional<z.ZodNumber>;

export declare type QueueOutgoingMessage = z.input<typeof QueueIncomingMessageSchema>;

export declare type QueueProducer = z.infer<typeof QueueProducerSchema>;

export declare const QueueProducerOptionsSchema: z.ZodObject<{
    queueName: z.ZodString;
    deliveryDelay: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;

export declare type QueueProducers = Map<string, z.infer<typeof QueueProducerSchema>>;

export declare const QueueProducerSchema: z.ZodIntersection<z.ZodObject<{
    queueName: z.ZodString;
    deliveryDelay: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    workerName: z.ZodString;
}, z.core.$strip>>;

export declare const QueueProducersSchema: z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodObject<{
    queueName: z.ZodString;
    deliveryDelay: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>, z.ZodObject<{
    workerName: z.ZodString;
}, z.core.$strip>>>;

export declare const QUEUES_PLUGIN: Plugin;

export declare const QUEUES_PLUGIN_NAME = "queues";

export declare const QueuesBatchRequestSchema: z.ZodObject<{
    messages: z.ZodArray<z.ZodObject<{
        contentType: z.ZodDefault<z.ZodEnum<{
            text: "text";
            json: "json";
            bytes: "bytes";
            v8: "v8";
        }>>;
        delaySecs: z.ZodOptional<z.ZodNumber>;
        body: z.ZodPipe<z.ZodString, z.ZodTransform<Buffer<ArrayBuffer>, string>>;
        id: z.ZodOptional<z.ZodString>;
        timestamp: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
}, z.core.$strip>;

export declare class QueuesError extends MiniflareError<QueuesErrorCode> {
}

export declare type QueuesErrorCode = "ERR_MULTIPLE_CONSUMERS" | "ERR_DEAD_LETTER_QUEUE_CYCLE";

export declare type QueuesOutgoingBatchRequest = z.input<typeof QueuesBatchRequestSchema>;

export declare const R2_PLUGIN: Plugin;

export declare const R2_PLUGIN_NAME = "r2";

export declare const R2_PUBLIC_SERVICE_NAME = "r2:public";

export declare const R2_S3_SERVICE_NAME = "r2:s3";

export declare const RATELIMIT_PLUGIN: Plugin;

export declare const RATELIMIT_PLUGIN_NAME = "ratelimit";

export declare function readPrefix(stream: ReadableStream_3<Uint8Array>, prefixLength: number): Promise<[prefix: Buffer, rest: ReadableStream_3<Uint8Array>]>;

export declare function reduceError(e: any): JsonError;

export declare type ReducerReviver = (value: unknown) => unknown;

export declare type ReducersRevivers = Record<string, ReducerReviver>;

export { ReferrerPolicy }

export declare function remoteProxyClientWorker(script?: () => string, options?: {
    rawTcp?: boolean;
}): {
    modules: {
        name: string;
        esModule: string;
    }[];
    bindings: Worker_Binding[];
    compatibilityFlags?: string[] | undefined;
    compatibilityDate: string;
};

export declare type RemoteProxyConnectionString = URL & {
    __brand: "RemoteProxyConnectionString";
};

export declare type ReplaceWorkersTypes<T> = T extends Request_4 ? Request_2 : T extends Response_4 ? Response_2 : T extends ReadableStream_2 ? ReadableStream_3 : Required<T> extends Required<RequestInit_4> ? RequestInit_2 : T extends Headers_3 ? Headers_2 : T extends Blob_2 ? Blob_3 : T extends AbortSignal_2 ? AbortSignal : T extends Promise<infer P> ? Promise<ReplaceWorkersTypes<P>> : T extends (...args: infer P) => infer R ? (...args: ReplaceWorkersTypes<P>) => ReplaceWorkersTypes<R> : T extends object ? {
    [K in keyof T]: OverloadReplaceWorkersTypes<T[K]>;
} : T;

declare class Request_2<CfType extends RequestInitCfType = RequestInitCfType> extends Request_3 {
    [kCf]?: CfType;
    constructor(input: RequestInfo_2, init?: RequestInit_2<CfType>);
    get cf(): CfType | undefined;
    clone(): Request_2<CfType>;
}
export { Request_2 as Request }

export { RequestCache }

export { RequestCredentials }

export { RequestDestination }

export { RequestDuplex }

declare type RequestInfo_2 = RequestInfo_3 | Request_2;
export { RequestInfo_2 as RequestInfo }

declare interface RequestInit_2<CfType extends RequestInitCfType = RequestInitCfType> extends RequestInit_3 {
    cf?: CfType;
}
export { RequestInit_2 as RequestInit }

export declare type RequestInitCfType = Partial<IncomingRequestCfProperties_2> | RequestInitCfProperties_2;

export { RequestMode }

export { RequestRedirect }

declare class Response_2 extends Response_3 {
    readonly [kWebSocket]: WebSocket_2 | null;
    static error(): Response_2;
    static redirect(url: string | URL, status: ResponseRedirectStatus): Response_2;
    static json(data: any, init?: ResponseInit_2): Response_2;
    constructor(body?: BodyInit_2, init?: ResponseInit_2);
    /** @ts-expect-error `status` is actually defined as a getter internally */
    get status(): number;
    get webSocket(): WebSocket_2 | null;
    clone(): Response_2;
}
export { Response_2 as Response }

declare interface ResponseInit_2 extends ResponseInit_3 {
    webSocket?: WebSocket_2 | null;
}
export { ResponseInit_2 as ResponseInit }

export { ResponseRedirectStatus }

export { ResponseType }

export declare interface Rollout {
    percentage: number;
    attribute?: string;
}

export declare class RouterError extends MiniflareError<RouterErrorCode> {
}

export declare type RouterErrorCode = "ERR_QUERY_STRING" | "ERR_INFIX_WILDCARD";

export declare interface Rule {
    priority: number;
    conditions: Condition[];
    serve_variation: string;
    rollout?: Rollout;
}

export declare class Runtime {
    #private;
    updateConfig(configBuffer: Buffer, options: Abortable & RuntimeOptions, workerNames: string[], abortSignal: AbortSignal): Promise<SocketPorts | undefined>;
    dispose(): Awaitable<void>;
}

export declare interface RuntimeOptions {
    entryAddress: string;
    loopbackAddress: string;
    requiredSockets: SocketIdentifier[];
    inspectorAddress?: string;
    debugPortAddress?: string;
    verbose?: boolean;
    handleStructuredLogs?: StructuredLogsHandler;
    onWorkerdCrashRestart?: () => void;
    runtimeEnv?: Record<string, string>;
}

export declare function sanitisePath(unsafe: string): string;

export declare const SECRET_STORE_PLUGIN: Plugin;

export declare const SECRET_STORE_PLUGIN_NAME = "secrets-store";

export declare interface SecretsStoreSecretAdmin {
    create(value: string): Promise<string>;
    update(value: string, id: string): Promise<string>;
    duplicate(id: string, newName: string): Promise<string>;
    delete(id: string): Promise<void>;
    list(): Promise<KVNamespaceListKey_2<{
        uuid: string;
    }, string>[]>;
    get(id: string): Promise<string>;
}

export declare interface SerialisableMatcherRegExps {
    include: string[];
    exclude: string[];
}

export declare interface SerialisableSiteMatcherRegExps {
    include?: SerialisableMatcherRegExps;
    exclude?: SerialisableMatcherRegExps;
}

export declare function serialiseRegExps(matcher: MatcherRegExps): SerialisableMatcherRegExps;

export declare function serialiseSiteRegExps(siteRegExps: SiteMatcherRegExps): SerialisableSiteMatcherRegExps;

export declare function serializeConfig(config: Config): Buffer;

declare type Service_2 = {
    name?: string;
} & ({
    worker?: Worker;
} | {
    network?: Network;
} | {
    external?: ExternalServer;
} | {
    disk?: DiskDirectory;
});
export { Service_2 as Service }

export declare const SERVICE_DEV_REGISTRY_PROXY = "dev-registry-proxy";

export declare const SERVICE_ENTRY = "core:entry";

export declare const SERVICE_LOOPBACK = "loopback";

export declare const SERVICE_QUEUE_PREFIX = "queues:queue";

export declare interface ServiceDesignator {
    name?: string;
    entrypoint?: string;
    props?: {
        json: string;
    };
}

export declare interface ServicesExtensions {
    services: Service_2[];
    extensions: Extension[];
}

export declare const SharedBindings: {
    readonly TEXT_NAMESPACE: "MINIFLARE_NAMESPACE";
    readonly DURABLE_OBJECT_NAMESPACE_OBJECT: "MINIFLARE_OBJECT";
    readonly MAYBE_SERVICE_BLOBS: "MINIFLARE_BLOBS";
    readonly MAYBE_SERVICE_LOOPBACK: "MINIFLARE_LOOPBACK";
    readonly MAYBE_JSON_ENABLE_CONTROL_ENDPOINTS: "MINIFLARE_ENABLE_CONTROL_ENDPOINTS";
};

export declare const SharedHeaders: {
    readonly LOG_LEVEL: "MF-Log-Level";
    readonly NAMESPACE: "MF-Namespace";
};

export declare const SiteBindings: {
    readonly KV_NAMESPACE_SITE: "__STATIC_CONTENT";
    readonly JSON_SITE_MANIFEST: "__STATIC_CONTENT_MANIFEST";
    readonly JSON_SITE_FILTER: "MINIFLARE_SITE_FILTER";
};

export declare interface SiteMatcherRegExps {
    include?: MatcherRegExps;
    exclude?: MatcherRegExps;
}

export declare const SITES_NO_CACHE_PREFIX = "$__MINIFLARE_SITES__$/";

declare type Socket_2 = {
    name?: string;
    address?: string;
    service?: ServiceDesignator;
} & ({
    http?: HttpOptions;
} | {
    https?: Socket_Https;
} | {
    tcp?: Socket_Tcp;
});
export { Socket_2 as Socket }

export declare const SOCKET_DEBUG_PORT = "debug-port";

export declare const SOCKET_DEV_REGISTRY = "dev-registry";

export declare const SOCKET_ENTRY = "entry";

export declare const SOCKET_ENTRY_LOCAL = "entry:local";

export declare interface Socket_Https {
    options?: HttpOptions;
    tlsOptions?: TlsOptions_2;
}

export declare interface Socket_Tcp {
    tlsOptions?: TlsOptions_2;
}

export declare type SocketIdentifier = string | typeof kInspectorSocket;

export declare type SocketPorts = Map<SocketIdentifier, number>;

export declare const STREAM_COMPAT_DATE = "2026-03-23";

export declare const STREAM_OBJECT_CLASS_NAME = "StreamObject";

export declare const STREAM_PLUGIN: Plugin;

export declare const STREAM_PLUGIN_NAME = "stream";

export declare interface StringifiedWithStream<RS> {
    value: string;
    unbufferedStream?: RS;
}

export declare function stringifyWithStreams<RS>(impl: PlatformImpl<RS>, value: unknown, reducers: ReducersRevivers, allowUnbufferedStream: boolean): StringifiedWithStream<RS> | Promise<StringifiedWithStream<RS>>;

export declare function stripAnsi(value: string): string;

export declare type StructuredLogsHandler = (structuredLog: WorkerdStructuredLog) => void;

export declare const structuredSerializableReducers: ReducersRevivers;

export declare const structuredSerializableRevivers: ReducersRevivers;

export declare const SYSTEM_ERROR_CODES: Set<"ERR_RUNTIME_FAILURE" | "ERR_PLUGIN_LOADING_FAILED">;

export declare function testRegExps(matcher: MatcherRegExps, value: string): boolean;

export declare function testSiteRegExps(regExps: SiteMatcherRegExps, key: string): boolean;

declare interface TlsOptions_2 {
    keypair?: TlsOptions_Keypair;
    requireClientCerts?: boolean;
    trustBrowserCas?: boolean;
    trustedCertificates?: string[];
    minVersion?: TlsOptions_Version;
    cipherList?: string;
}
export { TlsOptions_2 as TlsOptions }

export declare interface TlsOptions_Keypair {
    privateKey?: string;
    certificateChain?: string;
}

export declare const TlsOptions_Version: {
    /**
     * A good default chosen by the code maintainers. May change over time.
     *
     */
    readonly GOOD_DEFAULT: 0;
    readonly SSL3: 1;
    readonly TLS1DOT0: 2;
    readonly TLS1DOT1: 3;
    readonly TLS1DOT2: 4;
    readonly TLS1DOT3: 5;
};

export declare type TlsOptions_Version = (typeof TlsOptions_Version)[keyof typeof TlsOptions_Version];

export declare function _transformsForContentEncodingAndContentType(encoding: string | undefined, type: string | undefined | null): Transform[];

export declare type TypedEventListener<E extends Event> = ((e: E) => void) | {
    handleEvent(e: E): void;
};

export declare class TypedEventTarget<EventMap extends Record<string, Event>> extends EventTarget {
    addEventListener<Type extends keyof EventMap>(type: Type, listener: TypedEventListener<EventMap[Type]> | null, options?: AddEventListenerOptions | boolean): void;
    removeEventListener<Type extends keyof EventMap>(type: Type, listener: TypedEventListener<EventMap[Type]> | null, options?: EventListenerOptions | boolean): void;
    dispatchEvent(event: ValueOf<EventMap>): boolean;
}

export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

export declare type UnsafeUniqueKey = string | typeof kUnsafeEphemeralUniqueKey;

export declare const USER_ERROR_CODES: Set<"ERR_ADDRESS_IN_USE" | "ERR_DISPOSED" | "ERR_MODULE_PARSE" | "ERR_MODULE_STRING_SCRIPT" | "ERR_MODULE_DYNAMIC_SPEC" | "ERR_MODULE_RULE" | "ERR_PERSIST_UNSUPPORTED" | "ERR_FUTURE_COMPATIBILITY_DATE" | "ERR_NO_WORKERS" | "ERR_VALIDATION" | "ERR_DUPLICATE_NAME" | "ERR_DIFFERENT_STORAGE_BACKEND" | "ERR_DIFFERENT_UNIQUE_KEYS" | "ERR_DIFFERENT_PREVENT_EVICTION" | "ERR_DIFFERENT_S3_CREDENTIALS" | "ERR_MISSING_INSPECTOR_PROXY_PORT" | "ERR_MISSING_EXPLORER_UI">;

/** V1 protocol request (legacy module registry) */
export declare interface V1ModuleFallbackRequest {
    protocol: "v1";
    /** Import type: "import" for ES modules, "require" for CommonJS */
    type: "import" | "require";
    /** Module specifier as a path (e.g., "/my-module.js") */
    specifier: string;
    /** Original specifier as written in source code */
    rawSpecifier?: string;
    /** Referrer module path */
    referrer?: string;
}

/** V2 protocol request (new module registry) */
export declare interface V2ModuleFallbackRequest {
    protocol: "v2";
    /** Import type: includes "internal" for runtime-originated imports */
    type: "import" | "require" | "internal";
    /** Module specifier as a URL (e.g., "file:///bundle/my-module.js") */
    specifier: string;
    /** Original specifier as written in source code */
    rawSpecifier?: string;
    /** Referrer module URL */
    referrer?: string;
    /** Import attributes from the import statement */
    attributes?: Array<{
        name: string;
        value: string;
    }>;
}

export declare type V4DurableObject = {
    className: string;
    scriptName?: string;
    useSQLite?: boolean;
    unsafeUniqueKey?: string | symbol;
    unsafePreventEviction?: boolean;
    remoteProxyConnectionString?: RemoteProxyConnectionString;
    container?: {
        imageName: string;
    };
};

export declare type V4FetchHandler = (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;

export declare type V4IdEntry = {
    id: string;
    remoteProxyConnectionString?: RemoteProxyConnectionString;
};

export declare type V4MiniflareOptions = V4SharedOptions & (V4WorkerOptions | {
    workers: V4WorkerOptions[];
});

export declare const V4MiniflareOptionsSchema: z.ZodIntersection<z.ZodObject<{
    rootPath: z.ZodOptional<z.ZodString>;
    host: z.ZodOptional<z.ZodString>;
    port: z.ZodOptional<z.ZodNumber>;
    https: z.ZodOptional<z.ZodBoolean>;
    httpsKey: z.ZodOptional<z.ZodString>;
    httpsCert: z.ZodOptional<z.ZodString>;
    inspectorPort: z.ZodOptional<z.ZodNumber>;
    inspectorHost: z.ZodOptional<z.ZodString>;
    verbose: z.ZodOptional<z.ZodBoolean>;
    log: z.ZodOptional<z.ZodCustom<Log, Log>>;
    handleStructuredLogs: z.ZodOptional<z.ZodCustom<(log: V4WorkerdStructuredLog) => void, (log: V4WorkerdStructuredLog) => void>>;
    unsafeHandleRuntimeRestart: z.ZodOptional<z.ZodCustom<() => Awaitable<void>, () => Awaitable<void>>>;
    handleUncaughtError: z.ZodOptional<z.ZodCustom<(error: Error) => void, (error: Error) => void>>;
    upstream: z.ZodOptional<z.ZodString>;
    cf: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
    unsafeDevRegistryPath: z.ZodOptional<z.ZodString>;
    unsafeHandleDevRegistryUpdate: z.ZodOptional<z.ZodCustom<(registry: WorkerRegistry) => void, (registry: WorkerRegistry) => void>>;
    unsafeProxySharedSecret: z.ZodOptional<z.ZodString>;
    unsafeModuleFallbackService: z.ZodOptional<z.ZodCustom<V4FetchHandler, V4FetchHandler>>;
    unsafeTriggerHandlers: z.ZodOptional<z.ZodBoolean>;
    unsafeRuntimeEnv: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    unsafeLocalExplorer: z.ZodOptional<z.ZodBoolean>;
    unsafeObservability: z.ZodOptional<z.ZodBoolean>;
    unsafeInspectDurableObjects: z.ZodOptional<z.ZodBoolean>;
    logRequests: z.ZodDefault<z.ZodBoolean>;
    resourcePersistencePath: z.ZodOptional<z.ZodString>;
    isolatedResourcePersistencePath: z.ZodOptional<z.ZodString>;
    resourceTmpPath: z.ZodOptional<z.ZodString>;
    stripDisablePrettyError: z.ZodDefault<z.ZodBoolean>;
    telemetry: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        deviceId: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    publicUrl: z.ZodOptional<z.ZodURL>;
    containerEngine: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
        localDocker: z.ZodObject<{
            socketPath: z.ZodString;
            containerEgressInterceptorImage: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodString]>>;
}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
    workers: z.ZodArray<z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
        modules: z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                ESModule: "ESModule";
                CommonJS: "CommonJS";
                Text: "Text";
                Data: "Data";
                CompiledWasm: "CompiledWasm";
                PythonModule: "PythonModule";
                PythonRequirement: "PythonRequirement";
            }>;
            path: z.ZodString;
            contents: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>;
        }, z.core.$strip>>;
        modulesRoot: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        script: z.ZodString;
        scriptPath: z.ZodOptional<z.ZodString>;
        modules: z.ZodOptional<z.ZodBoolean>;
        modulesRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                ESModule: "ESModule";
                CommonJS: "CommonJS";
                Text: "Text";
                Data: "Data";
                CompiledWasm: "CompiledWasm";
                PythonModule: "PythonModule";
                PythonRequirement: "PythonRequirement";
            }>;
            include: z.ZodArray<z.ZodString>;
            fallthrough: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>>;
        modulesRoot: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
        scriptPath: z.ZodString;
        modules: z.ZodOptional<z.ZodBoolean>;
        modulesRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodEnum<{
                ESModule: "ESModule";
                CommonJS: "CommonJS";
                Text: "Text";
                Data: "Data";
                CompiledWasm: "CompiledWasm";
                PythonModule: "PythonModule";
                PythonRequirement: "PythonRequirement";
            }>;
            include: z.ZodArray<z.ZodString>;
            fallthrough: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>>;
        modulesRoot: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>]>, z.ZodObject<{
        name: z.ZodOptional<z.ZodString>;
        rootPath: z.ZodOptional<z.ZodString>;
        compatibilityDate: z.ZodOptional<z.ZodString>;
        compatibilityFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
        unsafeInspectorProxy: z.ZodOptional<z.ZodBoolean>;
        routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
        bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Json, unknown, z.core.$ZodTypeInternals<Json, unknown>>>>;
        wasmBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
        textBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        dataBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
        serviceBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
            name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
            entrypoint: z.ZodOptional<z.ZodString>;
            props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>, z.ZodObject<{
            network: z.ZodObject<{
                allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
                deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            external: z.ZodObject<{
                address: z.ZodString;
                http: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                https: z.ZodOptional<z.ZodObject<{
                    options: z.ZodOptional<z.ZodObject<{
                        style: z.ZodOptional<z.ZodEnum<{
                            readonly HOST: 0;
                            readonly PROXY: 1;
                        }>>;
                        forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                        cfBlobHeader: z.ZodOptional<z.ZodString>;
                        injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            name: z.ZodString;
                            value: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>>;
                        injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            name: z.ZodString;
                            value: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>>;
                    }, z.core.$strip>>;
                    tlsOptions: z.ZodOptional<z.ZodObject<{
                        keypair: z.ZodOptional<z.ZodObject<{
                            privateKey: z.ZodOptional<z.ZodString>;
                            certificateChain: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                        requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                        trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                        trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                        minVersion: z.ZodOptional<z.ZodEnum<{
                            readonly GOOD_DEFAULT: 0;
                            readonly SSL3: 1;
                            readonly TLS1DOT0: 2;
                            readonly TLS1DOT1: 3;
                            readonly TLS1DOT2: 4;
                            readonly TLS1DOT3: 5;
                        }>>;
                        cipherList: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    certificateHost: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            disk: z.ZodObject<{
                path: z.ZodString;
                writable: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
        }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
        outboundService: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
            name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
            entrypoint: z.ZodOptional<z.ZodString>;
            props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>, z.ZodObject<{
            network: z.ZodObject<{
                allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
                deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            external: z.ZodObject<{
                address: z.ZodString;
                http: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                https: z.ZodOptional<z.ZodObject<{
                    options: z.ZodOptional<z.ZodObject<{
                        style: z.ZodOptional<z.ZodEnum<{
                            readonly HOST: 0;
                            readonly PROXY: 1;
                        }>>;
                        forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                        cfBlobHeader: z.ZodOptional<z.ZodString>;
                        injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            name: z.ZodString;
                            value: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>>;
                        injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            name: z.ZodString;
                            value: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>>;
                    }, z.core.$strip>>;
                    tlsOptions: z.ZodOptional<z.ZodObject<{
                        keypair: z.ZodOptional<z.ZodObject<{
                            privateKey: z.ZodOptional<z.ZodString>;
                            certificateChain: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                        requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                        trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                        trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                        minVersion: z.ZodOptional<z.ZodEnum<{
                            readonly GOOD_DEFAULT: 0;
                            readonly SSL3: 1;
                            readonly TLS1DOT0: 2;
                            readonly TLS1DOT1: 3;
                            readonly TLS1DOT2: 4;
                            readonly TLS1DOT3: 5;
                        }>>;
                        cipherList: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    certificateHost: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            disk: z.ZodObject<{
                path: z.ZodString;
                writable: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
        }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>;
        unsafeEphemeralDurableObjects: z.ZodOptional<z.ZodBoolean>;
        unsafeDirectSockets: z.ZodOptional<z.ZodArray<z.ZodObject<{
            host: z.ZodOptional<z.ZodString>;
            port: z.ZodOptional<z.ZodNumber>;
            serviceName: z.ZodOptional<z.ZodString>;
            entrypoint: z.ZodOptional<z.ZodString>;
            proxy: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>>;
        connectHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
            protocol: z.ZodEnum<{
                tcp: "tcp";
            }>;
            port: z.ZodNumber;
            address: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        unsafeOverrideFetchWorker: z.ZodOptional<z.ZodString>;
        unsafeEvalBinding: z.ZodOptional<z.ZodString>;
        unsafeUseModuleFallbackService: z.ZodOptional<z.ZodBoolean>;
        unsafeRegisterWorker: z.ZodOptional<z.ZodBoolean>;
        tails: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
            name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
            entrypoint: z.ZodOptional<z.ZodString>;
            props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>, z.ZodObject<{
            network: z.ZodObject<{
                allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
                deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            external: z.ZodObject<{
                address: z.ZodString;
                http: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                https: z.ZodOptional<z.ZodObject<{
                    options: z.ZodOptional<z.ZodObject<{
                        style: z.ZodOptional<z.ZodEnum<{
                            readonly HOST: 0;
                            readonly PROXY: 1;
                        }>>;
                        forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                        cfBlobHeader: z.ZodOptional<z.ZodString>;
                        injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            name: z.ZodString;
                            value: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>>;
                        injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            name: z.ZodString;
                            value: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>>;
                    }, z.core.$strip>>;
                    tlsOptions: z.ZodOptional<z.ZodObject<{
                        keypair: z.ZodOptional<z.ZodObject<{
                            privateKey: z.ZodOptional<z.ZodString>;
                            certificateChain: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                        requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                        trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                        trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                        minVersion: z.ZodOptional<z.ZodEnum<{
                            readonly GOOD_DEFAULT: 0;
                            readonly SSL3: 1;
                            readonly TLS1DOT0: 2;
                            readonly TLS1DOT1: 3;
                            readonly TLS1DOT2: 4;
                            readonly TLS1DOT3: 5;
                        }>>;
                        cipherList: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    certificateHost: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            disk: z.ZodObject<{
                path: z.ZodString;
                writable: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
        }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
        streamingTails: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
            name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
            entrypoint: z.ZodOptional<z.ZodString>;
            props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>, z.ZodObject<{
            network: z.ZodObject<{
                allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
                deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            external: z.ZodObject<{
                address: z.ZodString;
                http: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                https: z.ZodOptional<z.ZodObject<{
                    options: z.ZodOptional<z.ZodObject<{
                        style: z.ZodOptional<z.ZodEnum<{
                            readonly HOST: 0;
                            readonly PROXY: 1;
                        }>>;
                        forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                        cfBlobHeader: z.ZodOptional<z.ZodString>;
                        injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            name: z.ZodString;
                            value: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>>;
                        injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            name: z.ZodString;
                            value: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>>;
                    }, z.core.$strip>>;
                    tlsOptions: z.ZodOptional<z.ZodObject<{
                        keypair: z.ZodOptional<z.ZodObject<{
                            privateKey: z.ZodOptional<z.ZodString>;
                            certificateChain: z.ZodOptional<z.ZodString>;
                        }, z.core.$strip>>;
                        requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                        trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                        trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                        minVersion: z.ZodOptional<z.ZodEnum<{
                            readonly GOOD_DEFAULT: 0;
                            readonly SSL3: 1;
                            readonly TLS1DOT0: 2;
                            readonly TLS1DOT1: 3;
                            readonly TLS1DOT2: 4;
                            readonly TLS1DOT3: 5;
                        }>>;
                        cipherList: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    certificateHost: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            disk: z.ZodObject<{
                path: z.ZodString;
                writable: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>;
        }, z.core.$strip>, z.ZodObject<{
            node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
        }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
        stripCfConnectingIp: z.ZodDefault<z.ZodBoolean>;
        zone: z.ZodOptional<z.ZodString>;
        access: z.ZodOptional<z.ZodObject<{
            aud: z.ZodString;
            identity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>>;
        unsafeBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            type: z.ZodString;
            plugin: z.ZodObject<{
                package: z.ZodString;
                name: z.ZodString;
            }, z.core.$strip>;
            options: z.ZodRecord<z.ZodString, z.ZodType<Json, unknown, z.core.$ZodTypeInternals<Json, unknown>>>;
        }, z.core.$strip>>>;
        cacheAPI: z.ZodOptional<z.ZodBoolean>;
        d1Databases: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
            id: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
        durableObjects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
            className: z.ZodString;
            scriptName: z.ZodOptional<z.ZodString>;
            useSQLite: z.ZodOptional<z.ZodBoolean>;
            unsafeUniqueKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kUnsafeEphemeralUniqueKey_2, typeof kUnsafeEphemeralUniqueKey_2>]>>;
            unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
            container: z.ZodOptional<z.ZodObject<{
                imageName: z.ZodString;
            }, z.core.$strip>>;
        }, z.core.$strip>]>>>;
        additionalUnboundDurableObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
            className: z.ZodString;
            scriptName: z.ZodOptional<z.ZodString>;
            useSQLite: z.ZodOptional<z.ZodBoolean>;
            unsafeUniqueKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kUnsafeEphemeralUniqueKey_2, typeof kUnsafeEphemeralUniqueKey_2>]>>;
            unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
            container: z.ZodOptional<z.ZodObject<{
                imageName: z.ZodString;
            }, z.core.$strip>>;
        }, z.core.$strip>>>;
        kvNamespaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
            id: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
        sitePath: z.ZodOptional<z.ZodString>;
        siteInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
        siteExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
        queueProducers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
            queueName: z.ZodString;
            deliveryDelay: z.ZodOptional<z.ZodNumber>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodString>]>>;
        queueConsumers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
            maxBatchSize: z.ZodOptional<z.ZodNumber>;
            maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
            maxRetries: z.ZodOptional<z.ZodNumber>;
            deadLetterQueue: z.ZodOptional<z.ZodString>;
            retryDelay: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strip>>, z.ZodArray<z.ZodString>]>>;
        r2Buckets: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
            id: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
            s3Credentials: z.ZodOptional<z.ZodObject<{
                accessKeyId: z.ZodString;
                secretAccessKey: z.ZodString;
            }, z.core.$strip>>;
        }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
        hyperdrives: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodURL, z.ZodCustom<URL_2, URL_2>]>>>;
        ratelimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            namespace_id: z.ZodString;
            simple: z.ZodObject<{
                limit: z.ZodNumber;
                period: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<10>, z.ZodLiteral<60>]>>>;
            }, z.core.$strip>;
        }, z.core.$strip>>>;
        assets: z.ZodOptional<z.ZodObject<{
            workerName: z.ZodOptional<z.ZodString>;
            directory: z.ZodString;
            binding: z.ZodOptional<z.ZodString>;
            run_worker_first: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
            routerConfig: z.ZodOptional<z.ZodObject<{
                account_id: z.ZodOptional<z.ZodNumber>;
                script_id: z.ZodOptional<z.ZodNumber>;
                debug: z.ZodOptional<z.ZodBoolean>;
                invoke_user_worker_ahead_of_assets: z.ZodOptional<z.ZodBoolean>;
                static_routing: z.ZodOptional<z.ZodObject<{
                    user_worker: z.ZodArray<z.ZodString>;
                    asset_worker: z.ZodOptional<z.ZodArray<z.ZodString>>;
                }, z.core.$strip>>;
                has_user_worker: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
            assetConfig: z.ZodOptional<z.ZodObject<{
                account_id: z.ZodOptional<z.ZodNumber>;
                script_id: z.ZodOptional<z.ZodNumber>;
                debug: z.ZodOptional<z.ZodBoolean>;
                redirects: z.ZodOptional<z.ZodObject<{
                    version: z.ZodLiteral<1>;
                    staticRules: z.ZodRecord<z.ZodString, z.ZodObject<{
                        status: z.ZodNumber;
                        to: z.ZodString;
                        lineNumber: z.ZodNumber;
                    }, z.core.$strip>>;
                    rules: z.ZodRecord<z.ZodString, z.ZodObject<{
                        status: z.ZodNumber;
                        to: z.ZodString;
                    }, z.core.$strip>>;
                }, z.core.$strip>>;
                headers: z.ZodOptional<z.ZodObject<{
                    version: z.ZodLiteral<2>;
                    rules: z.ZodRecord<z.ZodString, z.ZodObject<{
                        set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                        unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    }, z.core.$strip>>;
                }, z.core.$strip>>;
                html_handling: z.ZodOptional<z.ZodEnum<{
                    "auto-trailing-slash": "auto-trailing-slash";
                    "force-trailing-slash": "force-trailing-slash";
                    "drop-trailing-slash": "drop-trailing-slash";
                    none: "none";
                }>>;
                not_found_handling: z.ZodOptional<z.ZodEnum<{
                    none: "none";
                    "single-page-application": "single-page-application";
                    "404-page": "404-page";
                }>>;
                has_static_routing: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>>;
        }, z.core.$strip>>;
        workflows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            name: z.ZodString;
            className: z.ZodString;
            scriptName: z.ZodOptional<z.ZodString>;
            external: z.ZodOptional<z.ZodBoolean>;
            stepLimit: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strip>>>;
        pipelines: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
            stream: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>, z.ZodObject<{
            pipeline: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
        secretsStoreSecrets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            store_id: z.ZodString;
            secret_name: z.ZodString;
        }, z.core.$strip>>>;
        email: z.ZodOptional<z.ZodObject<{
            send_email: z.ZodOptional<z.ZodArray<z.ZodIntersection<z.ZodObject<{
                name: z.ZodString;
                remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
                allowed_sender_addresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
            }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
                destination_address: z.ZodOptional<z.ZodString>;
                allowed_destination_addresses: z.ZodOptional<z.ZodNever>;
            }, z.core.$strip>, z.ZodObject<{
                allowed_destination_addresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
                destination_address: z.ZodOptional<z.ZodNever>;
            }, z.core.$strip>]>>>>;
        }, z.core.$strip>>;
        analyticsEngineDatasets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            dataset: z.ZodString;
        }, z.core.$strip>>>;
        ai: z.ZodOptional<z.ZodObject<{
            binding: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>;
        agentMemory: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            namespace: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        aiSearchNamespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            namespace: z.ZodOptional<z.ZodString>;
            instance_name: z.ZodOptional<z.ZodString>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        aiSearchInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            namespace: z.ZodOptional<z.ZodString>;
            instance_name: z.ZodOptional<z.ZodString>;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        websearch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        browserRendering: z.ZodOptional<z.ZodObject<{
            binding: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
            headful: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        dispatchNamespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            namespace: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        images: z.ZodOptional<z.ZodObject<{
            binding: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>;
        stream: z.ZodOptional<z.ZodObject<{
            binding: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>;
        vectorize: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            index_name: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        vpcNetworks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
            tunnel_id: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>, z.ZodObject<{
            network_id: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>]>>>;
        vpcServices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            service_id: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        mtlsCertificates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            certificate_id: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        helloWorld: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            enable_timer: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>>;
        flagship: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            app_id: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
            namespace: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>>;
        workerLoaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{}, z.core.$strip>>>;
        media: z.ZodOptional<z.ZodObject<{
            binding: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        }, z.core.$strip>>;
        versionMetadata: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
}, z.core.$strip>, z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
    modules: z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            ESModule: "ESModule";
            CommonJS: "CommonJS";
            Text: "Text";
            Data: "Data";
            CompiledWasm: "CompiledWasm";
            PythonModule: "PythonModule";
            PythonRequirement: "PythonRequirement";
        }>;
        path: z.ZodString;
        contents: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>;
    }, z.core.$strip>>;
    modulesRoot: z.ZodOptional<z.ZodString>;
}, z.core.$strip>, z.ZodObject<{
    script: z.ZodString;
    scriptPath: z.ZodOptional<z.ZodString>;
    modules: z.ZodOptional<z.ZodBoolean>;
    modulesRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            ESModule: "ESModule";
            CommonJS: "CommonJS";
            Text: "Text";
            Data: "Data";
            CompiledWasm: "CompiledWasm";
            PythonModule: "PythonModule";
            PythonRequirement: "PythonRequirement";
        }>;
        include: z.ZodArray<z.ZodString>;
        fallthrough: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>>;
    modulesRoot: z.ZodOptional<z.ZodString>;
}, z.core.$strip>, z.ZodObject<{
    scriptPath: z.ZodString;
    modules: z.ZodOptional<z.ZodBoolean>;
    modulesRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            ESModule: "ESModule";
            CommonJS: "CommonJS";
            Text: "Text";
            Data: "Data";
            CompiledWasm: "CompiledWasm";
            PythonModule: "PythonModule";
            PythonRequirement: "PythonRequirement";
        }>;
        include: z.ZodArray<z.ZodString>;
        fallthrough: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>>;
    modulesRoot: z.ZodOptional<z.ZodString>;
}, z.core.$strip>]>, z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    rootPath: z.ZodOptional<z.ZodString>;
    compatibilityDate: z.ZodOptional<z.ZodString>;
    compatibilityFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    unsafeInspectorProxy: z.ZodOptional<z.ZodBoolean>;
    routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
    bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Json, unknown, z.core.$ZodTypeInternals<Json, unknown>>>>;
    wasmBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
    textBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    dataBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
    serviceBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
        name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network: z.ZodObject<{
            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tlsOptions: z.ZodOptional<z.ZodObject<{
                keypair: z.ZodOptional<z.ZodObject<{
                    privateKey: z.ZodOptional<z.ZodString>;
                    certificateChain: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                minVersion: z.ZodOptional<z.ZodEnum<{
                    readonly GOOD_DEFAULT: 0;
                    readonly SSL3: 1;
                    readonly TLS1DOT0: 2;
                    readonly TLS1DOT1: 3;
                    readonly TLS1DOT2: 4;
                    readonly TLS1DOT3: 5;
                }>>;
                cipherList: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        external: z.ZodObject<{
            address: z.ZodString;
            http: z.ZodOptional<z.ZodObject<{
                style: z.ZodOptional<z.ZodEnum<{
                    readonly HOST: 0;
                    readonly PROXY: 1;
                }>>;
                forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                cfBlobHeader: z.ZodOptional<z.ZodString>;
                injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>;
            https: z.ZodOptional<z.ZodObject<{
                options: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                certificateHost: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        disk: z.ZodObject<{
            path: z.ZodString;
            writable: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
    }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
    outboundService: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
        name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network: z.ZodObject<{
            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tlsOptions: z.ZodOptional<z.ZodObject<{
                keypair: z.ZodOptional<z.ZodObject<{
                    privateKey: z.ZodOptional<z.ZodString>;
                    certificateChain: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                minVersion: z.ZodOptional<z.ZodEnum<{
                    readonly GOOD_DEFAULT: 0;
                    readonly SSL3: 1;
                    readonly TLS1DOT0: 2;
                    readonly TLS1DOT1: 3;
                    readonly TLS1DOT2: 4;
                    readonly TLS1DOT3: 5;
                }>>;
                cipherList: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        external: z.ZodObject<{
            address: z.ZodString;
            http: z.ZodOptional<z.ZodObject<{
                style: z.ZodOptional<z.ZodEnum<{
                    readonly HOST: 0;
                    readonly PROXY: 1;
                }>>;
                forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                cfBlobHeader: z.ZodOptional<z.ZodString>;
                injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>;
            https: z.ZodOptional<z.ZodObject<{
                options: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                certificateHost: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        disk: z.ZodObject<{
            path: z.ZodString;
            writable: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
    }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>;
    unsafeEphemeralDurableObjects: z.ZodOptional<z.ZodBoolean>;
    unsafeDirectSockets: z.ZodOptional<z.ZodArray<z.ZodObject<{
        host: z.ZodOptional<z.ZodString>;
        port: z.ZodOptional<z.ZodNumber>;
        serviceName: z.ZodOptional<z.ZodString>;
        entrypoint: z.ZodOptional<z.ZodString>;
        proxy: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>>;
    connectHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
        protocol: z.ZodEnum<{
            tcp: "tcp";
        }>;
        port: z.ZodNumber;
        address: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    unsafeOverrideFetchWorker: z.ZodOptional<z.ZodString>;
    unsafeEvalBinding: z.ZodOptional<z.ZodString>;
    unsafeUseModuleFallbackService: z.ZodOptional<z.ZodBoolean>;
    unsafeRegisterWorker: z.ZodOptional<z.ZodBoolean>;
    tails: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
        name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network: z.ZodObject<{
            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tlsOptions: z.ZodOptional<z.ZodObject<{
                keypair: z.ZodOptional<z.ZodObject<{
                    privateKey: z.ZodOptional<z.ZodString>;
                    certificateChain: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                minVersion: z.ZodOptional<z.ZodEnum<{
                    readonly GOOD_DEFAULT: 0;
                    readonly SSL3: 1;
                    readonly TLS1DOT0: 2;
                    readonly TLS1DOT1: 3;
                    readonly TLS1DOT2: 4;
                    readonly TLS1DOT3: 5;
                }>>;
                cipherList: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        external: z.ZodObject<{
            address: z.ZodString;
            http: z.ZodOptional<z.ZodObject<{
                style: z.ZodOptional<z.ZodEnum<{
                    readonly HOST: 0;
                    readonly PROXY: 1;
                }>>;
                forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                cfBlobHeader: z.ZodOptional<z.ZodString>;
                injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>;
            https: z.ZodOptional<z.ZodObject<{
                options: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                certificateHost: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        disk: z.ZodObject<{
            path: z.ZodString;
            writable: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
    }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
    streamingTails: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
        name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network: z.ZodObject<{
            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tlsOptions: z.ZodOptional<z.ZodObject<{
                keypair: z.ZodOptional<z.ZodObject<{
                    privateKey: z.ZodOptional<z.ZodString>;
                    certificateChain: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                minVersion: z.ZodOptional<z.ZodEnum<{
                    readonly GOOD_DEFAULT: 0;
                    readonly SSL3: 1;
                    readonly TLS1DOT0: 2;
                    readonly TLS1DOT1: 3;
                    readonly TLS1DOT2: 4;
                    readonly TLS1DOT3: 5;
                }>>;
                cipherList: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        external: z.ZodObject<{
            address: z.ZodString;
            http: z.ZodOptional<z.ZodObject<{
                style: z.ZodOptional<z.ZodEnum<{
                    readonly HOST: 0;
                    readonly PROXY: 1;
                }>>;
                forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                cfBlobHeader: z.ZodOptional<z.ZodString>;
                injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>;
            https: z.ZodOptional<z.ZodObject<{
                options: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                certificateHost: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        disk: z.ZodObject<{
            path: z.ZodString;
            writable: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
    }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
    stripCfConnectingIp: z.ZodDefault<z.ZodBoolean>;
    zone: z.ZodOptional<z.ZodString>;
    access: z.ZodOptional<z.ZodObject<{
        aud: z.ZodString;
        identity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>>;
    unsafeBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodString;
        plugin: z.ZodObject<{
            package: z.ZodString;
            name: z.ZodString;
        }, z.core.$strip>;
        options: z.ZodRecord<z.ZodString, z.ZodType<Json, unknown, z.core.$ZodTypeInternals<Json, unknown>>>;
    }, z.core.$strip>>>;
    cacheAPI: z.ZodOptional<z.ZodBoolean>;
    d1Databases: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
    durableObjects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        className: z.ZodString;
        scriptName: z.ZodOptional<z.ZodString>;
        useSQLite: z.ZodOptional<z.ZodBoolean>;
        unsafeUniqueKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kUnsafeEphemeralUniqueKey_2, typeof kUnsafeEphemeralUniqueKey_2>]>>;
        unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        container: z.ZodOptional<z.ZodObject<{
            imageName: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>]>>>;
    additionalUnboundDurableObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
        className: z.ZodString;
        scriptName: z.ZodOptional<z.ZodString>;
        useSQLite: z.ZodOptional<z.ZodBoolean>;
        unsafeUniqueKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kUnsafeEphemeralUniqueKey_2, typeof kUnsafeEphemeralUniqueKey_2>]>>;
        unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        container: z.ZodOptional<z.ZodObject<{
            imageName: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>>>;
    kvNamespaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
    sitePath: z.ZodOptional<z.ZodString>;
    siteInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
    siteExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
    queueProducers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
        queueName: z.ZodString;
        deliveryDelay: z.ZodOptional<z.ZodNumber>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodString>]>>;
    queueConsumers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
        maxBatchSize: z.ZodOptional<z.ZodNumber>;
        maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
        maxRetries: z.ZodOptional<z.ZodNumber>;
        deadLetterQueue: z.ZodOptional<z.ZodString>;
        retryDelay: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>, z.ZodArray<z.ZodString>]>>;
    r2Buckets: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        s3Credentials: z.ZodOptional<z.ZodObject<{
            accessKeyId: z.ZodString;
            secretAccessKey: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
    hyperdrives: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodURL, z.ZodCustom<URL_2, URL_2>]>>>;
    ratelimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace_id: z.ZodString;
        simple: z.ZodObject<{
            limit: z.ZodNumber;
            period: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<10>, z.ZodLiteral<60>]>>>;
        }, z.core.$strip>;
    }, z.core.$strip>>>;
    assets: z.ZodOptional<z.ZodObject<{
        workerName: z.ZodOptional<z.ZodString>;
        directory: z.ZodString;
        binding: z.ZodOptional<z.ZodString>;
        run_worker_first: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
        routerConfig: z.ZodOptional<z.ZodObject<{
            account_id: z.ZodOptional<z.ZodNumber>;
            script_id: z.ZodOptional<z.ZodNumber>;
            debug: z.ZodOptional<z.ZodBoolean>;
            invoke_user_worker_ahead_of_assets: z.ZodOptional<z.ZodBoolean>;
            static_routing: z.ZodOptional<z.ZodObject<{
                user_worker: z.ZodArray<z.ZodString>;
                asset_worker: z.ZodOptional<z.ZodArray<z.ZodString>>;
            }, z.core.$strip>>;
            has_user_worker: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        assetConfig: z.ZodOptional<z.ZodObject<{
            account_id: z.ZodOptional<z.ZodNumber>;
            script_id: z.ZodOptional<z.ZodNumber>;
            debug: z.ZodOptional<z.ZodBoolean>;
            redirects: z.ZodOptional<z.ZodObject<{
                version: z.ZodLiteral<1>;
                staticRules: z.ZodRecord<z.ZodString, z.ZodObject<{
                    status: z.ZodNumber;
                    to: z.ZodString;
                    lineNumber: z.ZodNumber;
                }, z.core.$strip>>;
                rules: z.ZodRecord<z.ZodString, z.ZodObject<{
                    status: z.ZodNumber;
                    to: z.ZodString;
                }, z.core.$strip>>;
            }, z.core.$strip>>;
            headers: z.ZodOptional<z.ZodObject<{
                version: z.ZodLiteral<2>;
                rules: z.ZodRecord<z.ZodString, z.ZodObject<{
                    set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
                }, z.core.$strip>>;
            }, z.core.$strip>>;
            html_handling: z.ZodOptional<z.ZodEnum<{
                "auto-trailing-slash": "auto-trailing-slash";
                "force-trailing-slash": "force-trailing-slash";
                "drop-trailing-slash": "drop-trailing-slash";
                none: "none";
            }>>;
            not_found_handling: z.ZodOptional<z.ZodEnum<{
                none: "none";
                "single-page-application": "single-page-application";
                "404-page": "404-page";
            }>>;
            has_static_routing: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    workflows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        className: z.ZodString;
        scriptName: z.ZodOptional<z.ZodString>;
        external: z.ZodOptional<z.ZodBoolean>;
        stepLimit: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>>;
    pipelines: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        stream: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        pipeline: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
    secretsStoreSecrets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        store_id: z.ZodString;
        secret_name: z.ZodString;
    }, z.core.$strip>>>;
    email: z.ZodOptional<z.ZodObject<{
        send_email: z.ZodOptional<z.ZodArray<z.ZodIntersection<z.ZodObject<{
            name: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
            allowed_sender_addresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
            destination_address: z.ZodOptional<z.ZodString>;
            allowed_destination_addresses: z.ZodOptional<z.ZodNever>;
        }, z.core.$strip>, z.ZodObject<{
            allowed_destination_addresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
            destination_address: z.ZodOptional<z.ZodNever>;
        }, z.core.$strip>]>>>>;
    }, z.core.$strip>>;
    analyticsEngineDatasets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        dataset: z.ZodString;
    }, z.core.$strip>>>;
    ai: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>;
    agentMemory: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    aiSearchNamespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodOptional<z.ZodString>;
        instance_name: z.ZodOptional<z.ZodString>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    aiSearchInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodOptional<z.ZodString>;
        instance_name: z.ZodOptional<z.ZodString>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    websearch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    browserRendering: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        headful: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    dispatchNamespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    images: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>;
    stream: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>;
    vectorize: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        index_name: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    vpcNetworks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
        tunnel_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>]>>>;
    vpcServices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        service_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    mtlsCertificates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        certificate_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    helloWorld: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        enable_timer: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>>;
    flagship: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        app_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    workerLoaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{}, z.core.$strip>>>;
    media: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>;
    versionMetadata: z.ZodOptional<z.ZodString>;
}, z.core.$strip>>]>>;

export declare type V4ModuleDefinition = {
    type: V4ModuleRuleType;
    path: string;
    contents?: string | Uint8Array;
};

export declare type V4ModuleRule = {
    type: V4ModuleRuleType;
    include: string[];
    fallthrough?: boolean;
};

export declare type V4ModuleRuleType = "ESModule" | "CommonJS" | "Text" | "Data" | "CompiledWasm" | "PythonModule" | "PythonRequirement";

export declare type V4Namespace = Record<string, string | V4IdEntry> | string[];

export declare type V4NodeHandler = (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;

export declare type V4QueueConsumerOptions = {
    maxBatchSize?: number;
    maxBatchTimeout?: number;
    maxRetries?: number;
    deadLetterQueue?: string;
    retryDelay?: number;
};

export declare type V4QueueProducerOptions = {
    queueName: string;
    deliveryDelay?: number;
    remoteProxyConnectionString?: RemoteProxyConnectionString;
};

export declare type V4RemoteBinding = {
    remoteProxyConnectionString?: RemoteProxyConnectionString;
};

export declare type V4RemoteBindingWithName = V4RemoteBinding & {
    binding: string;
};

export declare type V4ServiceDesignator = string | symbol | {
    name: string | symbol;
    entrypoint?: string;
    props?: Record<string, unknown>;
    remoteProxyConnectionString?: RemoteProxyConnectionString;
} | {
    network: {
        allow?: string[];
        deny?: string[];
        tlsOptions?: unknown;
    };
} | {
    external: {
        address: string;
        http?: unknown;
        https?: unknown;
    };
} | {
    disk: {
        path: string;
        writable?: boolean;
    };
} | {
    node: V4NodeHandler;
} | V4FetchHandler;

export declare type V4SharedOptions = {
    [key: string]: unknown;
    rootPath?: string;
    host?: string;
    port?: number;
    https?: boolean;
    httpsKey?: string;
    httpsCert?: string;
    inspectorPort?: number;
    inspectorHost?: string;
    verbose?: boolean;
    log?: Log;
    handleStructuredLogs?: (log: V4WorkerdStructuredLog) => void;
    unsafeHandleRuntimeRestart?: () => Awaitable<void>;
    handleUncaughtError?: (error: Error) => void;
    upstream?: string;
    cf?: boolean | string | Record<string, unknown>;
    unsafeDevRegistryPath?: string;
    unsafeHandleDevRegistryUpdate?: (registry: WorkerRegistry) => void;
    unsafeProxySharedSecret?: string;
    unsafeModuleFallbackService?: V4FetchHandler;
    unsafeTriggerHandlers?: boolean;
    unsafeRuntimeEnv?: Record<string, string>;
    unsafeLocalExplorer?: boolean;
    unsafeObservability?: boolean;
    unsafeInspectDurableObjects?: boolean;
    logRequests?: boolean;
    resourcePersistencePath?: string;
    isolatedResourcePersistencePath?: string;
    resourceTmpPath?: string;
    stripDisablePrettyError?: boolean;
    telemetry?: {
        enabled?: boolean;
        deviceId?: string;
    };
    publicUrl?: string;
    containerEngine?: {
        localDocker: {
            socketPath: string;
            containerEgressInterceptorImage?: string;
        };
    } | string;
};

export declare type V4SourceOptions = {
    modules: V4ModuleDefinition[];
    modulesRoot?: string;
} | {
    script: string;
    scriptPath?: string;
    modules?: boolean;
    modulesRules?: V4ModuleRule[];
    modulesRoot?: string;
} | {
    scriptPath: string;
    modules?: boolean;
    modulesRules?: V4ModuleRule[];
    modulesRoot?: string;
};

export declare interface V4WorkerdStructuredLog {
    timestamp: number;
    level: string;
    message: string;
}

export declare type V4WorkerOptions = V4SourceOptions & V4WorkerOptionsShape;

export declare const V4WorkerOptionsSchema: z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
    modules: z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            ESModule: "ESModule";
            CommonJS: "CommonJS";
            Text: "Text";
            Data: "Data";
            CompiledWasm: "CompiledWasm";
            PythonModule: "PythonModule";
            PythonRequirement: "PythonRequirement";
        }>;
        path: z.ZodString;
        contents: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>;
    }, z.core.$strip>>;
    modulesRoot: z.ZodOptional<z.ZodString>;
}, z.core.$strip>, z.ZodObject<{
    script: z.ZodString;
    scriptPath: z.ZodOptional<z.ZodString>;
    modules: z.ZodOptional<z.ZodBoolean>;
    modulesRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            ESModule: "ESModule";
            CommonJS: "CommonJS";
            Text: "Text";
            Data: "Data";
            CompiledWasm: "CompiledWasm";
            PythonModule: "PythonModule";
            PythonRequirement: "PythonRequirement";
        }>;
        include: z.ZodArray<z.ZodString>;
        fallthrough: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>>;
    modulesRoot: z.ZodOptional<z.ZodString>;
}, z.core.$strip>, z.ZodObject<{
    scriptPath: z.ZodString;
    modules: z.ZodOptional<z.ZodBoolean>;
    modulesRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<{
            ESModule: "ESModule";
            CommonJS: "CommonJS";
            Text: "Text";
            Data: "Data";
            CompiledWasm: "CompiledWasm";
            PythonModule: "PythonModule";
            PythonRequirement: "PythonRequirement";
        }>;
        include: z.ZodArray<z.ZodString>;
        fallthrough: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>>;
    modulesRoot: z.ZodOptional<z.ZodString>;
}, z.core.$strip>]>, z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    rootPath: z.ZodOptional<z.ZodString>;
    compatibilityDate: z.ZodOptional<z.ZodString>;
    compatibilityFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    unsafeInspectorProxy: z.ZodOptional<z.ZodBoolean>;
    routes: z.ZodOptional<z.ZodArray<z.ZodString>>;
    bindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Json, unknown, z.core.$ZodTypeInternals<Json, unknown>>>>;
    wasmBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
    textBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    dataBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
    serviceBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
        name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network: z.ZodObject<{
            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tlsOptions: z.ZodOptional<z.ZodObject<{
                keypair: z.ZodOptional<z.ZodObject<{
                    privateKey: z.ZodOptional<z.ZodString>;
                    certificateChain: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                minVersion: z.ZodOptional<z.ZodEnum<{
                    readonly GOOD_DEFAULT: 0;
                    readonly SSL3: 1;
                    readonly TLS1DOT0: 2;
                    readonly TLS1DOT1: 3;
                    readonly TLS1DOT2: 4;
                    readonly TLS1DOT3: 5;
                }>>;
                cipherList: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        external: z.ZodObject<{
            address: z.ZodString;
            http: z.ZodOptional<z.ZodObject<{
                style: z.ZodOptional<z.ZodEnum<{
                    readonly HOST: 0;
                    readonly PROXY: 1;
                }>>;
                forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                cfBlobHeader: z.ZodOptional<z.ZodString>;
                injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>;
            https: z.ZodOptional<z.ZodObject<{
                options: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                certificateHost: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        disk: z.ZodObject<{
            path: z.ZodString;
            writable: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
    }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
    outboundService: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
        name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network: z.ZodObject<{
            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tlsOptions: z.ZodOptional<z.ZodObject<{
                keypair: z.ZodOptional<z.ZodObject<{
                    privateKey: z.ZodOptional<z.ZodString>;
                    certificateChain: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                minVersion: z.ZodOptional<z.ZodEnum<{
                    readonly GOOD_DEFAULT: 0;
                    readonly SSL3: 1;
                    readonly TLS1DOT0: 2;
                    readonly TLS1DOT1: 3;
                    readonly TLS1DOT2: 4;
                    readonly TLS1DOT3: 5;
                }>>;
                cipherList: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        external: z.ZodObject<{
            address: z.ZodString;
            http: z.ZodOptional<z.ZodObject<{
                style: z.ZodOptional<z.ZodEnum<{
                    readonly HOST: 0;
                    readonly PROXY: 1;
                }>>;
                forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                cfBlobHeader: z.ZodOptional<z.ZodString>;
                injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>;
            https: z.ZodOptional<z.ZodObject<{
                options: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                certificateHost: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        disk: z.ZodObject<{
            path: z.ZodString;
            writable: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
    }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>;
    unsafeEphemeralDurableObjects: z.ZodOptional<z.ZodBoolean>;
    unsafeDirectSockets: z.ZodOptional<z.ZodArray<z.ZodObject<{
        host: z.ZodOptional<z.ZodString>;
        port: z.ZodOptional<z.ZodNumber>;
        serviceName: z.ZodOptional<z.ZodString>;
        entrypoint: z.ZodOptional<z.ZodString>;
        proxy: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>>;
    connectHandlers: z.ZodOptional<z.ZodArray<z.ZodObject<{
        protocol: z.ZodEnum<{
            tcp: "tcp";
        }>;
        port: z.ZodNumber;
        address: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    unsafeOverrideFetchWorker: z.ZodOptional<z.ZodString>;
    unsafeEvalBinding: z.ZodOptional<z.ZodString>;
    unsafeUseModuleFallbackService: z.ZodOptional<z.ZodBoolean>;
    unsafeRegisterWorker: z.ZodOptional<z.ZodBoolean>;
    tails: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
        name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network: z.ZodObject<{
            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tlsOptions: z.ZodOptional<z.ZodObject<{
                keypair: z.ZodOptional<z.ZodObject<{
                    privateKey: z.ZodOptional<z.ZodString>;
                    certificateChain: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                minVersion: z.ZodOptional<z.ZodEnum<{
                    readonly GOOD_DEFAULT: 0;
                    readonly SSL3: 1;
                    readonly TLS1DOT0: 2;
                    readonly TLS1DOT1: 3;
                    readonly TLS1DOT2: 4;
                    readonly TLS1DOT3: 5;
                }>>;
                cipherList: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        external: z.ZodObject<{
            address: z.ZodString;
            http: z.ZodOptional<z.ZodObject<{
                style: z.ZodOptional<z.ZodEnum<{
                    readonly HOST: 0;
                    readonly PROXY: 1;
                }>>;
                forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                cfBlobHeader: z.ZodOptional<z.ZodString>;
                injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>;
            https: z.ZodOptional<z.ZodObject<{
                options: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                certificateHost: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        disk: z.ZodObject<{
            path: z.ZodString;
            writable: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
    }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
    streamingTails: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>, z.ZodObject<{
        name: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kCurrentWorker, typeof kCurrentWorker>]>;
        entrypoint: z.ZodOptional<z.ZodString>;
        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network: z.ZodObject<{
            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tlsOptions: z.ZodOptional<z.ZodObject<{
                keypair: z.ZodOptional<z.ZodObject<{
                    privateKey: z.ZodOptional<z.ZodString>;
                    certificateChain: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                minVersion: z.ZodOptional<z.ZodEnum<{
                    readonly GOOD_DEFAULT: 0;
                    readonly SSL3: 1;
                    readonly TLS1DOT0: 2;
                    readonly TLS1DOT1: 3;
                    readonly TLS1DOT2: 4;
                    readonly TLS1DOT3: 5;
                }>>;
                cipherList: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        external: z.ZodObject<{
            address: z.ZodString;
            http: z.ZodOptional<z.ZodObject<{
                style: z.ZodOptional<z.ZodEnum<{
                    readonly HOST: 0;
                    readonly PROXY: 1;
                }>>;
                forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                cfBlobHeader: z.ZodOptional<z.ZodString>;
                injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    value: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>;
            https: z.ZodOptional<z.ZodObject<{
                options: z.ZodOptional<z.ZodObject<{
                    style: z.ZodOptional<z.ZodEnum<{
                        readonly HOST: 0;
                        readonly PROXY: 1;
                    }>>;
                    forwardedProtoHeader: z.ZodOptional<z.ZodString>;
                    cfBlobHeader: z.ZodOptional<z.ZodString>;
                    injectRequestHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                    injectResponseHeaders: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        name: z.ZodString;
                        value: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>>;
                }, z.core.$strip>>;
                tlsOptions: z.ZodOptional<z.ZodObject<{
                    keypair: z.ZodOptional<z.ZodObject<{
                        privateKey: z.ZodOptional<z.ZodString>;
                        certificateChain: z.ZodOptional<z.ZodString>;
                    }, z.core.$strip>>;
                    requireClientCerts: z.ZodOptional<z.ZodBoolean>;
                    trustBrowserCas: z.ZodOptional<z.ZodBoolean>;
                    trustedCertificates: z.ZodOptional<z.ZodArray<z.ZodString>>;
                    minVersion: z.ZodOptional<z.ZodEnum<{
                        readonly GOOD_DEFAULT: 0;
                        readonly SSL3: 1;
                        readonly TLS1DOT0: 2;
                        readonly TLS1DOT1: 3;
                        readonly TLS1DOT2: 4;
                        readonly TLS1DOT3: 5;
                    }>>;
                    cipherList: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>;
                certificateHost: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        disk: z.ZodObject<{
            path: z.ZodString;
            writable: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>;
    }, z.core.$strip>, z.ZodObject<{
        node: z.ZodCustom<V4NodeHandler, V4NodeHandler>;
    }, z.core.$strip>, z.ZodCustom<V4FetchHandler, V4FetchHandler>]>>>;
    stripCfConnectingIp: z.ZodDefault<z.ZodBoolean>;
    zone: z.ZodOptional<z.ZodString>;
    access: z.ZodOptional<z.ZodObject<{
        aud: z.ZodString;
        identity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>>;
    unsafeBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodString;
        plugin: z.ZodObject<{
            package: z.ZodString;
            name: z.ZodString;
        }, z.core.$strip>;
        options: z.ZodRecord<z.ZodString, z.ZodType<Json, unknown, z.core.$ZodTypeInternals<Json, unknown>>>;
    }, z.core.$strip>>>;
    cacheAPI: z.ZodOptional<z.ZodBoolean>;
    d1Databases: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
    durableObjects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        className: z.ZodString;
        scriptName: z.ZodOptional<z.ZodString>;
        useSQLite: z.ZodOptional<z.ZodBoolean>;
        unsafeUniqueKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kUnsafeEphemeralUniqueKey_2, typeof kUnsafeEphemeralUniqueKey_2>]>>;
        unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        container: z.ZodOptional<z.ZodObject<{
            imageName: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>]>>>;
    additionalUnboundDurableObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
        className: z.ZodString;
        scriptName: z.ZodOptional<z.ZodString>;
        useSQLite: z.ZodOptional<z.ZodBoolean>;
        unsafeUniqueKey: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<typeof kUnsafeEphemeralUniqueKey_2, typeof kUnsafeEphemeralUniqueKey_2>]>>;
        unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        container: z.ZodOptional<z.ZodObject<{
            imageName: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>>>;
    kvNamespaces: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
    sitePath: z.ZodOptional<z.ZodString>;
    siteInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
    siteExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
    queueProducers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
        queueName: z.ZodString;
        deliveryDelay: z.ZodOptional<z.ZodNumber>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodString>]>>;
    queueConsumers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
        maxBatchSize: z.ZodOptional<z.ZodNumber>;
        maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
        maxRetries: z.ZodOptional<z.ZodNumber>;
        deadLetterQueue: z.ZodOptional<z.ZodString>;
        retryDelay: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>, z.ZodArray<z.ZodString>]>>;
    r2Buckets: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        s3Credentials: z.ZodOptional<z.ZodObject<{
            accessKeyId: z.ZodString;
            secretAccessKey: z.ZodString;
        }, z.core.$strip>>;
    }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
    hyperdrives: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodURL, z.ZodCustom<URL_2, URL_2>]>>>;
    ratelimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace_id: z.ZodString;
        simple: z.ZodObject<{
            limit: z.ZodNumber;
            period: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<10>, z.ZodLiteral<60>]>>>;
        }, z.core.$strip>;
    }, z.core.$strip>>>;
    assets: z.ZodOptional<z.ZodObject<{
        workerName: z.ZodOptional<z.ZodString>;
        directory: z.ZodString;
        binding: z.ZodOptional<z.ZodString>;
        run_worker_first: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
        routerConfig: z.ZodOptional<z.ZodObject<{
            account_id: z.ZodOptional<z.ZodNumber>;
            script_id: z.ZodOptional<z.ZodNumber>;
            debug: z.ZodOptional<z.ZodBoolean>;
            invoke_user_worker_ahead_of_assets: z.ZodOptional<z.ZodBoolean>;
            static_routing: z.ZodOptional<z.ZodObject<{
                user_worker: z.ZodArray<z.ZodString>;
                asset_worker: z.ZodOptional<z.ZodArray<z.ZodString>>;
            }, z.core.$strip>>;
            has_user_worker: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        assetConfig: z.ZodOptional<z.ZodObject<{
            account_id: z.ZodOptional<z.ZodNumber>;
            script_id: z.ZodOptional<z.ZodNumber>;
            debug: z.ZodOptional<z.ZodBoolean>;
            redirects: z.ZodOptional<z.ZodObject<{
                version: z.ZodLiteral<1>;
                staticRules: z.ZodRecord<z.ZodString, z.ZodObject<{
                    status: z.ZodNumber;
                    to: z.ZodString;
                    lineNumber: z.ZodNumber;
                }, z.core.$strip>>;
                rules: z.ZodRecord<z.ZodString, z.ZodObject<{
                    status: z.ZodNumber;
                    to: z.ZodString;
                }, z.core.$strip>>;
            }, z.core.$strip>>;
            headers: z.ZodOptional<z.ZodObject<{
                version: z.ZodLiteral<2>;
                rules: z.ZodRecord<z.ZodString, z.ZodObject<{
                    set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
                }, z.core.$strip>>;
            }, z.core.$strip>>;
            html_handling: z.ZodOptional<z.ZodEnum<{
                "auto-trailing-slash": "auto-trailing-slash";
                "force-trailing-slash": "force-trailing-slash";
                "drop-trailing-slash": "drop-trailing-slash";
                none: "none";
            }>>;
            not_found_handling: z.ZodOptional<z.ZodEnum<{
                none: "none";
                "single-page-application": "single-page-application";
                "404-page": "404-page";
            }>>;
            has_static_routing: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    workflows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        name: z.ZodString;
        className: z.ZodString;
        scriptName: z.ZodOptional<z.ZodString>;
        external: z.ZodOptional<z.ZodBoolean>;
        stepLimit: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>>;
    pipelines: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        stream: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        pipeline: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>]>>, z.ZodArray<z.ZodString>]>>;
    secretsStoreSecrets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        store_id: z.ZodString;
        secret_name: z.ZodString;
    }, z.core.$strip>>>;
    email: z.ZodOptional<z.ZodObject<{
        send_email: z.ZodOptional<z.ZodArray<z.ZodIntersection<z.ZodObject<{
            name: z.ZodString;
            remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
            allowed_sender_addresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
            destination_address: z.ZodOptional<z.ZodString>;
            allowed_destination_addresses: z.ZodOptional<z.ZodNever>;
        }, z.core.$strip>, z.ZodObject<{
            allowed_destination_addresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
            destination_address: z.ZodOptional<z.ZodNever>;
        }, z.core.$strip>]>>>>;
    }, z.core.$strip>>;
    analyticsEngineDatasets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        dataset: z.ZodString;
    }, z.core.$strip>>>;
    ai: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>;
    agentMemory: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    aiSearchNamespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodOptional<z.ZodString>;
        instance_name: z.ZodOptional<z.ZodString>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    aiSearchInstances: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodOptional<z.ZodString>;
        instance_name: z.ZodOptional<z.ZodString>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    websearch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    browserRendering: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        headful: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    dispatchNamespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    images: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>;
    stream: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>;
    vectorize: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        index_name: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    vpcNetworks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
        tunnel_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>, z.ZodObject<{
        network_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>]>>>;
    vpcServices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        service_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    mtlsCertificates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        certificate_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    helloWorld: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        enable_timer: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>>;
    flagship: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        app_id: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    artifacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        namespace: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>>;
    workerLoaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{}, z.core.$strip>>>;
    media: z.ZodOptional<z.ZodObject<{
        binding: z.ZodString;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
    }, z.core.$strip>>;
    versionMetadata: z.ZodOptional<z.ZodString>;
}, z.core.$strip>>;

export declare type V4WorkerOptionsShape = {
    [key: string]: unknown;
    name?: string;
    rootPath?: string;
    compatibilityDate?: string;
    compatibilityFlags?: string[];
    unsafeInspectorProxy?: boolean;
    routes?: string[];
    bindings?: Record<string, Json>;
    wasmBindings?: Record<string, string | Uint8Array>;
    textBlobBindings?: Record<string, string>;
    dataBlobBindings?: Record<string, string | Uint8Array>;
    serviceBindings?: Record<string, V4ServiceDesignator>;
    outboundService?: V4ServiceDesignator;
    unsafeEphemeralDurableObjects?: boolean;
    unsafeDirectSockets?: Array<{
        host?: string;
        port?: number;
        serviceName?: string;
        entrypoint?: string;
        proxy?: boolean;
    }>;
    connectHandlers?: Array<{
        protocol: "tcp";
        port: number;
        address?: string;
    }>;
    unsafeOverrideFetchWorker?: string;
    unsafeEvalBinding?: string;
    unsafeUseModuleFallbackService?: boolean;
    unsafeRegisterWorker?: boolean;
    tails?: V4ServiceDesignator[];
    streamingTails?: V4ServiceDesignator[];
    stripCfConnectingIp?: boolean;
    zone?: string;
    access?: {
        aud: string;
        identity?: Record<string, unknown>;
    };
    unsafeBindings?: Array<{
        name: string;
        type: string;
        plugin: {
            package: string;
            name: string;
        };
        options: Record<string, Json>;
    }>;
    cacheAPI?: boolean;
    d1Databases?: V4Namespace;
    durableObjects?: Record<string, string | V4DurableObject>;
    additionalUnboundDurableObjects?: V4DurableObject[];
    kvNamespaces?: V4Namespace;
    sitePath?: string;
    siteInclude?: string[];
    siteExclude?: string[];
    queueProducers?: Record<string, V4QueueProducerOptions> | string[] | Record<string, string>;
    queueConsumers?: Record<string, V4QueueConsumerOptions> | string[];
    r2Buckets?: Record<string, string | (V4IdEntry & {
        s3Credentials?: {
            accessKeyId: string;
            secretAccessKey: string;
        };
    })> | string[];
    hyperdrives?: Record<string, string | URL>;
    ratelimits?: Record<string, {
        namespace_id: string;
        simple: {
            limit: number;
            period?: 10 | 60;
        };
    }>;
    assets?: {
        workerName?: string;
        directory: string;
        binding?: string;
        run_worker_first?: boolean | string[];
        routerConfig?: RouterConfig;
        assetConfig?: Omit<AssetConfig, "compatibility_date" | "compatibility_flags">;
    };
    workflows?: Record<string, {
        name: string;
        className: string;
        scriptName?: string;
        external?: boolean;
        stepLimit?: number;
    }>;
    pipelines?: Record<string, string | ({
        stream: string;
    } & V4RemoteBinding) | ({
        pipeline: string;
    } & V4RemoteBinding)> | string[];
    secretsStoreSecrets?: Record<string, {
        store_id: string;
        secret_name: string;
    }>;
    email?: {
        send_email?: Array<{
            name: string;
            remoteProxyConnectionString?: RemoteProxyConnectionString;
            allowed_sender_addresses?: string[];
        } & ({
            destination_address?: string;
            allowed_destination_addresses?: never;
        } | {
            allowed_destination_addresses?: string[];
            destination_address?: never;
        })>;
    };
    analyticsEngineDatasets?: Record<string, {
        dataset: string;
    }>;
    ai?: V4RemoteBindingWithName;
    agentMemory?: Record<string, {
        namespace: string;
    } & V4RemoteBinding>;
    aiSearchNamespaces?: Record<string, {
        namespace?: string;
        instance_name?: string;
    } & V4RemoteBinding>;
    aiSearchInstances?: Record<string, {
        namespace?: string;
        instance_name?: string;
    } & V4RemoteBinding>;
    websearch?: Record<string, V4RemoteBinding>;
    browserRendering?: V4RemoteBindingWithName & {
        headful?: boolean;
    };
    dispatchNamespaces?: Record<string, {
        namespace: string;
    } & V4RemoteBinding>;
    images?: V4RemoteBindingWithName;
    stream?: V4RemoteBindingWithName;
    vectorize?: Record<string, {
        index_name: string;
    } & V4RemoteBinding>;
    vpcNetworks?: Record<string, ({
        tunnel_id: string;
    } | {
        network_id: string;
    }) & V4RemoteBinding>;
    vpcServices?: Record<string, {
        service_id: string;
    } & V4RemoteBinding>;
    mtlsCertificates?: Record<string, {
        certificate_id: string;
    } & V4RemoteBinding>;
    helloWorld?: Record<string, {
        enable_timer?: boolean;
    }>;
    flagship?: Record<string, {
        app_id: string;
    } & V4RemoteBinding>;
    artifacts?: Record<string, {
        namespace: string;
    } & V4RemoteBinding>;
    workerLoaders?: Record<string, Record<string, never>>;
    media?: V4RemoteBindingWithName;
    versionMetadata?: string;
};

export declare type ValueOf<T> = T[keyof T];

export declare const VECTORIZE_PLUGIN: Plugin;

export declare const VECTORIZE_PLUGIN_NAME = "vectorize";

export declare const VERSION_METADATA_PLUGIN: Plugin;

export declare const VERSION_METADATA_PLUGIN_NAME = "version-metadata";

export declare function viewToBuffer(view: ArrayBufferView): ArrayBuffer;

export declare type Void = typeof kVoid;

export declare const VPC_NETWORKS_PLUGIN: Plugin;

export declare const VPC_NETWORKS_PLUGIN_NAME = "vpc-networks";

export declare const VPC_SERVICES_PLUGIN: Plugin;

export declare const VPC_SERVICES_PLUGIN_NAME = "vpc-services";

export declare class WaitGroup {
    private counter;
    private resolveQueue;
    add(): void;
    done(): void;
    wait(): Promise<void>;
}

export declare const WEBSEARCH_PLUGIN: Plugin;

export declare const WEBSEARCH_PLUGIN_NAME = "websearch";

declare class WebSocket_2 extends TypedEventTarget<WebSocketEventMap_2> {
    #private;
    static readonly READY_STATE_CONNECTING = 0;
    static readonly READY_STATE_OPEN = 1;
    static readonly READY_STATE_CLOSING = 2;
    static readonly READY_STATE_CLOSED = 3;
    [kPair]?: WebSocket_2;
    [kAccepted]: boolean;
    [kCoupled]: boolean;
    [kClosedOutgoing]: boolean;
    [kClosedIncoming]: boolean;
    get readyState(): number;
    accept(): void;
    send(message: string | ArrayBuffer | Uint8Array<ArrayBuffer>): void;
    [kSend](message: string | ArrayBuffer | Uint8Array<ArrayBuffer>): void;
    close(code?: number, reason?: string): void;
    [kClose](code?: number, reason?: string): void;
    [kError](error?: Error): void;
}
export { WebSocket_2 as WebSocket }

declare type WebSocketEventMap_2 = {
    message: MessageEvent_2;
    close: CloseEvent_2;
    error: ErrorEvent_2;
};
export { WebSocketEventMap_2 as WebSocketEventMap }

declare type WebSocketPair_2 = {
    0: WebSocket_2;
    1: WebSocket_2;
};

declare const WebSocketPair_2: {
    new (): WebSocketPair_2;
};
export { WebSocketPair_2 as WebSocketPair }

export declare type Worker = ({
    modules?: Worker_Module[];
} | {
    serviceWorkerScript?: string;
} | {
    inherit?: string;
}) & {
    compatibilityDate?: string;
    compatibilityFlags?: string[];
    bindings?: Worker_Binding[];
    globalOutbound?: ServiceDesignator;
    cacheApiOutbound?: ServiceDesignator;
    durableObjectNamespaces?: Worker_DurableObjectNamespace[];
    durableObjectUniqueKeyModifier?: string;
    durableObjectStorage?: Worker_DurableObjectStorage;
    moduleFallback?: string;
    tails?: ServiceDesignator[];
    streamingTails?: ServiceDesignator[];
    containerEngine?: Worker_ContainerEngine;
    accessBlobHeader?: string;
    accessBindingService?: ServiceDesignator;
};

export declare type Worker_Binding = {
    name?: string;
} & ({
    parameter?: Worker_Binding_Parameter;
} | {
    text?: string;
} | {
    data?: Uint8Array;
} | {
    json?: string;
} | {
    wasmModule?: Uint8Array;
} | {
    cryptoKey?: Worker_Binding_CryptoKey;
} | {
    service?: ServiceDesignator;
} | {
    durableObjectNamespace?: Worker_Binding_DurableObjectNamespaceDesignator;
} | {
    kvNamespace?: ServiceDesignator;
} | {
    r2Bucket?: ServiceDesignator;
} | {
    obsolete0?: ServiceDesignator;
} | {
    wrapped?: Worker_Binding_WrappedBinding;
} | {
    queue?: ServiceDesignator;
} | {
    fromEnvironment?: string;
} | {
    analyticsEngine?: ServiceDesignator;
} | {
    hyperdrive?: Worker_Binding_Hyperdrive;
} | {
    unsafeEval?: Void;
} | {
    workerLoader?: Worker_Binding_WorkerLoader;
} | {
    workerdDebugPort?: Void;
});

export declare type Worker_Binding_CryptoKey = ({
    raw?: Uint8Array;
} | {
    hex?: string;
} | {
    base64?: string;
} | {
    pkcs8?: string;
} | {
    spki?: string;
} | {
    jwk?: string;
}) & {
    algorithm?: Worker_Binding_CryptoKey_Algorithm;
    extractable?: boolean;
    usages?: Worker_Binding_CryptoKey_Usage[];
};

export declare type Worker_Binding_CryptoKey_Algorithm = {
    name?: string;
} | {
    json?: string;
};

export declare const Worker_Binding_CryptoKey_Usage: {
    readonly ENCRYPT: 0;
    readonly DECRYPT: 1;
    readonly SIGN: 2;
    readonly VERIFY: 3;
    readonly DERIVE_KEY: 4;
    readonly DERIVE_BITS: 5;
    readonly WRAP_KEY: 6;
    readonly UNWRAP_KEY: 7;
};

export declare type Worker_Binding_CryptoKey_Usage = (typeof Worker_Binding_CryptoKey_Usage)[keyof typeof Worker_Binding_CryptoKey_Usage];

export declare type Worker_Binding_DurableObjectNamespaceDesignator = {
    className?: string;
    serviceName?: string;
};

export declare interface Worker_Binding_Hyperdrive {
    designator?: ServiceDesignator;
    database?: string;
    user?: string;
    password?: string;
    scheme?: string;
}

export declare interface Worker_Binding_MemoryCache {
    id?: string;
    limits?: Worker_Binding_MemoryCacheLimits;
}

export declare interface Worker_Binding_MemoryCacheLimits {
    maxKeys?: number;
    maxValueSize?: number;
    maxTotalValueSize?: number;
}

export declare interface Worker_Binding_Parameter {
    type?: Worker_Binding_Type;
    optional?: boolean;
}

export declare const WORKER_BINDING_SERVICE_LOOPBACK: Worker_Binding;

export declare type Worker_Binding_Type = {
    text?: Void;
} | {
    data?: Void;
} | {
    json?: Void;
} | {
    wasm?: Void;
} | {
    cryptoKey?: Worker_Binding_CryptoKey_Usage[];
} | {
    service?: Void;
} | {
    durableObjectNamespace: Void;
} | {
    kvNamespace?: Void;
} | {
    r2Bucket?: Void;
} | {
    obsolete0?: Void;
} | {
    queue?: Void;
} | {
    analyticsEngine?: Void;
} | {
    hyperdrive?: Void;
};

export declare interface Worker_Binding_WorkerLoader {
    id?: string;
}

export declare interface Worker_Binding_WrappedBinding {
    moduleName?: string;
    entrypoint?: string;
    innerBindings?: Worker_Binding[];
}

export declare type Worker_ContainerEngine = {
    localDocker: Worker_DockerConfiguration;
};

export declare type Worker_DockerConfiguration = {
    socketPath: string;
    containerEgressInterceptorImage?: string;
};

export declare type Worker_DurableObjectNamespace = {
    className?: string;
    preventEviction?: boolean;
    enableSql?: boolean;
    container?: Worker_DurableObjectNamespace_ContainerOptions;
} & ({
    uniqueKey?: string;
} | {
    ephemeralLocal?: Void;
});

export declare interface Worker_DurableObjectNamespace_ContainerOptions {
    imageName?: string;
    privileges?: Worker_DurableObjectNamespace_ContainerOptions_ContainerPrivileges;
}

export declare interface Worker_DurableObjectNamespace_ContainerOptions_ContainerPrivileges {
    capabilities?: string[];
    devices?: Worker_DurableObjectNamespace_ContainerOptions_ContainerPrivileges_Device[];
    securityOpt?: string[];
}

export declare interface Worker_DurableObjectNamespace_ContainerOptions_ContainerPrivileges_Device {
    pathOnHost?: string;
    pathInContainer?: string;
    cgroupPermissions?: string;
}

export declare type Worker_DurableObjectStorage = {
    none?: Void;
} | {
    inMemory?: Void;
} | {
    localDisk?: string;
};

export declare const WORKER_LOADER_PLUGIN: Plugin;

export declare const WORKER_LOADER_PLUGIN_NAME = "worker-loader";

export declare type Worker_Module = {
    name: string;
} & ({
    esModule?: string;
} | {
    commonJsModule?: string;
} | {
    text?: string;
} | {
    data?: Uint8Array;
} | {
    wasm?: Uint8Array;
} | {
    json?: string;
} | {
    pythonModule?: string;
} | {
    obsoletePythonRequirement?: string;
});

export declare type WorkerDefinition = {
    /**
     * Address of the workerd debug port for this worker's process (e.g. "127.0.0.1:12345").
     * The debug port provides native Cap'n Proto RPC access to all services/entrypoints.
     */
    debugPortAddress: string;
    /**
     * The workerd service name for the default entrypoint. This varies by worker type:
     * - Workers with assets: routes through the assets RPC proxy
     * - Vite workers: routes through the vite proxy worker
     * - Plain workers: routes directly to the user worker service
     */
    defaultEntrypointService: string;
    /**
     * The workerd service name for the user worker directly
     * For plain workers this is identical to defaultEntrypointService, but for other
     * workers it bypasses the Assets proxy (whether built-in or userland)
     */
    userWorkerService: string;
    /**
     * Queue names consumed by this Worker. Producers in other dev sessions use
     * this to route messages for these queues to this process's queue broker.
     */
    queueConsumers?: string[];
    /** Canonical persistence root when this instance can own shared storage. */
    storageScope?: string;
};

export declare type WorkerdStructuredLog = z.infer<typeof workerdStructuredLogSchema>;

export declare const workerdStructuredLogSchema: z.ZodObject<{
    timestamp: z.ZodNumber;
    level: z.ZodString;
    message: z.ZodString;
}, z.core.$strip>;

export declare type WorkerOptions = z.input<typeof WorkerOptionsSchema>;

export declare const WorkerOptionsSchema: z.ZodObject<{
    config: z.ZodPipe<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodLiteral<"worker">;
        cache: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodBoolean;
            crossVersionCache: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strict>>;
        compatibilityDate: z.ZodString;
        compatibilityFlags: z.ZodOptional<z.ZodArray<z.ZodString>>;
        domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
        triggers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            type: z.ZodLiteral<"email">;
            addresses: z.ZodArray<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"fetch">;
            pattern: z.ZodString;
            zone: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"queue">;
            name: z.ZodString;
            deadLetterQueue: z.ZodOptional<z.ZodString>;
            maxBatchSize: z.ZodOptional<z.ZodNumber>;
            maxBatchTimeout: z.ZodOptional<z.ZodNumber>;
            maxConcurrency: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            maxRetries: z.ZodOptional<z.ZodNumber>;
            retryDelay: z.ZodOptional<z.ZodNumber>;
            visibilityTimeoutMs: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"scheduled">;
            schedule: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"connect">;
            protocol: z.ZodEnum<{
                tcp: "tcp";
            }>;
            port: z.ZodNumber;
            address: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>], "type">>>;
        placement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
            mode: z.ZodEnum<{
                off: "off";
                smart: "smart";
            }>;
            hint: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
            region: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
            host: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            mode: z.ZodOptional<z.ZodLiteral<"targeted">>;
            hostname: z.ZodString;
        }, z.core.$strict>]>>;
        limits: z.ZodOptional<z.ZodObject<{
            cpuMs: z.ZodOptional<z.ZodNumber>;
            subrequests: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strict>>;
        logpush: z.ZodOptional<z.ZodBoolean>;
        observability: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodOptional<z.ZodBoolean>;
            headSamplingRate: z.ZodOptional<z.ZodNumber>;
            redactQueryString: z.ZodOptional<z.ZodBoolean>;
            logs: z.ZodOptional<z.ZodObject<{
                enabled: z.ZodOptional<z.ZodBoolean>;
                headSamplingRate: z.ZodOptional<z.ZodNumber>;
                invocationLogs: z.ZodOptional<z.ZodBoolean>;
                persist: z.ZodOptional<z.ZodBoolean>;
                destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>;
            traces: z.ZodOptional<z.ZodObject<{
                enabled: z.ZodOptional<z.ZodBoolean>;
                headSamplingRate: z.ZodOptional<z.ZodNumber>;
                persist: z.ZodOptional<z.ZodBoolean>;
                destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        workersDev: z.ZodOptional<z.ZodBoolean>;
        previewUrls: z.ZodOptional<z.ZodBoolean>;
        firstPartyWorker: z.ZodOptional<z.ZodBoolean>;
        unsafe: z.ZodOptional<z.ZodObject<{
            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            capnp: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                basePath: z.ZodString;
                sourceSchemas: z.ZodArray<z.ZodString>;
                compiledSchema: z.ZodOptional<z.ZodNever>;
            }, z.core.$strict>, z.ZodObject<{
                basePath: z.ZodOptional<z.ZodNever>;
                sourceSchemas: z.ZodOptional<z.ZodNever>;
                compiledSchema: z.ZodString;
            }, z.core.$strict>]>>;
        }, z.core.$strict>>;
        manifest: z.ZodOptional<z.ZodObject<{
            mainModule: z.ZodString;
            modulesRoot: z.ZodDefault<z.ZodString>;
            modules: z.ZodRecord<z.ZodString, z.ZodObject<{
                type: z.ZodEnum<{
                    json: "json";
                    text: "text";
                    esm: "esm";
                    cjs: "cjs";
                    python: "python";
                    "python-requirement": "python-requirement";
                    wasm: "wasm";
                    data: "data";
                    sourcemap: "sourcemap";
                }>;
                contents: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<{
            type: "external";
            address: string;
            http?: {
                capnpConnectHost: string;
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            https?: {
                options?: {
                    capnpConnectHost: string;
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
                certificateHost?: string | undefined;
            } | undefined;
        } | ({
            type: "send-email";
            destinationAddress?: string | undefined;
            allowedDestinationAddresses?: string[] | undefined;
            allowedSenderAddresses?: string[] | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & SendEmailBinding) | ({
            type: "vpc-network";
            tunnelId?: string | undefined;
            networkId?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & VpcNetworkBinding) | {
            type: "browser";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
            headful?: boolean | undefined;
        } | {
            type: "hyperdrive";
            id: string;
            dev: {
                connectionString: string;
            };
        } | {
            type: "worker";
            worker: string | typeof kCurrentWorker;
            exportName?: string | undefined;
            props?: Record<string, unknown> | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "fetcher";
            handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
        } | {
            type: "node-handler";
            handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
        } | {
            type: "network";
            allow?: string[] | undefined;
            deny?: string[] | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
        } | {
            type: "disk";
            path: string;
            writable?: boolean | undefined;
        } | {
            type: "hello-world";
            enable_timer?: boolean | undefined;
        } | {
            type: "workflow";
            name: string;
            worker: string;
            exportName: string;
            limits?: {
                steps?: number | undefined;
            } | undefined;
        } | {
            type: "agent-memory";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search-namespace";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "analytics-engine-dataset";
            name?: string | undefined;
        } | {
            type: "artifacts";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "assets";
        } | {
            type: "d1";
            name?: string | undefined;
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "dispatch-namespace";
            namespace?: string | undefined;
            outbound?: {
                worker: string;
                parameters?: string[] | undefined;
            } | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "durable-object";
            worker: string;
            exportName: string;
        } | {
            type: "flagship";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "images";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "json";
            value: z.core.util.JSONType;
        } | {
            type: "kv";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "logfwdr";
            destination: string;
        } | {
            type: "media";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "mtls-certificate";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "pipeline";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "queue";
            name?: string | undefined;
            deliveryDelay?: number | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "rate-limit";
            namespace: string;
            simple: {
                limit: number;
                period: 60 | 10;
            };
        } | {
            type: "r2";
            name?: string | undefined;
            jurisdiction?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
                experimentalS3Credentials?: {
                    accessKeyId: string;
                    secretAccessKey: string;
                } | undefined;
            } | undefined;
        } | {
            type: "secret";
        } | {
            type: "secrets-store-secret";
            storeId: string;
            secretName: string;
        } | {
            type: "stream";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "text";
            value: string;
        } | {
            type: "vectorize";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "version-metadata";
        } | {
            type: "vpc-service";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "web-search";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "worker-loader";
        } | {
            [x: string]: unknown;
            type: `unsafe:${string}`;
            dev?: {
                plugin: {
                    package: string;
                    name: string;
                };
                options?: Record<string, unknown> | undefined;
            } | undefined;
        }, {
            type: "external";
            address: string;
            http?: {
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            https?: {
                options?: {
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
                certificateHost?: string | undefined;
            } | undefined;
        } | ({
            type: "send-email";
            destinationAddress?: string | undefined;
            allowedDestinationAddresses?: string[] | undefined;
            allowedSenderAddresses?: string[] | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & {
            type: "send-email";
            destinationAddress?: string | undefined;
            allowedDestinationAddresses?: string[] | undefined;
            allowedSenderAddresses?: string[] | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        }) | ({
            type: "vpc-network";
            tunnelId?: string | undefined;
            networkId?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & {
            type: "vpc-network";
            tunnelId?: string | undefined;
            networkId?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        }) | {
            type: "browser";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
            headful?: boolean | undefined;
        } | {
            type: "hyperdrive";
            id: string;
            dev: {
                connectionString: string;
            };
        } | {
            type: "worker";
            worker: string | typeof kCurrentWorker;
            exportName?: string | undefined;
            props?: Record<string, unknown> | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "fetcher";
            handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
        } | {
            type: "node-handler";
            handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
        } | {
            type: "network";
            allow?: string[] | undefined;
            deny?: string[] | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
        } | {
            type: "disk";
            path: string;
            writable?: boolean | undefined;
        } | {
            type: "hello-world";
            enable_timer?: boolean | undefined;
        } | {
            type: "workflow";
            name: string;
            worker: string;
            exportName: string;
            limits?: {
                steps?: number | undefined;
            } | undefined;
        } | {
            type: "agent-memory";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search-namespace";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "analytics-engine-dataset";
            name?: string | undefined;
        } | {
            type: "artifacts";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "assets";
        } | {
            type: "d1";
            name?: string | undefined;
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "dispatch-namespace";
            namespace?: string | undefined;
            outbound?: {
                worker: string;
                parameters?: string[] | undefined;
            } | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "durable-object";
            worker: string;
            exportName: string;
        } | {
            type: "flagship";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "images";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "json";
            value: z.core.util.JSONType;
        } | {
            type: "kv";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "logfwdr";
            destination: string;
        } | {
            type: "media";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "mtls-certificate";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "pipeline";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "queue";
            name?: string | undefined;
            deliveryDelay?: number | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "rate-limit";
            namespace: string;
            simple: {
                limit: number;
                period: 60 | 10;
            };
        } | {
            type: "r2";
            name?: string | undefined;
            jurisdiction?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
                experimentalS3Credentials?: {
                    accessKeyId: string;
                    secretAccessKey: string;
                } | undefined;
            } | undefined;
        } | {
            type: "secret";
        } | {
            type: "secrets-store-secret";
            storeId: string;
            secretName: string;
        } | {
            type: "stream";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "text";
            value: string;
        } | {
            type: "vectorize";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "version-metadata";
        } | {
            type: "vpc-service";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "web-search";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "worker-loader";
        } | {
            [x: string]: unknown;
            type: `unsafe:${string}`;
            dev?: {
                plugin: {
                    package: string;
                    name: string;
                };
                options?: Record<string, unknown> | undefined;
            } | undefined;
        }, z.core.$ZodTypeInternals<{
            type: "external";
            address: string;
            http?: {
                capnpConnectHost: string;
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            https?: {
                options?: {
                    capnpConnectHost: string;
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
                certificateHost?: string | undefined;
            } | undefined;
        } | ({
            type: "send-email";
            destinationAddress?: string | undefined;
            allowedDestinationAddresses?: string[] | undefined;
            allowedSenderAddresses?: string[] | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & SendEmailBinding) | ({
            type: "vpc-network";
            tunnelId?: string | undefined;
            networkId?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & VpcNetworkBinding) | {
            type: "browser";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
            headful?: boolean | undefined;
        } | {
            type: "hyperdrive";
            id: string;
            dev: {
                connectionString: string;
            };
        } | {
            type: "worker";
            worker: string | typeof kCurrentWorker;
            exportName?: string | undefined;
            props?: Record<string, unknown> | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "fetcher";
            handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
        } | {
            type: "node-handler";
            handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
        } | {
            type: "network";
            allow?: string[] | undefined;
            deny?: string[] | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
        } | {
            type: "disk";
            path: string;
            writable?: boolean | undefined;
        } | {
            type: "hello-world";
            enable_timer?: boolean | undefined;
        } | {
            type: "workflow";
            name: string;
            worker: string;
            exportName: string;
            limits?: {
                steps?: number | undefined;
            } | undefined;
        } | {
            type: "agent-memory";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search-namespace";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "analytics-engine-dataset";
            name?: string | undefined;
        } | {
            type: "artifacts";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "assets";
        } | {
            type: "d1";
            name?: string | undefined;
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "dispatch-namespace";
            namespace?: string | undefined;
            outbound?: {
                worker: string;
                parameters?: string[] | undefined;
            } | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "durable-object";
            worker: string;
            exportName: string;
        } | {
            type: "flagship";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "images";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "json";
            value: z.core.util.JSONType;
        } | {
            type: "kv";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "logfwdr";
            destination: string;
        } | {
            type: "media";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "mtls-certificate";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "pipeline";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "queue";
            name?: string | undefined;
            deliveryDelay?: number | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "rate-limit";
            namespace: string;
            simple: {
                limit: number;
                period: 60 | 10;
            };
        } | {
            type: "r2";
            name?: string | undefined;
            jurisdiction?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
                experimentalS3Credentials?: {
                    accessKeyId: string;
                    secretAccessKey: string;
                } | undefined;
            } | undefined;
        } | {
            type: "secret";
        } | {
            type: "secrets-store-secret";
            storeId: string;
            secretName: string;
        } | {
            type: "stream";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "text";
            value: string;
        } | {
            type: "vectorize";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "version-metadata";
        } | {
            type: "vpc-service";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "web-search";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "worker-loader";
        } | {
            [x: string]: unknown;
            type: `unsafe:${string}`;
            dev?: {
                plugin: {
                    package: string;
                    name: string;
                };
                options?: Record<string, unknown> | undefined;
            } | undefined;
        }, {
            type: "external";
            address: string;
            http?: {
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            https?: {
                options?: {
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
                certificateHost?: string | undefined;
            } | undefined;
        } | ({
            type: "send-email";
            destinationAddress?: string | undefined;
            allowedDestinationAddresses?: string[] | undefined;
            allowedSenderAddresses?: string[] | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & {
            type: "send-email";
            destinationAddress?: string | undefined;
            allowedDestinationAddresses?: string[] | undefined;
            allowedSenderAddresses?: string[] | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        }) | ({
            type: "vpc-network";
            tunnelId?: string | undefined;
            networkId?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & {
            type: "vpc-network";
            tunnelId?: string | undefined;
            networkId?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        }) | {
            type: "browser";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
            headful?: boolean | undefined;
        } | {
            type: "hyperdrive";
            id: string;
            dev: {
                connectionString: string;
            };
        } | {
            type: "worker";
            worker: string | typeof kCurrentWorker;
            exportName?: string | undefined;
            props?: Record<string, unknown> | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "fetcher";
            handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
        } | {
            type: "node-handler";
            handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
        } | {
            type: "network";
            allow?: string[] | undefined;
            deny?: string[] | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
        } | {
            type: "disk";
            path: string;
            writable?: boolean | undefined;
        } | {
            type: "hello-world";
            enable_timer?: boolean | undefined;
        } | {
            type: "workflow";
            name: string;
            worker: string;
            exportName: string;
            limits?: {
                steps?: number | undefined;
            } | undefined;
        } | {
            type: "agent-memory";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search-namespace";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "analytics-engine-dataset";
            name?: string | undefined;
        } | {
            type: "artifacts";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "assets";
        } | {
            type: "d1";
            name?: string | undefined;
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "dispatch-namespace";
            namespace?: string | undefined;
            outbound?: {
                worker: string;
                parameters?: string[] | undefined;
            } | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "durable-object";
            worker: string;
            exportName: string;
        } | {
            type: "flagship";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "images";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "json";
            value: z.core.util.JSONType;
        } | {
            type: "kv";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "logfwdr";
            destination: string;
        } | {
            type: "media";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "mtls-certificate";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "pipeline";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "queue";
            name?: string | undefined;
            deliveryDelay?: number | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "rate-limit";
            namespace: string;
            simple: {
                limit: number;
                period: 60 | 10;
            };
        } | {
            type: "r2";
            name?: string | undefined;
            jurisdiction?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
                experimentalS3Credentials?: {
                    accessKeyId: string;
                    secretAccessKey: string;
                } | undefined;
            } | undefined;
        } | {
            type: "secret";
        } | {
            type: "secrets-store-secret";
            storeId: string;
            secretName: string;
        } | {
            type: "stream";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "text";
            value: string;
        } | {
            type: "vectorize";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "version-metadata";
        } | {
            type: "vpc-service";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "web-search";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "worker-loader";
        } | {
            [x: string]: unknown;
            type: `unsafe:${string}`;
            dev?: {
                plugin: {
                    package: string;
                    name: string;
                };
                options?: Record<string, unknown> | undefined;
            } | undefined;
        }>>>>;
        exports: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
            type: z.ZodLiteral<"durable-object">;
            state: z.ZodOptional<z.ZodLiteral<"created">>;
            storage: z.ZodEnum<{
                sqlite: "sqlite";
                "legacy-kv": "legacy-kv";
            }>;
            unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
            unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
            container: z.ZodOptional<z.ZodCustom<{
                imageName: string;
            }, {
                imageName: string;
            }>>;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"durable-object">;
            state: z.ZodLiteral<"deleted">;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"durable-object">;
            state: z.ZodLiteral<"renamed">;
            renamedTo: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"durable-object">;
            state: z.ZodLiteral<"transferred">;
            transferredTo: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"durable-object">;
            state: z.ZodLiteral<"expecting-transfer">;
            storage: z.ZodEnum<{
                sqlite: "sqlite";
                "legacy-kv": "legacy-kv";
            }>;
            transferFrom: z.ZodString;
            unsafeUniqueKey: z.ZodOptional<z.ZodCustom<UnsafeUniqueKey, UnsafeUniqueKey>>;
            unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
            container: z.ZodOptional<z.ZodCustom<{
                imageName: string;
            }, {
                imageName: string;
            }>>;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"worker">;
            cache: z.ZodOptional<z.ZodObject<{
                enabled: z.ZodBoolean;
            }, z.core.$strict>>;
        }, z.core.$strict>]>>, z.ZodTransform<Record<string, {
            type: "durable-object";
            storage: "sqlite" | "legacy-kv";
            state?: "created" | undefined;
            unsafeUniqueKey?: UnsafeUniqueKey | undefined;
            unsafePreventEviction?: boolean | undefined;
            container?: {
                imageName: string;
            } | undefined;
        } | {
            type: "durable-object";
            state: "expecting-transfer";
            storage: "sqlite" | "legacy-kv";
            transferFrom: string;
            unsafeUniqueKey?: UnsafeUniqueKey | undefined;
            unsafePreventEviction?: boolean | undefined;
            container?: {
                imageName: string;
            } | undefined;
        } | {
            type: "worker";
            cache?: {
                enabled: boolean;
            } | undefined;
        }>, Record<string, {
            type: "durable-object";
            storage: "sqlite" | "legacy-kv";
            state?: "created" | undefined;
            unsafeUniqueKey?: UnsafeUniqueKey | undefined;
            unsafePreventEviction?: boolean | undefined;
            container?: {
                imageName: string;
            } | undefined;
        } | {
            type: "durable-object";
            state: "deleted";
        } | {
            type: "durable-object";
            state: "renamed";
            renamedTo: string;
        } | {
            type: "durable-object";
            state: "transferred";
            transferredTo: string;
        } | {
            type: "durable-object";
            state: "expecting-transfer";
            storage: "sqlite" | "legacy-kv";
            transferFrom: string;
            unsafeUniqueKey?: UnsafeUniqueKey | undefined;
            unsafePreventEviction?: boolean | undefined;
            container?: {
                imageName: string;
            } | undefined;
        } | {
            type: "worker";
            cache?: {
                enabled: boolean;
            } | undefined;
        }>>>>;
        assets: z.ZodOptional<z.ZodObject<{
            htmlHandling: z.ZodOptional<z.ZodEnum<{
                "auto-trailing-slash": "auto-trailing-slash";
                "drop-trailing-slash": "drop-trailing-slash";
                "force-trailing-slash": "force-trailing-slash";
                none: "none";
            }>>;
            notFoundHandling: z.ZodOptional<z.ZodEnum<{
                none: "none";
                "single-page-application": "single-page-application";
                "404-page": "404-page";
            }>>;
            runWorkerFirst: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodBoolean]>>;
            directory: z.ZodString;
            hasUserWorker: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strict>>;
        tailConsumers: z.ZodOptional<z.ZodArray<z.ZodObject<{
            worker: z.ZodString;
            streaming: z.ZodOptional<z.ZodBoolean>;
            entrypoint: z.ZodOptional<z.ZodString>;
            props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>>>;
    }, z.core.$strict>, z.ZodTransform<ParsedMiniflareWorkerConfig, {
        name: string;
        type: "worker";
        compatibilityDate: string;
        cache?: {
            enabled: boolean;
            crossVersionCache?: boolean | undefined;
        } | undefined;
        compatibilityFlags?: string[] | undefined;
        domains?: string[] | undefined;
        triggers?: ({
            type: "email";
            addresses: string[];
        } | {
            type: "fetch";
            pattern: string;
            zone?: string | undefined;
        } | {
            type: "queue";
            name: string;
            deadLetterQueue?: string | undefined;
            maxBatchSize?: number | undefined;
            maxBatchTimeout?: number | undefined;
            maxConcurrency?: number | null | undefined;
            maxRetries?: number | undefined;
            retryDelay?: number | undefined;
            visibilityTimeoutMs?: number | undefined;
        } | {
            type: "scheduled";
            schedule: string;
        } | {
            type: "connect";
            protocol: "tcp";
            port: number;
            address?: string | undefined;
        })[] | undefined;
        placement?: {
            mode: "off" | "smart";
            hint?: string | undefined;
        } | {
            region: string;
            mode?: "targeted" | undefined;
        } | {
            host: string;
            mode?: "targeted" | undefined;
        } | {
            hostname: string;
            mode?: "targeted" | undefined;
        } | undefined;
        limits?: {
            cpuMs?: number | undefined;
            subrequests?: number | undefined;
        } | undefined;
        logpush?: boolean | undefined;
        observability?: {
            enabled?: boolean | undefined;
            headSamplingRate?: number | undefined;
            redactQueryString?: boolean | undefined;
            logs?: {
                enabled?: boolean | undefined;
                headSamplingRate?: number | undefined;
                invocationLogs?: boolean | undefined;
                persist?: boolean | undefined;
                destinations?: string[] | undefined;
            } | undefined;
            traces?: {
                enabled?: boolean | undefined;
                headSamplingRate?: number | undefined;
                persist?: boolean | undefined;
                destinations?: string[] | undefined;
            } | undefined;
        } | undefined;
        workersDev?: boolean | undefined;
        previewUrls?: boolean | undefined;
        firstPartyWorker?: boolean | undefined;
        unsafe?: {
            metadata?: Record<string, unknown> | undefined;
            capnp?: {
                basePath: string;
                sourceSchemas: string[];
                compiledSchema?: undefined;
            } | {
                compiledSchema: string;
                basePath?: undefined;
                sourceSchemas?: undefined;
            } | undefined;
        } | undefined;
        manifest?: {
            mainModule: string;
            modulesRoot: string;
            modules: Record<string, {
                type: "text" | "json" | "esm" | "cjs" | "python" | "python-requirement" | "wasm" | "data" | "sourcemap";
                contents: string | Uint8Array<ArrayBuffer>;
            }>;
        } | undefined;
        env?: Record<string, {
            type: "external";
            address: string;
            http?: {
                capnpConnectHost: string;
                style?: 0 | 1 | undefined;
                forwardedProtoHeader?: string | undefined;
                cfBlobHeader?: string | undefined;
                injectRequestHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
                injectResponseHeaders?: {
                    name: string;
                    value?: string | undefined;
                }[] | undefined;
            } | undefined;
            https?: {
                options?: {
                    capnpConnectHost: string;
                    style?: 0 | 1 | undefined;
                    forwardedProtoHeader?: string | undefined;
                    cfBlobHeader?: string | undefined;
                    injectRequestHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                    injectResponseHeaders?: {
                        name: string;
                        value?: string | undefined;
                    }[] | undefined;
                } | undefined;
                tlsOptions?: {
                    keypair?: {
                        privateKey?: string | undefined;
                        certificateChain?: string | undefined;
                    } | undefined;
                    requireClientCerts?: boolean | undefined;
                    trustBrowserCas?: boolean | undefined;
                    trustedCertificates?: string[] | undefined;
                    minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                    cipherList?: string | undefined;
                } | undefined;
                certificateHost?: string | undefined;
            } | undefined;
        } | ({
            type: "send-email";
            destinationAddress?: string | undefined;
            allowedDestinationAddresses?: string[] | undefined;
            allowedSenderAddresses?: string[] | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & SendEmailBinding) | ({
            type: "vpc-network";
            tunnelId?: string | undefined;
            networkId?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } & VpcNetworkBinding) | {
            type: "browser";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
            headful?: boolean | undefined;
        } | {
            type: "hyperdrive";
            id: string;
            dev: {
                connectionString: string;
            };
        } | {
            type: "worker";
            worker: string | typeof kCurrentWorker;
            exportName?: string | undefined;
            props?: Record<string, unknown> | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "fetcher";
            handler: (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>;
        } | {
            type: "node-handler";
            handler: (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>;
        } | {
            type: "network";
            allow?: string[] | undefined;
            deny?: string[] | undefined;
            tlsOptions?: {
                keypair?: {
                    privateKey?: string | undefined;
                    certificateChain?: string | undefined;
                } | undefined;
                requireClientCerts?: boolean | undefined;
                trustBrowserCas?: boolean | undefined;
                trustedCertificates?: string[] | undefined;
                minVersion?: 0 | 4 | 2 | 1 | 3 | 5 | undefined;
                cipherList?: string | undefined;
            } | undefined;
        } | {
            type: "disk";
            path: string;
            writable?: boolean | undefined;
        } | {
            type: "hello-world";
            enable_timer?: boolean | undefined;
        } | {
            type: "workflow";
            name: string;
            worker: string;
            exportName: string;
            limits?: {
                steps?: number | undefined;
            } | undefined;
        } | {
            type: "agent-memory";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "ai-search-namespace";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "analytics-engine-dataset";
            name?: string | undefined;
        } | {
            type: "artifacts";
            namespace: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "assets";
        } | {
            type: "d1";
            name?: string | undefined;
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "dispatch-namespace";
            namespace?: string | undefined;
            outbound?: {
                worker: string;
                parameters?: string[] | undefined;
            } | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "durable-object";
            worker: string;
            exportName: string;
        } | {
            type: "flagship";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "images";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "json";
            value: z.core.util.JSONType;
        } | {
            type: "kv";
            id?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "logfwdr";
            destination: string;
        } | {
            type: "media";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "mtls-certificate";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "pipeline";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "queue";
            name?: string | undefined;
            deliveryDelay?: number | undefined;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "rate-limit";
            namespace: string;
            simple: {
                limit: number;
                period: 60 | 10;
            };
        } | {
            type: "r2";
            name?: string | undefined;
            jurisdiction?: string | undefined;
            dev?: {
                remote?: boolean | undefined;
                experimentalS3Credentials?: {
                    accessKeyId: string;
                    secretAccessKey: string;
                } | undefined;
            } | undefined;
        } | {
            type: "secret";
        } | {
            type: "secrets-store-secret";
            storeId: string;
            secretName: string;
        } | {
            type: "stream";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "text";
            value: string;
        } | {
            type: "vectorize";
            name: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "version-metadata";
        } | {
            type: "vpc-service";
            id: string;
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "web-search";
            dev?: {
                remote?: boolean | undefined;
            } | undefined;
        } | {
            type: "worker-loader";
        } | {
            [x: string]: unknown;
            type: `unsafe:${string}`;
            dev?: {
                plugin: {
                    package: string;
                    name: string;
                };
                options?: Record<string, unknown> | undefined;
            } | undefined;
        }> | undefined;
        exports?: Record<string, {
            type: "durable-object";
            storage: "sqlite" | "legacy-kv";
            state?: "created" | undefined;
            unsafeUniqueKey?: UnsafeUniqueKey | undefined;
            unsafePreventEviction?: boolean | undefined;
            container?: {
                imageName: string;
            } | undefined;
        } | {
            type: "durable-object";
            state: "expecting-transfer";
            storage: "sqlite" | "legacy-kv";
            transferFrom: string;
            unsafeUniqueKey?: UnsafeUniqueKey | undefined;
            unsafePreventEviction?: boolean | undefined;
            container?: {
                imageName: string;
            } | undefined;
        } | {
            type: "worker";
            cache?: {
                enabled: boolean;
            } | undefined;
        }> | undefined;
        assets?: {
            directory: string;
            hasUserWorker: boolean;
            htmlHandling?: "auto-trailing-slash" | "force-trailing-slash" | "drop-trailing-slash" | "none" | undefined;
            notFoundHandling?: "none" | "single-page-application" | "404-page" | undefined;
            runWorkerFirst?: boolean | string[] | undefined;
        } | undefined;
        tailConsumers?: {
            worker: string;
            streaming?: boolean | undefined;
            entrypoint?: string | undefined;
            props?: Record<string, unknown> | undefined;
        }[] | undefined;
    }>>;
    legacy: z.ZodOptional<z.ZodObject<{
        serviceWorkerScript: z.ZodOptional<z.ZodString>;
        serviceWorkerScriptPath: z.ZodOptional<z.ZodString>;
        wasmBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
        textBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        dataBlobBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>>;
        sitePath: z.ZodOptional<z.ZodString>;
        siteInclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
        siteExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strict>>;
    dev: z.ZodDefault<z.ZodObject<{
        rootPath: z.ZodDefault<z.ZodString>;
        cacheAPI: z.ZodDefault<z.ZodBoolean>;
        outboundService: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
            type: z.ZodLiteral<"fetcher">;
            handler: z.ZodCustom<(request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>, (request: Request_2, miniflare: Miniflare) => Awaitable<Response_2>>;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"node-handler">;
            handler: z.ZodCustom<(req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>, (req: http.IncomingMessage, res: http.ServerResponse, miniflare: Miniflare) => Awaitable<void>>;
        }, z.core.$strict>, z.ZodObject<{
            type: z.ZodLiteral<"worker">;
            worker: z.ZodString;
            exportName: z.ZodOptional<z.ZodString>;
            props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            dev: z.ZodOptional<z.ZodObject<{
                remote: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strict>>;
        }, z.core.$strict>], "type">>;
        remoteProxyConnectionString: z.ZodOptional<z.ZodCustom<RemoteProxyConnectionString, RemoteProxyConnectionString>>;
        unsafeInspectorProxy: z.ZodOptional<z.ZodBoolean>;
        unsafeDirectSockets: z.ZodOptional<z.ZodArray<z.ZodObject<{
            host: z.ZodOptional<z.ZodString>;
            port: z.ZodOptional<z.ZodNumber>;
            serviceName: z.ZodOptional<z.ZodString>;
            entrypoint: z.ZodOptional<z.ZodString>;
            proxy: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strict>>>;
        unsafeOverrideFetchWorker: z.ZodOptional<z.ZodString>;
        unsafeEvalBinding: z.ZodOptional<z.ZodString>;
        useModuleFallbackService: z.ZodOptional<z.ZodBoolean>;
        unsafeRegisterWorker: z.ZodDefault<z.ZodBoolean>;
        unsafeEphemeralDurableObjects: z.ZodOptional<z.ZodBoolean>;
        stripCfConnectingIp: z.ZodDefault<z.ZodBoolean>;
        zone: z.ZodOptional<z.ZodString>;
        access: z.ZodOptional<z.ZodObject<{
            aud: z.ZodString;
            identity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
}, z.core.$strict>;

export declare type WorkerRegistry = Record<string, WorkerDefinition & {
    created: number;
    instanceId?: string;
}>;

export declare interface WorkerRoute {
    target: string;
    route: string;
    specificity: number;
    protocol?: string;
    allowHostnamePrefix: boolean;
    hostname: string;
    path: string;
    allowPathSuffix: boolean;
}

export declare interface WorkflowOption {
    name: string;
    className: string;
    scriptName?: string;
}

export declare const WORKFLOWS_PLUGIN: Plugin;

export declare const WORKFLOWS_PLUGIN_NAME = "workflows";

export declare const WORKFLOWS_STORAGE_SERVICE_NAME = "workflows:storage";

export declare function zAwaitable<T extends z.ZodType>(type: T): z.ZodUnion<[T, z.ZodPromise<T>]>;

export { }