wrangler 2.20.2 → 2.21.0

package/wrangler-dist/cli.d.ts

@@ -9,7 +9,6 @@ import { Readable } from 'stream';
 import { ReadableStream } from 'stream/web';
 import { Socket } from 'net';
 import { TcpNetConnectOpts } from 'net';
-import { TlsOptions } from 'tls';
 import { TLSSocket } from 'tls';
 import { URL as URL_2 } from 'url';
 import { URLSearchParams as URLSearchParams_2 } from 'url';
@@ -59,7 +58,7 @@ declare class BodyReadable extends Readable {
     /** Consumes and returns the body as a JavaScript Object
      *  https://fetch.spec.whatwg.org/#dom-body-json
      */
-    json(): Promise<any>
+    json(): Promise<unknown>
 
     /** Consumes and returns the body as a Blob
      *  https://fetch.spec.whatwg.org/#dom-body-blob
@@ -105,6 +104,7 @@ declare function buildConnector (options?: buildConnector.BuildOptions): buildCo
 
 declare namespace buildConnector {
     type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+        allowH2?: boolean;
         maxCachedSessions?: number | null;
         socketPath?: string | null;
         timeout?: number | null;
@@ -126,18 +126,14 @@ declare namespace buildConnector {
     type Callback = (...args: CallbackArgs) => void
     type CallbackArgs = [null, Socket | TLSSocket] | [Error, null]
 
-    type connector = connectorAsync | connectorSync
-
-    interface connectorSync {
-        (options: buildConnector.Options): Socket | TLSSocket
-    }
-
-    interface connectorAsync {
+    interface connector {
         (options: buildConnector.Options, callback: buildConnector.Callback): void
     }
 }
 
-/** A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default. */
+/**
+ * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
+ */
 declare class Client extends Dispatcher {
     constructor(url: string | URL_2, options?: Client.Options);
     /** Property to get and set the pipelining factor. */
@@ -149,39 +145,71 @@ declare class Client extends Dispatcher {
 }
 
 declare namespace Client {
+    interface OptionsInterceptors {
+        Client: readonly Dispatcher.DispatchInterceptor[];
+    }
     interface Options {
-        /** the timeout after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
-        keepAliveTimeout?: number | null;
-        /** the maximum allowed `idleTimeout` when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
-        keepAliveMaxTimeout?: number | null;
-        /** A number subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
-        keepAliveTimeoutThreshold?: number | null;
-        /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
-        pipelining?: number | null;
-        /** **/
-        connect?: buildConnector.BuildOptions | buildConnector.connector | null;
-        /** The maximum length of request headers in bytes. Default: `16384` (16KiB). */
-        maxHeaderSize?: number | null;
+        /** TODO */
+        interceptors?: OptionsInterceptors;
+        /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+        maxHeaderSize?: number;
+        /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+        headersTimeout?: number;
+        /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
+        socketTimeout?: never;
+        /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
+        requestTimeout?: never;
+        /** TODO */
+        connectTimeout?: number;
         /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
-        bodyTimeout?: number | null;
-        /** The amount of time the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
-        headersTimeout?: number | null;
+        bodyTimeout?: number;
+        /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
+        idleTimeout?: never;
+        /** @deprecated unsupported keepAlive, use pipelining=0 instead */
+        keepAlive?: never;
+        /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+        keepAliveTimeout?: number;
+        /** @deprecated unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead */
+        maxKeepAliveTimeout?: never;
+        /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+        keepAliveMaxTimeout?: number;
+        /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+        keepAliveTimeoutThreshold?: number;
+        /** TODO */
+        socketPath?: string;
+        /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+        pipelining?: number;
+        /** @deprecated use the connect option instead */
+        tls?: never;
         /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
         strictContentLength?: boolean;
-        /** @deprecated use the connect option instead */
-        tls?: TlsOptions | null;
-        /** */
+        /** TODO */
+        maxCachedSessions?: number;
+        /** TODO */
+        maxRedirections?: number;
+        /** TODO */
+        connect?: buildConnector.BuildOptions | buildConnector.connector;
+        /** TODO */
         maxRequestsPerClient?: number;
+        /** TODO */
+        localAddress?: string;
         /** Max response body size in bytes, -1 is disabled */
-        maxResponseSize?: number | null;
+        maxResponseSize?: number;
         /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
         autoSelectFamily?: boolean;
         /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
         autoSelectFamilyAttemptTimeout?: number;
-
-        interceptors?: {Client: readonly Dispatcher[] | undefined}
+        /**
+         * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
+         * @default false
+         */
+        allowH2?: boolean;
+        /**
+         * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+         * @default 100
+         */
+        maxConcurrentStreams?: number
     }
-
     interface SocketInfo {
         localAddress?: string
         localPort?: number
@@ -192,8 +220,6 @@ declare namespace Client {
         bytesWritten?: number
         bytesRead?: number
     }
-
-
 }
 
 /**
@@ -337,7 +363,7 @@ declare namespace Dispatcher {
         blocking?: boolean;
         /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
         upgrade?: boolean | string | null;
-        /** The amount of time the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
+        /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
         headersTimeout?: number | null;
         /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. */
         bodyTimeout?: number | null;
@@ -345,6 +371,8 @@ declare namespace Dispatcher {
         reset?: boolean;
         /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
         throwOnError?: boolean;
+        /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server*/
+        expectContinue?: boolean;
     }
     interface ConnectOptions {
         path: string;
@@ -370,6 +398,8 @@ declare namespace Dispatcher {
         onInfo?: (info: { statusCode: number, headers: Record<string, string | string[]> }) => void;
         /** Default: `null` */
         responseHeader?: 'raw' | null;
+        /** Default: `64 KiB` */
+        highWaterMark?: number;
     }
     interface PipelineOptions extends RequestOptions {
         /** `true` if the `handler` will return an object stream. Default: `false` */
@@ -435,7 +465,7 @@ declare namespace Dispatcher {
         /** Invoked when request is upgraded either due to a `Upgrade` header or `CONNECT` method. */
         onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex): void;
         /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
-        onHeaders?(statusCode: number, headers: Buffer[] | string[] | null, resume: () => void): boolean;
+        onHeaders?(statusCode: number, headers: Buffer[] | string[] | null, resume: () => void, statusText: string): boolean;
         /** Invoked when response payload data is received. */
         onData?(chunk: Buffer): boolean;
         /** Invoked when response payload and trailers have been received and the request has completed. */
@@ -455,7 +485,7 @@ declare namespace Dispatcher {
         arrayBuffer(): Promise<ArrayBuffer>;
         blob(): Promise<Blob_2>;
         formData(): Promise<never>;
-        json(): Promise<any>;
+        json(): Promise<unknown>;
         text(): Promise<string>;
     }
 
@@ -943,7 +973,10 @@ declare interface EnvironmentNonInheritable {
 }
 
 declare namespace Errors {
-    class UndiciError extends Error { }
+    class UndiciError extends Error {
+        name: string;
+        code: string;
+    }
 
     /** Connect timeout error. */
     class ConnectTimeoutError extends UndiciError {
@@ -970,6 +1003,12 @@ declare namespace Errors {
     }
 
     class ResponseStatusCodeError extends UndiciError {
+        constructor (
+        message?: string,
+        statusCode?: number,
+        headers?: IncomingHttpHeaders | string[] | null,
+        body?: null | Record<string, any> | string
+        );
         name: 'ResponseStatusCodeError';
         code: 'UND_ERR_RESPONSE_STATUS_CODE';
         body: null | Record<string, any> | string
@@ -1469,7 +1508,7 @@ declare interface RequestInit {
     body?: BodyInit
     redirect?: RequestRedirect
     integrity?: string
-    signal?: AbortSignal
+    signal?: AbortSignal | null
     credentials?: RequestCredentials
     mode?: RequestMode
     referrer?: string