@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/types/index.d.ts

@@ -1,41 +1,31 @@
-import Dispatcher from './dispatcher'
+import Dispatcher from'./dispatcher'
 import { setGlobalDispatcher, getGlobalDispatcher } from './global-dispatcher'
 import { setGlobalOrigin, getGlobalOrigin } from './global-origin'
-import Pool from './pool'
+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 Dispatcher1Wrapper from './dispatcher1-wrapper'
-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 Client from'./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 mockErrors from'./mock-errors'
+import ProxyAgent from'./proxy-agent'
 import EnvHttpProxyAgent from './env-http-proxy-agent'
-import RetryHandler from './retry-handler'
-import RetryAgent from './retry-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 './file'
+export * from './filereader'
 export * from './formdata'
 export * from './diagnostics-channel'
 export * from './websocket'
@@ -43,51 +33,39 @@ 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, Dispatcher1Wrapper, 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 { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, interceptors, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, EnvHttpProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent }
 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 Dispatcher1Wrapper: typeof import('./dispatcher1-wrapper').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
+  var Dispatcher: typeof import('./dispatcher').default
+  var Pool: typeof import('./pool').default;
+  var RedirectHandler: typeof import ('./handlers').RedirectHandler
+  var DecoratorHandler: typeof import ('./handlers').DecoratorHandler
+  var RetryHandler: typeof import ('./retry-handler').default
+  var createRedirectInterceptor: typeof import ('./interceptors').default.createRedirectInterceptor
+  var BalancedPool: typeof import('./balanced-pool').default;
+  var Client: typeof import('./client').default;
+  var buildConnector: typeof import('./connector').default;
+  var errors: typeof import('./errors').default;
+  var Agent: typeof import('./agent').default;
+  var setGlobalDispatcher: typeof import('./global-dispatcher').setGlobalDispatcher;
+  var getGlobalDispatcher: typeof import('./global-dispatcher').getGlobalDispatcher;
+  var request: typeof import('./api').request;
+  var stream: typeof import('./api').stream;
+  var pipeline: typeof import('./api').pipeline;
+  var connect: typeof import('./api').connect;
+  var upgrade: typeof import('./api').upgrade;
+  var MockClient: typeof import('./mock-client').default;
+  var MockPool: typeof import('./mock-pool').default;
+  var MockAgent: typeof import('./mock-agent').default;
+  var mockErrors: typeof import('./mock-errors').default;
+  var fetch: typeof import('./fetch').fetch;
+  var Headers: typeof import('./fetch').Headers;
+  var Response: typeof import('./fetch').Response;
+  var Request: typeof import('./fetch').Request;
+  var FormData: typeof import('./formdata').FormData;
+  var File: typeof import('./file').File;
+  var FileReader: typeof import('./filereader').FileReader;
+  var caches: typeof import('./cache').caches;
+  var interceptors: typeof import('./interceptors').default;
 }

package/node_modules/undici/types/interceptors.d.ts

@@ -1,82 +1,32 @@
-import CacheHandler from './cache-interceptor'
-import Dispatcher from './dispatcher'
-import RetryHandler from './retry-handler'
 import { LookupOptions } from 'node:dns'
 
-export default Interceptors
+import Dispatcher from "./dispatcher";
+import RetryHandler from "./retry-handler";
+
+export default Interceptors;
 
 declare namespace Interceptors {
   export type DumpInterceptorOpts = { maxSize?: number }
   export type RetryInterceptorOpts = RetryHandler.RetryOptions
-  export type RedirectInterceptorOpts = { maxRedirections?: number, throwOnMaxRedirect?: boolean, stripHeadersOnRedirect?: string[], stripHeadersOnCrossOriginRedirect?: string[] }
-  export type DecompressInterceptorOpts = {
-    skipErrorResponses?: boolean
-    skipStatusCodes?: number[]
-    /** Maximum decompressed response size in bytes per stage. 0 disables the limit. @default 0 */
-    maxSize?: number
-  }
-
+  export type RedirectInterceptorOpts = { maxRedirections?: number }
   export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
-  export type CacheInterceptorOpts = CacheHandler.CacheOptions
 
   // DNS interceptor
   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 DNSInterceptorOriginRecords = { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null }
   export type DNSInterceptorOpts = {
     maxTTL?: number
     maxItems?: number
-    lookup?: (origin: URL, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
+    lookup?: (hostname: string, 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
-  }
-
-  // Deduplicate interceptor
-  export type DeduplicateMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
-  export type DeduplicateInterceptorOpts = {
-    /**
-     * The HTTP methods to deduplicate.
-     * Note: Only safe HTTP methods can be deduplicated.
-     * @default ['GET']
-     */
-    methods?: DeduplicateMethods[]
-    /**
-     * Header names that, if present in a request, will cause the request to skip deduplication.
-     * Header name matching is case-insensitive.
-     * @default []
-     */
-    skipHeaderNames?: string[]
-    /**
-     * Header names to exclude from the deduplication key.
-     * Requests with different values for these headers will still be deduplicated together.
-     * Useful for headers like `x-request-id` that vary per request but shouldn't affect deduplication.
-     * Header name matching is case-insensitive.
-     * @default []
-     */
-    excludeHeaderNames?: string[]
-    /**
-     * Maximum bytes buffered per paused waiting deduplicated handler.
-     * If a waiting handler remains paused and exceeds this threshold,
-     * it is failed with an abort error to prevent unbounded memory growth.
-     * @default 5 * 1024 * 1024
-     */
-    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 createRedirectInterceptor(opts: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function dump(opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function retry(opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
+  export function redirect(opts?: RedirectInterceptorOpts): 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/node_modules/undici/types/mock-agent.d.ts

@@ -1,69 +1,50 @@
 import Agent from './agent'
 import Dispatcher from './dispatcher'
 import { Interceptable, MockInterceptor } from './mock-interceptor'
-import MockDispatch = MockInterceptor.MockDispatch
-import { MockCallHistory } from './mock-call-history'
+import MockDispatch = MockInterceptor.MockDispatch;
 
 export default MockAgent
 
+interface PendingInterceptor extends MockDispatch {
+  origin: string;
+}
+
 /** A mocked Agent class that implements the Agent API. It allows one to intercept HTTP requests made through undici and return mocked responses instead. */
 declare class MockAgent<TMockAgentOptions extends MockAgent.Options = MockAgent.Options> extends Dispatcher {
-  constructor (options?: TMockAgentOptions)
+  constructor(options?: MockAgent.Options)
   /** Creates and retrieves mock Dispatcher instances which can then be used to intercept HTTP requests. If the number of connections on the mock agent is set to 1, a MockClient instance is returned. Otherwise a MockPool instance is returned. */
-  get<TInterceptable extends Interceptable>(origin: string): TInterceptable
-  get<TInterceptable extends Interceptable>(origin: RegExp): TInterceptable
-  get<TInterceptable extends Interceptable>(origin: ((origin: string) => boolean)): TInterceptable
+  get<TInterceptable extends Interceptable>(origin: string): TInterceptable;
+  get<TInterceptable extends Interceptable>(origin: RegExp): TInterceptable;
+  get<TInterceptable extends Interceptable>(origin: ((origin: string) => boolean)): TInterceptable;
   /** Dispatches a mocked request. */
-  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
+  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
   /** Closes the mock agent and waits for registered mock pools and clients to also close before resolving. */
-  close (): Promise<void>
+  close(): Promise<void>;
   /** Disables mocking in MockAgent. */
-  deactivate (): void
+  deactivate(): void;
   /** Enables mocking in a MockAgent instance. When instantiated, a MockAgent is automatically activated. Therefore, this method is only effective after `MockAgent.deactivate` has been called. */
-  activate (): void
+  activate(): void;
   /** Define host matchers so only matching requests that aren't intercepted by the mock dispatchers will be attempted. */
-  enableNetConnect (): void
-  enableNetConnect (host: string): void
-  enableNetConnect (host: RegExp): void
-  enableNetConnect (host: ((host: string) => boolean)): void
+  enableNetConnect(): void;
+  enableNetConnect(host: string): void;
+  enableNetConnect(host: RegExp): void;
+  enableNetConnect(host: ((host: string) => boolean)): void;
   /** Causes all requests to throw when requests are not matched in a MockAgent intercept. */
-  disableNetConnect (): void
-  /** get call history. returns the MockAgent call history or undefined if the option is not enabled. */
-  getCallHistory (): MockCallHistory | undefined
-  /** clear every call history. Any MockCallHistoryLog will be deleted on the MockCallHistory instance */
-  clearCallHistory (): void
-  /** Enable call history. Any subsequence calls will then be registered. */
-  enableCallHistory (): this
-  /** Disable call history. Any subsequence calls will then not be registered. */
-  disableCallHistory (): this
-  pendingInterceptors (): MockAgent.PendingInterceptor[]
-  assertNoPendingInterceptors (options?: {
-    pendingInterceptorsFormatter?: MockAgent.PendingInterceptorsFormatter;
-  }): void
+  disableNetConnect(): void;
+  pendingInterceptors(): PendingInterceptor[];
+  assertNoPendingInterceptors(options?: {
+    pendingInterceptorsFormatter?: PendingInterceptorsFormatter;
+  }): void;
 }
 
-declare namespace MockAgent {
-  /** An interceptor that was registered on a mock dispatcher and has not been consumed yet. */
-  export interface PendingInterceptor extends MockDispatch {
-    origin: string;
-  }
-
-  export interface PendingInterceptorsFormatter {
-    format(pendingInterceptors: readonly PendingInterceptor[]): string;
-  }
+interface PendingInterceptorsFormatter {
+  format(pendingInterceptors: readonly PendingInterceptor[]): string;
+}
 
+declare namespace MockAgent {
   /** MockAgent options. */
   export interface Options extends Agent.Options {
     /** A custom agent to be encapsulated by the MockAgent. */
-    agent?: Dispatcher;
-
-    /** Ignore trailing slashes in the path */
-    ignoreTrailingSlash?: boolean;
-
-    /** Accept URLs with search parameters using non standard syntaxes. default false */
-    acceptNonStandardSearchParameters?: boolean;
-
-    /** Enable call history. you can either call MockAgent.enableCallHistory(). default false */
-    enableCallHistory?: boolean
+    agent?: Agent;
   }
 }

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

@@ -7,15 +7,13 @@ export default MockClient
 
 /** MockClient extends the Client API and allows one to mock requests. */
 declare class MockClient extends Client implements Interceptable {
-  constructor (origin: string, options: MockClient.Options)
+  constructor(origin: string, options: MockClient.Options);
   /** Intercepts any matching requests that use the same origin as this mock client. */
-  intercept (options: MockInterceptor.Options): MockInterceptor
+  intercept(options: MockInterceptor.Options): MockInterceptor;
   /** Dispatches a mocked request. */
-  dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean
+  dispatch(options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandlers): boolean;
   /** Closes the mock client and gracefully waits for enqueued requests to complete. */
-  close (): Promise<void>
-  /** Clean up all the prepared mocks. */
-  cleanMocks (): void
+  close(): Promise<void>;
 }
 
 declare namespace MockClient {

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

@@ -5,8 +5,8 @@ export default MockErrors
 declare namespace MockErrors {
   /** The request does not match any registered mock dispatches. */
   export class MockNotMatchedError extends Errors.UndiciError {
-    constructor (message?: string)
-    name: 'MockNotMatchedError'
-    code: 'UND_MOCK_ERR_MOCK_NOT_MATCHED'
+    constructor(message?: string);
+    name: 'MockNotMatchedError';
+    code: 'UND_MOCK_ERR_MOCK_NOT_MATCHED';
   }
 }

package/node_modules/undici/types/mock-interceptor.d.ts

@@ -1,36 +1,42 @@
 import { IncomingHttpHeaders } from './header'
-import Dispatcher from './dispatcher'
+import Dispatcher from './dispatcher';
 import { BodyInit, Headers } from './fetch'
 
+export {
+  Interceptable,
+  MockInterceptor,
+  MockScope
+}
+
 /** The scope associated with a mock dispatch. */
 declare class MockScope<TData extends object = object> {
-  constructor (mockDispatch: MockInterceptor.MockDispatch<TData>)
+  constructor(mockDispatch: MockInterceptor.MockDispatch<TData>);
   /** Delay a reply by a set amount of time in ms. */
-  delay (waitInMs: number): MockScope<TData>
+  delay(waitInMs: number): MockScope<TData>;
   /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
-  persist (): MockScope<TData>
+  persist(): MockScope<TData>;
   /** Define a reply for a set amount of matching requests. */
-  times (repeatTimes: number): MockScope<TData>
+  times(repeatTimes: number): MockScope<TData>;
 }
 
 /** The interceptor for a Mock. */
 declare class MockInterceptor {
-  constructor (options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[])
+  constructor(options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[]);
   /** Mock an undici request with the defined reply. */
-  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>
+  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>;
   reply<TData extends object = object>(
     statusCode: number,
     data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>,
     responseOptions?: MockInterceptor.MockResponseOptions
-  ): MockScope<TData>
+  ): MockScope<TData>;
   /** Mock an undici request by throwing the defined reply error. */
-  replyWithError<TError extends Error = Error>(error: TError): MockScope
+  replyWithError<TError extends Error = Error>(error: TError): MockScope;
   /** Set default reply headers on the interceptor for subsequent mocked replies. */
-  defaultReplyHeaders (headers: IncomingHttpHeaders): MockInterceptor
+  defaultReplyHeaders(headers: IncomingHttpHeaders): MockInterceptor;
   /** Set default reply trailers on the interceptor for subsequent mocked replies. */
-  defaultReplyTrailers (trailers: Record<string, string>): MockInterceptor
+  defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor;
   /** Set automatically calculated content-length header on subsequent mocked replies. */
-  replyContentLength (): MockInterceptor
+  replyContentLength(): MockInterceptor;
 }
 
 declare namespace MockInterceptor {
@@ -69,30 +75,19 @@ declare namespace MockInterceptor {
     headers?: Headers | Record<string, string>;
     origin?: string;
     body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+    maxRedirections?: number;
   }
 
   export type MockResponseDataHandler<TData extends object = object> = (
     opts: MockResponseCallbackOptions
-  ) => TData | Buffer | string
-
-  export type MockReplyOptions<TData extends object = object> = {
-    statusCode: number, data?: TData | Buffer | string, responseOptions?: MockResponseOptions
-  }
+  ) => TData | Buffer | string;
 
   export type MockReplyOptionsCallback<TData extends object = object> = (
     opts: MockResponseCallbackOptions
-  ) => MockReplyOptions<TData> | Promise<MockReplyOptions<TData>>
+  ) => { statusCode: number, data?: TData | Buffer | string, responseOptions?: MockResponseOptions }
 }
 
 interface Interceptable extends Dispatcher {
   /** Intercepts any matching requests that use the same origin as this mock client. */
   intercept(options: MockInterceptor.Options): MockInterceptor;
-  /** Clean up all the prepared mocks. */
-  cleanMocks (): void
-}
-
-export {
-  Interceptable,
-  MockInterceptor,
-  MockScope
 }

package/node_modules/undici/types/mock-pool.d.ts

@@ -7,15 +7,13 @@ export default MockPool
 
 /** MockPool extends the Pool API and allows one to mock requests. */
 declare class MockPool extends Pool implements Interceptable {
-  constructor (origin: string, options: MockPool.Options)
+  constructor(origin: string, options: MockPool.Options);
   /** Intercepts any matching requests that use the same origin as this mock pool. */
-  intercept (options: MockInterceptor.Options): MockInterceptor
+  intercept(options: MockInterceptor.Options): MockInterceptor;
   /** Dispatches a mocked request. */
-  dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean
+  dispatch(options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandlers): boolean;
   /** Closes the mock pool and gracefully waits for enqueued requests to complete. */
-  close (): Promise<void>
-  /** Clean up all the prepared mocks. */
-  cleanMocks (): void
+  close(): Promise<void>;
 }
 
 declare namespace MockPool {

package/node_modules/undici/types/patch.d.ts

@@ -2,6 +2,10 @@
 
 // See https://github.com/nodejs/undici/issues/1740
 
+export type DOMException = typeof globalThis extends { DOMException: infer T }
+ ? T
+ : any
+
 export interface EventInit {
   bubbles?: boolean
   cancelable?: boolean

package/node_modules/undici/types/pool-stats.d.ts

@@ -1,19 +1,19 @@
-import Pool from './pool'
+import Pool from "./pool"
 
 export default PoolStats
 
 declare class PoolStats {
-  constructor (pool: Pool)
+  constructor(pool: Pool);
   /** Number of open socket connections in this pool. */
-  connected: number
+  connected: number;
   /** Number of open socket connections in this pool that do not have an active request. */
-  free: number
+  free: number;
   /** Number of pending requests across all clients in this pool. */
-  pending: number
+  pending: number;
   /** Number of queued requests across all clients in this pool. */
-  queued: number
+  queued: number;
   /** Number of currently active requests across all clients in this pool. */
-  running: number
+  running: number;
   /** Number of active, pending, or queued requests across all clients in this pool. */
-  size: number
+  size: number;
 }

package/node_modules/undici/types/pool.d.ts

@@ -1,39 +1,39 @@
 import Client from './client'
 import TPoolStats from './pool-stats'
-import { URL } from 'node:url'
-import Dispatcher from './dispatcher'
+import { URL } from 'url'
+import Dispatcher from "./dispatcher";
 
 export default Pool
 
-type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
 
 declare class Pool extends Dispatcher {
-  constructor (url: string | URL, options?: Pool.Options)
+  constructor(url: string | URL, options?: Pool.Options)
   /** `true` after `pool.close()` has been called. */
-  closed: boolean
+  closed: boolean;
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
-  destroyed: boolean
+  destroyed: boolean;
   /** Aggregate stats for a Pool. */
-  readonly stats: TPoolStats
+  readonly stats: TPoolStats;
 
   // Override dispatcher APIs.
-  override connect (
+  override connect(
     options: PoolConnectOptions
-  ): Promise<Dispatcher.ConnectData>
-  override connect (
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
     options: PoolConnectOptions,
     callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void
+  ): void;
 }
 
 declare namespace Pool {
-  export type PoolStats = TPoolStats
+  export type PoolStats = TPoolStats;
   export interface Options extends Client.Options {
     /** Default: `(origin, opts) => new Client(origin, opts)`. */
     factory?(origin: URL, opts: object): Dispatcher;
     /** The max number of clients to create. `null` if no limit. Default `null`. */
     connections?: number | null;
-    /** The amount of time before a client is removed from the pool and closed. `null` if no time limit. Default `null` */
-    clientTtl?: number | null;
+
+    interceptors?: { Pool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options["interceptors"]
   }
 }

package/node_modules/undici/types/proxy-agent.d.ts

@@ -1,15 +1,15 @@
 import Agent from './agent'
-import buildConnector from './connector'
+import buildConnector from './connector';
 import Dispatcher from './dispatcher'
-import { OutgoingHttpHeaders } from './header'
+import { IncomingHttpHeaders } from './header'
 
 export default ProxyAgent
 
 declare class ProxyAgent extends Dispatcher {
-  constructor (options: ProxyAgent.Options | string)
+  constructor(options: ProxyAgent.Options | string)
 
-  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
-  close (): Promise<void>
+  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+  close(): Promise<void>;
 }
 
 declare namespace ProxyAgent {
@@ -20,17 +20,10 @@ declare namespace ProxyAgent {
      */
     auth?: string;
     token?: string;
-    headers?: OutgoingHttpHeaders;
+    headers?: IncomingHttpHeaders;
     requestTls?: buildConnector.BuildOptions;
     proxyTls?: buildConnector.BuildOptions;
     clientFactory?(origin: URL, opts: object): Dispatcher;
-    /**
-     * Undici tunnels via CONNECT when the target endpoint uses HTTPS, and
-     * forwards (HTTP/1.1 absolute-form request-target, per RFC 9112 §3.2.2)
-     * otherwise, regardless of whether the proxy URL is HTTP or HTTPS. The
-     * non-tunneled forwarding path does not negotiate HTTP/2 with the proxy.
-     * Set to true to force tunneling for plain HTTP requests as well.
-     */
     proxyTunnel?: boolean;
   }
 }