wrangler 3.57.2 → 3.59.0

package/wrangler-dist/cli.d.ts

@@ -94,51 +94,68 @@ declare type BaseErrorEvent<Source = string, Data = undefined> = {
     data: Data;
 };
 
+declare type BinaryFile = File_2<Uint8Array>;
+
 declare type BinaryType = 'blob' | 'arraybuffer'
 
 declare type Binding = {
-    type: "kv";
-    id: string;
+    type: "plain_text";
+    value: string;
 } | {
-    type: "r2";
-    bucket_name: string;
+    type: "json";
+    value: Json;
+} | ({
+    type: "kv_namespace";
+} & BindingOmit<CfKvNamespace>) | ({
+    type: "send_email";
+} & BindingOmit<CfSendEmailBindings>) | {
+    type: "wasm_module";
+    source: BinaryFile;
 } | {
-    type: "d1";
-    /** The binding name used to refer to the D1 database in the worker. */
-    binding: string;
-    /** The name of this D1 database. */
-    database_name: string;
-    /** The UUID of this D1 database (not required). */
-    database_id: string;
-    /** The UUID of this D1 database for Wrangler Dev (if specified). */
-    preview_database_id?: string;
-    /** The name of the migrations table for this D1 database (defaults to 'd1_migrations'). */
-    migrations_table?: string;
-    /** The path to the directory of migrations for this D1 database (defaults to './migrations'). */
-    migrations_dir?: string;
-    /** Internal use only. */
-    database_internal_env?: string;
+    type: "text_blob";
+    source: File_2;
 } | {
-    type: "durable-object";
-    className: string;
-    service?: ServiceDesignator;
+    type: "browser";
 } | {
-    type: "service";
-    service: ServiceDesignator | ServiceFetch;
+    type: "ai";
 } | {
-    type: "queue-producer";
-    name: string;
+    type: "version_metadata";
 } | {
+    type: "data_blob";
+    source: BinaryFile;
+} | ({
+    type: "durable_object_namespace";
+} & BindingOmit<CfDurableObject>) | ({
+    type: "queue";
+} & BindingOmit<CfQueue>) | ({
+    type: "r2_bucket";
+} & BindingOmit<CfR2Bucket>) | ({
+    type: "d1";
+} & Omit<CfD1Database, "binding">) | ({
+    type: "vectorize";
+} & Omit<CfVectorize, "binding">) | ({
     type: "constellation";
-    project_id: string;
-} | {
-    type: "var";
-    value: string | Json | Uint8Array;
-} | {
-    type: `unsafe-${string}`;
-    [key: string]: unknown;
+} & Omit<CfConstellation, "binding">) | ({
+    type: "hyperdrive";
+} & Omit<CfHyperdrive, "binding">) | ({
+    type: "service";
+} & Omit<CfService, "binding">) | {
+    type: "fetcher";
+    fetcher: ServiceFetch;
+} | ({
+    type: "analytics_engine";
+} & Omit<CfAnalyticsEngineDataset, "binding">) | ({
+    type: "dispatch_namespace";
+} & Omit<CfDispatchNamespace, "binding">) | ({
+    type: "mtls_certificate";
+} & Omit<CfMTlsCertificate, "binding">) | ({
+    type: "logfwdr";
+} & Omit<CfLogfwdrBinding, "name">) | {
+    type: `unsafe_${string}`;
 };
 
+declare type BindingOmit<T> = Omit<T, "binding" | "name">;
+
 /**
  * Result of the `getBindingsProxy` utility
  */
@@ -264,23 +281,26 @@ declare namespace buildConnector {
     }
 }
 
+declare type Bundle = EsbuildBundle;
+
 declare type BundleCompleteEvent = {
     type: "bundleComplete";
     config: StartDevWorkerOptions;
-    bundle: EsbuildBundle;
+    bundle: Bundle;
 };
 
-declare class BundlerController extends Controller {
+declare class BundlerController extends Controller<BundlerControllerEventMap> {
     onConfigUpdate(_: ConfigUpdateEvent): void;
     teardown(): Promise<void>;
     emitBundleStartEvent(data: BundleStartEvent): void;
     emitBundleCompletetEvent(data: BundleCompleteEvent): void;
-    on(event: "bundleStart", listener: (_: BundleStartEvent) => void): this;
-    on(event: "bundleComplete", listener: (_: BundleCompleteEvent) => void): this;
-    on(event: "error", listener: (_: ErrorEvent) => void): this;
-    once: typeof BundlerController.on;
 }
 
+declare type BundlerControllerEventMap = ControllerEventMap & {
+    bundleStart: [BundleStartEvent];
+    bundleComplete: [BundleCompleteEvent];
+};
+
 declare type BundleStartEvent = {
     type: "bundleStart";
     config: StartDevWorkerOptions;
@@ -378,6 +398,36 @@ declare interface CfAccount {
     accountId: string;
 }
 
+declare interface CfAnalyticsEngineDataset {
+    binding: string;
+    dataset?: string;
+}
+
+declare interface CfConstellation {
+    binding: string;
+    project_id: string;
+}
+
+declare interface CfD1Database {
+    binding: string;
+    database_id: string;
+    database_name?: string;
+    preview_database_id?: string;
+    database_internal_env?: string;
+    migrations_table?: string;
+    migrations_dir?: string;
+}
+
+declare interface CfDispatchNamespace {
+    binding: string;
+    namespace: string;
+    outbound?: {
+        service: string;
+        environment?: string;
+        parameters?: string[];
+    };
+}
+
 /**
  * A Durable Object.
  */
@@ -388,6 +438,25 @@ declare interface CfDurableObject {
     environment?: string;
 }
 
+declare interface CfHyperdrive {
+    binding: string;
+    id: string;
+    localConnectionString?: string;
+}
+
+/**
+ * A KV namespace.
+ */
+declare interface CfKvNamespace {
+    binding: string;
+    id: string;
+}
+
+declare interface CfLogfwdrBinding {
+    name: string;
+    destination: string;
+}
+
 /**
  * An imported module.
  */
@@ -430,13 +499,51 @@ declare interface CfModule {
 /**
  * A module type.
  */
-declare type CfModuleType = "esm" | "commonjs" | "compiled-wasm" | "text" | "buffer" | "python" | "python-requirement";
+declare type CfModuleType = "esm" | "commonjs" | "compiled-wasm" | "text" | "buffer" | "python" | "python-requirement" | "nodejs-compat-module";
+
+declare interface CfMTlsCertificate {
+    binding: string;
+    certificate_id: string;
+}
+
+declare interface CfQueue {
+    binding: string;
+    queue_name: string;
+    delivery_delay?: number;
+}
+
+declare interface CfR2Bucket {
+    binding: string;
+    bucket_name: string;
+    jurisdiction?: string;
+}
 
 /**
  * The type of Worker
  */
 declare type CfScriptFormat = "modules" | "service-worker";
 
+/**
+ * A binding to send email.
+ */
+declare interface CfSendEmailBindings {
+    name: string;
+    destination_address?: string;
+    allowed_destination_addresses?: string[];
+}
+
+declare interface CfService {
+    binding: string;
+    service: string;
+    environment?: string;
+    entrypoint?: string;
+}
+
+declare interface CfVectorize {
+    binding: string;
+    index_name: string;
+}
+
 /**
  * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
  */
@@ -553,17 +660,41 @@ declare type CloudchamberConfig = {
     memory?: string;
 };
 
-declare class ConfigController extends EventEmitter_2 {
+/**
+ * This is the static type definition for the configuration object.
+ *
+ * It reflects a normalized and validated version of the configuration that you can write in wrangler.toml,
+ * and optionally augment with arguments passed directly to wrangler.
+ *
+ * For more information about the configuration object, see the
+ * documentation at https://developers.cloudflare.com/workers/cli-wrangler/configuration
+ *
+ * Notes:
+ *
+ * - Fields that are only specified in `ConfigFields` and not `Environment` can only appear
+ * in the top level config and should not appear in any environments.
+ * - Fields that are specified in `PagesConfigFields` are only relevant for Pages projects
+ * - All top level fields in config and environments are optional in the wrangler.toml file.
+ *
+ * Legend for the annotations:
+ *
+ * - `@breaking`: the deprecation/optionality is a breaking change from Wrangler v1.
+ * - `@todo`: there's more work to be done (with details attached).
+ */
+declare type Config = ConfigFields<DevConfig> & PagesConfigFields & Environment;
+
+declare class ConfigController extends Controller<ConfigControllerEventMap> {
     config?: StartDevWorkerOptions;
     setOptions(_: StartDevWorkerOptions): void;
     updateOptions(_: Partial<StartDevWorkerOptions>): void;
     teardown(): Promise<void>;
     emitConfigUpdateEvent(data: ConfigUpdateEvent): void;
-    on(event: "configUpdate", listener: (_: ConfigUpdateEvent) => void): this;
-    on(event: "error", listener: (_: ErrorEvent) => void): this;
-    once: typeof ConfigController.on;
 }
 
+declare type ConfigControllerEventMap = ControllerEventMap & {
+    configUpdate: [ConfigUpdateEvent];
+};
+
 declare interface ConfigFields<Dev extends RawDevConfig> {
     configPath: string | undefined;
     /**
@@ -658,7 +789,7 @@ declare interface ConfigFields<Dev extends RawDevConfig> {
         exclude: string[];
         browser_TTL: number | undefined;
         serve_single_page_app: boolean;
-    } | undefined;
+    } | string | undefined;
     /**
      * A list of wasm modules that your worker should be bound to. This is
      * the "legacy" way of binding to a wasm module. ES module workers should
@@ -699,7 +830,7 @@ declare interface ConfigFields<Dev extends RawDevConfig> {
 /**
  * The possible types for a `Rule`.
  */
-declare type ConfigModuleRuleType = "ESModule" | "CommonJS" | "CompiledWasm" | "Text" | "Data" | "PythonModule" | "PythonRequirement";
+declare type ConfigModuleRuleType = "ESModule" | "CommonJS" | "CompiledWasm" | "Text" | "Data" | "PythonModule" | "PythonRequirement" | "NodeJsCompatModule";
 
 declare type ConfigUpdateEvent = {
     type: "configUpdate";
@@ -712,9 +843,14 @@ url: string | URL_2 | UrlObject,
 options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions, 'origin' | 'path'>
 ): Promise<Dispatcher.ConnectData>;
 
-declare abstract class Controller extends EventEmitter_2 {
+declare abstract class Controller<EventMap extends ControllerEventMap = ControllerEventMap> extends TypedEventEmitterImpl<EventMap> {
+    emitErrorEvent(data: ErrorEvent): void;
 }
 
+declare type ControllerEventMap = {
+    error: [ErrorEvent];
+};
+
 declare interface Cookie {
     name: string
     value: string
@@ -1956,7 +2092,7 @@ declare interface EnvironmentNonInheritable {
 
 declare type ErrorEvent = BaseErrorEvent<"ConfigController" | "BundlerController" | "LocalRuntimeController" | "RemoteRuntimeController" | "ProxyWorker" | "InspectorProxyWorker"> | BaseErrorEvent<"ProxyController", {
     config?: StartDevWorkerOptions;
-    bundle?: EsbuildBundle;
+    bundle?: Bundle;
 }>;
 
 declare namespace Errors {
@@ -2086,6 +2222,7 @@ declare namespace Errors {
 declare type EsbuildBundle = {
     id: number;
     path: string;
+    entrypointSource: string;
     entry: Entry;
     type: CfModuleType;
     modules: CfModule[];
@@ -2420,7 +2557,7 @@ declare class Headers implements SpecIterable<[string, string]> {
 
 declare type HeadersInit = string[][] | Record<string, string | ReadonlyArray<string>> | Headers
 
-declare type Hook<T, Args extends unknown[] = unknown[]> = T | Promise<T> | ((...args: Args) => T | Promise<T>);
+declare type Hook<T extends string | number | object> = T | Promise<T> | (() => T | Promise<T>);
 
 /**
  * @property terminate Terminates HTTP server.
@@ -2682,7 +2819,7 @@ declare class MockScope<TData extends object = object> {
 }
 
 declare interface ModuleRule {
-    type: "ESModule" | "CommonJS" | "NodeJSCompat" | "CompiledWasm" | "Text" | "Data";
+    type: "ESModule" | "CommonJS" | "NodeJsCompatModule" | "CompiledWasm" | "Text" | "Data";
     include?: string[];
     fallthrough?: boolean;
 }
@@ -23138,7 +23275,7 @@ declare namespace ProxyAgent {
     }
 }
 
-declare class ProxyController extends EventEmitter_2 {
+declare class ProxyController extends Controller<ProxyControllerEventMap> {
     ready: DeferredPromise<ReadyEvent>;
     proxyWorker?: Miniflare;
     proxyWorkerOptions?: MiniflareOptions;
@@ -23162,13 +23299,15 @@ declare class ProxyController extends EventEmitter_2 {
     teardown(): Promise<void>;
     emitReadyEvent(proxyWorker: Miniflare): void;
     emitPreviewTokenExpiredEvent(proxyData: ProxyData): void;
-    emitErrorEvent(reason: string, cause: Error | SerializedError): void;
-    on(event: "ready", listener: (_: ReadyEvent) => void): this;
-    on(event: "previewTokenExpired", listener: (_: PreviewTokenExpiredEvent) => void): this;
-    on(event: "error", listener: (_: ErrorEvent) => void): this;
-    once: typeof ProxyController.on;
+    emitErrorEvent(data: ErrorEvent): void;
+    emitErrorEvent(reason: string, cause?: Error | SerializedError): void;
 }
 
+declare type ProxyControllerEventMap = ControllerEventMap & {
+    ready: [ReadyEvent];
+    previewTokenExpired: [PreviewTokenExpiredEvent];
+};
+
 declare type ProxyData = {
     userWorkerUrl: UrlOriginParts;
     userWorkerInspectorUrl: UrlOriginAndPathnameParts;
@@ -23198,6 +23337,8 @@ declare type ProxyWorkerOutgoingRequestBody = {
     args: Parameters<typeof console.debug>;
 };
 
+declare type QueueConsumer = NonNullable<Config["queues"]["consumers"]>[number];
+
 declare type RawConfig = Partial<ConfigFields<RawDevConfig>> & PagesConfigFields & RawEnvironment & DeprecatedConfigFields & EnvironmentMap & {
     $schema?: string;
 };
@@ -23237,14 +23378,14 @@ declare type ReferrerPolicy =
 declare type ReloadCompleteEvent = {
     type: "reloadComplete";
     config: StartDevWorkerOptions;
-    bundle: EsbuildBundle;
+    bundle: Bundle;
     proxyData: ProxyData;
 };
 
 declare type ReloadStartEvent = {
     type: "reloadStart";
     config: StartDevWorkerOptions;
-    bundle: EsbuildBundle;
+    bundle: Bundle;
 };
 
 declare class Request implements BodyMixin {
@@ -23505,19 +23646,20 @@ declare type Rule = {
     fallthrough?: boolean;
 };
 
-declare abstract class RuntimeController extends Controller {
+declare abstract class RuntimeController extends Controller<RuntimeControllerEventMap> {
     abstract onBundleStart(_: BundleStartEvent): void;
     abstract onBundleComplete(_: BundleCompleteEvent): void;
     abstract onPreviewTokenExpired(_: PreviewTokenExpiredEvent): void;
     abstract teardown(): Promise<void>;
     abstract emitReloadStartEvent(data: ReloadStartEvent): void;
-    abstract emitReloadCompletetEvent(data: ReloadCompleteEvent): void;
-    on(event: "reloadStart", listener: (_: ReloadStartEvent) => void): this;
-    on(event: "reloadComplete", listener: (_: ReloadCompleteEvent) => void): this;
-    on(event: "error", listener: (_: ErrorEvent) => void): this;
-    once: typeof RuntimeController.on;
+    abstract emitReloadCompleteEvent(data: ReloadCompleteEvent): void;
 }
 
+declare type RuntimeControllerEventMap = ControllerEventMap & {
+    reloadStart: [ReloadStartEvent];
+    reloadComplete: [ReloadCompleteEvent];
+};
+
 /**
  * Convert a MIMEType object to a string.
  * @see https://mimesniff.spec.whatwg.org/#serialize-a-mime-type
@@ -23531,12 +23673,7 @@ declare type SerializedError = {
     cause?: unknown;
 };
 
-declare interface ServiceDesignator {
-    name: string;
-    env?: string;
-}
-
-declare type ServiceFetch = (request: Request_2) => Promise<Response_2>;
+declare type ServiceFetch = (request: Request_2) => Promise<Response_2> | Response_2;
 
 declare function setCookie (headers: Headers, cookie: Cookie): void
 
@@ -23573,7 +23710,7 @@ declare interface SpecIterator<T, TReturn = any, TNext = undefined> {
 
 declare interface StartDevWorkerOptions {
     /** The name of the worker. */
-    name: string;
+    name?: string;
     /**
      * The javascript or typescript entry-point of the worker.
      * This is the `main` property of a wrangler.toml.
@@ -23657,6 +23794,8 @@ declare interface StartDevWorkerOptions {
         outboundService?: ServiceFetch;
         /** An undici MockAgent to declaratively mock fetch calls to particular resources. */
         mockFetch?: undici.MockAgent;
+        /** Gets a fetcher to a specific worker, used for multi-worker development */
+        getRegisteredWorker?(name: string): WorkerDefinition | undefined;
     };
 }
 
@@ -23681,30 +23820,35 @@ declare type Trigger = {
 } | {
     type: "route";
     pattern: string;
-    customDomain: true;
-} | {
+} | ({
     type: "route";
-    pattern: string;
-    zoneId: string;
-    customDomain?: true;
-    zoneName?: never;
-} | {
+} & ZoneIdRoute) | ({
     type: "route";
-    pattern: string;
-    zoneName: string;
-    customDomain?: true;
-    zoneId?: never;
-} | {
-    type: "schedule";
-    schedule: string;
-} | {
+} & ZoneNameRoute) | ({
+    type: "route";
+} & CustomDomainRoute) | {
+    type: "cron";
+    cron: string;
+} | ({
     type: "queue-consumer";
-    name: string;
-    maxBatchSize?: number;
-    maxBatchTimeout?: number;
-    maxRetries?: string;
-    deadLetterQueue?: string;
-};
+} & QueueConsumer);
+
+declare interface TypedEventEmitter<EventMap extends Record<string | symbol, unknown[]>> extends EventEmitter_2 {
+    addListener<Name extends keyof EventMap>(eventName: Name, listener: (...args: EventMap[Name]) => void): this;
+    on<Name extends keyof EventMap>(eventName: Name, listener: (...args: EventMap[Name]) => void): this;
+    once<Name extends keyof EventMap>(eventName: Name, listener: (...args: EventMap[Name]) => void): this;
+    removeListener<Name extends keyof EventMap>(eventName: Name, listener: (...args: EventMap[Name]) => void): this;
+    off<Name extends keyof EventMap>(eventName: Name, listener: (...args: EventMap[Name]) => void): this;
+    removeAllListeners(event?: keyof EventMap): this;
+    listeners<Name extends keyof EventMap>(eventName: Name): ((...args: EventMap[Name]) => void)[];
+    rawListeners<Name extends keyof EventMap>(eventName: Name): ((...args: EventMap[Name]) => void)[];
+    emit<Name extends keyof EventMap>(eventName: Name, ...args: EventMap[Name]): boolean;
+    listenerCount<Name extends keyof EventMap>(eventName: Name, listener?: (...args: EventMap[Name]) => void): number;
+    prependListener<Name extends keyof EventMap>(eventName: Name, listener: (...args: EventMap[Name]) => void): this;
+    prependOnceListener<Name extends keyof EventMap>(eventName: Name, listener: (...args: EventMap[Name]) => void): this;
+}
+
+declare const TypedEventEmitterImpl: new <EventMap extends Record<string | symbol, unknown[]>>() => TypedEventEmitter<EventMap>;
 
 declare namespace Undici {
     var Dispatcher: Dispatcher
@@ -24036,6 +24180,21 @@ declare interface WebSocketInit {
     headers?: HeadersInit
 }
 
+declare type WorkerDefinition = {
+    port: number | undefined;
+    protocol: "http" | "https" | undefined;
+    host: string | undefined;
+    mode: "local" | "remote";
+    headers?: Record<string, string>;
+    entrypointAddresses?: WorkerEntrypointsDefinition;
+    durableObjects: {
+        name: string;
+        className: string;
+    }[];
+    durableObjectsHost?: string;
+    durableObjectsPort?: number;
+};
+
 declare type WorkerEntrypointsDefinition = Record<"default" | string, {
     host: string;
     port: number;