cdk-ecr-deployment 3.0.75 → 3.0.77

package/node_modules/@types/cacheable-request/node_modules/@types/node/vm.d.ts

@@ -34,7 +34,7 @@
  *
  * console.log(x); // 1; y is not defined.
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/vm.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/vm.js)
  */
 declare module "vm" {
     import { ImportAttributes } from "node:module";
@@ -66,7 +66,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v20.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
             | ((specifier: string, script: Script, importAttributes: ImportAttributes) => Module)
@@ -348,9 +348,9 @@ declare module "vm" {
     }
     /**
      * If given a `contextObject`, the `vm.createContext()` method will
-     * [prepare that object](https://nodejs.org/docs/latest-v20.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
+     * [prepare that object](https://nodejs.org/docs/latest-v22.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
      * and return a reference to it so that it can be used in `{@link runInContext}` or
-     * [`script.runInContext()`](https://nodejs.org/docs/latest-v20.x/api/vm.html#scriptrunincontextcontextifiedobject-options). Inside such
+     * [`script.runInContext()`](https://nodejs.org/docs/latest-v22.x/api/vm.html#scriptrunincontextcontextifiedobject-options). Inside such
      * scripts, the `contextObject` will be the global object, retaining all of its
      * existing properties but also having the built-in objects and functions any
      * standard [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global
@@ -598,8 +598,6 @@ declare module "vm" {
         specifier: string,
         referencingModule: Module,
         extra: {
-            /** @deprecated Use `attributes` instead */
-            assert: ImportAttributes;
             attributes: ImportAttributes;
         },
     ) => Module | Promise<Module>;
@@ -914,7 +912,7 @@ declare module "vm" {
          * and `vm.compileFunction()` so that Node.js uses the default ESM loader from the main
          * context to load the requested module.
          *
-         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v20.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         const USE_MAIN_CONTEXT_DEFAULT_LOADER: number;
     }

package/node_modules/@types/cacheable-request/node_modules/@types/node/wasi.d.ts

@@ -67,7 +67,7 @@
  * wat2wasm demo.wat
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/wasi.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/wasi.js)
  */
 declare module "wasi" {
     interface WASIOptions {

package/node_modules/@types/cacheable-request/node_modules/@types/node/worker_threads.d.ts

@@ -49,7 +49,7 @@
  *
  * Worker threads inherit non-process-specific options by default. Refer to `Worker constructor options` to know how to customize worker thread options,
  * specifically `argv` and `execArgv` options.
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/worker_threads.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/worker_threads.js)
  */
 declare module "worker_threads" {
     import { Blob } from "node:buffer";

package/node_modules/@types/cacheable-request/node_modules/@types/node/zlib.d.ts

@@ -9,7 +9,7 @@
  * ```
  *
  * Compression and decompression are built around the Node.js
- * [Streams API](https://nodejs.org/docs/latest-v20.x/api/stream.html).
+ * [Streams API](https://nodejs.org/docs/latest-v22.x/api/stream.html).
  *
  * Compressing or decompressing a stream (such as a file) can be accomplished by
  * piping the source stream through a `zlib` `Transform` stream into a destination
@@ -89,7 +89,7 @@
  *   });
  * ```
  * @since v0.5.8
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/zlib.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/zlib.js)
  */
 declare module "zlib" {
     import * as stream from "node:stream";
@@ -143,7 +143,7 @@ declare module "zlib" {
             }
             | undefined;
         /**
-         * Limits output size when using [convenience methods](https://nodejs.org/docs/latest-v20.x/api/zlib.html#convenience-methods).
+         * Limits output size when using [convenience methods](https://nodejs.org/docs/latest-v22.x/api/zlib.html#convenience-methods).
          * @default buffer.kMaxLength
          */
         maxOutputLength?: number | undefined;

package/node_modules/@types/cacheable-request/node_modules/undici-types/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Matteo Collina and Undici contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/balanced-pool.d.ts

@@ -4,6 +4,8 @@ import { URL } from 'url'
 
 export default BalancedPool
 
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
 declare class BalancedPool extends Dispatcher {
   constructor(url: string | string[] | URL | URL[], options?: Pool.Options);
 
@@ -15,4 +17,13 @@ declare class BalancedPool extends Dispatcher {
   closed: boolean;
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
   destroyed: boolean;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: BalancedPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: BalancedPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
 }

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/client.d.ts

@@ -3,6 +3,8 @@ import { TlsOptions } from 'tls'
 import Dispatcher from './dispatcher'
 import buildConnector from "./connector";
 
+type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+
 /**
  * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
  */
@@ -14,6 +16,15 @@ export class Client extends Dispatcher {
   closed: boolean;
   /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
   destroyed: boolean;
+
+  // Override dispatcher APIs.
+  override connect(
+    options: ClientConnectOptions
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
+    options: ClientConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void;
 }
 
 export declare namespace Client {
@@ -77,7 +88,7 @@ export declare namespace Client {
     */
     allowH2?: boolean;
     /**
-     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overriden by a SETTINGS remote frame.
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
      * @default 100
     */
     maxConcurrentStreams?: number

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/diagnostics-channel.d.ts

@@ -9,8 +9,7 @@ declare namespace DiagnosticsChannel {
     completed: boolean;
     method?: Dispatcher.HttpMethod;
     path: string;
-    headers: string;
-    addHeader(key: string, value: string): Request;
+    headers: any;
   }
   interface Response {
     statusCode: number;

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/dispatcher.d.ts

@@ -18,6 +18,9 @@ declare class Dispatcher extends EventEmitter {
   /** Starts two-way communications with the requested resource. */
   connect(options: Dispatcher.ConnectOptions): Promise<Dispatcher.ConnectData>;
   connect(options: Dispatcher.ConnectOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+  /** Compose a chain of dispatchers */
+  compose(dispatchers: Dispatcher.DispatcherInterceptor[]): Dispatcher.ComposedDispatcher;
+  compose(...dispatchers: Dispatcher.DispatcherInterceptor[]): Dispatcher.ComposedDispatcher;
   /** Performs an HTTP request. */
   request(options: Dispatcher.RequestOptions): Promise<Dispatcher.ResponseData>;
   request(options: Dispatcher.RequestOptions, callback: (err: Error | null, data: Dispatcher.ResponseData) => void): void;
@@ -93,6 +96,8 @@ declare class Dispatcher extends EventEmitter {
 }
 
 declare namespace Dispatcher {
+  export interface ComposedDispatcher extends Dispatcher {}
+  export type DispatcherInterceptor = (dispatch: Dispatcher['dispatch']) => Dispatcher['dispatch'];
   export interface DispatchOptions {
     origin?: string | URL;
     path: string;
@@ -100,7 +105,7 @@ declare namespace Dispatcher {
     /** Default: `null` */
     body?: string | Buffer | Uint8Array | Readable | null | FormData;
     /** Default: `null` */
-    headers?: IncomingHttpHeaders | string[] | null;
+    headers?: IncomingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null;
     /** Query string params to be embedded in the request URL. Default: `null` */
     query?: Record<string, any>;
     /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
@@ -121,6 +126,7 @@ declare namespace Dispatcher {
     expectContinue?: boolean;
   }
   export interface ConnectOptions {
+    origin: string | URL;
     path: string;
     /** Default: `null` */
     headers?: IncomingHttpHeaders | string[] | null;
@@ -130,6 +136,8 @@ declare namespace Dispatcher {
     opaque?: unknown;
     /** Default: 0 */
     maxRedirections?: number;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
     /** Default: `null` */
     responseHeader?: 'raw' | null;
   }
@@ -140,6 +148,8 @@ declare namespace Dispatcher {
     signal?: AbortSignal | EventEmitter | null;
     /** Default: 0 */
     maxRedirections?: number;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
     /** Default: `null` */
     onInfo?: (info: { statusCode: number, headers: Record<string, string | string[]> }) => void;
     /** Default: `null` */
@@ -163,6 +173,8 @@ declare namespace Dispatcher {
     signal?: AbortSignal | EventEmitter | null;
     /** Default: 0 */
     maxRedirections?: number;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
     /** Default: `null` */
     responseHeader?: 'raw' | null;
   }
@@ -210,8 +222,10 @@ declare namespace Dispatcher {
     onError?(err: Error): void;
     /** Invoked when request is upgraded either due to a `Upgrade` header or `CONNECT` method. */
     onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex): void;
+    /** Invoked when response is received, before headers have been read. **/
+    onResponseStarted?(): void;
     /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
-    onHeaders?(statusCode: number, headers: Buffer[] | string[] | null, resume: () => void): boolean;
+    onHeaders?(statusCode: number, headers: Buffer[] | string[] | null, resume: () => void, statusText: string): boolean;
     /** Invoked when response payload data is received. */
     onData?(chunk: Buffer): boolean;
     /** Invoked when response payload and trailers have been received and the request has completed. */
@@ -226,7 +240,7 @@ declare namespace Dispatcher {
    * @link https://fetch.spec.whatwg.org/#body-mixin
    */
   interface BodyMixin {
-    readonly body?: never; // throws on node v16.6.0
+    readonly body?: never;
     readonly bodyUsed: boolean;
     arrayBuffer(): Promise<ArrayBuffer>;
     blob(): Promise<Blob>;

package/node_modules/@types/cacheable-request/node_modules/undici-types/eventsource.d.ts

@@ -0,0 +1,61 @@
+import { MessageEvent, ErrorEvent } from './websocket'
+
+import {
+  EventTarget,
+  Event,
+  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
+  onmessage: (this: EventSource, ev: MessageEvent) => any
+  onopen: (this: EventSource, ev: Event) => any
+  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
+}

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/fetch.d.ts

@@ -27,12 +27,29 @@ export type BodyInit =
   | null
   | string
 
-export interface BodyMixin {
+export class BodyMixin {
   readonly body: ReadableStream | null
   readonly bodyUsed: boolean
 
   readonly arrayBuffer: () => Promise<ArrayBuffer>
   readonly blob: () => Promise<Blob>
+  /**
+   * @deprecated This method is not recommended for parsing multipart/form-data bodies in server environments.
+   * It is recommended to use a library such as [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) as follows:
+   * 
+   * @example
+   * ```js
+   * import { Busboy } from '@fastify/busboy'
+   * import { Readable } from 'node:stream'
+   * 
+   * const response = await fetch('...')
+   * const busboy = new Busboy({ headers: { 'content-type': response.headers.get('content-type') } })
+   * 
+   * // handle events emitted from `busboy`
+   * 
+   * Readable.fromWeb(response.body).pipe(busboy)
+   * ```
+   */
   readonly formData: () => Promise<FormData>
   readonly json: () => Promise<unknown>
   readonly text: () => Promise<string>
@@ -105,10 +122,10 @@ export interface RequestInit {
   method?: string
   keepalive?: boolean
   headers?: HeadersInit
-  body?: BodyInit
+  body?: BodyInit | null
   redirect?: RequestRedirect
   integrity?: string
-  signal?: AbortSignal
+  signal?: AbortSignal | null
   credentials?: RequestCredentials
   mode?: RequestMode
   referrer?: string
@@ -135,7 +152,7 @@ export type RequestRedirect = 'error' | 'follow' | 'manual'
 
 export type RequestDuplex = 'half'
 
-export declare class Request implements BodyMixin {
+export declare class Request extends BodyMixin {
   constructor (input: RequestInfo, init?: RequestInit)
 
   readonly cache: RequestCache
@@ -153,15 +170,6 @@ export declare class Request implements BodyMixin {
   readonly signal: AbortSignal
   readonly duplex: RequestDuplex
 
-  readonly body: ReadableStream | null
-  readonly bodyUsed: boolean
-
-  readonly arrayBuffer: () => Promise<ArrayBuffer>
-  readonly blob: () => Promise<Blob>
-  readonly formData: () => Promise<FormData>
-  readonly json: () => Promise<unknown>
-  readonly text: () => Promise<string>
-
   readonly clone: () => Request
 }
 
@@ -181,7 +189,7 @@ export type ResponseType =
 
 export type ResponseRedirectStatus = 301 | 302 | 303 | 307 | 308
 
-export declare class Response implements BodyMixin {
+export declare class Response extends BodyMixin {
   constructor (body?: BodyInit, init?: ResponseInit)
 
   readonly headers: Headers
@@ -192,15 +200,6 @@ export declare class Response implements BodyMixin {
   readonly url: string
   readonly redirected: boolean
 
-  readonly body: ReadableStream | null
-  readonly bodyUsed: boolean
-
-  readonly arrayBuffer: () => Promise<ArrayBuffer>
-  readonly blob: () => Promise<Blob>
-  readonly formData: () => Promise<FormData>
-  readonly json: () => Promise<unknown>
-  readonly text: () => Promise<string>
-
   readonly clone: () => Response
 
   static error (): Response

package/node_modules/@types/cacheable-request/node_modules/undici-types/handlers.d.ts

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

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/index.d.ts

@@ -14,9 +14,13 @@ import MockPool from'./mock-pool'
 import MockAgent from'./mock-agent'
 import mockErrors from'./mock-errors'
 import ProxyAgent from'./proxy-agent'
+import RetryHandler from'./retry-handler'
+import RetryAgent from'./retry-agent'
 import { request, pipeline, stream, connect, upgrade } from './api'
 
+export * from './util'
 export * from './cookies'
+export * from './eventsource'
 export * from './fetch'
 export * from './file'
 export * from './filereader'
@@ -27,7 +31,7 @@ export * from './content-type'
 export * from './cache'
 export { Interceptable } from './mock-interceptor'
 
-export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, RedirectHandler, DecoratorHandler }
+export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, RedirectHandler, DecoratorHandler, RetryHandler, RetryAgent }
 export default Undici
 
 declare namespace Undici {
@@ -35,6 +39,7 @@ declare namespace Undici {
   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').createRedirectInterceptor
   var BalancedPool: typeof import('./balanced-pool').default;
   var Client: typeof import('./client').default;

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici-types",
-  "version": "5.26.5",
+  "version": "6.11.1",
   "description": "A stand-alone types package for Undici",
   "homepage": "https://undici.nodejs.org",
   "bugs": {

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/pool.d.ts

@@ -5,6 +5,8 @@ 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. */
@@ -13,6 +15,15 @@ declare class Pool extends Dispatcher {
   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 {

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/proxy-agent.d.ts

@@ -1,9 +1,7 @@
 import Agent from './agent'
 import buildConnector from './connector';
-import Client from './client'
 import Dispatcher from './dispatcher'
 import { IncomingHttpHeaders } from './header'
-import Pool from './pool'
 
 export default ProxyAgent
 

package/node_modules/{undici-types → @types/cacheable-request/node_modules/undici-types}/readable.d.ts

@@ -44,9 +44,8 @@ declare class BodyReadable extends Readable {
    */
   readonly bodyUsed: boolean
 
-  /** Throws on node 16.6.0
-   *
-   *  If body is null, it should return null as the body
+  /** 
+   * If body is null, it should return null as the body
    *
    *  If body is not null, should return the body as a ReadableStream
    *

package/node_modules/@types/cacheable-request/node_modules/undici-types/retry-agent.d.ts

@@ -0,0 +1,11 @@
+import Agent from './agent'
+import buildConnector from './connector';
+import Dispatcher from './dispatcher'
+import { IncomingHttpHeaders } from './header'
+import RetryHandler from './retry-handler'
+
+export default RetryAgent
+
+declare class RetryAgent extends Dispatcher {
+  constructor(dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
+}

package/node_modules/@types/cacheable-request/node_modules/undici-types/retry-handler.d.ts

@@ -0,0 +1,116 @@
+import Dispatcher from "./dispatcher";
+
+export default RetryHandler;
+
+declare class RetryHandler implements Dispatcher.DispatchHandlers {
+  constructor(
+    options: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    },
+    retryHandlers: RetryHandler.RetryHandlers
+  );
+}
+
+declare namespace RetryHandler {
+  export type RetryState = { counter: number; };
+
+  export type RetryContext = {
+    state: RetryState;
+    opts: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    };
+  }
+
+  export type OnRetryCallback = (result?: Error | null) => void;
+
+  export type RetryCallback = (
+    err: Error,
+    context: {
+      state: RetryState;
+      opts: Dispatcher.DispatchOptions & {
+        retryOptions?: RetryHandler.RetryOptions;
+      };
+    },
+    callback: OnRetryCallback
+  ) => number | null;
+
+  export interface RetryOptions {
+    /**
+     * Callback to be invoked on every retry iteration.
+     * It receives the error, current state of the retry object and the options object
+     * passed when instantiating the retry handler.
+     *
+     * @type {RetryCallback}
+     * @memberof RetryOptions
+     */
+    retry?: RetryCallback;
+    /**
+     * Maximum number of retries to allow.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Max number of milliseconds allow between retries
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 30000
+     */
+    maxTimeout?: number;
+    /**
+     * Initial number of milliseconds to wait before retrying for the first time.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 500
+     */
+    minTimeout?: number;
+    /**
+     * Factior to multiply the timeout factor between retries.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 2
+     */
+    timeoutFactor?: number;
+    /**
+     * It enables to automatically infer timeout between retries based on the `Retry-After` header.
+     *
+     * @type {boolean}
+     * @memberof RetryOptions
+     * @default true
+     */
+    retryAfter?: boolean;
+    /**
+     * HTTP methods to retry.
+     *
+     * @type {Dispatcher.HttpMethod[]}
+     * @memberof RetryOptions
+     * @default ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
+     */
+    methods?: Dispatcher.HttpMethod[];
+    /**
+     * Error codes to be retried. e.g. `ECONNRESET`, `ENOTFOUND`, `ETIMEDOUT`, `ECONNREFUSED`, etc.
+     *
+     * @type {string[]}
+     * @default ['ECONNRESET','ECONNREFUSED','ENOTFOUND','ENETDOWN','ENETUNREACH','EHOSTDOWN','EHOSTUNREACH','EPIPE']
+     */
+    errorCodes?: string[];
+    /**
+     * HTTP status codes to be retried.
+     *
+     * @type {number[]}
+     * @memberof RetryOptions
+     * @default [500, 502, 503, 504, 429],
+     */
+    statusCodes?: number[];
+  }
+
+  export interface RetryHandlers {
+    dispatch: Dispatcher["dispatch"];
+    handler: Dispatcher.DispatchHandlers;
+  }
+}