cdk-ecr-deployment 2.5.30 → 2.5.32

package/node_modules/@types/responselike/node_modules/@types/node/globals.d.ts

@@ -20,9 +20,9 @@ interface ErrorConstructor {
  ------------------------------------------------*/
 
 // For backwards compability
-interface NodeRequire extends NodeJS.Require { }
-interface RequireResolve extends NodeJS.RequireResolve { }
-interface NodeModule extends NodeJS.Module { }
+interface NodeRequire extends NodeJS.Require {}
+interface RequireResolve extends NodeJS.RequireResolve {}
+interface NodeModule extends NodeJS.Module {}
 
 declare var process: NodeJS.Process;
 declare var console: Console;
@@ -41,7 +41,7 @@ declare var exports: any;
  */
 declare var gc: undefined | (() => void);
 
-//#region borrowed
+// #region borrowed
 // from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
 interface AbortController {
@@ -67,24 +67,44 @@ interface AbortSignal extends EventTarget {
     throwIfAborted(): void;
 }
 
-declare var AbortController: typeof globalThis extends {onmessage: any; AbortController: infer T}
-    ? T
+declare var AbortController: typeof globalThis extends { onmessage: any; AbortController: infer T } ? T
     : {
         prototype: AbortController;
         new(): AbortController;
     };
 
-declare var AbortSignal: typeof globalThis extends {onmessage: any; AbortSignal: infer T}
-    ? T
+declare var AbortSignal: typeof globalThis extends { onmessage: any; AbortSignal: infer T } ? T
     : {
         prototype: AbortSignal;
         new(): AbortSignal;
         abort(reason?: any): AbortSignal;
         timeout(milliseconds: number): AbortSignal;
     };
-//#endregion borrowed
+// #endregion borrowed
 
-//#region ArrayLike.at()
+// #region Disposable
+interface SymbolConstructor {
+    /**
+     * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
+     */
+    readonly dispose: unique symbol;
+
+    /**
+     * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
+     */
+    readonly asyncDispose: unique symbol;
+}
+
+interface Disposable {
+    [Symbol.dispose](): void;
+}
+
+interface AsyncDisposable {
+    [Symbol.asyncDispose](): PromiseLike<void>;
+}
+// #endregion Disposable
+
+// #region ArrayLike.at()
 interface RelativeIndexable<T> {
     /**
      * Takes an integer value and returns the item at that index,
@@ -107,7 +127,7 @@ interface Float32Array extends RelativeIndexable<number> {}
 interface Float64Array extends RelativeIndexable<number> {}
 interface BigInt64Array extends RelativeIndexable<bigint> {}
 interface BigUint64Array extends RelativeIndexable<bigint> {}
-//#endregion ArrayLike.at() end
+// #endregion ArrayLike.at() end
 
 /**
  * @since v17.0.0
@@ -116,7 +136,7 @@ interface BigUint64Array extends RelativeIndexable<bigint> {}
  */
 declare function structuredClone<T>(
     value: T,
-    transfer?: { transfer: ReadonlyArray<import('worker_threads').TransferListItem> },
+    transfer?: { transfer: ReadonlyArray<import("worker_threads").TransferListItem> },
 ): T;
 
 /*----------------------------------------------*
@@ -213,7 +233,7 @@ declare namespace NodeJS {
         pause(): this;
         resume(): this;
         isPaused(): boolean;
-        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean | undefined; }): T;
+        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean | undefined }): T;
         unpipe(destination?: WritableStream): this;
         unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
         wrap(oldStream: ReadableStream): this;
@@ -229,7 +249,7 @@ declare namespace NodeJS {
         end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
     }
 
-    interface ReadWriteStream extends ReadableStream, WritableStream { }
+    interface ReadWriteStream extends ReadableStream, WritableStream {}
 
     interface RefCounted {
         ref(): this;
@@ -262,14 +282,14 @@ declare namespace NodeJS {
     }
 
     interface RequireResolve {
-        (id: string, options?: { paths?: string[] | undefined; }): string;
+        (id: string, options?: { paths?: string[] | undefined }): string;
         paths(request: string): string[] | null;
     }
 
     interface RequireExtensions extends Dict<(m: Module, filename: string) => any> {
-        '.js': (m: Module, filename: string) => any;
-        '.json': (m: Module, filename: string) => any;
-        '.node': (m: Module, filename: string) => any;
+        ".js": (m: Module, filename: string) => any;
+        ".json": (m: Module, filename: string) => any;
+        ".node": (m: Module, filename: string) => any;
     }
     interface Module {
         /**
@@ -300,4 +320,62 @@ declare namespace NodeJS {
     interface ReadOnlyDict<T> {
         readonly [key: string]: T | undefined;
     }
+
+    namespace fetch {
+        type _Request = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").Request;
+        type _Response = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").Response;
+        type _FormData = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").FormData;
+        type _Headers = typeof globalThis extends { onmessage: any } ? {} : import("undici-types").Headers;
+        type _RequestInit = typeof globalThis extends { onmessage: any } ? {}
+            : import("undici-types").RequestInit;
+        type Request = globalThis.Request;
+        type Response = globalThis.Response;
+        type Headers = globalThis.Headers;
+        type FormData = globalThis.FormData;
+        type RequestInit = globalThis.RequestInit;
+        type RequestInfo = import("undici-types").RequestInfo;
+        type HeadersInit = import("undici-types").HeadersInit;
+        type BodyInit = import("undici-types").BodyInit;
+        type RequestRedirect = import("undici-types").RequestRedirect;
+        type RequestCredentials = import("undici-types").RequestCredentials;
+        type RequestMode = import("undici-types").RequestMode;
+        type ReferrerPolicy = import("undici-types").ReferrerPolicy;
+        type Dispatcher = import("undici-types").Dispatcher;
+        type RequestDuplex = import("undici-types").RequestDuplex;
+    }
 }
+
+interface RequestInit extends NodeJS.fetch._RequestInit {}
+
+declare function fetch(
+    input: NodeJS.fetch.RequestInfo,
+    init?: RequestInit,
+): Promise<Response>;
+
+interface Request extends NodeJS.fetch._Request {}
+declare var Request: typeof globalThis extends {
+    onmessage: any;
+    Request: infer T;
+} ? T
+    : typeof import("undici-types").Request;
+
+interface Response extends NodeJS.fetch._Response {}
+declare var Response: typeof globalThis extends {
+    onmessage: any;
+    Response: infer T;
+} ? T
+    : typeof import("undici-types").Response;
+
+interface FormData extends NodeJS.fetch._FormData {}
+declare var FormData: typeof globalThis extends {
+    onmessage: any;
+    FormData: infer T;
+} ? T
+    : typeof import("undici-types").FormData;
+
+interface Headers extends NodeJS.fetch._Headers {}
+declare var Headers: typeof globalThis extends {
+    onmessage: any;
+    Headers: infer T;
+} ? T
+    : typeof import("undici-types").Headers;