cloudstructs 0.6.10 → 0.6.11

package/node_modules/@slack/logger/node_modules/@types/node/https.d.ts

@@ -8,7 +8,10 @@ declare module 'https' {
     import * as tls from 'node:tls';
     import * as http from 'node:http';
     import { URL } from 'node:url';
-    type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
+    type ServerOptions<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
     type RequestOptions = http.RequestOptions &
         tls.SecureContextOptions & {
             rejectUnauthorized?: boolean | undefined; // Defaults to true
@@ -26,14 +29,23 @@ declare module 'https' {
         constructor(options?: AgentOptions);
         options: AgentOptions;
     }
-    interface Server extends http.Server {}
+    interface Server<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > extends http.Server<Request, Response> {}
     /**
      * See `http.Server` for more information.
      * @since v0.3.4
      */
-    class Server extends tls.Server {
-        constructor(requestListener?: http.RequestListener);
-        constructor(options: ServerOptions, requestListener?: http.RequestListener);
+    class Server<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    > extends tls.Server {
+        constructor(requestListener?: http.RequestListener<Request, Response>);
+        constructor(
+            options: ServerOptions<Request, Response>,
+            requestListener?: http.RequestListener<Request, Response>,
+        );
         /**
          * Closes all connections connected to this server.
          * @since v18.2.0
@@ -46,25 +58,54 @@ declare module 'https' {
         closeIdleConnections(): void;
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        addListener(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        addListener(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        addListener(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         addListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         addListener(event: 'close', listener: () => void): this;
         addListener(event: 'connection', listener: (socket: Duplex) => void): this;
         addListener(event: 'error', listener: (err: Error) => void): this;
         addListener(event: 'listening', listener: () => void): this;
-        addListener(event: 'checkContinue', listener: http.RequestListener): this;
-        addListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        addListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        addListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        addListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        addListener(event: 'request', listener: http.RequestListener): this;
-        addListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        addListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        addListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        addListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
         emit(event: string, ...args: any[]): boolean;
         emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
-        emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
-        emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
+        emit(
+            event: 'newSession',
+            sessionId: Buffer,
+            sessionData: Buffer,
+            callback: (err: Error, resp: Buffer) => void,
+        ): boolean;
+        emit(
+            event: 'OCSPRequest',
+            certificate: Buffer,
+            issuer: Buffer,
+            callback: (err: Error | null, resp: Buffer) => void,
+        ): boolean;
         emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
         emit(event: 'secureConnection', tlsSocket: tls.TLSSocket): boolean;
         emit(event: 'tlsClientError', err: Error, tlsSocket: tls.TLSSocket): boolean;
@@ -72,80 +113,156 @@ declare module 'https' {
         emit(event: 'connection', socket: Duplex): boolean;
         emit(event: 'error', err: Error): boolean;
         emit(event: 'listening'): boolean;
-        emit(event: 'checkContinue', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'checkExpectation', req: http.IncomingMessage, res: http.ServerResponse): boolean;
+        emit(
+            event: 'checkContinue',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
+        emit(
+            event: 'checkExpectation',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
         emit(event: 'clientError', err: Error, socket: Duplex): boolean;
-        emit(event: 'connect', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
-        emit(event: 'request', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'upgrade', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
+        emit(event: 'connect', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
+        emit(
+            event: 'request',
+            req: InstanceType<Request>,
+            res: InstanceType<Response> & { req: InstanceType<Request> },
+        ): boolean;
+        emit(event: 'upgrade', req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        on(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        on(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        on(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         on(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         on(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         on(event: 'close', listener: () => void): this;
         on(event: 'connection', listener: (socket: Duplex) => void): this;
         on(event: 'error', listener: (err: Error) => void): this;
         on(event: 'listening', listener: () => void): this;
-        on(event: 'checkContinue', listener: http.RequestListener): this;
-        on(event: 'checkExpectation', listener: http.RequestListener): this;
+        on(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        on(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         on(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        on(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        on(event: 'request', listener: http.RequestListener): this;
-        on(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        on(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        on(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        on(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        once(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        once(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        once(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         once(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         once(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         once(event: 'close', listener: () => void): this;
         once(event: 'connection', listener: (socket: Duplex) => void): this;
         once(event: 'error', listener: (err: Error) => void): this;
         once(event: 'listening', listener: () => void): this;
-        once(event: 'checkContinue', listener: http.RequestListener): this;
-        once(event: 'checkExpectation', listener: http.RequestListener): this;
+        once(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        once(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         once(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        once(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        once(event: 'request', listener: http.RequestListener): this;
-        once(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        once(event: 'connect', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
+        once(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        once(event: 'upgrade', listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        prependListener(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        prependListener(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        prependListener(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         prependListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         prependListener(event: 'close', listener: () => void): this;
         prependListener(event: 'connection', listener: (socket: Duplex) => void): this;
         prependListener(event: 'error', listener: (err: Error) => void): this;
         prependListener(event: 'listening', listener: () => void): this;
-        prependListener(event: 'checkContinue', listener: http.RequestListener): this;
-        prependListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        prependListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        prependListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependListener(event: 'request', listener: http.RequestListener): this;
-        prependListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        prependListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        prependListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
+        prependOnceListener(
+            event: 'newSession',
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
+        ): this;
+        prependOnceListener(
+            event: 'OCSPRequest',
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        prependOnceListener(
+            event: 'resumeSession',
+            listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
+        ): this;
         prependOnceListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
         prependOnceListener(event: 'close', listener: () => void): this;
         prependOnceListener(event: 'connection', listener: (socket: Duplex) => void): this;
         prependOnceListener(event: 'error', listener: (err: Error) => void): this;
         prependOnceListener(event: 'listening', listener: () => void): this;
-        prependOnceListener(event: 'checkContinue', listener: http.RequestListener): this;
-        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener): this;
+        prependOnceListener(event: 'checkContinue', listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener<Request, Response>): this;
         prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependOnceListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: 'request', listener: http.RequestListener): this;
-        prependOnceListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
+        prependOnceListener(
+            event: 'connect',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
+        prependOnceListener(event: 'request', listener: http.RequestListener<Request, Response>): this;
+        prependOnceListener(
+            event: 'upgrade',
+            listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
+        ): this;
     }
     /**
      * ```js
@@ -184,8 +301,17 @@ declare module 'https' {
      * @param options Accepts `options` from `createServer`, `createSecureContext` and `createServer`.
      * @param requestListener A listener to be added to the `'request'` event.
      */
-    function createServer(requestListener?: http.RequestListener): Server;
-    function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
+    function createServer<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    >(requestListener?: http.RequestListener<Request, Response>): Server<Request, Response>;
+    function createServer<
+        Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
+        Response extends typeof http.ServerResponse = typeof http.ServerResponse,
+    >(
+        options: ServerOptions<Request, Response>,
+        requestListener?: http.RequestListener<Request, Response>,
+    ): Server<Request, Response>;
     /**
      * Makes a request to a secure web server.
      *
@@ -366,8 +492,15 @@ declare module 'https' {
      * @since v0.3.6
      * @param options Accepts all `options` from `request`, with some differences in default values:
      */
-    function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function request(
+        options: RequestOptions | string | URL,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
+    function request(
+        url: string | URL,
+        options: RequestOptions,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
     /**
      * Like `http.get()` but for HTTPS.
      *
@@ -392,8 +525,15 @@ declare module 'https' {
      * @since v0.3.6
      * @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`.
      */
-    function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
+    function get(
+        options: RequestOptions | string | URL,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
+    function get(
+        url: string | URL,
+        options: RequestOptions,
+        callback?: (res: http.IncomingMessage) => void,
+    ): http.ClientRequest;
     let globalAgent: Agent;
 }
 declare module 'node:https' {

package/node_modules/@slack/logger/node_modules/@types/node/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for non-npm package Node.js 18.7
+// Type definitions for non-npm package Node.js 18.11
 // Project: https://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>
@@ -67,7 +67,7 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support NodeJS and TypeScript 3.7+.
+// NOTE: These definitions support NodeJS and TypeScript 4.9+.
 
 // Reference required types from the default lib:
 /// <reference lib="es2020" />
@@ -92,6 +92,7 @@
 /// <reference path="dns/promises.d.ts" />
 /// <reference path="dns/promises.d.ts" />
 /// <reference path="domain.d.ts" />
+/// <reference path="dom-events.d.ts" />
 /// <reference path="events.d.ts" />
 /// <reference path="fs.d.ts" />
 /// <reference path="fs/promises.d.ts" />

package/node_modules/@slack/logger/node_modules/@types/node/net.d.ts

@@ -54,6 +54,9 @@ declare module 'net' {
         hints?: number | undefined;
         family?: number | undefined;
         lookup?: LookupFunction | undefined;
+        noDelay?: boolean | undefined;
+        keepAlive?: boolean | undefined;
+        keepAliveInitialDelay?: number | undefined;
     }
     interface IpcSocketConnectOpts extends ConnectOpts {
         path: string;
@@ -128,6 +131,17 @@ declare module 'net' {
          * @return The socket itself.
          */
         pause(): this;
+        /**
+         * Close the TCP connection by sending an RST packet and destroy the stream.
+         * If this TCP socket is in connecting status, it will send an RST packet
+         * and destroy this TCP socket once it is connected. Otherwise, it will call
+         * `socket.destroy` with an `ERR_SOCKET_CLOSED` Error. If this is not a TCP socket
+         * (for example, a pipe), calling this method will immediately throw
+         * an `ERR_INVALID_HANDLE_TYPE` Error.
+         * @since v18.3.0
+         * @return The socket itself.
+         */
+        resetAndDestroy(): this;
         /**
          * Resumes reading after a call to `socket.pause()`.
          * @return The socket itself.
@@ -263,6 +277,11 @@ declare module 'net' {
          * @since v0.9.6
          */
         readonly localPort?: number;
+        /**
+         * The string representation of the local IP family. `'IPv4'` or `'IPv6'`.
+         * @since v18.8.0
+         */
+        readonly localFamily?: string;
         /**
          * This property represents the state of the connection as a string.
          * @see {https://nodejs.org/api/net.html#socketreadystate}
@@ -312,7 +331,8 @@ declare module 'net' {
          *   5. end
          *   6. error
          *   7. lookup
-         *   8. timeout
+         *   8. ready
+         *   9. timeout
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'close', listener: (hadError: boolean) => void): this;
@@ -399,6 +419,33 @@ declare module 'net' {
          * @default false
          */
         pauseOnConnect?: boolean | undefined;
+        /**
+         * If set to `true`, it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
+         * @default false
+         * @since v16.5.0
+         */
+        noDelay?: boolean | undefined;
+        /**
+         * If set to `true`, it enables keep-alive functionality on the socket immediately after a new incoming connection is received,
+         * similarly on what is done in `socket.setKeepAlive([enable][, initialDelay])`.
+         * @default false
+         * @since v16.5.0
+         */
+        keepAlive?: boolean | undefined;
+        /**
+         * If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
+         * @default 0
+         * @since v16.5.0
+         */
+        keepAliveInitialDelay?: number | undefined;
+    }
+    interface DropArgument {
+        localAddress?: string;
+        localPort?: number;
+        localFamily?: string;
+        remoteAddress?: string;
+        remotePort?: number;
+        remoteFamily?: string;
     }
     /**
      * This class is used to create a TCP or `IPC` server.
@@ -536,37 +583,44 @@ declare module 'net' {
          *   2. connection
          *   3. error
          *   4. listening
+         *   5. drop
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: 'close', listener: () => void): this;
         addListener(event: 'connection', listener: (socket: Socket) => void): this;
         addListener(event: 'error', listener: (err: Error) => void): this;
         addListener(event: 'listening', listener: () => void): this;
+        addListener(event: 'drop', listener: (data?: DropArgument) => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: 'close'): boolean;
         emit(event: 'connection', socket: Socket): boolean;
         emit(event: 'error', err: Error): boolean;
         emit(event: 'listening'): boolean;
+        emit(event: 'drop', data?: DropArgument): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: 'close', listener: () => void): this;
         on(event: 'connection', listener: (socket: Socket) => void): this;
         on(event: 'error', listener: (err: Error) => void): this;
         on(event: 'listening', listener: () => void): this;
+        on(event: 'drop', listener: (data?: DropArgument) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: 'close', listener: () => void): this;
         once(event: 'connection', listener: (socket: Socket) => void): this;
         once(event: 'error', listener: (err: Error) => void): this;
         once(event: 'listening', listener: () => void): this;
+        once(event: 'drop', listener: (data?: DropArgument) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: 'close', listener: () => void): this;
         prependListener(event: 'connection', listener: (socket: Socket) => void): this;
         prependListener(event: 'error', listener: (err: Error) => void): this;
         prependListener(event: 'listening', listener: () => void): this;
+        prependListener(event: 'drop', listener: (data?: DropArgument) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: 'close', listener: () => void): this;
         prependOnceListener(event: 'connection', listener: (socket: Socket) => void): this;
         prependOnceListener(event: 'error', listener: (err: Error) => void): this;
         prependOnceListener(event: 'listening', listener: () => void): this;
+        prependOnceListener(event: 'drop', listener: (data?: DropArgument) => void): this;
     }
     type IPVersion = 'ipv4' | 'ipv6';
     /**
@@ -792,7 +846,6 @@ declare module 'net' {
     class SocketAddress {
         constructor(options: SocketAddressInitOptions);
         /**
-         * Either \`'ipv4'\` or \`'ipv6'\`.
          * @since v15.14.0, v14.18.0
          */
         readonly address: string;

package/node_modules/@slack/logger/node_modules/@types/node/os.d.ts

@@ -28,6 +28,7 @@ declare module 'os' {
     }
     interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
         family: 'IPv4';
+        scopeid?: undefined;
     }
     interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
         family: 'IPv6';
@@ -413,6 +414,15 @@ declare module 'os' {
      * @since v0.5.0
      */
     function platform(): NodeJS.Platform;
+    /**
+     * Returns the machine type as a string, such as arm, aarch64, mips, mips64, ppc64, ppc64le, s390, s390x, i386, i686, x86_64.
+     *
+     * On POSIX systems, the machine type is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname).
+     * On Windows, `RtlGetVersion()` is used, and if it is not available, `GetVersionExW()` will be used.
+     * See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
+     * @since v18.9.0
+     */
+    function machine(): string;
     /**
      * Returns the operating system's default directory for temporary files as a
      * string.

package/node_modules/@slack/logger/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.7.10",
+    "version": "18.11.8",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -213,6 +213,13 @@
     ],
     "main": "",
     "types": "index.d.ts",
+    "typesVersions": {
+        "<4.9.0-0": {
+            "*": [
+                "ts4.8/*"
+            ]
+        }
+    },
     "repository": {
         "type": "git",
         "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
@@ -220,6 +227,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "2276f7706b7dc01b87e597a7f6d2139aef6178472539ee3b171167046b8c8182",
-    "typeScriptVersion": "4.0"
+    "typesPublisherContentHash": "a23a6d5ceb48ac0215ccd7cba47e75f2a3ae678b228d576c89294138777a2847",
+    "typeScriptVersion": "4.1"
 }

package/node_modules/@slack/logger/node_modules/@types/node/path.d.ts

@@ -122,10 +122,10 @@ declare module 'path' {
              * Often used to extract the file name from a fully qualified path.
              *
              * @param path the path to evaluate.
-             * @param ext optionally, an extension to remove from the result.
+             * @param suffix optionally, an extension to remove from the result.
              * @throws {TypeError} if `path` is not a string or if `ext` is given and is not a string.
              */
-            basename(path: string, ext?: string): string;
+            basename(path: string, suffix?: string): string;
             /**
              * Return the extension of the path, from the last '.' to end of string in the last portion of the path.
              * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
@@ -137,11 +137,11 @@ declare module 'path' {
             /**
              * The platform-specific file separator. '\\' or '/'.
              */
-            readonly sep: string;
+            readonly sep: '\\' | '/';
             /**
              * The platform-specific file delimiter. ';' or ':'.
              */
-            readonly delimiter: string;
+            readonly delimiter: ';' | ':';
             /**
              * Returns an object from a path string - the opposite of format().
              *

package/node_modules/@slack/logger/node_modules/@types/node/perf_hooks.d.ts

@@ -604,6 +604,21 @@ declare module 'perf_hooks' {
      * @since v15.9.0, v14.18.0
      */
     function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
+
+    import { performance as _performance } from 'perf_hooks';
+    global {
+        /**
+         * `performance` is a global reference for `require('perf_hooks').performance`
+         * https://nodejs.org/api/globals.html#performance
+         * @since v16.0.0
+         */
+        var performance: typeof globalThis extends {
+            onmessage: any;
+            performance: infer T;
+        }
+            ? T
+            : typeof _performance;
+    }
 }
 declare module 'node:perf_hooks' {
     export * from 'perf_hooks';

package/node_modules/@slack/logger/node_modules/@types/node/process.d.ts

@@ -97,7 +97,7 @@ declare module 'process' {
             type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => 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.
+             * as *anything* can be thrown/rejected, it is therefore unsafe to assume that the value is an Error.
              */
             type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void;
             type WarningListener = (warning: Error) => void;

package/node_modules/@slack/logger/node_modules/@types/node/querystring.d.ts

@@ -6,9 +6,9 @@
  * const querystring = require('querystring');
  * ```
  *
- * The `querystring` API is considered Legacy. While it is still maintained,
- * new code should use the `URLSearchParams` API instead.
- * @deprecated Legacy
+ * `querystring` is more performant than `URLSearchParams` but is not a
+ * standardized API. Use `URLSearchParams` when performance is not critical
+ * or when compatibility with browser code is desirable.
  * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/querystring.js)
  */
 declare module 'querystring' {