aws-delivlib 15.2.0 → 15.3.0

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/fs.d.ts

@@ -1,23 +1,3 @@
-/**
- * The `node:fs` module enables interacting with the file system in a
- * way modeled on standard POSIX functions.
- *
- * To use the promise-based APIs:
- *
- * ```js
- * import * as fs from 'node:fs/promises';
- * ```
- *
- * To use the callback and sync APIs:
- *
- * ```js
- * import * as fs from 'node:fs';
- * ```
- *
- * All file system operations have synchronous, callback, and promise-based
- * forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/fs.js)
- */
 declare module "node:fs" {
     import { NonSharedBuffer } from "node:buffer";
     import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
@@ -400,7 +380,8 @@ declare module "node:fs" {
         "ready": [];
     }
     /**
-     * Instances of `fs.ReadStream` are created and returned using the {@link createReadStream} function.
+     * Instances of `fs.ReadStream` cannot be constructed directly. They are created and
+     * returned using the `fs.createReadStream()` function.
      * @since v0.1.93
      */
     class ReadStream extends stream.Readable {
@@ -663,7 +644,8 @@ declare module "node:fs" {
         "ready": [];
     }
     /**
-     * Instances of `fs.WriteStream` are created and returned using the {@link createWriteStream} function.
+     * Instances of `fs.WriteStream` cannot be constructed directly. They are created and
+     * returned using the `fs.createWriteStream()` function.
      * @since v0.1.93
      */
     class WriteStream extends stream.Writable {
@@ -1164,6 +1146,7 @@ declare module "node:fs" {
         options:
             | (StatOptions & {
                 bigint?: false | undefined;
+                throwIfNoEntry?: true | undefined;
             })
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void,
@@ -1172,33 +1155,82 @@ declare module "node:fs" {
         path: PathLike,
         options: StatOptions & {
             bigint: true;
+            throwIfNoEntry?: true | undefined;
         },
         callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void,
     ): void;
     function stat(
         path: PathLike,
-        options: StatOptions | undefined,
+        options: StatOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry: false;
+        },
+        callback: (err: NodeJS.ErrnoException | null, stats: Stats | undefined) => void,
+    ): void;
+    function stat(
+        path: PathLike,
+        options: StatOptions & {
+            bigint: true;
+            throwIfNoEntry: false;
+        },
+        callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats | undefined) => void,
+    ): void;
+    function stat(
+        path: PathLike,
+        options: StatOptions & {
+            throwIfNoEntry?: true | undefined;
+        },
         callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void,
     ): void;
+    function stat(
+        path: PathLike,
+        options: StatOptions | undefined,
+        callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats | undefined) => void,
+    ): void;
     namespace stat {
+        // TODO: aliased promisify signatures
         /**
          * Asynchronous stat(2) - Get file status.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
          */
+        function __promisify__(path: PathLike): Promise<Stats>;
         function __promisify__(
             path: PathLike,
             options?: StatOptions & {
                 bigint?: false | undefined;
+                throwIfNoEntry?: true | undefined;
             },
         ): Promise<Stats>;
         function __promisify__(
             path: PathLike,
             options: StatOptions & {
                 bigint: true;
+                throwIfNoEntry?: true | undefined;
             },
         ): Promise<BigIntStats>;
-        function __promisify__(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats>;
+        function __promisify__(
+            path: PathLike,
+            options: StatOptions & {
+                bigint?: false | undefined;
+                throwIfNoEntry: false;
+            },
+        ): Promise<Stats | undefined>;
+        function __promisify__(
+            path: PathLike,
+            options: StatOptions & {
+                bigint: true;
+                throwIfNoEntry: false;
+            },
+        ): Promise<BigIntStats | undefined>;
+        function __promisify__(
+            path: PathLike,
+            options: StatOptions & {
+                throwIfNoEntry?: true | undefined;
+            },
+        ): Promise<Stats | BigIntStats>;
+        function __promisify__(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats | undefined>;
     }
+    /** @deprecated This orphaned interface will be removed in a future version. */
     interface StatSyncFn extends Function {
         (path: PathLike, options?: undefined): Stats;
         (
@@ -1240,7 +1272,42 @@ declare module "node:fs" {
      * Synchronous stat(2) - Get file status.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    const statSync: StatSyncFn;
+    function statSync(path: PathLike): Stats;
+    function statSync(
+        path: PathLike,
+        options?: StatOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry?: true | undefined;
+        },
+    ): Stats;
+    function statSync(
+        path: PathLike,
+        options: StatOptions & {
+            bigint: true;
+            throwIfNoEntry?: true | undefined;
+        },
+    ): BigIntStats;
+    function statSync(
+        path: PathLike,
+        options: StatOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry: false;
+        },
+    ): Stats | undefined;
+    function statSync(
+        path: PathLike,
+        options: StatOptions & {
+            bigint: true;
+            throwIfNoEntry: false;
+        },
+    ): BigIntStats | undefined;
+    function statSync(
+        path: PathLike,
+        options: StatOptions & {
+            throwIfNoEntry?: true | undefined;
+        },
+    ): Stats | BigIntStats;
+    function statSync(path: PathLike, options?: StatOptions): Stats | BigIntStats | undefined;
     /**
      * Invokes the callback with the `fs.Stats` for the file descriptor.
      *
@@ -1430,7 +1497,42 @@ declare module "node:fs" {
      * Synchronous lstat(2) - Get file status. Does not dereference symbolic links.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    const lstatSync: StatSyncFn;
+    function lstatSync(path: PathLike): Stats;
+    function lstatSync(
+        path: PathLike,
+        options?: StatOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry?: true | undefined;
+        },
+    ): Stats;
+    function lstatSync(
+        path: PathLike,
+        options: StatOptions & {
+            bigint: true;
+            throwIfNoEntry?: true | undefined;
+        },
+    ): BigIntStats;
+    function lstatSync(
+        path: PathLike,
+        options: StatOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry: false;
+        },
+    ): Stats | undefined;
+    function lstatSync(
+        path: PathLike,
+        options: StatOptions & {
+            bigint: true;
+            throwIfNoEntry: false;
+        },
+    ): BigIntStats | undefined;
+    function lstatSync(
+        path: PathLike,
+        options: StatOptions & {
+            throwIfNoEntry?: true | undefined;
+        },
+    ): Stats | BigIntStats;
+    function lstatSync(path: PathLike, options?: StatOptions): Stats | BigIntStats | undefined;
     /**
      * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail. No arguments other than
      * a possible
@@ -3553,10 +3655,12 @@ declare module "node:fs" {
      */
     function unwatchFile(filename: PathLike, listener?: StatsListener): void;
     function unwatchFile(filename: PathLike, listener?: BigIntStatsListener): void;
+    type WatchIgnorePredicate = string | RegExp | ((filename: string) => boolean);
     interface WatchOptions extends Abortable {
         encoding?: BufferEncoding | "buffer" | undefined;
         persistent?: boolean | undefined;
         recursive?: boolean | undefined;
+        ignore?: WatchIgnorePredicate | readonly WatchIgnorePredicate[] | undefined;
     }
     interface WatchOptionsWithBufferEncoding extends WatchOptions {
         encoding: "buffer";
@@ -4479,10 +4583,10 @@ declare module "node:fs" {
     }
     interface StatOptions {
         bigint?: boolean | undefined;
-    }
-    interface StatSyncOptions extends StatOptions {
         throwIfNoEntry?: boolean | undefined;
     }
+    /** @deprecated This orphaned interface will be removed in a future version. Use `StatOptions` instead. */
+    interface StatSyncOptions extends StatOptions {}
     interface CopyOptionsBase {
         /**
          * Dereference symlinks

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/http.d.ts

@@ -1,44 +1,3 @@
-/**
- * To use the HTTP server and client one must import the `node:http` module.
- *
- * The HTTP interfaces in Node.js are designed to support many features
- * of the protocol which have been traditionally difficult to use.
- * In particular, large, possibly chunk-encoded, messages. The interface is
- * careful to never buffer entire requests or responses, so the
- * user is able to stream data.
- *
- * HTTP message headers are represented by an object like this:
- *
- * ```json
- * { "content-length": "123",
- *   "content-type": "text/plain",
- *   "connection": "keep-alive",
- *   "host": "example.com",
- *   "accept": "*" }
- * ```
- *
- * Keys are lowercased. Values are not modified.
- *
- * In order to support the full spectrum of possible HTTP applications, the Node.js
- * HTTP API is very low-level. It deals with stream handling and message
- * parsing only. It parses a message into headers and body but it does not
- * parse the actual headers or the body.
- *
- * See `message.headers` for details on how duplicate headers are handled.
- *
- * The raw headers as they were received are retained in the `rawHeaders` property, which is an array of `[key, value, key2, value2, ...]`. For
- * example, the previous message header object might have a `rawHeaders` list like the following:
- *
- * ```js
- * [ 'ConTent-Length', '123456',
- *   'content-LENGTH', '123',
- *   'content-type', 'text/plain',
- *   'CONNECTION', 'keep-alive',
- *   'Host', 'example.com',
- *   'accepT', '*' ]
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/http.js)
- */
 declare module "node:http" {
     import { NonSharedBuffer } from "node:buffer";
     import { LookupOptions } from "node:dns";
@@ -954,7 +913,7 @@ declare module "node:http" {
          * been transmitted are equal or not.
          *
          * Attempting to set a header field name or value that contains invalid characters
-         * will result in a \[`Error`\]\[\] being thrown.
+         * will result in a `Error` being thrown.
          * @since v0.1.30
          */
         writeHead(
@@ -1664,7 +1623,7 @@ declare module "node:http" {
          * sockets. Do not modify.
          * @since v0.5.9
          */
-        readonly requests: NodeJS.ReadOnlyDict<IncomingMessage[]>;
+        readonly requests: NodeJS.ReadOnlyDict<ClientRequest[]>;
         constructor(opts?: AgentOptions);
         /**
          * Destroy any sockets that are currently in use by the agent.
@@ -2136,6 +2095,27 @@ declare module "node:http" {
      * @param [max=1000]
      */
     function setMaxIdleHTTPParsers(max: number): void;
+    /**
+     * Dynamically resets the global configurations to enable built-in proxy support for
+     * `fetch()` and `http.request()`/`https.request()` at runtime, as an alternative
+     * to using the `--use-env-proxy` flag or `NODE_USE_ENV_PROXY` environment variable.
+     * It can also be used to override settings configured from the environment variables.
+     *
+     * As this function resets the global configurations, any previously configured
+     * `http.globalAgent`, `https.globalAgent` or undici global dispatcher would be
+     * overridden after this function is invoked. It's recommended to invoke it before any
+     * requests are made and avoid invoking it in the middle of any requests.
+     *
+     * See [Built-in Proxy Support](https://nodejs.org/docs/latest-v25.x/api/http.html#built-in-proxy-support) for details on proxy URL formats and `NO_PROXY`
+     * syntax.
+     * @since v25.4.0
+     * @param proxyEnv An object containing proxy configuration. This accepts the
+     * same options as the `proxyEnv` option accepted by {@link Agent}. **Default:**
+     * `process.env`.
+     * @returns A function that restores the original agent and dispatcher
+     * settings to the state before this `http.setGlobalProxyFromEnv()` is invoked.
+     */
+    function setGlobalProxyFromEnv(proxyEnv?: ProxyEnv): () => void;
     /**
      * Global instance of `Agent` which is used as the default for all HTTP client
      * requests. Diverges from a default `Agent` configuration by having `keepAlive`

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/http2.d.ts

@@ -1,13 +1,3 @@
-/**
- * The `node:http2` module provides an implementation of the [HTTP/2](https://tools.ietf.org/html/rfc7540) protocol.
- * It can be accessed using:
- *
- * ```js
- * import http2 from 'node:http2';
- * ```
- * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/http2.js)
- */
 declare module "node:http2" {
     import { NonSharedBuffer } from "node:buffer";
     import { InternalEventEmitter } from "node:events";
@@ -1252,10 +1242,14 @@ declare module "node:http2" {
     > extends SessionOptions {
         streamResetBurst?: number | undefined;
         streamResetRate?: number | undefined;
+        /** @deprecated Use `http1Options.IncomingMessage` instead. */
         Http1IncomingMessage?: Http1Request | undefined;
+        /** @deprecated Use `http1Options.ServerResponse` instead. */
         Http1ServerResponse?: Http1Response | undefined;
+        http1Options?: Http1Options<Http1Request, Http1Response> | undefined;
         Http2ServerRequest?: Http2Request | undefined;
         Http2ServerResponse?: Http2Response | undefined;
+        strictSingleValueFields?: boolean | undefined;
     }
     interface SecureClientSessionOptions extends ClientSessionOptions, tls.ConnectionOptions {}
     interface SecureServerSessionOptions<
@@ -1279,6 +1273,14 @@ declare module "node:http2" {
         allowHTTP1?: boolean | undefined;
         origins?: string[] | undefined;
     }
+    interface Http1Options<
+        Request extends typeof IncomingMessage,
+        Response extends typeof ServerResponse<InstanceType<Request>>,
+    > {
+        IncomingMessage?: Request | undefined;
+        ServerResponse?: Response | undefined;
+        keepAliveTimeout?: number | undefined;
+    }
     interface Http2ServerCommon {
         setTimeout(msec?: number, callback?: () => void): this;
         /**
@@ -1296,7 +1298,10 @@ declare module "node:http2" {
         "checkContinue": [request: InstanceType<Http2Request>, response: InstanceType<Http2Response>];
         "request": [request: InstanceType<Http2Request>, response: InstanceType<Http2Response>];
         "session": [session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>];
-        "sessionError": [err: Error];
+        "sessionError": [
+            err: Error,
+            session: ServerHttp2Session<Http1Request, Http1Response, Http2Request, Http2Response>,
+        ];
     }
     interface Http2Server<
         Http1Request extends typeof IncomingMessage = typeof IncomingMessage,

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/https.d.ts

@@ -1,8 +1,3 @@
-/**
- * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
- * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/https.js)
- */
 declare module "node:https" {
     import * as http from "node:http";
     import { Duplex } from "node:stream";

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/index.d.ts

@@ -95,6 +95,7 @@
 /// <reference path="sqlite.d.ts" />
 /// <reference path="stream.d.ts" />
 /// <reference path="stream/consumers.d.ts" />
+/// <reference path="stream/iter.d.ts" />
 /// <reference path="stream/promises.d.ts" />
 /// <reference path="stream/web.d.ts" />
 /// <reference path="string_decoder.d.ts" />
@@ -113,3 +114,4 @@
 /// <reference path="wasi.d.ts" />
 /// <reference path="worker_threads.d.ts" />
 /// <reference path="zlib.d.ts" />
+/// <reference path="zlib/iter.d.ts" />

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/inspector/promises.d.ts

@@ -1,9 +1,3 @@
-/**
- * The `node:inspector/promises` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector/promises.js)
- * @since v19.0.0
- */
 declare module "node:inspector/promises" {
     import { EventEmitter } from "node:events";
     export { close, console, NetworkResources, open, url, waitForDebugger } from "node:inspector";

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/inspector.d.ts

@@ -1,8 +1,3 @@
-/**
- * The `node:inspector` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector.js)
- */
 declare module "node:inspector" {
     import { EventEmitter } from "node:events";
     /**
@@ -218,6 +213,51 @@ declare module "node:inspector" {
          */
         function put(url: string, data: string): void;
     }
+    namespace DOMStorage {
+        /**
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+         *
+         * Broadcasts the `DOMStorage.domStorageItemAdded` event to connected frontends.
+         * This event indicates that a new item has been added to the storage.
+         * @since v25.5.0
+         */
+        function domStorageItemAdded(params: DomStorageItemAddedEventDataType): void;
+        /**
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+         *
+         * Broadcasts the `DOMStorage.domStorageItemRemoved` event to connected frontends.
+         * This event indicates that an item has been removed from the storage.
+         * @since v25.5.0
+         */
+        function domStorageItemRemoved(params: DomStorageItemRemovedEventDataType): void;
+        /**
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+
+         * Broadcasts the `DOMStorage.domStorageItemUpdated` event to connected frontends.
+         * This event indicates that a storage item has been updated.
+         * @since v25.5.0
+         */
+        function domStorageItemUpdated(params: DomStorageItemUpdatedEventDataType): void;
+        /**
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+         *
+         * Broadcasts the `DOMStorage.domStorageItemsCleared` event to connected
+         * frontends. This event indicates that all items have been cleared from the
+         * storage.
+         * @since v25.5.0
+         */
+        function domStorageItemsCleared(params: DomStorageItemsClearedEventDataType): void;
+        /**
+         * This feature is only available with the
+         * `--experimental-storage-inspection` flag enabled.
+         * @since v25.5.0
+         */
+        function registerStorage(params: unknown): void;
+    }
 }
 declare module "inspector" {
     export * from "node:inspector";