raza-fca-pkg 1.0.0

package/.cache/typescript/5.9/node_modules/undici-types/interceptors.d.ts

@@ -0,0 +1,39 @@
+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
+
+  // DNS interceptor
+  export type DNSInterceptorRecord = { address: string, ttl: number, family: 4 | 6 }
+  export type DNSInterceptorOriginRecords = { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null }
+  export type DNSInterceptorOpts = {
+    maxTTL?: number
+    maxItems?: number
+    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
+  }
+
+  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
+}

package/.cache/typescript/5.9/node_modules/undici-types/mock-agent.d.ts

@@ -0,0 +1,68 @@
+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;
+}
+
+/** 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)
+  /** 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
+  /** Dispatches a mocked request. */
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
+  /** Closes the mock agent and waits for registered mock pools and clients to also close before resolving. */
+  close (): Promise<void>
+  /** Disables mocking in MockAgent. */
+  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
+  /** 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
+  /** 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 (): PendingInterceptor[]
+  assertNoPendingInterceptors (options?: {
+    pendingInterceptorsFormatter?: PendingInterceptorsFormatter;
+  }): void
+}
+
+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
+  }
+}

package/.cache/typescript/5.9/node_modules/undici-types/mock-call-history.d.ts

@@ -0,0 +1,111 @@
+import Dispatcher from './dispatcher'
+
+declare namespace MockCallHistoryLog {
+  /** request's configuration properties */
+  export type MockCallHistoryLogProperties = 'protocol' | 'host' | 'port' | 'origin' | 'path' | 'hash' | 'fullUrl' | 'method' | 'searchParams' | 'body' | 'headers'
+}
+
+/** a log reflecting request configuration  */
+declare class MockCallHistoryLog {
+  constructor (requestInit: Dispatcher.DispatchOptions)
+  /** protocol used. ie. 'https:' or 'http:' etc... */
+  protocol: string
+  /** request's host. */
+  host: string
+  /** request's port. */
+  port: string
+  /** request's origin. ie. https://localhost:3000. */
+  origin: string
+  /** path. never contains searchParams. */
+  path: string
+  /** request's hash. */
+  hash: string
+  /** the full url requested. */
+  fullUrl: string
+  /** request's method. */
+  method: string
+  /** search params. */
+  searchParams: Record<string, string>
+  /** request's body */
+  body: string | null | undefined
+  /** request's headers */
+  headers: Record<string, string | string[]> | null | undefined
+
+  /** returns an Map of property / value pair */
+  toMap (): Map<MockCallHistoryLog.MockCallHistoryLogProperties, string | Record<string, string | string[]> | null | undefined>
+
+  /** returns a string computed with all key value pair */
+  toString (): string
+}
+
+declare namespace MockCallHistory {
+  export type FilterCallsOperator = 'AND' | 'OR'
+
+  /** modify the filtering behavior */
+  export interface FilterCallsOptions {
+    /** the operator to apply when filtering. 'OR' will adds any MockCallHistoryLog matching any criteria given. 'AND' will adds only MockCallHistoryLog matching every criteria given. (default 'OR')  */
+    operator?: FilterCallsOperator | Lowercase<FilterCallsOperator>
+  }
+  /** a function to be executed for filtering MockCallHistoryLog */
+  export type FilterCallsFunctionCriteria = (log: MockCallHistoryLog) => boolean
+
+  /** parameter to filter MockCallHistoryLog */
+  export type FilterCallsParameter = string | RegExp | undefined | null
+
+  /** an object to execute multiple filtering at once */
+  export interface FilterCallsObjectCriteria extends Record<string, FilterCallsParameter> {
+    /** filter by request protocol. ie https: */
+    protocol?: FilterCallsParameter;
+    /** filter by request host. */
+    host?: FilterCallsParameter;
+    /** filter by request port. */
+    port?: FilterCallsParameter;
+    /** filter by request origin. */
+    origin?: FilterCallsParameter;
+    /** filter by request path. */
+    path?: FilterCallsParameter;
+    /** filter by request hash. */
+    hash?: FilterCallsParameter;
+    /** filter by request fullUrl. */
+    fullUrl?: FilterCallsParameter;
+    /** filter by request method. */
+    method?: FilterCallsParameter;
+  }
+}
+
+/** a call history to track requests configuration */
+declare class MockCallHistory {
+  constructor (name: string)
+  /** returns an array of MockCallHistoryLog. */
+  calls (): Array<MockCallHistoryLog>
+  /** returns the first MockCallHistoryLog */
+  firstCall (): MockCallHistoryLog | undefined
+  /** returns the last MockCallHistoryLog. */
+  lastCall (): MockCallHistoryLog | undefined
+  /** returns the nth MockCallHistoryLog. */
+  nthCall (position: number): MockCallHistoryLog | undefined
+  /** return all MockCallHistoryLog matching any of criteria given. if an object is used with multiple properties, you can change the operator to apply during filtering on options */
+  filterCalls (criteria: MockCallHistory.FilterCallsFunctionCriteria | MockCallHistory.FilterCallsObjectCriteria | RegExp, options?: MockCallHistory.FilterCallsOptions): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given protocol. if a string is given, it is matched with includes */
+  filterCallsByProtocol (protocol: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given host. if a string is given, it is matched with includes */
+  filterCallsByHost (host: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given port. if a string is given, it is matched with includes */
+  filterCallsByPort (port: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given origin. if a string is given, it is matched with includes */
+  filterCallsByOrigin (origin: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given path. if a string is given, it is matched with includes */
+  filterCallsByPath (path: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given hash. if a string is given, it is matched with includes */
+  filterCallsByHash (hash: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given fullUrl. if a string is given, it is matched with includes */
+  filterCallsByFullUrl (fullUrl: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** return all MockCallHistoryLog matching the given method. if a string is given, it is matched with includes */
+  filterCallsByMethod (method: MockCallHistory.FilterCallsParameter): Array<MockCallHistoryLog>
+  /** clear all MockCallHistoryLog on this MockCallHistory. */
+  clear (): void
+  /** use it with for..of loop or spread operator */
+  [Symbol.iterator]: () => Generator<MockCallHistoryLog>
+}
+
+export { MockCallHistoryLog, MockCallHistory }

package/.cache/typescript/5.9/node_modules/undici-types/mock-client.d.ts

@@ -0,0 +1,27 @@
+import Client from './client'
+import Dispatcher from './dispatcher'
+import MockAgent from './mock-agent'
+import { MockInterceptor, Interceptable } from './mock-interceptor'
+
+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)
+  /** Intercepts any matching requests that use the same origin as this mock client. */
+  intercept (options: MockInterceptor.Options): MockInterceptor
+  /** Dispatches a mocked request. */
+  dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean
+  /** Closes the mock client and gracefully waits for enqueued requests to complete. */
+  close (): Promise<void>
+  /** Clean up all the prepared mocks. */
+  cleanMocks (): void
+}
+
+declare namespace MockClient {
+  /** MockClient options. */
+  export interface Options extends Client.Options {
+    /** The agent to associate this MockClient with. */
+    agent: MockAgent;
+  }
+}

package/.cache/typescript/5.9/node_modules/undici-types/mock-errors.d.ts

@@ -0,0 +1,12 @@
+import Errors from './errors'
+
+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'
+  }
+}

package/.cache/typescript/5.9/node_modules/undici-types/mock-interceptor.d.ts

@@ -0,0 +1,94 @@
+import { IncomingHttpHeaders } from './header'
+import Dispatcher from './dispatcher'
+import { BodyInit, Headers } from './fetch'
+
+/** The scope associated with a mock dispatch. */
+declare class MockScope<TData extends object = object> {
+  constructor (mockDispatch: MockInterceptor.MockDispatch<TData>)
+  /** Delay a reply by a set amount of time in ms. */
+  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>
+  /** Define a reply for a set amount of matching requests. */
+  times (repeatTimes: number): MockScope<TData>
+}
+
+/** The interceptor for a Mock. */
+declare class MockInterceptor {
+  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>(
+    statusCode: number,
+    data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>,
+    responseOptions?: MockInterceptor.MockResponseOptions
+  ): MockScope<TData>
+  /** Mock an undici request by throwing the defined reply error. */
+  replyWithError<TError extends Error = Error>(error: TError): MockScope
+  /** Set default reply headers on the interceptor for subsequent mocked replies. */
+  defaultReplyHeaders (headers: IncomingHttpHeaders): MockInterceptor
+  /** Set default reply trailers on the interceptor for subsequent mocked replies. */
+  defaultReplyTrailers (trailers: Record<string, string>): MockInterceptor
+  /** Set automatically calculated content-length header on subsequent mocked replies. */
+  replyContentLength (): MockInterceptor
+}
+
+declare namespace MockInterceptor {
+  /** MockInterceptor options. */
+  export interface Options {
+    /** Path to intercept on. */
+    path: string | RegExp | ((path: string) => boolean);
+    /** Method to intercept on. Defaults to GET. */
+    method?: string | RegExp | ((method: string) => boolean);
+    /** Body to intercept on. */
+    body?: string | RegExp | ((body: string) => boolean);
+    /** Headers to intercept on. */
+    headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+    /** Query params to intercept on */
+    query?: Record<string, any>;
+  }
+  export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
+    times: number | null;
+    persist: boolean;
+    consumed: boolean;
+    data: MockDispatchData<TData, TError>;
+  }
+  export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
+    error: TError | null;
+    statusCode?: number;
+    data?: TData | string;
+  }
+  export interface MockResponseOptions {
+    headers?: IncomingHttpHeaders;
+    trailers?: Record<string, string>;
+  }
+
+  export interface MockResponseCallbackOptions {
+    path: string;
+    method: string;
+    headers?: Headers | Record<string, string>;
+    origin?: string;
+    body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+  }
+
+  export type MockResponseDataHandler<TData extends object = object> = (
+    opts: MockResponseCallbackOptions
+  ) => TData | Buffer | string
+
+  export type MockReplyOptionsCallback<TData extends object = object> = (
+    opts: MockResponseCallbackOptions
+  ) => { 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/.cache/typescript/5.9/node_modules/undici-types/mock-pool.d.ts

@@ -0,0 +1,27 @@
+import Pool from './pool'
+import MockAgent from './mock-agent'
+import { Interceptable, MockInterceptor } from './mock-interceptor'
+import Dispatcher from './dispatcher'
+
+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)
+  /** Intercepts any matching requests that use the same origin as this mock pool. */
+  intercept (options: MockInterceptor.Options): MockInterceptor
+  /** Dispatches a mocked request. */
+  dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean
+  /** Closes the mock pool and gracefully waits for enqueued requests to complete. */
+  close (): Promise<void>
+  /** Clean up all the prepared mocks. */
+  cleanMocks (): void
+}
+
+declare namespace MockPool {
+  /** MockPool options. */
+  export interface Options extends Pool.Options {
+    /** The agent to associate this MockPool with. */
+    agent: MockAgent;
+  }
+}

package/.cache/typescript/5.9/node_modules/undici-types/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "undici-types",
+  "version": "7.16.0",
+  "description": "A stand-alone types package for Undici",
+  "homepage": "https://undici.nodejs.org",
+  "bugs": {
+    "url": "https://github.com/nodejs/undici/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nodejs/undici.git"
+  },
+  "license": "MIT",
+  "types": "index.d.ts",
+  "files": [
+    "*.d.ts"
+  ],
+  "contributors": [
+    {
+      "name": "Daniele Belardi",
+      "url": "https://github.com/dnlup",
+      "author": true
+    },
+    {
+      "name": "Ethan Arrowood",
+      "url": "https://github.com/ethan-arrowood",
+      "author": true
+    },
+    {
+      "name": "Matteo Collina",
+      "url": "https://github.com/mcollina",
+      "author": true
+    },
+    {
+      "name": "Matthew Aitken",
+      "url": "https://github.com/KhafraDev",
+      "author": true
+    },
+    {
+      "name": "Robert Nagy",
+      "url": "https://github.com/ronag",
+      "author": true
+    },
+    {
+      "name": "Szymon Marczak",
+      "url": "https://github.com/szmarczak",
+      "author": true
+    },
+    {
+      "name": "Tomas Della Vedova",
+      "url": "https://github.com/delvedor",
+      "author": true
+    }
+  ]
+}

package/.cache/typescript/5.9/node_modules/undici-types/patch.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+
+// See https://github.com/nodejs/undici/issues/1740
+
+export interface EventInit {
+  bubbles?: boolean
+  cancelable?: boolean
+  composed?: boolean
+}
+
+export interface EventListenerOptions {
+  capture?: boolean
+}
+
+export interface AddEventListenerOptions extends EventListenerOptions {
+  once?: boolean
+  passive?: boolean
+  signal?: AbortSignal
+}
+
+export type EventListenerOrEventListenerObject = EventListener | EventListenerObject
+
+export interface EventListenerObject {
+  handleEvent (object: Event): void
+}
+
+export interface EventListener {
+  (evt: Event): void
+}

package/.cache/typescript/5.9/node_modules/undici-types/pool-stats.d.ts

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

package/.cache/typescript/5.9/node_modules/undici-types/pool.d.ts

@@ -0,0 +1,41 @@
+import Client from './client'
+import TPoolStats from './pool-stats'
+import { URL } from 'url'
+import Dispatcher from './dispatcher'
+
+export default Pool
+
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class Pool extends Dispatcher {
+  constructor (url: string | URL, options?: Pool.Options)
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+  /** Aggregate stats for a Pool. */
+  readonly stats: TPoolStats
+
+  // Override dispatcher APIs.
+  override connect (
+    options: PoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: PoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+declare namespace Pool {
+  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/.cache/typescript/5.9/node_modules/undici-types/proxy-agent.d.ts

@@ -0,0 +1,29 @@
+import Agent from './agent'
+import buildConnector from './connector'
+import Dispatcher from './dispatcher'
+import { IncomingHttpHeaders } from './header'
+
+export default ProxyAgent
+
+declare class ProxyAgent extends Dispatcher {
+  constructor (options: ProxyAgent.Options | string)
+
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
+  close (): Promise<void>
+}
+
+declare namespace ProxyAgent {
+  export interface Options extends Agent.Options {
+    uri: string;
+    /**
+     * @deprecated use opts.token
+     */
+    auth?: string;
+    token?: string;
+    headers?: IncomingHttpHeaders;
+    requestTls?: buildConnector.BuildOptions;
+    proxyTls?: buildConnector.BuildOptions;
+    clientFactory?(origin: URL, opts: object): Dispatcher;
+    proxyTunnel?: boolean;
+  }
+}

package/.cache/typescript/5.9/node_modules/undici-types/readable.d.ts

@@ -0,0 +1,68 @@
+import { Readable } from 'stream'
+import { Blob } from 'buffer'
+
+export default BodyReadable
+
+declare class BodyReadable extends Readable {
+  constructor (opts: {
+    resume: (this: Readable, size: number) => void | null;
+    abort: () => void | null;
+    contentType?: string;
+    contentLength?: number;
+    highWaterMark?: number;
+  })
+
+  /** 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<unknown>
+
+  /** Consumes and returns the body as a Blob
+   *  https://fetch.spec.whatwg.org/#dom-body-blob
+   */
+  blob (): Promise<Blob>
+
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes (): Promise<Uint8Array>
+
+  /** 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
+
+  /**
+   * 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: 131072
+   * @param opts.signal AbortSignal to cancel the operation (optional)
+   */
+  dump (opts?: { limit: number; signal?: AbortSignal }): Promise<void>
+}

package/.cache/typescript/5.9/node_modules/undici-types/retry-agent.d.ts

@@ -0,0 +1,8 @@
+import Dispatcher from './dispatcher'
+import RetryHandler from './retry-handler'
+
+export default RetryAgent
+
+declare class RetryAgent extends Dispatcher {
+  constructor (dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
+}