cdk-ecr-deployment 0.0.79 → 0.0.83

package/node_modules/@types/cacheable-request/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.10.3",
+    "version": "16.11.11",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -110,6 +110,11 @@
             "url": "https://github.com/eps1lon",
             "githubUsername": "eps1lon"
         },
+        {
+            "name": "Seth Westphal",
+            "url": "https://github.com/westy92",
+            "githubUsername": "westy92"
+        },
         {
             "name": "Simon Schick",
             "url": "https://github.com/SimonSchick",
@@ -155,11 +160,6 @@
             "url": "https://github.com/trivikr",
             "githubUsername": "trivikr"
         },
-        {
-            "name": "Minh Son Nguyen",
-            "url": "https://github.com/nguymin4",
-            "githubUsername": "nguymin4"
-        },
         {
             "name": "Junxiao Shi",
             "url": "https://github.com/yoursunny",
@@ -225,6 +225,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "6b890401c9e8ed8ad1296e2cfeef65f2ba29feb793d490917f614c65e7f33f07",
-    "typeScriptVersion": "3.7"
+    "typesPublisherContentHash": "2c07ab3f15ad8f0250e091bd0ca3ffaa5918c556923138897e7eabf6ec03c778",
+    "typeScriptVersion": "3.8"
 }

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

@@ -94,7 +94,11 @@ declare module 'process' {
             type ExitListener = (code: number) => void;
             type RejectionHandledListener = (promise: Promise<unknown>) => void;
             type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => void;
-            type UnhandledRejectionListener = (reason: {} | null | undefined, promise: Promise<unknown>) => void;
+            /**
+             * Most of the time the unhandledRejection will be an Error, but this should not be relied upon
+             * as *anything* can be thrown/rejected, it is therefore unsafe to assume the the value is an Error.
+             */
+            type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void;
             type WarningListener = (warning: Error) => void;
             type MessageListener = (message: unknown, sendHandle: unknown) => void;
             type SignalsListener = (signal: Signals) => void;

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

@@ -236,6 +236,7 @@ declare module 'readline' {
          * @since v0.1.98
          */
         write(data: string | Buffer, key?: Key): void;
+        write(data: undefined | null | string | Buffer, key: Key): void;
         /**
          * Returns the real position of the cursor in relation to the input
          * prompt + string. Long input (wrapping) strings, as well as multiple

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

@@ -1,5 +1,390 @@
 declare module 'stream/web' {
     // stub module, pending copy&paste from .d.ts or manual impl
+    // copy from lib.dom.d.ts
+
+    interface ReadableWritablePair<R = any, W = any> {
+        readable: ReadableStream<R>;
+        /**
+         * Provides a convenient, chainable way of piping this readable stream
+         * through a transform stream (or any other { writable, readable }
+         * pair). It simply pipes the stream into the writable side of the
+         * supplied pair, and returns the readable side for further use.
+         *
+         * Piping a stream will lock it for the duration of the pipe, preventing
+         * any other consumer from acquiring a reader.
+         */
+        writable: WritableStream<W>;
+    }
+
+    interface StreamPipeOptions {
+        preventAbort?: boolean;
+        preventCancel?: boolean;
+        /**
+         * Pipes this readable stream to a given writable stream destination.
+         * The way in which the piping process behaves under various error
+         * conditions can be customized with a number of passed options. It
+         * returns a promise that fulfills when the piping process completes
+         * successfully, or rejects if any errors were encountered.
+         *
+         * Piping a stream will lock it for the duration of the pipe, preventing
+         * any other consumer from acquiring a reader.
+         *
+         * Errors and closures of the source and destination streams propagate
+         * as follows:
+         *
+         * An error in this source readable stream will abort destination,
+         * unless preventAbort is truthy. The returned promise will be rejected
+         * with the source's error, or with any error that occurs during
+         * aborting the destination.
+         *
+         * An error in destination will cancel this source readable stream,
+         * unless preventCancel is truthy. The returned promise will be rejected
+         * with the destination's error, or with any error that occurs during
+         * canceling the source.
+         *
+         * When this source readable stream closes, destination will be closed,
+         * unless preventClose is truthy. The returned promise will be fulfilled
+         * once this process completes, unless an error is encountered while
+         * closing the destination, in which case it will be rejected with that
+         * error.
+         *
+         * If destination starts out closed or closing, this source readable
+         * stream will be canceled, unless preventCancel is true. The returned
+         * promise will be rejected with an error indicating piping to a closed
+         * stream failed, or with any error that occurs during canceling the
+         * source.
+         *
+         * The signal option can be set to an AbortSignal to allow aborting an
+         * ongoing pipe operation via the corresponding AbortController. In this
+         * case, this source readable stream will be canceled, and destination
+         * aborted, unless the respective options preventCancel or preventAbort
+         * are set.
+         */
+        preventClose?: boolean;
+        signal?: AbortSignal;
+    }
+
+    interface ReadableStreamGenericReader {
+        readonly closed: Promise<undefined>;
+        cancel(reason?: any): Promise<void>;
+    }
+
+    interface ReadableStreamDefaultReadValueResult<T> {
+        done: false;
+        value: T;
+    }
+
+    interface ReadableStreamDefaultReadDoneResult {
+        done: true;
+        value?: undefined;
+    }
+    type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
+    type ReadableStreamDefaultReadResult<T> =
+        | ReadableStreamDefaultReadValueResult<T>
+        | ReadableStreamDefaultReadDoneResult;
+
+    interface ReadableByteStreamControllerCallback {
+        (controller: ReadableByteStreamController): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSinkAbortCallback {
+        (reason?: any): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSinkCloseCallback {
+        (): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSinkStartCallback {
+        (controller: WritableStreamDefaultController): any;
+    }
+
+    interface UnderlyingSinkWriteCallback<W> {
+        (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSourceCancelCallback {
+        (reason?: any): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSourcePullCallback<R> {
+        (controller: ReadableStreamController<R>): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingSourceStartCallback<R> {
+        (controller: ReadableStreamController<R>): any;
+    }
+
+    interface TransformerFlushCallback<O> {
+        (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+    }
+
+    interface TransformerStartCallback<O> {
+        (controller: TransformStreamDefaultController<O>): any;
+    }
+
+    interface TransformerTransformCallback<I, O> {
+        (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+    }
+
+    interface UnderlyingByteSource {
+        autoAllocateChunkSize?: number;
+        cancel?: ReadableStreamErrorCallback;
+        pull?: ReadableByteStreamControllerCallback;
+        start?: ReadableByteStreamControllerCallback;
+        type: 'bytes';
+    }
+
+    interface UnderlyingSource<R = any> {
+        cancel?: UnderlyingSourceCancelCallback;
+        pull?: UnderlyingSourcePullCallback<R>;
+        start?: UnderlyingSourceStartCallback<R>;
+        type?: undefined;
+    }
+
+    interface UnderlyingSink<W = any> {
+        abort?: UnderlyingSinkAbortCallback;
+        close?: UnderlyingSinkCloseCallback;
+        start?: UnderlyingSinkStartCallback;
+        type?: undefined;
+        write?: UnderlyingSinkWriteCallback<W>;
+    }
+
+    interface ReadableStreamErrorCallback {
+        (reason: any): void | PromiseLike<void>;
+    }
+
+    /** This Streams API interface represents a readable stream of byte data. */
+    interface ReadableStream<R = any> {
+        readonly locked: boolean;
+        cancel(reason?: any): Promise<void>;
+        getReader(): ReadableStreamDefaultReader<R>;
+        pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
+        pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
+        tee(): [ReadableStream<R>, ReadableStream<R>];
+        [Symbol.asyncIterator](options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+    }
+
+    const ReadableStream: {
+        prototype: ReadableStream;
+        new (
+            underlyingSource: UnderlyingByteSource,
+            strategy?: QueuingStrategy<Uint8Array>,
+        ): ReadableStream<Uint8Array>;
+        new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
+    };
+
+    interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
+        read(): Promise<ReadableStreamDefaultReadResult<R>>;
+        releaseLock(): void;
+    }
+
+    const ReadableStreamDefaultReader: {
+        prototype: ReadableStreamDefaultReader;
+        new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
+    };
+
+    const ReadableStreamBYOBReader: any;
+    const ReadableStreamBYOBRequest: any;
+
+    interface ReadableByteStreamController {
+        readonly byobRequest: undefined;
+        readonly desiredSize: number | null;
+        close(): void;
+        enqueue(chunk: ArrayBufferView): void;
+        error(error?: any): void;
+    }
+
+    const ReadableByteStreamController: {
+        prototype: ReadableByteStreamController;
+        new (): ReadableByteStreamController;
+    };
+
+    interface ReadableStreamDefaultController<R = any> {
+        readonly desiredSize: number | null;
+        close(): void;
+        enqueue(chunk?: R): void;
+        error(e?: any): void;
+    }
+
+    const ReadableStreamDefaultController: {
+        prototype: ReadableStreamDefaultController;
+        new (): ReadableStreamDefaultController;
+    };
+
+    interface Transformer<I = any, O = any> {
+        flush?: TransformerFlushCallback<O>;
+        readableType?: undefined;
+        start?: TransformerStartCallback<O>;
+        transform?: TransformerTransformCallback<I, O>;
+        writableType?: undefined;
+    }
+
+    interface TransformStream<I = any, O = any> {
+        readonly readable: ReadableStream<O>;
+        readonly writable: WritableStream<I>;
+    }
+
+    const TransformStream: {
+        prototype: TransformStream;
+        new <I = any, O = any>(
+            transformer?: Transformer<I, O>,
+            writableStrategy?: QueuingStrategy<I>,
+            readableStrategy?: QueuingStrategy<O>,
+        ): TransformStream<I, O>;
+    };
+
+    interface TransformStreamDefaultController<O = any> {
+        readonly desiredSize: number | null;
+        enqueue(chunk?: O): void;
+        error(reason?: any): void;
+        terminate(): void;
+    }
+
+    const TransformStreamDefaultController: {
+        prototype: TransformStreamDefaultController;
+        new (): TransformStreamDefaultController;
+    };
+
+    /**
+     * This Streams API interface provides a standard abstraction for writing
+     * streaming data to a destination, known as a sink. This object comes with
+     * built-in back pressure and queuing.
+     */
+    interface WritableStream<W = any> {
+        readonly locked: boolean;
+        abort(reason?: any): Promise<void>;
+        close(): Promise<void>;
+        getWriter(): WritableStreamDefaultWriter<W>;
+    }
+
+    const WritableStream: {
+        prototype: WritableStream;
+        new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
+    };
+
+    /**
+     * This Streams API interface is the object returned by
+     * WritableStream.getWriter() and once created locks the < writer to the
+     * WritableStream ensuring that no other streams can write to the underlying
+     * sink.
+     */
+    interface WritableStreamDefaultWriter<W = any> {
+        readonly closed: Promise<undefined>;
+        readonly desiredSize: number | null;
+        readonly ready: Promise<undefined>;
+        abort(reason?: any): Promise<void>;
+        close(): Promise<void>;
+        releaseLock(): void;
+        write(chunk?: W): Promise<void>;
+    }
+
+    const WritableStreamDefaultWriter: {
+        prototype: WritableStreamDefaultWriter;
+        new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
+    };
+
+    /**
+     * This Streams API interface represents a controller allowing control of a
+     * WritableStream's state. When constructing a WritableStream, the
+     * underlying sink is given a corresponding WritableStreamDefaultController
+     * instance to manipulate.
+     */
+    interface WritableStreamDefaultController {
+        error(e?: any): void;
+    }
+
+    const WritableStreamDefaultController: {
+        prototype: WritableStreamDefaultController;
+        new (): WritableStreamDefaultController;
+    };
+
+    interface QueuingStrategy<T = any> {
+        highWaterMark?: number;
+        size?: QueuingStrategySize<T>;
+    }
+
+    interface QueuingStrategySize<T = any> {
+        (chunk?: T): number;
+    }
+
+    interface QueuingStrategyInit {
+        /**
+         * Creates a new ByteLengthQueuingStrategy with the provided high water
+         * mark.
+         *
+         * Note that the provided high water mark will not be validated ahead of
+         * time. Instead, if it is negative, NaN, or not a number, the resulting
+         * ByteLengthQueuingStrategy will cause the corresponding stream
+         * constructor to throw.
+         */
+        highWaterMark: number;
+    }
+
+    /**
+     * This Streams API interface provides a built-in byte length queuing
+     * strategy that can be used when constructing streams.
+     */
+    interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
+        readonly highWaterMark: number;
+        readonly size: QueuingStrategySize<ArrayBufferView>;
+    }
+
+    const ByteLengthQueuingStrategy: {
+        prototype: ByteLengthQueuingStrategy;
+        new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
+    };
+
+    /**
+     * This Streams API interface provides a built-in byte length queuing
+     * strategy that can be used when constructing streams.
+     */
+    interface CountQueuingStrategy extends QueuingStrategy {
+        readonly highWaterMark: number;
+        readonly size: QueuingStrategySize;
+    }
+
+    const CountQueuingStrategy: {
+        prototype: CountQueuingStrategy;
+        new (init: QueuingStrategyInit): CountQueuingStrategy;
+    };
+
+    interface TextEncoderStream {
+        /** Returns "utf-8". */
+        readonly encoding: 'utf-8';
+        readonly readable: ReadableStream<Uint8Array>;
+        readonly writable: WritableStream<string>;
+        readonly [Symbol.toStringTag]: string;
+    }
+
+    const TextEncoderStream: {
+        prototype: TextEncoderStream;
+        new (): TextEncoderStream;
+    };
+
+    interface TextDecoderOptions {
+        fatal?: boolean;
+        ignoreBOM?: boolean;
+    }
+
+    type BufferSource = ArrayBufferView | ArrayBuffer;
+
+    interface TextDecoderStream {
+        /** Returns encoding's name, lower cased. */
+        readonly encoding: string;
+        /** Returns `true` if error mode is "fatal", and `false` otherwise. */
+        readonly fatal: boolean;
+        /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
+        readonly ignoreBOM: boolean;
+        readonly readable: ReadableStream<string>;
+        readonly writable: WritableStream<BufferSource>;
+        readonly [Symbol.toStringTag]: string;
+    }
+
+    const TextDecoderStream: {
+        prototype: TextDecoderStream;
+        new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
+    };
 }
 declare module 'node:stream/web' {
     export * from 'stream/web';

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

@@ -71,6 +71,30 @@ declare module 'url' {
     function parse(urlString: string, parseQueryString: false | undefined, slashesDenoteHost?: boolean): UrlWithStringQuery;
     function parse(urlString: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
     function parse(urlString: string, parseQueryString: boolean, slashesDenoteHost?: boolean): Url;
+    /**
+     * The URL object has both a `toString()` method and `href` property that return string serializations of the URL.
+     * These are not, however, customizable in any way. The `url.format(URL[, options])` method allows for basic
+     * customization of the output.
+     * Returns a customizable serialization of a URL `String` representation of a `WHATWG URL` object.
+     *
+     * ```js
+     * import url from 'url';
+     * const myURL = new URL('https://a:b@測試?abc#foo');
+     *
+     * console.log(myURL.href);
+     * // Prints https://a:b@xn--g6w251d/?abc#foo
+     *
+     * console.log(myURL.toString());
+     * // Prints https://a:b@xn--g6w251d/?abc#foo
+     *
+     * console.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));
+     * // Prints 'https://測試/?abc'
+     * ```
+     * @since v7.6.0
+     * @param urlObject A `WHATWG URL` object
+     * @param options
+     */
+    function format(urlObject: URL, options?: URLFormatOptions): string;
     /**
      * The `url.format()` method returns a formatted URL string derived from`urlObject`.
      *
@@ -134,7 +158,6 @@ declare module 'url' {
      * @deprecated Legacy: Use the WHATWG URL API instead.
      * @param urlObject A URL object (as returned by `url.parse()` or constructed otherwise). If a string, it is converted to an object by passing it to `url.parse()`.
      */
-    function format(urlObject: URL, options?: URLFormatOptions): string;
     function format(urlObject: UrlObject | string): string;
     /**
      * The `url.resolve()` method resolves a target URL relative to a base URL in a

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

@@ -113,6 +113,20 @@ declare module 'util' {
      * @since v10.0.0
      */
     export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    /**
+     * Returns the string name for a numeric error code that comes from a Node.js API.
+     * The mapping between error codes and error names is platform-dependent.
+     * See `Common System Errors` for the names of common errors.
+     *
+     * ```js
+     * fs.access('file/that/does/not/exist', (err) => {
+     *   const name = util.getSystemErrorName(err.errno);
+     *   console.error(name);  // ENOENT
+     * });
+     * ```
+     * @since v9.7.0
+     */
+    export function getSystemErrorName(err: number): string;
     /**
      * Returns a Map of all system error codes available from the Node.js API.
      * The mapping between error codes and error names is platform-dependent.
@@ -314,6 +328,9 @@ declare module 'util' {
          * Allows changing inspect settings from the repl.
          */
         let replDefaults: InspectOptions;
+        /**
+         * That can be used to declare custom inspect functions.
+         */
         const custom: unique symbol;
     }
     /**
@@ -520,6 +537,7 @@ declare module 'util' {
      * @return The logging function
      */
     export function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger;
+    export const debug: typeof debuglog;
     /**
      * Returns `true` if the given `object` is a `Boolean`. Otherwise, returns `false`.
      *
@@ -789,6 +807,16 @@ declare module 'util' {
      * @since v9.0.0
      */
     export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean;
+    /**
+     * Returns `str` with any ANSI escape codes removed.
+     *
+     * ```js
+     * console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
+     * // Prints "value"
+     * ```
+     * @since v16.11.0
+     */
+    export function stripVTControlCharacters(str: string): string;
     /**
      * Takes an `async` function (or a function that returns a `Promise`) and returns a
      * function following the error-first callback style, i.e. taking
@@ -961,6 +989,9 @@ declare module 'util' {
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>;
     export function promisify(fn: Function): Function;
     export namespace promisify {
+        /**
+         * That can be used to declare custom promisified variants of functions.
+         */
         const custom: unique symbol;
     }
     /**

package/node_modules/@types/keyv/node_modules/@types/node/README.md

@@ -8,9 +8,9 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Tue, 05 Oct 2021 20:31:28 GMT
+ * Last updated: Tue, 30 Nov 2021 01:01:04 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`
 
 # Credits
-These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Minh Son Nguyen](https://github.com/nguymin4), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Surasak Chaisurin](https://github.com/Ryan-Willpower), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), and [wafuwafu13](https://github.com/wafuwafu13).
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Seth Westphal](https://github.com/westy92), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Surasak Chaisurin](https://github.com/Ryan-Willpower), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), and [wafuwafu13](https://github.com/wafuwafu13).

package/node_modules/@types/keyv/node_modules/@types/node/child_process.d.ts

@@ -789,6 +789,7 @@ declare module 'child_process' {
     function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptions): ChildProcess;
     interface ExecOptions extends CommonOptions {
         shell?: string | undefined;
+        signal?: AbortSignal | undefined;
         maxBuffer?: number | undefined;
         killSignal?: NodeJS.Signals | number | undefined;
     }

package/node_modules/@types/keyv/node_modules/@types/node/crypto.d.ts

@@ -1175,7 +1175,7 @@ declare module 'crypto' {
      *   generateKeySync
      * } = await import('crypto');
      *
-     * const key = generateKeySync('hmac', 64);
+     * const key = generateKeySync('hmac', { length: 64 });
      * console.log(key.export().toString('hex'));  // e89..........41e
      * ```
      * @since v15.0.0

package/node_modules/@types/keyv/node_modules/@types/node/dgram.d.ts

@@ -166,17 +166,17 @@ declare module 'dgram' {
          * @since v0.1.99
          * @param callback with no parameters. Called when binding is complete.
          */
-        bind(port?: number, address?: string, callback?: () => void): void;
-        bind(port?: number, callback?: () => void): void;
-        bind(callback?: () => void): void;
-        bind(options: BindOptions, callback?: () => void): void;
+        bind(port?: number, address?: string, callback?: () => void): this;
+        bind(port?: number, callback?: () => void): this;
+        bind(callback?: () => void): this;
+        bind(options: BindOptions, callback?: () => void): this;
         /**
          * Close the underlying socket and stop listening for data on it. If a callback is
          * provided, it is added as a listener for the `'close'` event.
          * @since v0.1.99
          * @param callback Called when the socket has been closed.
          */
-        close(callback?: () => void): void;
+        close(callback?: () => void): this;
         /**
          * Associates the `dgram.Socket` to a remote address and port. Every
          * message sent by this handle is automatically sent to that destination. Also,
@@ -414,7 +414,7 @@ declare module 'dgram' {
          * This method throws `EBADF` if called on an unbound socket.
          * @since v0.3.8
          */
-        setMulticastLoopback(flag: boolean): void;
+        setMulticastLoopback(flag: boolean): boolean;
         /**
          * Sets the `IP_MULTICAST_TTL` socket option. While TTL generally stands for
          * "Time to Live", in this context it specifies the number of IP hops that a
@@ -427,7 +427,7 @@ declare module 'dgram' {
          * This method throws `EBADF` if called on an unbound socket.
          * @since v0.3.8
          */
-        setMulticastTTL(ttl: number): void;
+        setMulticastTTL(ttl: number): number;
         /**
          * Sets the `SO_RCVBUF` socket option. Sets the maximum socket receive buffer
          * in bytes.
@@ -457,7 +457,7 @@ declare module 'dgram' {
          * This method throws `EBADF` if called on an unbound socket.
          * @since v0.1.101
          */
-        setTTL(ttl: number): void;
+        setTTL(ttl: number): number;
         /**
          * By default, binding a socket will cause it to block the Node.js process from
          * exiting as long as the socket is open. The `socket.unref()` method can be used