wrangler 0.0.0-e6c9c5c0 → 0.0.0-e6e1daba

package/wrangler-dist/cli.d.ts

@@ -1,10 +1,21 @@
 /// <reference types="node" />
 
 import { Blob as Blob_2 } from 'buffer';
-import Dispatcher = require('./dispatcher');
+import { ConnectionOptions } from 'tls';
+import { Duplex } from 'stream';
+import { EventEmitter } from 'events';
+import { IpcNetConnectOpts } from 'net';
+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';
+import { Writable } from 'stream';
+
+declare type AbortSignal_2 = unknown;
 
 declare interface BlobPropertyBag {
     type?: string
@@ -33,6 +44,158 @@ declare interface BodyMixin {
     readonly text: () => Promise<string>
 }
 
+declare class BodyReadable extends Readable {
+    constructor(
+    resume?: (this: Readable, size: number) => void | null,
+    abort?: () => void | null,
+    contentType?: string
+    )
+
+    /** Consumes and returns the body as a string
+     *  https://fetch.spec.whatwg.org/#dom-body-text
+     */
+    text(): Promise<string>
+
+    /** Consumes and returns the body as a JavaScript Object
+     *  https://fetch.spec.whatwg.org/#dom-body-json
+     */
+    json(): Promise<any>
+
+    /** Consumes and returns the body as a Blob
+     *  https://fetch.spec.whatwg.org/#dom-body-blob
+     */
+    blob(): Promise<Blob_2>
+
+    /** Consumes and returns the body as an ArrayBuffer
+     *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+     */
+    arrayBuffer(): Promise<ArrayBuffer>
+
+    /** Not implemented
+     *
+     *  https://fetch.spec.whatwg.org/#dom-body-formdata
+     */
+    formData(): Promise<never>
+
+    /** Returns true if the body is not null and the body has been consumed
+     *
+     *  Otherwise, returns false
+     *
+     * https://fetch.spec.whatwg.org/#dom-body-bodyused
+     */
+    readonly bodyUsed: boolean
+
+    /** Throws on node 16.6.0
+     *
+     *  If body is null, it should return null as the body
+     *
+     *  If body is not null, should return the body as a ReadableStream
+     *
+     *  https://fetch.spec.whatwg.org/#dom-body-body
+     */
+    readonly body: never | undefined
+
+    /** Dumps the response body by reading `limit` number of bytes.
+     * @param opts.limit Number of bytes to read (optional) - Default: 262144
+     */
+    dump(opts?: { limit: number }): Promise<void>
+}
+
+declare function buildConnector (options?: buildConnector.BuildOptions): buildConnector.connector
+
+declare namespace buildConnector {
+    type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+        maxCachedSessions?: number | null;
+        socketPath?: string | null;
+        timeout?: number | null;
+        port?: number;
+        keepAlive?: boolean | null;
+        keepAliveInitialDelay?: number | null;
+    }
+
+    interface Options {
+        hostname: string
+        host?: string
+        protocol: string
+        port: string
+        servername?: string
+        localAddress?: string | null
+        httpSocket?: Socket
+    }
+
+    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 {
+        (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. */
+declare class Client extends Dispatcher {
+    constructor(url: string | URL_2, options?: Client.Options);
+    /** Property to get and set the pipelining factor. */
+    pipelining: number;
+    /** `true` after `client.close()` has been called. */
+    closed: boolean;
+    /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+    destroyed: boolean;
+}
+
+declare namespace Client {
+    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;
+        /** 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;
+        /** 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;
+        /** */
+        maxRequestsPerClient?: number;
+        /** Max response body size in bytes, -1 is disabled */
+        maxResponseSize?: number | null;
+        /** 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}
+    }
+
+    interface SocketInfo {
+        localAddress?: string
+        localPort?: number
+        remoteAddress?: string
+        remotePort?: number
+        remoteFamily?: string
+        timeout?: number
+        bytesWritten?: number
+        bytesRead?: number
+    }
+
+
+}
+
 /**
  * The possible types for a `Rule`.
  */
@@ -43,6 +206,8 @@ declare type CustomDomainRoute = {
     custom_domain: boolean;
 };
 
+export declare function deleteMTlsCertificate(accountId: string, certificateId: string): Promise<unknown>;
+
 /**
  * Deprecated upload configuration.
  */
@@ -74,6 +239,231 @@ declare interface DeprecatedUpload {
     rules?: Environment["rules"];
 }
 
+/** Dispatcher is the core API used to dispatch requests. */
+declare class Dispatcher extends EventEmitter {
+    /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
+    dispatch(options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+    /** Starts two-way communications with the requested resource. */
+    connect(options: Dispatcher.ConnectOptions): Promise<Dispatcher.ConnectData>;
+    connect(options: Dispatcher.ConnectOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+    /** Performs an HTTP request. */
+    request(options: Dispatcher.RequestOptions): Promise<Dispatcher.ResponseData>;
+    request(options: Dispatcher.RequestOptions, callback: (err: Error | null, data: Dispatcher.ResponseData) => void): void;
+    /** For easy use with `stream.pipeline`. */
+    pipeline(options: Dispatcher.PipelineOptions, handler: Dispatcher.PipelineHandler): Duplex;
+    /** A faster version of `Dispatcher.request`. */
+    stream(options: Dispatcher.RequestOptions, factory: Dispatcher.StreamFactory): Promise<Dispatcher.StreamData>;
+    stream(options: Dispatcher.RequestOptions, factory: Dispatcher.StreamFactory, callback: (err: Error | null, data: Dispatcher.StreamData) => void): void;
+    /** Upgrade to a different protocol. */
+    upgrade(options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>;
+    upgrade(options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void;
+    /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
+    close(): Promise<void>;
+    close(callback: () => void): void;
+    /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
+    destroy(): Promise<void>;
+    destroy(err: Error | null): Promise<void>;
+    destroy(callback: () => void): void;
+    destroy(err: Error | null, callback: () => void): void;
+
+    on(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+    on(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    on(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    on(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+
+    once(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+    once(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    once(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    once(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+
+    off(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+    off(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    off(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    off(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+
+    addListener(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+    addListener(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    addListener(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    addListener(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+    removeListener(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+    removeListener(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    removeListener(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    removeListener(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+    prependListener(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+    prependListener(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    prependListener(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    prependListener(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+    prependOnceListener(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+    prependOnceListener(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    prependOnceListener(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    prependOnceListener(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+    listeners(eventName: 'connect'): ((origin: URL_2, targets: readonly Dispatcher[]) => void)[]
+    listeners(eventName: 'disconnect'): ((origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+    listeners(eventName: 'connectionError'): ((origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+    listeners(eventName: 'drain'): ((origin: URL_2) => void)[];
+
+    rawListeners(eventName: 'connect'): ((origin: URL_2, targets: readonly Dispatcher[]) => void)[]
+    rawListeners(eventName: 'disconnect'): ((origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+    rawListeners(eventName: 'connectionError'): ((origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+    rawListeners(eventName: 'drain'): ((origin: URL_2) => void)[];
+
+    emit(eventName: 'connect', origin: URL_2, targets: readonly Dispatcher[]): boolean;
+    emit(eventName: 'disconnect', origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+    emit(eventName: 'connectionError', origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+    emit(eventName: 'drain', origin: URL_2): boolean;
+}
+
+declare namespace Dispatcher {
+    interface DispatchOptions {
+        origin?: string | URL_2;
+        path: string;
+        method: HttpMethod;
+        /** Default: `null` */
+        body?: string | Buffer | Uint8Array | Readable | null | FormData;
+        /** Default: `null` */
+        headers?: IncomingHttpHeaders | string[] | null;
+        /** Query string params to be embedded in the request URL. Default: `null` */
+        query?: Record<string, any>;
+        /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
+        idempotent?: boolean;
+        /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. */
+        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. */
+        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;
+        /** Whether the request should stablish a keep-alive or not. Default `false` */
+        reset?: boolean;
+        /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
+        throwOnError?: boolean;
+    }
+    interface ConnectOptions {
+        path: string;
+        /** Default: `null` */
+        headers?: IncomingHttpHeaders | string[] | null;
+        /** Default: `null` */
+        signal?: AbortSignal_2 | EventEmitter | null;
+        /** This argument parameter is passed through to `ConnectData` */
+        opaque?: unknown;
+        /** Default: 0 */
+        maxRedirections?: number;
+        /** Default: `null` */
+        responseHeader?: 'raw' | null;
+    }
+    interface RequestOptions extends DispatchOptions {
+        /** Default: `null` */
+        opaque?: unknown;
+        /** Default: `null` */
+        signal?: AbortSignal_2 | EventEmitter | null;
+        /** Default: 0 */
+        maxRedirections?: number;
+        /** Default: `null` */
+        onInfo?: (info: { statusCode: number, headers: Record<string, string | string[]> }) => void;
+        /** Default: `null` */
+        responseHeader?: 'raw' | null;
+    }
+    interface PipelineOptions extends RequestOptions {
+        /** `true` if the `handler` will return an object stream. Default: `false` */
+        objectMode?: boolean;
+    }
+    interface UpgradeOptions {
+        path: string;
+        /** Default: `'GET'` */
+        method?: string;
+        /** Default: `null` */
+        headers?: IncomingHttpHeaders | string[] | null;
+        /** A string of comma separated protocols, in descending preference order. Default: `'Websocket'` */
+        protocol?: string;
+        /** Default: `null` */
+        signal?: AbortSignal_2 | EventEmitter | null;
+        /** Default: 0 */
+        maxRedirections?: number;
+        /** Default: `null` */
+        responseHeader?: 'raw' | null;
+    }
+    interface ConnectData {
+        statusCode: number;
+        headers: IncomingHttpHeaders;
+        socket: Duplex;
+        opaque: unknown;
+    }
+    interface ResponseData {
+        statusCode: number;
+        headers: IncomingHttpHeaders;
+        body: BodyReadable & BodyMixin;
+        trailers: Record<string, string>;
+        opaque: unknown;
+        context: object;
+    }
+    interface PipelineHandlerData {
+        statusCode: number;
+        headers: IncomingHttpHeaders;
+        opaque: unknown;
+        body: BodyReadable;
+        context: object;
+    }
+    interface StreamData {
+        opaque: unknown;
+        trailers: Record<string, string>;
+    }
+    interface UpgradeData {
+        headers: IncomingHttpHeaders;
+        socket: Duplex;
+        opaque: unknown;
+    }
+    interface StreamFactoryData {
+        statusCode: number;
+        headers: IncomingHttpHeaders;
+        opaque: unknown;
+        context: object;
+    }
+    type StreamFactory = (data: StreamFactoryData) => Writable;
+    interface DispatchHandlers {
+        /** Invoked before request is dispatched on socket. May be invoked multiple times when a request is retried when the request at the head of the pipeline fails. */
+        onConnect?(abort: () => void): void;
+        /** Invoked when an error has occurred. */
+        onError?(err: Error): void;
+        /** 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;
+        /** 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. */
+        onComplete?(trailers: string[] | null): void;
+        /** Invoked when a body chunk is sent to the server. May be invoked multiple times for chunked requests */
+        onBodySent?(chunkSize: number, totalBytesSent: number): void;
+    }
+    type PipelineHandler = (data: PipelineHandlerData) => Readable;
+    type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
+
+    /**
+     * @link https://fetch.spec.whatwg.org/#body-mixin
+     */
+    interface BodyMixin {
+        readonly body?: never; // throws on node v16.6.0
+        readonly bodyUsed: boolean;
+        arrayBuffer(): Promise<ArrayBuffer>;
+        blob(): Promise<Blob_2>;
+        formData(): Promise<never>;
+        json(): Promise<any>;
+        text(): Promise<string>;
+    }
+
+    interface DispatchInterceptor {
+        (dispatch: Dispatcher['dispatch']): Dispatcher['dispatch']
+    }
+}
+
 declare type DurableObjectBindings = {
     /** The name of the binding used to refer to the Durable Object */
     name: string;
@@ -146,7 +536,7 @@ declare interface EnvironmentInheritable {
      * Whether we use <name>.<subdomain>.workers.dev to
      * test and deploy your worker.
      *
-     * @default `true` (This is a breaking change from wrangler 1)
+     * @default `true` (This is a breaking change from Wrangler v1)
      * @breaking
      * @inheritable
      */
@@ -508,6 +898,127 @@ declare interface EnvironmentNonInheritable {
             [key: string]: unknown;
         }[];
     };
+    mtls_certificates: {
+        /** The binding name used to refer to the certificate in the worker */
+        binding: string;
+        /** The uuid of the uploaded mTLS certificate */
+        certificate_id: string;
+    }[];
+}
+
+declare namespace Errors {
+    class UndiciError extends Error { }
+
+    /** Connect timeout error. */
+    class ConnectTimeoutError extends UndiciError {
+        name: 'ConnectTimeoutError';
+        code: 'UND_ERR_CONNECT_TIMEOUT';
+    }
+
+    /** A header exceeds the `headersTimeout` option. */
+    class HeadersTimeoutError extends UndiciError {
+        name: 'HeadersTimeoutError';
+        code: 'UND_ERR_HEADERS_TIMEOUT';
+    }
+
+    /** Headers overflow error. */
+    class HeadersOverflowError extends UndiciError {
+        name: 'HeadersOverflowError'
+        code: 'UND_ERR_HEADERS_OVERFLOW'
+    }
+
+    /** A body exceeds the `bodyTimeout` option. */
+    class BodyTimeoutError extends UndiciError {
+        name: 'BodyTimeoutError';
+        code: 'UND_ERR_BODY_TIMEOUT';
+    }
+
+    class ResponseStatusCodeError extends UndiciError {
+        name: 'ResponseStatusCodeError';
+        code: 'UND_ERR_RESPONSE_STATUS_CODE';
+        body: null | Record<string, any> | string
+        status: number
+        statusCode: number
+        headers: IncomingHttpHeaders | string[] | null;
+    }
+
+    /** Passed an invalid argument. */
+    class InvalidArgumentError extends UndiciError {
+        name: 'InvalidArgumentError';
+        code: 'UND_ERR_INVALID_ARG';
+    }
+
+    /** Returned an invalid value. */
+    class InvalidReturnValueError extends UndiciError {
+        name: 'InvalidReturnValueError';
+        code: 'UND_ERR_INVALID_RETURN_VALUE';
+    }
+
+    /** The request has been aborted by the user. */
+    class RequestAbortedError extends UndiciError {
+        name: 'AbortError';
+        code: 'UND_ERR_ABORTED';
+    }
+
+    /** Expected error with reason. */
+    class InformationalError extends UndiciError {
+        name: 'InformationalError';
+        code: 'UND_ERR_INFO';
+    }
+
+    /** Request body length does not match content-length header. */
+    class RequestContentLengthMismatchError extends UndiciError {
+        name: 'RequestContentLengthMismatchError';
+        code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+    }
+
+    /** Response body length does not match content-length header. */
+    class ResponseContentLengthMismatchError extends UndiciError {
+        name: 'ResponseContentLengthMismatchError';
+        code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+    }
+
+    /** Trying to use a destroyed client. */
+    class ClientDestroyedError extends UndiciError {
+        name: 'ClientDestroyedError';
+        code: 'UND_ERR_DESTROYED';
+    }
+
+    /** Trying to use a closed client. */
+    class ClientClosedError extends UndiciError {
+        name: 'ClientClosedError';
+        code: 'UND_ERR_CLOSED';
+    }
+
+    /** There is an error with the socket. */
+    class SocketError extends UndiciError {
+        name: 'SocketError';
+        code: 'UND_ERR_SOCKET';
+        socket: Client.SocketInfo | null
+    }
+
+    /** Encountered unsupported functionality. */
+    class NotSupportedError extends UndiciError {
+        name: 'NotSupportedError';
+        code: 'UND_ERR_NOT_SUPPORTED';
+    }
+
+    /** No upstream has been added to the BalancedPool. */
+    class BalancedPoolMissingUpstreamError extends UndiciError {
+        name: 'MissingUpstreamError';
+        code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+    }
+
+    class HTTPParserError extends UndiciError {
+        name: 'HTTPParserError';
+        code: string;
+    }
+
+    /** The response exceed the length allowed. */
+    class ResponseExceededMaxSizeError extends UndiciError {
+        name: 'ResponseExceededMaxSizeError';
+        code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+    }
 }
 
 declare class File extends Blob_2 {
@@ -643,6 +1154,16 @@ declare class FormData {
  */
 declare type FormDataEntryValue = string | File
 
+/**
+ *  fetches an mTLS certificate from the account mTLS certificate store by ID
+ */
+export declare function getMTlsCertificate(accountId: string, id: string): Promise<MTlsCertificateResponse>;
+
+/**
+ *  fetches an mTLS certificate from the account mTLS certificate store by name. will throw an error if no certificates are found, or multiple are found with that name
+ */
+export declare function getMTlsCertificateByName(accountId: string, name: string): Promise<MTlsCertificateResponse>;
+
 declare class Headers implements SpecIterable<[string, string]> {
     constructor (init?: HeadersInit)
     readonly append: (name: string, value: string) => void
@@ -650,6 +1171,7 @@ declare class Headers implements SpecIterable<[string, string]> {
     readonly get: (name: string) => string | null
     readonly has: (name: string) => boolean
     readonly set: (name: string, value: string) => void
+    readonly getSetCookie: () => string[]
     readonly forEach: (
     callbackfn: (value: string, key: string, iterable: Headers) => void,
     thisArg?: unknown
@@ -663,6 +1185,56 @@ declare class Headers implements SpecIterable<[string, string]> {
 
 declare type HeadersInit = string[][] | Record<string, string | ReadonlyArray<string>> | Headers
 
+/**
+ * The header type declaration of `undici`.
+ */
+declare type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+
+/**
+ *  lists mTLS certificates for an account. filtering by name is supported
+ */
+export declare function listMTlsCertificates(accountId: string, filter: MTlsCertificateListFilter): Promise<MTlsCertificateResponse[]>;
+
+/**
+ * details for uploading an mTLS certificate via the ssl api
+ */
+declare interface MTlsCertificateBody {
+    certificateChain: string;
+    privateKey: string;
+    name?: string;
+}
+
+/**
+ * supported filters for listing mTLS certificates via the ssl api
+ */
+declare interface MTlsCertificateListFilter {
+    name?: string;
+}
+
+/**
+ * the representation of an mTLS certificate in the account certificate store
+ */
+declare interface MTlsCertificateResponse {
+    id: string;
+    name?: string;
+    ca: boolean;
+    certificates: string;
+    expires_on: string;
+    issuer: string;
+    serial_number: string;
+    signature: string;
+    uploaded_on: string;
+}
+
+/**
+ * details for uploading an mTLS certificate from disk
+ */
+declare interface MTlsCertificateUploadDetails {
+    certificateChainFilename: string;
+    privateKeyFilename: string;
+    name?: string;
+}
+
 declare interface PagesPublishOptions {
     /**
      * Path to static assets to publish to Pages
@@ -709,6 +1281,13 @@ declare interface PagesPublishOptions {
      * Default: false
      */
     bundle?: boolean;
+    /**
+     * Whether to process non-JS module imports or not, such as
+     * wasm/text/binary, when we run bundling on `functions` or
+     * `_worker.js`
+     * Default: false
+     */
+    experimentalWorkerBundle?: boolean;
 }
 
 /**
@@ -716,7 +1295,7 @@ declare interface PagesPublishOptions {
  * NOTE: You will need the `CLOUDFLARE_API_KEY` environment
  * variable set
  */
-declare function publish({ directory, accountId, projectName, branch, skipCaching, commitMessage, commitHash, commitDirty, functionsDirectory: customFunctionsDirectory, bundle, }: PagesPublishOptions): Promise<{
+declare function publish({ directory, accountId, projectName, branch, skipCaching, commitMessage, commitHash, commitDirty, functionsDirectory: customFunctionsDirectory, bundle, experimentalWorkerBundle, }: PagesPublishOptions): Promise<{
     environment: "production" | "preview";
     id: string;
     url: string;
@@ -806,6 +1385,7 @@ declare class Request implements BodyMixin {
 
     readonly keepalive: boolean
     readonly signal: AbortSignal
+    readonly duplex: RequestDuplex
 
     readonly body: ReadableStream | null
     readonly bodyUsed: boolean
@@ -849,6 +1429,8 @@ declare type RequestDestination =
 | 'worker'
 | 'xslt'
 
+declare type RequestDuplex = 'half'
+
 declare type RequestInfo = string | URL_2 | Request
 
 declare interface RequestInit {
@@ -865,6 +1447,7 @@ declare interface RequestInit {
     referrerPolicy?: ReferrerPolicy
     window?: null
     dispatcher?: Dispatcher
+    duplex?: RequestDuplex
 }
 
 declare type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
@@ -1013,6 +1596,16 @@ export declare interface UnstableDevWorker {
     waitUntilExit: () => Promise<void>;
 }
 
+/**
+ *  uploads an mTLS certificate and private key pair to the account mTLS certificate store
+ */
+export declare function uploadMTlsCertificate(accountId: string, body: MTlsCertificateBody): Promise<MTlsCertificateResponse>;
+
+/**
+ * reads an mTLS certificate and private key pair from disk and uploads it to the account mTLS certificate store
+ */
+export declare function uploadMTlsCertificateFromFs(accountId: string, details: MTlsCertificateUploadDetails): Promise<MTlsCertificateResponse>;
+
 declare type ZoneIdRoute = {
     pattern: string;
     zone_id: string;