@runlith/tagma 0.0.0-stage → 0.1.0

package/types/undici/errors.d.ts

@@ -0,0 +1,117 @@
+import { IncomingHttpHeaders } from './header';
+import Client from './client';
+export default Errors;
+declare namespace Errors {
+    export class UndiciError extends Error {
+        name: string;
+        code: string;
+    }
+    export class ConnectTimeoutError extends UndiciError {
+        name: 'ConnectTimeoutError';
+        code: 'UND_ERR_CONNECT_TIMEOUT';
+    }
+    export class HeadersTimeoutError extends UndiciError {
+        name: 'HeadersTimeoutError';
+        code: 'UND_ERR_HEADERS_TIMEOUT';
+    }
+    export class HeadersOverflowError extends UndiciError {
+        name: 'HeadersOverflowError';
+        code: 'UND_ERR_HEADERS_OVERFLOW';
+    }
+    export class BodyTimeoutError extends UndiciError {
+        name: 'BodyTimeoutError';
+        code: 'UND_ERR_BODY_TIMEOUT';
+    }
+    export class ResponseError extends UndiciError {
+        constructor(message: string, code: number, options: {
+            headers?: IncomingHttpHeaders | string[] | null;
+            body?: null | Record<string, any> | string;
+        });
+        name: 'ResponseError';
+        code: 'UND_ERR_RESPONSE';
+        statusCode: number;
+        body: null | Record<string, any> | string;
+        headers: IncomingHttpHeaders | string[] | null;
+    }
+    export class InvalidArgumentError extends UndiciError {
+        name: 'InvalidArgumentError';
+        code: 'UND_ERR_INVALID_ARG';
+    }
+    export class InvalidReturnValueError extends UndiciError {
+        name: 'InvalidReturnValueError';
+        code: 'UND_ERR_INVALID_RETURN_VALUE';
+    }
+    export class RequestAbortedError extends UndiciError {
+        name: 'AbortError';
+        code: 'UND_ERR_ABORTED';
+    }
+    export class InformationalError extends UndiciError {
+        name: 'InformationalError';
+        code: 'UND_ERR_INFO';
+    }
+    export class RequestContentLengthMismatchError extends UndiciError {
+        name: 'RequestContentLengthMismatchError';
+        code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+    }
+    export class ResponseContentLengthMismatchError extends UndiciError {
+        name: 'ResponseContentLengthMismatchError';
+        code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+    }
+    export class ClientDestroyedError extends UndiciError {
+        name: 'ClientDestroyedError';
+        code: 'UND_ERR_DESTROYED';
+    }
+    export class ClientClosedError extends UndiciError {
+        name: 'ClientClosedError';
+        code: 'UND_ERR_CLOSED';
+    }
+    export class SocketError extends UndiciError {
+        name: 'SocketError';
+        code: 'UND_ERR_SOCKET';
+        socket: Client.SocketInfo | null;
+    }
+    export class NotSupportedError extends UndiciError {
+        name: 'NotSupportedError';
+        code: 'UND_ERR_NOT_SUPPORTED';
+    }
+    export class BalancedPoolMissingUpstreamError extends UndiciError {
+        name: 'MissingUpstreamError';
+        code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+    }
+    export class HTTPParserError extends UndiciError {
+        name: 'HTTPParserError';
+        code: string;
+    }
+    export class ResponseExceededMaxSizeError extends UndiciError {
+        name: 'ResponseExceededMaxSizeError';
+        code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+    }
+    export class RequestRetryError extends UndiciError {
+        constructor(message: string, statusCode: number, headers?: IncomingHttpHeaders | string[] | null, body?: null | Record<string, any> | string);
+        name: 'RequestRetryError';
+        code: 'UND_ERR_REQ_RETRY';
+        statusCode: number;
+        data: {
+            count: number;
+        };
+        headers: Record<string, string | string[]>;
+    }
+    export class SecureProxyConnectionError extends UndiciError {
+        constructor(cause?: Error, message?: string, options?: Record<any, any>);
+        name: 'SecureProxyConnectionError';
+        code: 'UND_ERR_PRX_TLS';
+    }
+    export class MaxOriginsReachedError extends UndiciError {
+        name: 'MaxOriginsReachedError';
+        code: 'UND_ERR_MAX_ORIGINS_REACHED';
+    }
+    export class Socks5ProxyError extends UndiciError {
+        constructor(message?: string, code?: string);
+        name: 'Socks5ProxyError';
+        code: string;
+    }
+    export class MessageSizeExceededError extends UndiciError {
+        name: 'MessageSizeExceededError';
+        code: 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED';
+    }
+}

package/types/undici/eventsource.d.ts

@@ -0,0 +1,39 @@
+import { MessageEvent, ErrorEvent } from './websocket';
+import Dispatcher from './dispatcher';
+import { EventListenerOptions, AddEventListenerOptions, EventListenerOrEventListenerObject } from './patch';
+interface EventSourceEventMap {
+    error: ErrorEvent;
+    message: MessageEvent;
+    open: Event;
+}
+interface EventSource extends EventTarget {
+    close(): void;
+    readonly CLOSED: 2;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    onerror: ((this: EventSource, ev: ErrorEvent) => any) | null;
+    onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
+    onopen: ((this: EventSource, ev: Event) => any) | null;
+    readonly readyState: 0 | 1 | 2;
+    readonly url: string;
+    readonly withCredentials: boolean;
+    addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+export declare const EventSource: {
+    prototype: EventSource;
+    new (url: string | URL, init?: EventSourceInit): EventSource;
+    readonly CLOSED: 2;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+};
+interface EventSourceInit {
+    withCredentials?: boolean;
+    dispatcher?: Dispatcher;
+    node?: {
+        dispatcher?: Dispatcher;
+        reconnectionTime?: number;
+    };
+}

package/types/undici/fetch.d.ts

@@ -0,0 +1,122 @@
+/// <reference path="../node/index.d.ts" />
+import { Blob } from 'node:buffer';
+import { URL, URLSearchParams } from 'node:url';
+import { ReadableStream } from 'node:stream/web';
+import { FormData } from './formdata';
+import { HeaderRecord } from './header';
+import Dispatcher from './dispatcher';
+export type RequestInfo = string | URL | Request;
+export declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+export type BodyInit = ArrayBuffer | AsyncIterable<Uint8Array> | Blob | FormData | Iterable<Uint8Array> | NodeJS.ArrayBufferView | URLSearchParams | null | string;
+export class BodyMixin {
+    readonly body: ReadableStream | null;
+    readonly bodyUsed: boolean;
+    readonly arrayBuffer: () => Promise<ArrayBuffer>;
+    readonly blob: () => Promise<Blob>;
+    readonly bytes: () => Promise<Uint8Array>;
+    readonly formData: () => Promise<FormData>;
+    readonly json: () => Promise<unknown>;
+    readonly text: () => Promise<string>;
+}
+export interface SpecIterator<T, TReturn = any, TNext = undefined> {
+    next(...args: [
+    ] | [
+        TNext
+    ]): IteratorResult<T, TReturn>;
+}
+export interface SpecIterableIterator<T> extends SpecIterator<T> {
+    [Symbol.iterator](): SpecIterableIterator<T>;
+}
+export interface SpecIterable<T> {
+    [Symbol.iterator](): SpecIterator<T>;
+}
+export type HeadersInit = [
+    string,
+    string
+][] | HeaderRecord | Headers;
+export declare class Headers implements SpecIterable<[
+    string,
+    string
+]> {
+    constructor(init?: HeadersInit);
+    readonly append: (name: string, value: string) => void;
+    readonly delete: (name: string) => void;
+    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) => void;
+    readonly keys: () => SpecIterableIterator<string>;
+    readonly values: () => SpecIterableIterator<string>;
+    readonly entries: () => SpecIterableIterator<[
+        string,
+        string
+    ]>;
+    readonly [Symbol.iterator]: () => SpecIterableIterator<[
+        string,
+        string
+    ]>;
+}
+export type RequestCache = 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload';
+export type RequestCredentials = 'omit' | 'include' | 'same-origin';
+type RequestDestination = '' | 'audio' | 'audioworklet' | 'document' | 'embed' | 'font' | 'image' | 'manifest' | 'object' | 'paintworklet' | 'report' | 'script' | 'sharedworker' | 'style' | 'track' | 'video' | 'worker' | 'xslt';
+export interface RequestInit {
+    body?: BodyInit | null;
+    cache?: RequestCache;
+    credentials?: RequestCredentials;
+    dispatcher?: Dispatcher;
+    duplex?: RequestDuplex;
+    headers?: HeadersInit;
+    integrity?: string;
+    keepalive?: boolean;
+    method?: string;
+    mode?: RequestMode;
+    redirect?: RequestRedirect;
+    referrer?: string;
+    referrerPolicy?: ReferrerPolicy;
+    signal?: AbortSignal | null;
+    window?: null;
+}
+export type ReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+export type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin';
+export type RequestRedirect = 'error' | 'follow' | 'manual';
+export type RequestDuplex = 'half';
+export declare class Request extends BodyMixin {
+    constructor(input: RequestInfo, init?: RequestInit);
+    readonly cache: RequestCache;
+    readonly credentials: RequestCredentials;
+    readonly destination: RequestDestination;
+    readonly headers: Headers;
+    readonly integrity: string;
+    readonly method: string;
+    readonly mode: RequestMode;
+    readonly redirect: RequestRedirect;
+    readonly referrer: string;
+    readonly referrerPolicy: ReferrerPolicy;
+    readonly url: string;
+    readonly keepalive: boolean;
+    readonly signal: AbortSignal;
+    readonly duplex: RequestDuplex;
+    readonly clone: () => Request;
+}
+export interface ResponseInit {
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly headers?: HeadersInit;
+}
+export type ResponseType = 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+export type ResponseRedirectStatus = 301 | 302 | 303 | 307 | 308;
+export declare class Response extends BodyMixin {
+    constructor(body?: BodyInit, init?: ResponseInit);
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly type: ResponseType;
+    readonly url: string;
+    readonly redirected: boolean;
+    readonly clone: () => Response;
+    static error(): Response;
+    static json(data: any, init?: ResponseInit): Response;
+    static redirect(url: string | URL, status?: ResponseRedirectStatus): Response;
+}

package/types/undici/formdata.d.ts

@@ -0,0 +1,24 @@
+/// <reference path="../node/index.d.ts" />
+import { File } from 'node:buffer';
+import { SpecIterableIterator } from './fetch';
+declare type FormDataEntryValue = string | File;
+export declare class FormData {
+    append(name: string, value: unknown, fileName?: string): void;
+    set(name: string, value: unknown, fileName?: string): void;
+    get(name: string): FormDataEntryValue | null;
+    getAll(name: string): FormDataEntryValue[];
+    has(name: string): boolean;
+    delete(name: string): void;
+    forEach: (callbackfn: (value: FormDataEntryValue, key: string, iterable: FormData) => void, thisArg?: unknown) => void;
+    keys: () => SpecIterableIterator<string>;
+    values: () => SpecIterableIterator<FormDataEntryValue>;
+    entries: () => SpecIterableIterator<[
+        string,
+        FormDataEntryValue
+    ]>;
+    [Symbol.iterator]: () => SpecIterableIterator<[
+        string,
+        FormDataEntryValue
+    ]>;
+    readonly [Symbol.toStringTag]: string;
+}

package/types/undici/global-dispatcher.d.ts

@@ -0,0 +1,4 @@
+import Dispatcher from './dispatcher';
+declare function setGlobalDispatcher<DispatcherImplementation extends Dispatcher>(dispatcher: DispatcherImplementation): void;
+declare function getGlobalDispatcher(): Dispatcher;
+export { getGlobalDispatcher, setGlobalDispatcher };

package/types/undici/global-origin.d.ts

@@ -0,0 +1,3 @@
+declare function setGlobalOrigin(origin: string | URL | undefined): void;
+declare function getGlobalOrigin(): URL | undefined;
+export { setGlobalOrigin, getGlobalOrigin };

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

@@ -0,0 +1,35 @@
+import { URL } from 'node:url';
+import Dispatcher from './dispatcher';
+import buildConnector from './connector';
+type H2ClientOptions = Omit<Dispatcher.ConnectOptions, 'origin'>;
+export class H2CClient extends Dispatcher {
+    constructor(url: string | URL, options?: H2CClient.Options);
+    pipelining: number;
+    closed: boolean;
+    destroyed: boolean;
+    override connect(options: H2ClientOptions): Promise<Dispatcher.ConnectData>;
+    override connect(options: H2ClientOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+}
+export declare namespace H2CClient {
+    export interface Options {
+        maxHeaderSize?: number;
+        headersTimeout?: number;
+        connectTimeout?: number;
+        bodyTimeout?: number;
+        keepAliveTimeout?: number;
+        keepAliveMaxTimeout?: number;
+        keepAliveTimeoutThreshold?: number;
+        socketPath?: string;
+        pipelining?: number;
+        strictContentLength?: boolean;
+        maxCachedSessions?: number;
+        connect?: Omit<Partial<buildConnector.BuildOptions>, 'allowH2'> | buildConnector.connector;
+        maxRequestsPerClient?: number;
+        localAddress?: string;
+        maxResponseSize?: number;
+        autoSelectFamily?: boolean;
+        autoSelectFamilyAttemptTimeout?: number;
+        maxConcurrentStreams?: number;
+    }
+}
+export default H2CClient;

package/types/undici/handlers.d.ts

@@ -0,0 +1,7 @@
+import Dispatcher from './dispatcher';
+export declare class RedirectHandler implements Dispatcher.DispatchHandler {
+    constructor(dispatch: Dispatcher.Dispatch, maxRedirections: number, opts: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandler, redirectionLimitReached: boolean);
+}
+export declare class DecoratorHandler implements Dispatcher.DispatchHandler {
+    constructor(handler: Dispatcher.DispatchHandler);
+}

package/types/undici/header.d.ts

@@ -0,0 +1,10 @@
+import { Autocomplete } from './utility';
+export type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+type HeaderNames = Autocomplete<'Accept' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Encoding' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'Alt-Svc' | 'Alt-Used' | 'Authorization' | 'Cache-Control' | 'Clear-Site-Data' | 'Connection' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'Device-Memory' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Forwarded' | 'From' | 'Host' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Unmodified-Since' | 'Keep-Alive' | 'Last-Modified' | 'Link' | 'Location' | 'Max-Forwards' | 'Origin' | 'Permissions-Policy' | 'Priority' | 'Proxy-Authenticate' | 'Proxy-Authorization' | 'Range' | 'Referer' | 'Referrer-Policy' | 'Retry-After' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-Purpose' | 'Sec-WebSocket-Accept' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'SourceMap' | 'Strict-Transport-Security' | 'TE' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Upgrade-Insecure-Requests' | 'User-Agent' | 'Vary' | 'Via' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options'>;
+type IANARegisteredMimeType = Autocomplete<'audio/aac' | 'video/x-msvideo' | 'image/avif' | 'video/av1' | 'application/octet-stream' | 'image/bmp' | 'text/css' | 'text/csv' | 'application/vnd.ms-fontobject' | 'application/epub+zip' | 'image/gif' | 'application/gzip' | 'text/html' | 'image/x-icon' | 'text/calendar' | 'image/jpeg' | 'text/javascript' | 'application/json' | 'application/ld+json' | 'audio/x-midi' | 'audio/mpeg' | 'video/mp4' | 'video/mpeg' | 'audio/ogg' | 'video/ogg' | 'application/ogg' | 'audio/opus' | 'font/otf' | 'application/pdf' | 'image/png' | 'application/rtf' | 'image/svg+xml' | 'image/tiff' | 'video/mp2t' | 'font/ttf' | 'text/plain' | 'application/wasm' | 'video/webm' | 'audio/webm' | 'image/webp' | 'font/woff' | 'font/woff2' | 'application/xhtml+xml' | 'application/xml' | 'application/zip' | 'video/3gpp' | 'video/3gpp2' | 'model/gltf+json' | 'model/gltf-binary'>;
+type KnownHeaderValues = {
+    'content-type': IANARegisteredMimeType;
+};
+export type HeaderRecord = {
+    [K in HeaderNames | Lowercase<HeaderNames>]?: Lowercase<K> extends keyof KnownHeaderValues ? KnownHeaderValues[Lowercase<K>] : string;
+};

package/types/undici/index.d.ts

@@ -0,0 +1,85 @@
+import Dispatcher from './dispatcher';
+import { setGlobalDispatcher, getGlobalDispatcher } from './global-dispatcher';
+import { setGlobalOrigin, getGlobalOrigin } from './global-origin';
+import Pool from './pool';
+import { RedirectHandler, DecoratorHandler } from './handlers';
+import BalancedPool from './balanced-pool';
+import RoundRobinPool from './round-robin-pool';
+import Client from './client';
+import H2CClient from './h2c-client';
+import buildConnector from './connector';
+import errors from './errors';
+import Agent from './agent';
+import MockClient from './mock-client';
+import MockPool from './mock-pool';
+import MockAgent from './mock-agent';
+import { SnapshotAgent } from './snapshot-agent';
+import { MockCallHistory, MockCallHistoryLog } from './mock-call-history';
+import mockErrors from './mock-errors';
+import ProxyAgent from './proxy-agent';
+import Socks5ProxyAgent from './socks5-proxy-agent';
+import EnvHttpProxyAgent from './env-http-proxy-agent';
+import RetryHandler from './retry-handler';
+import RetryAgent from './retry-agent';
+import { request, pipeline, stream, connect, upgrade } from './api';
+import interceptors from './interceptors';
+import CacheInterceptor from './cache-interceptor';
+declare const cacheStores: {
+    MemoryCacheStore: typeof CacheInterceptor.MemoryCacheStore;
+    SqliteCacheStore: typeof CacheInterceptor.SqliteCacheStore;
+};
+export * from './util';
+export * from './cookies';
+export * from './eventsource';
+export * from './fetch';
+export * from './formdata';
+export * from './diagnostics-channel';
+export * from './websocket';
+export * from './content-type';
+export * from './cache';
+export { Interceptable } from './mock-interceptor';
+declare function globalThisInstall(): void;
+export { Dispatcher, BalancedPool, RoundRobinPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, cacheStores, MockClient, MockPool, MockAgent, SnapshotAgent, MockCallHistory, MockCallHistoryLog, mockErrors, ProxyAgent, Socks5ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent, H2CClient, globalThisInstall as install };
+export default Undici;
+declare namespace Undici {
+    const Dispatcher: typeof import('./dispatcher').default;
+    const Pool: typeof import('./pool').default;
+    const RedirectHandler: typeof import('./handlers').RedirectHandler;
+    const DecoratorHandler: typeof import('./handlers').DecoratorHandler;
+    const RetryHandler: typeof import('./retry-handler').default;
+    const BalancedPool: typeof import('./balanced-pool').default;
+    const RoundRobinPool: typeof import('./round-robin-pool').default;
+    const Client: typeof import('./client').default;
+    const H2CClient: typeof import('./h2c-client').default;
+    const buildConnector: typeof import('./connector').default;
+    const errors: typeof import('./errors').default;
+    const Agent: typeof import('./agent').default;
+    const setGlobalDispatcher: typeof import('./global-dispatcher').setGlobalDispatcher;
+    const getGlobalDispatcher: typeof import('./global-dispatcher').getGlobalDispatcher;
+    const request: typeof import('./api').request;
+    const stream: typeof import('./api').stream;
+    const pipeline: typeof import('./api').pipeline;
+    const connect: typeof import('./api').connect;
+    const upgrade: typeof import('./api').upgrade;
+    const MockClient: typeof import('./mock-client').default;
+    const MockPool: typeof import('./mock-pool').default;
+    const MockAgent: typeof import('./mock-agent').default;
+    const SnapshotAgent: typeof import('./snapshot-agent').SnapshotAgent;
+    const MockCallHistory: typeof import('./mock-call-history').MockCallHistory;
+    const MockCallHistoryLog: typeof import('./mock-call-history').MockCallHistoryLog;
+    const mockErrors: typeof import('./mock-errors').default;
+    const ProxyAgent: typeof import('./proxy-agent').default;
+    const Socks5ProxyAgent: typeof import('./socks5-proxy-agent').default;
+    const fetch: typeof import('./fetch').fetch;
+    const Headers: typeof import('./fetch').Headers;
+    const Response: typeof import('./fetch').Response;
+    const Request: typeof import('./fetch').Request;
+    const FormData: typeof import('./formdata').FormData;
+    const caches: typeof import('./cache').caches;
+    const interceptors: typeof import('./interceptors').default;
+    const cacheStores: {
+        MemoryCacheStore: typeof import('./cache-interceptor').default.MemoryCacheStore;
+        SqliteCacheStore: typeof import('./cache-interceptor').default.SqliteCacheStore;
+    };
+    const install: typeof globalThisInstall;
+}

package/types/undici/interceptors.d.ts

@@ -0,0 +1,70 @@
+import CacheHandler from './cache-interceptor';
+import Dispatcher from './dispatcher';
+import RetryHandler from './retry-handler';
+import { LookupOptions } from 'node:dns';
+export default Interceptors;
+declare namespace Interceptors {
+    export type DumpInterceptorOpts = {
+        maxSize?: number;
+    };
+    export type RetryInterceptorOpts = RetryHandler.RetryOptions;
+    export type RedirectInterceptorOpts = {
+        maxRedirections?: number;
+    };
+    export type DecompressInterceptorOpts = {
+        skipErrorResponses?: boolean;
+        skipStatusCodes?: number[];
+    };
+    export type ResponseErrorInterceptorOpts = {
+        throwOnError: boolean;
+    };
+    export type CacheInterceptorOpts = CacheHandler.CacheOptions;
+    export type DNSInterceptorRecord = {
+        address: string;
+        ttl: number;
+        family: 4 | 6;
+    };
+    export type DNSInterceptorOriginRecords = {
+        records: {
+            4: {
+                ips: DNSInterceptorRecord[];
+            } | null;
+            6: {
+                ips: DNSInterceptorRecord[];
+            } | null;
+        };
+    };
+    export type DNSStorage = {
+        size: number;
+        get(origin: string): DNSInterceptorOriginRecords | null;
+        set(origin: string, records: DNSInterceptorOriginRecords | null, options: {
+            ttl: number;
+        }): void;
+        delete(origin: string): void;
+        full(): boolean;
+    };
+    export type DNSInterceptorOpts = {
+        maxTTL?: number;
+        maxItems?: number;
+        lookup?: (origin: URL, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void;
+        pick?: (origin: URL, records: DNSInterceptorOriginRecords, affinity: 4 | 6) => DNSInterceptorRecord;
+        dualStack?: boolean;
+        affinity?: 4 | 6;
+        storage?: DNSStorage;
+    };
+    export type DeduplicateMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE';
+    export type DeduplicateInterceptorOpts = {
+        methods?: DeduplicateMethods[];
+        skipHeaderNames?: string[];
+        excludeHeaderNames?: string[];
+        maxBufferSize?: number;
+    };
+    export function dump(opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor;
+    export function retry(opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor;
+    export function redirect(opts?: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor;
+    export function decompress(opts?: DecompressInterceptorOpts): Dispatcher.DispatcherComposeInterceptor;
+    export function responseError(opts?: ResponseErrorInterceptorOpts): Dispatcher.DispatcherComposeInterceptor;
+    export function dns(opts?: DNSInterceptorOpts): Dispatcher.DispatcherComposeInterceptor;
+    export function cache(opts?: CacheInterceptorOpts): Dispatcher.DispatcherComposeInterceptor;
+    export function deduplicate(opts?: DeduplicateInterceptorOpts): Dispatcher.DispatcherComposeInterceptor;
+}

package/types/undici/mock-agent.d.ts

@@ -0,0 +1,43 @@
+import Agent from './agent';
+import Dispatcher from './dispatcher';
+import { Interceptable, MockInterceptor } from './mock-interceptor';
+import MockDispatch = MockInterceptor.MockDispatch;
+import { MockCallHistory } from './mock-call-history';
+export default MockAgent;
+interface PendingInterceptor extends MockDispatch {
+    origin: string;
+}
+declare class MockAgent<TMockAgentOptions extends MockAgent.Options = MockAgent.Options> extends Dispatcher {
+    constructor(options?: TMockAgentOptions);
+    get<TInterceptable extends Interceptable>(origin: string): TInterceptable;
+    get<TInterceptable extends Interceptable>(origin: RegExp): TInterceptable;
+    get<TInterceptable extends Interceptable>(origin: ((origin: string) => boolean)): TInterceptable;
+    dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean;
+    close(): Promise<void>;
+    deactivate(): void;
+    activate(): void;
+    enableNetConnect(): void;
+    enableNetConnect(host: string): void;
+    enableNetConnect(host: RegExp): void;
+    enableNetConnect(host: ((host: string) => boolean)): void;
+    disableNetConnect(): void;
+    getCallHistory(): MockCallHistory | undefined;
+    clearCallHistory(): void;
+    enableCallHistory(): this;
+    disableCallHistory(): this;
+    pendingInterceptors(): PendingInterceptor[];
+    assertNoPendingInterceptors(options?: {
+        pendingInterceptorsFormatter?: PendingInterceptorsFormatter;
+    }): void;
+}
+interface PendingInterceptorsFormatter {
+    format(pendingInterceptors: readonly PendingInterceptor[]): string;
+}
+declare namespace MockAgent {
+    export interface Options extends Agent.Options {
+        agent?: Dispatcher;
+        ignoreTrailingSlash?: boolean;
+        acceptNonStandardSearchParameters?: boolean;
+        enableCallHistory?: boolean;
+    }
+}

package/types/undici/mock-call-history.d.ts

@@ -0,0 +1,57 @@
+import Dispatcher from './dispatcher';
+declare namespace MockCallHistoryLog {
+    export type MockCallHistoryLogProperties = 'protocol' | 'host' | 'port' | 'origin' | 'path' | 'hash' | 'fullUrl' | 'method' | 'searchParams' | 'body' | 'headers';
+}
+declare class MockCallHistoryLog {
+    constructor(requestInit: Dispatcher.DispatchOptions);
+    protocol: string;
+    host: string;
+    port: string;
+    origin: string;
+    path: string;
+    hash: string;
+    fullUrl: string;
+    method: string;
+    searchParams: Record<string, string>;
+    body: string | null | undefined;
+    headers: Record<string, string | string[]> | null | undefined;
+    toMap(): Map<MockCallHistoryLog.MockCallHistoryLogProperties, string | Record<string, string | string[]> | null | undefined>;
+    toString(): string;
+}
+declare namespace MockCallHistory {
+    export type FilterCallsOperator = 'AND' | 'OR';
+    export interface FilterCallsOptions {
+        operator?: FilterCallsOperator | Lowercase<FilterCallsOperator>;
+    }
+    export type FilterCallsFunctionCriteria = (log: MockCallHistoryLog) => boolean;
+    export type FilterCallsParameter = string | RegExp | undefined | null;
+    export interface FilterCallsObjectCriteria extends Record<string, FilterCallsParameter> {
+        protocol?: FilterCallsParameter;
+        host?: FilterCallsParameter;
+        port?: FilterCallsParameter;
+        origin?: FilterCallsParameter;
+        path?: FilterCallsParameter;
+        hash?: FilterCallsParameter;
+        fullUrl?: FilterCallsParameter;
+        method?: FilterCallsParameter;
+    }
+}
+declare class MockCallHistory {
+    constructor(name: string);
+    calls(): Array<MockCallHistoryLog>;
+    firstCall(): MockCallHistoryLog | undefined;
+    lastCall(): MockCallHistoryLog | undefined;
+    nthCall(position: number): MockCallHistoryLog | undefined;
+    filterCalls(criteria: MockCallHistory.FilterCallsFunctionCriteria | MockCallHistory.FilterCallsObjectCriteria | RegExp, options?: MockCallHistory.FilterCallsOptions): Array<MockCallHistoryLog>;
+    filterCallsByProtocol(protocol: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>;
+    filterCallsByHost(host: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>;
+    filterCallsByPort(port: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>;
+    filterCallsByOrigin(origin: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>;
+    filterCallsByPath(path: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>;
+    filterCallsByHash(hash: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>;
+    filterCallsByFullUrl(fullUrl: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>;
+    filterCallsByMethod(method: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>;
+    clear(): void;
+    [Symbol.iterator]: () => Generator<MockCallHistoryLog>;
+}
+export { MockCallHistoryLog, MockCallHistory };

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

@@ -0,0 +1,17 @@
+import Client from './client';
+import Dispatcher from './dispatcher';
+import MockAgent from './mock-agent';
+import { MockInterceptor, Interceptable } from './mock-interceptor';
+export default MockClient;
+declare class MockClient extends Client implements Interceptable {
+    constructor(origin: string, options: MockClient.Options);
+    intercept(options: MockInterceptor.Options): MockInterceptor;
+    dispatch(options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean;
+    close(): Promise<void>;
+    cleanMocks(): void;
+}
+declare namespace MockClient {
+    export interface Options extends Client.Options {
+        agent: MockAgent;
+    }
+}

package/types/undici/mock-errors.d.ts

@@ -0,0 +1,9 @@
+import Errors from './errors';
+export default MockErrors;
+declare namespace MockErrors {
+    export class MockNotMatchedError extends Errors.UndiciError {
+        constructor(message?: string);
+        name: 'MockNotMatchedError';
+        code: 'UND_MOCK_ERR_MOCK_NOT_MATCHED';
+    }
+}