@runlith/tagma 0.0.0-stage → 0.2.3

package/types/undici/cache-interceptor.d.ts

@@ -0,0 +1,98 @@
+import { Readable, Writable } from 'node:stream';
+export default CacheHandler;
+declare namespace CacheHandler {
+    export type CacheMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE';
+    export interface CacheHandlerOptions {
+        store: CacheStore;
+        cacheByDefault?: number;
+        type?: CacheOptions['type'];
+    }
+    export interface CacheOptions {
+        store?: CacheStore;
+        methods?: CacheMethods[];
+        cacheByDefault?: number;
+        type?: 'shared' | 'private';
+        origins?: (string | RegExp)[];
+    }
+    export interface CacheControlDirectives {
+        'max-stale'?: number;
+        'min-fresh'?: number;
+        'max-age'?: number;
+        's-maxage'?: number;
+        'stale-while-revalidate'?: number;
+        'stale-if-error'?: number;
+        public?: true;
+        private?: true | string[];
+        'no-store'?: true;
+        'no-cache'?: true | string[];
+        'must-revalidate'?: true;
+        'proxy-revalidate'?: true;
+        immutable?: true;
+        'no-transform'?: true;
+        'must-understand'?: true;
+        'only-if-cached'?: true;
+    }
+    export interface CacheKey {
+        origin: string;
+        method: string;
+        path: string;
+        headers?: Record<string, string | string[]>;
+    }
+    export interface CacheValue {
+        statusCode: number;
+        statusMessage: string;
+        headers: Record<string, string | string[]>;
+        vary?: Record<string, string | string[] | null>;
+        etag?: string;
+        cacheControlDirectives?: CacheControlDirectives;
+        cachedAt: number;
+        staleAt: number;
+        deleteAt: number;
+    }
+    export interface DeleteByUri {
+        origin: string;
+        method: string;
+        path: string;
+    }
+    type GetResult = {
+        statusCode: number;
+        statusMessage: string;
+        headers: Record<string, string | string[]>;
+        vary?: Record<string, string | string[] | null>;
+        etag?: string;
+        body?: Readable | Iterable<Buffer> | AsyncIterable<Buffer> | Buffer | Iterable<string> | AsyncIterable<string> | string;
+        cacheControlDirectives: CacheControlDirectives;
+        cachedAt: number;
+        staleAt: number;
+        deleteAt: number;
+    };
+    export interface CacheStore {
+        get(key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined;
+        createWriteStream(key: CacheKey, val: CacheValue): Writable | undefined;
+        delete(key: CacheKey): void | Promise<void>;
+    }
+    export interface MemoryCacheStoreOpts {
+        maxCount?: number;
+        maxSize?: number;
+        maxEntrySize?: number;
+        errorCallback?: (err: Error) => void;
+    }
+    export class MemoryCacheStore implements CacheStore {
+        constructor(opts?: MemoryCacheStoreOpts);
+        get(key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined;
+        createWriteStream(key: CacheKey, value: CacheValue): Writable | undefined;
+        delete(key: CacheKey): void | Promise<void>;
+    }
+    export interface SqliteCacheStoreOpts {
+        location?: string;
+        maxCount?: number;
+        maxEntrySize?: number;
+    }
+    export class SqliteCacheStore implements CacheStore {
+        constructor(opts?: SqliteCacheStoreOpts);
+        close(): void;
+        get(key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined;
+        createWriteStream(key: CacheKey, value: CacheValue): Writable | undefined;
+        delete(key: CacheKey): void | Promise<void>;
+    }
+}

package/types/undici/cache.d.ts

@@ -0,0 +1,30 @@
+import type { RequestInfo, Response, Request } from './fetch';
+export interface CacheStorage {
+    match(request: RequestInfo, options?: MultiCacheQueryOptions): Promise<Response | undefined>;
+    has(cacheName: string): Promise<boolean>;
+    open(cacheName: string): Promise<Cache>;
+    delete(cacheName: string): Promise<boolean>;
+    keys(): Promise<string[]>;
+}
+declare const CacheStorage: {
+    prototype: CacheStorage;
+    new (): CacheStorage;
+};
+export interface Cache {
+    match(request: RequestInfo, options?: CacheQueryOptions): Promise<Response | undefined>;
+    matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Response[]>;
+    add(request: RequestInfo): Promise<undefined>;
+    addAll(requests: RequestInfo[]): Promise<undefined>;
+    put(request: RequestInfo, response: Response): Promise<undefined>;
+    delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
+    keys(request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Request[]>;
+}
+export interface CacheQueryOptions {
+    ignoreSearch?: boolean;
+    ignoreMethod?: boolean;
+    ignoreVary?: boolean;
+}
+export interface MultiCacheQueryOptions extends CacheQueryOptions {
+    cacheName?: string;
+}
+export declare const caches: CacheStorage;

package/types/undici/client-stats.d.ts

@@ -0,0 +1,9 @@
+import Client from './client';
+export default ClientStats;
+declare class ClientStats {
+    constructor(pool: Client);
+    connected: boolean;
+    pending: number;
+    running: number;
+    size: number;
+}

package/types/undici/client.d.ts

@@ -0,0 +1,61 @@
+import { URL } from 'node:url';
+import Dispatcher from './dispatcher';
+import buildConnector from './connector';
+import TClientStats from './client-stats';
+type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>;
+export class Client extends Dispatcher {
+    constructor(url: string | URL, options?: Client.Options);
+    pipelining: number;
+    closed: boolean;
+    destroyed: boolean;
+    readonly stats: TClientStats;
+    override connect(options: ClientConnectOptions): Promise<Dispatcher.ConnectData>;
+    override connect(options: ClientConnectOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+}
+export declare namespace Client {
+    export interface OptionsInterceptors {
+        Client: readonly Dispatcher.DispatchInterceptor[];
+    }
+    export interface Options {
+        interceptors?: OptionsInterceptors;
+        maxHeaderSize?: number;
+        headersTimeout?: number;
+        socketTimeout?: never;
+        requestTimeout?: never;
+        connectTimeout?: number;
+        bodyTimeout?: number;
+        idleTimeout?: never;
+        keepAlive?: never;
+        keepAliveTimeout?: number;
+        maxKeepAliveTimeout?: never;
+        keepAliveMaxTimeout?: number;
+        keepAliveTimeoutThreshold?: number;
+        socketPath?: string;
+        pipelining?: number;
+        tls?: never;
+        strictContentLength?: boolean;
+        maxCachedSessions?: number;
+        connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
+        maxRequestsPerClient?: number;
+        localAddress?: string;
+        maxResponseSize?: number;
+        autoSelectFamily?: boolean;
+        autoSelectFamilyAttemptTimeout?: number;
+        allowH2?: boolean;
+        maxConcurrentStreams?: number;
+        initialWindowSize?: number;
+        connectionWindowSize?: number;
+        pingInterval?: number;
+    }
+    export interface SocketInfo {
+        localAddress?: string;
+        localPort?: number;
+        remoteAddress?: string;
+        remotePort?: number;
+        remoteFamily?: string;
+        timeout?: number;
+        bytesWritten?: number;
+        bytesRead?: number;
+    }
+}
+export default Client;

package/types/undici/connector.d.ts

@@ -0,0 +1,37 @@
+import { TLSSocket, ConnectionOptions } from 'node:tls';
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'node:net';
+export default buildConnector;
+declare function buildConnector(options?: buildConnector.BuildOptions): buildConnector.connector;
+declare namespace buildConnector {
+    export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+        allowH2?: boolean;
+        maxCachedSessions?: number | null;
+        socketPath?: string | null;
+        timeout?: number | null;
+        port?: number;
+        keepAlive?: boolean | null;
+        keepAliveInitialDelay?: number | null;
+        typeOfService?: number | null;
+    };
+    export interface Options {
+        hostname: string;
+        host?: string;
+        protocol: string;
+        port: string;
+        servername?: string;
+        localAddress?: string | null;
+        socketPath?: string | null;
+        httpSocket?: Socket;
+    }
+    export type Callback = (...args: CallbackArgs) => void;
+    type CallbackArgs = [
+        null,
+        Socket | TLSSocket
+    ] | [
+        Error,
+        null
+    ];
+    export interface connector {
+        (options: buildConnector.Options, callback: buildConnector.Callback): void;
+    }
+}

package/types/undici/content-type.d.ts

@@ -0,0 +1,9 @@
+/// <reference path="../node/index.d.ts" />
+interface MIMEType {
+    type: string;
+    subtype: string;
+    parameters: Map<string, string>;
+    essence: string;
+}
+export function parseMIMEType(input: string): 'failure' | MIMEType;
+export function serializeAMimeType(mimeType: MIMEType): string;

package/types/undici/cookies.d.ts

@@ -0,0 +1,22 @@
+/// <reference path="../node/index.d.ts" />
+import type { Headers } from './fetch';
+export interface Cookie {
+    name: string;
+    value: string;
+    expires?: Date | number;
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    unparsed?: string[];
+}
+export function deleteCookie(headers: Headers, name: string, attributes?: {
+    name?: string;
+    domain?: string;
+}): void;
+export function getCookies(headers: Headers): Record<string, string>;
+export function getSetCookies(headers: Headers): Cookie[];
+export function setCookie(headers: Headers, cookie: Cookie): void;
+export function parseCookie(cookie: string): Cookie | null;

package/types/undici/diagnostics-channel.d.ts

@@ -0,0 +1,72 @@
+import { Socket } from 'node:net';
+import { URL } from 'node:url';
+import buildConnector from './connector';
+import Dispatcher from './dispatcher';
+declare namespace DiagnosticsChannel {
+    interface Request {
+        origin?: string | URL;
+        completed: boolean;
+        method?: Dispatcher.HttpMethod;
+        path: string;
+        headers: any;
+    }
+    interface Response {
+        statusCode: number;
+        statusText: string;
+        headers: Array<Buffer>;
+    }
+    interface ConnectParams {
+        host: URL['host'];
+        hostname: URL['hostname'];
+        protocol: URL['protocol'];
+        port: URL['port'];
+        servername: string | null;
+    }
+    type Connector = buildConnector.connector;
+    export interface RequestCreateMessage {
+        request: Request;
+    }
+    export interface RequestBodySentMessage {
+        request: Request;
+    }
+    export interface RequestBodyChunkSentMessage {
+        request: Request;
+        chunk: Uint8Array | string;
+    }
+    export interface RequestBodyChunkReceivedMessage {
+        request: Request;
+        chunk: Buffer;
+    }
+    export interface RequestHeadersMessage {
+        request: Request;
+        response: Response;
+    }
+    export interface RequestTrailersMessage {
+        request: Request;
+        trailers: Array<Buffer>;
+    }
+    export interface RequestErrorMessage {
+        request: Request;
+        error: Error;
+    }
+    export interface ClientSendHeadersMessage {
+        request: Request;
+        headers: string;
+        socket: Socket;
+    }
+    export interface ClientBeforeConnectMessage {
+        connectParams: ConnectParams;
+        connector: Connector;
+    }
+    export interface ClientConnectedMessage {
+        socket: Socket;
+        connectParams: ConnectParams;
+        connector: Connector;
+    }
+    export interface ClientConnectErrorMessage {
+        error: Error;
+        socket: Socket;
+        connectParams: ConnectParams;
+        connector: Connector;
+    }
+}

package/types/undici/dispatcher.d.ts

@@ -0,0 +1,207 @@
+import { URL } from 'node:url';
+import { Duplex, Readable, Writable } from 'node:stream';
+import { EventEmitter } from 'node:events';
+import { Blob } from 'node:buffer';
+import { IncomingHttpHeaders } from './header';
+import BodyReadable from './readable';
+import { FormData } from './formdata';
+import Errors from './errors';
+import { Autocomplete } from './utility';
+type AbortSignal = unknown;
+export default Dispatcher;
+export type UndiciHeaders = Record<string, string | string[]> | IncomingHttpHeaders | string[] | Iterable<[
+    string,
+    string | string[] | undefined
+]> | null;
+declare class Dispatcher extends EventEmitter {
+    dispatch(options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean;
+    connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void;
+    connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>;
+    compose(dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+    compose(...dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+    request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ResponseData<TOpaque>) => void): void;
+    request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>;
+    pipeline<TOpaque = null>(options: Dispatcher.PipelineOptions<TOpaque>, handler: Dispatcher.PipelineHandler<TOpaque>): Duplex;
+    stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>, callback: (err: Error | null, data: Dispatcher.StreamData<TOpaque>) => void): void;
+    stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>;
+    upgrade(options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void;
+    upgrade(options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>;
+    close(callback: () => void): void;
+    close(): Promise<void>;
+    destroy(err: Error | null, callback: () => void): void;
+    destroy(callback: () => void): void;
+    destroy(err: Error | null): Promise<void>;
+    destroy(): Promise<void>;
+    on(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+    on(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    on(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    on(eventName: 'drain', callback: (origin: URL) => void): this;
+    once(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+    once(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    once(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    once(eventName: 'drain', callback: (origin: URL) => void): this;
+    off(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+    off(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    off(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    off(eventName: 'drain', callback: (origin: URL) => void): this;
+    addListener(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+    addListener(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    addListener(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    addListener(eventName: 'drain', callback: (origin: URL) => void): this;
+    removeListener(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+    removeListener(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    removeListener(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    removeListener(eventName: 'drain', callback: (origin: URL) => void): this;
+    prependListener(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+    prependListener(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    prependListener(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    prependListener(eventName: 'drain', callback: (origin: URL) => void): this;
+    prependOnceListener(eventName: 'connect', callback: (origin: URL, targets: readonly Dispatcher[]) => void): this;
+    prependOnceListener(eventName: 'disconnect', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    prependOnceListener(eventName: 'connectionError', callback: (origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+    prependOnceListener(eventName: 'drain', callback: (origin: URL) => void): this;
+    listeners(eventName: 'connect'): ((origin: URL, targets: readonly Dispatcher[]) => void)[];
+    listeners(eventName: 'disconnect'): ((origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+    listeners(eventName: 'connectionError'): ((origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+    listeners(eventName: 'drain'): ((origin: URL) => void)[];
+    rawListeners(eventName: 'connect'): ((origin: URL, targets: readonly Dispatcher[]) => void)[];
+    rawListeners(eventName: 'disconnect'): ((origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+    rawListeners(eventName: 'connectionError'): ((origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+    rawListeners(eventName: 'drain'): ((origin: URL) => void)[];
+    emit(eventName: 'connect', origin: URL, targets: readonly Dispatcher[]): boolean;
+    emit(eventName: 'disconnect', origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+    emit(eventName: 'connectionError', origin: URL, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+    emit(eventName: 'drain', origin: URL): boolean;
+}
+declare namespace Dispatcher {
+    export interface ComposedDispatcher extends Dispatcher {
+    }
+    export type Dispatch = Dispatcher['dispatch'];
+    export type DispatcherComposeInterceptor = (dispatch: Dispatch) => Dispatch;
+    export interface DispatchOptions {
+        origin?: string | URL;
+        path: string;
+        method: HttpMethod;
+        body?: string | Buffer | Uint8Array | Readable | null | FormData;
+        headers?: UndiciHeaders;
+        query?: Record<string, any>;
+        idempotent?: boolean;
+        blocking?: boolean;
+        typeOfService?: number | null;
+        upgrade?: boolean | string | null;
+        headersTimeout?: number | null;
+        bodyTimeout?: number | null;
+        reset?: boolean;
+        throwOnError?: boolean;
+        expectContinue?: boolean;
+    }
+    export interface ConnectOptions<TOpaque = null> {
+        origin: string | URL;
+        path: string;
+        headers?: UndiciHeaders;
+        signal?: AbortSignal | EventEmitter | null;
+        opaque?: TOpaque;
+        redirectionLimitReached?: boolean;
+        responseHeaders?: 'raw' | null;
+    }
+    export interface RequestOptions<TOpaque = null> extends DispatchOptions {
+        opaque?: TOpaque;
+        signal?: AbortSignal | EventEmitter | null;
+        redirectionLimitReached?: boolean;
+        onInfo?: (info: {
+            statusCode: number;
+            headers: Record<string, string | string[]>;
+        }) => void;
+        responseHeaders?: 'raw' | null;
+        highWaterMark?: number;
+    }
+    export interface PipelineOptions<TOpaque = null> extends RequestOptions<TOpaque> {
+        objectMode?: boolean;
+    }
+    export interface UpgradeOptions {
+        path: string;
+        method?: string;
+        headers?: UndiciHeaders;
+        protocol?: string;
+        signal?: AbortSignal | EventEmitter | null;
+        redirectionLimitReached?: boolean;
+        responseHeaders?: 'raw' | null;
+    }
+    export interface ConnectData<TOpaque = null> {
+        statusCode: number;
+        headers: IncomingHttpHeaders;
+        socket: Duplex;
+        opaque: TOpaque;
+    }
+    export interface ResponseData<TOpaque = null> {
+        statusCode: number;
+        statusText: string;
+        headers: IncomingHttpHeaders;
+        body: BodyReadable & BodyMixin;
+        trailers: Record<string, string>;
+        opaque: TOpaque;
+        context: object;
+    }
+    export interface PipelineHandlerData<TOpaque = null> {
+        statusCode: number;
+        headers: IncomingHttpHeaders;
+        opaque: TOpaque;
+        body: BodyReadable;
+        context: object;
+    }
+    export interface StreamData<TOpaque = null> {
+        opaque: TOpaque;
+        trailers: Record<string, string>;
+    }
+    export interface UpgradeData<TOpaque = null> {
+        headers: IncomingHttpHeaders;
+        socket: Duplex;
+        opaque: TOpaque;
+    }
+    export interface StreamFactoryData<TOpaque = null> {
+        statusCode: number;
+        headers: IncomingHttpHeaders;
+        opaque: TOpaque;
+        context: object;
+    }
+    export type StreamFactory<TOpaque = null> = (data: StreamFactoryData<TOpaque>) => Writable;
+    export interface DispatchController {
+        get aborted(): boolean;
+        get paused(): boolean;
+        get reason(): Error | null;
+        abort(reason: Error): void;
+        pause(): void;
+        resume(): void;
+    }
+    export interface DispatchHandler {
+        onRequestStart?(controller: DispatchController, context: any): void;
+        onRequestUpgrade?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, socket: Duplex): void;
+        onResponseStart?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, statusMessage?: string): void;
+        onResponseData?(controller: DispatchController, chunk: Buffer): void;
+        onResponseEnd?(controller: DispatchController, trailers: IncomingHttpHeaders): void;
+        onResponseError?(controller: DispatchController, error: Error): void;
+        onConnect?(abort: (err?: Error) => void): void;
+        onError?(err: Error): void;
+        onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex): void;
+        onResponseStarted?(): void;
+        onHeaders?(statusCode: number, headers: Buffer[], resume: () => void, statusText: string): boolean;
+        onData?(chunk: Buffer): boolean;
+        onComplete?(trailers: string[] | null): void;
+        onBodySent?(chunkSize: number, totalBytesSent: number): void;
+    }
+    export type PipelineHandler<TOpaque = null> = (data: PipelineHandlerData<TOpaque>) => Readable;
+    export type HttpMethod = Autocomplete<'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'>;
+    interface BodyMixin {
+        readonly body?: never;
+        readonly bodyUsed: boolean;
+        arrayBuffer(): Promise<ArrayBuffer>;
+        blob(): Promise<Blob>;
+        bytes(): Promise<Uint8Array>;
+        formData(): Promise<never>;
+        json(): Promise<unknown>;
+        text(): Promise<string>;
+    }
+    export interface DispatchInterceptor {
+        (dispatch: Dispatch): Dispatch;
+    }
+}

package/types/undici/env-http-proxy-agent.d.ts

@@ -0,0 +1,15 @@
+import Agent from './agent';
+import ProxyAgent from './proxy-agent';
+import Dispatcher from './dispatcher';
+export default EnvHttpProxyAgent;
+declare class EnvHttpProxyAgent extends Dispatcher {
+    constructor(opts?: EnvHttpProxyAgent.Options);
+    dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean;
+}
+declare namespace EnvHttpProxyAgent {
+    export interface Options extends Omit<ProxyAgent.Options, 'uri'> {
+        httpProxy?: string;
+        httpsProxy?: string;
+        noProxy?: string;
+    }
+}