node-red-contrib-tak-registration 0.11.1 → 0.11.4

package/node_modules/@types/node/module.d.ts

@@ -1,9 +1,10 @@
 /**
  * @since v0.3.7
+ * @experimental
  */
-declare module 'module' {
-    import { URL } from 'node:url';
-    import { MessagePort } from 'node:worker_threads';
+declare module "module" {
+    import { URL } from "node:url";
+    import { MessagePort } from "node:worker_threads";
     namespace Module {
         /**
          * The `module.syncBuiltinESMExports()` method updates all the live bindings for
@@ -64,6 +65,24 @@ declare module 'module' {
             originalLine: number;
             originalColumn: number;
         }
+        interface SourceOrigin {
+            /**
+             * The name of the range in the source map, if one was provided
+             */
+            name?: string;
+            /**
+             * The file name of the original source, as reported in the SourceMap
+             */
+            fileName: string;
+            /**
+             * The 1-indexed lineNumber of the corresponding call site in the original source
+             */
+            lineNumber: number;
+            /**
+             * The 1-indexed columnNumber of the corresponding call site in the original source
+             */
+            columnNumber: number;
+        }
         /**
          * @since v13.7.0, v12.17.0
          */
@@ -92,11 +111,23 @@ declare module 'module' {
              * @param columnOffset The zero-indexed column number offset in the generated source
              */
             findEntry(lineOffset: number, columnOffset: number): SourceMapping;
+            /**
+             * Given a 1-indexed `lineNumber` and `columnNumber` from a call site in the generated source,
+             * find the corresponding call site location in the original source.
+             *
+             * If the `lineNumber` and `columnNumber` provided are not found in any source map,
+             * then an empty object is returned.
+             * @param lineNumber The 1-indexed line number of the call site in the generated source
+             * @param columnNumber The 1-indexed column number of the call site in the generated source
+             */
+            findOrigin(lineNumber: number, columnNumber: number): SourceOrigin | {};
         }
-        interface ImportAssertions extends NodeJS.Dict<string> {
+        /** @deprecated Use `ImportAttributes` instead */
+        interface ImportAssertions extends ImportAttributes {}
+        interface ImportAttributes extends NodeJS.Dict<string> {
             type?: string | undefined;
         }
-        type ModuleFormat = 'builtin' | 'commonjs' | 'json' | 'module' | 'wasm';
+        type ModuleFormat = "builtin" | "commonjs" | "json" | "module" | "wasm";
         type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
         interface GlobalPreloadContext {
             port: MessagePort;
@@ -113,22 +144,26 @@ declare module 'module' {
          */
         type GlobalPreloadHook = (context: GlobalPreloadContext) => string;
         /**
-         * The `initialize` hook provides a way to define a custom function that runs in the loader's thread
-         * when the loader is initialized. Initialization happens when the loader is registered via `register`
-         * or registered via the `--experimental-loader` command line option.
+         * The `initialize` hook provides a way to define a custom function that runs in the hooks thread
+         * when the hooks module is initialized. Initialization happens when the hooks module is registered via `register`.
          *
-         * This hook can send and receive data from a `register` invocation, including ports and other transferrable objects.
+         * This hook can receive data from a `register` invocation, including ports and other transferrable objects.
+         * The return value of `initialize` can be a `Promise`, in which case it will be awaited before the main application thread execution resumes.
          */
-        type InitializeHook<Data = any, ReturnType = any> = (data: Data) => ReturnType;
+        type InitializeHook<Data = any> = (data: Data) => void | Promise<void>;
         interface ResolveHookContext {
             /**
              * Export conditions of the relevant `package.json`
              */
             conditions: string[];
+            /**
+             * @deprecated Use `importAttributes` instead
+             */
+            importAssertions: ImportAttributes;
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: ImportAssertions;
+            importAttributes: ImportAttributes;
             /**
              * The module importing this one, or undefined if this is the Node.js entry point
              */
@@ -140,9 +175,13 @@ declare module 'module' {
              */
             format?: ModuleFormat | null | undefined;
             /**
-             * The import assertions to use when caching the module (optional; if excluded the input will be used)
+             * @deprecated Use `importAttributes` instead
+             */
+            importAssertions?: ImportAttributes | undefined;
+            /**
+             * The import attributes to use when caching the module (optional; if excluded the input will be used)
              */
-            importAssertions?: ImportAssertions | undefined;
+            importAttributes?: ImportAttributes | undefined;
             /**
              * A signal that this hook intends to terminate the chain of `resolve` hooks.
              * @default false
@@ -165,7 +204,10 @@ declare module 'module' {
         type ResolveHook = (
             specifier: string,
             context: ResolveHookContext,
-            nextResolve: (specifier: string, context?: ResolveHookContext) => ResolveFnOutput | Promise<ResolveFnOutput>
+            nextResolve: (
+                specifier: string,
+                context?: ResolveHookContext,
+            ) => ResolveFnOutput | Promise<ResolveFnOutput>,
         ) => ResolveFnOutput | Promise<ResolveFnOutput>;
         interface LoadHookContext {
             /**
@@ -176,10 +218,14 @@ declare module 'module' {
              * The format optionally supplied by the `resolve` hook chain
              */
             format: ModuleFormat;
+            /**
+             * @deprecated Use `importAttributes` instead
+             */
+            importAssertions: ImportAttributes;
             /**
              *  An object whose key-value pairs represent the assertions for the module to import
              */
-            importAssertions: ImportAssertions;
+            importAttributes: ImportAttributes;
         }
         interface LoadFnOutput {
             format: ModuleFormat;
@@ -204,11 +250,11 @@ declare module 'module' {
         type LoadHook = (
             url: string,
             context: LoadHookContext,
-            nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>
+            nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>,
         ) => LoadFnOutput | Promise<LoadFnOutput>;
     }
     interface RegisterOptions<Data> {
-        parentURL: string;
+        parentURL: string | URL;
         data?: Data | undefined;
         transferList?: any[] | undefined;
     }
@@ -220,8 +266,12 @@ declare module 'module' {
         static builtinModules: string[];
         static isBuiltin(moduleName: string): boolean;
         static Module: typeof Module;
-        static register<Data = any, ReturnType = any>(specifier: string, parentURL?: string, options?: RegisterOptions<Data>): ReturnType;
-        static register<Data = any, ReturnType = any>(specifier: string, options?: RegisterOptions<Data>): ReturnType;
+        static register<Data = any>(
+            specifier: string | URL,
+            parentURL?: string | URL,
+            options?: RegisterOptions<Data>,
+        ): void;
+        static register<Data = any>(specifier: string | URL, options?: RegisterOptions<Data>): void;
         constructor(id: string, parent?: Module);
     }
     global {
@@ -231,27 +281,21 @@ declare module 'module' {
              * Provides a module-relative resolution function scoped to each module, returning
              * the URL string.
              *
-             * @param specified The module specifier to resolve relative to the current module.
-             * @returns The absolute (`file:`) URL string for the resolved module.
-             */
-            resolve(specified: string): string;
-            /**
-             * This feature is only available with the `--experimental-import-meta-resolve`
+             * Second `parent` parameter is only used when the `--experimental-import-meta-resolve`
              * command flag enabled.
              *
-             * Provides a module-relative resolution function scoped to each module, returning
-             * the URL string.
+             * @since v20.6.0
              *
-             * @param specified The module specifier to resolve relative to `parent`.
+             * @param specifier The module specifier to resolve relative to `parent`.
              * @param parent The absolute parent module URL to resolve from.
              * @returns The absolute (`file:`) URL string for the resolved module.
              */
-            resolve(specified: string, parent: string | URL): string;
+            resolve(specifier: string, parent?: string | URL | undefined): string;
         }
     }
     export = Module;
 }
-declare module 'node:module' {
-    import module = require('module');
+declare module "node:module" {
+    import module = require("module");
     export = module;
 }

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

@@ -12,11 +12,15 @@
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/net.js)
  */
-declare module 'net' {
-    import * as stream from 'node:stream';
-    import { Abortable, EventEmitter } from 'node:events';
-    import * as dns from 'node:dns';
-    type LookupFunction = (hostname: string, options: dns.LookupAllOptions, callback: (err: NodeJS.ErrnoException | null, addresses: dns.LookupAddress[]) => void) => void;
+declare module "net" {
+    import * as stream from "node:stream";
+    import { Abortable, EventEmitter } from "node:events";
+    import * as dns from "node:dns";
+    type LookupFunction = (
+        hostname: string,
+        options: dns.LookupAllOptions,
+        callback: (err: NodeJS.ErrnoException | null, addresses: dns.LookupAddress[]) => void,
+    ) => void;
     interface AddressInfo {
         address: string;
         family: string;
@@ -70,7 +74,7 @@ declare module 'net' {
         path: string;
     }
     type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;
-    type SocketReadyState = 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
+    type SocketReadyState = "opening" | "open" | "readOnly" | "writeOnly" | "closed";
     /**
      * This class is an abstraction of a TCP socket or a streaming `IPC` endpoint
      * (uses named pipes on Windows, and Unix domain sockets otherwise). It is also
@@ -87,6 +91,12 @@ declare module 'net' {
      */
     class Socket extends stream.Duplex {
         constructor(options?: SocketConstructorOpts);
+        /**
+         * Destroys the socket after all data is written. If the `finish` event was already emitted the socket is destroyed immediately.
+         * If the socket is still writable it implicitly calls `socket.end()`.
+         * @since v0.3.4
+         */
+        destroySoon(): void;
         /**
          * Sends data on the socket. The second parameter specifies the encoding in the
          * case of a string. It defaults to UTF8 encoding.
@@ -230,6 +240,15 @@ declare module 'net' {
          * @return The socket itself.
          */
         ref(): this;
+        /**
+         * This property is only present if the family autoselection algorithm is enabled in `socket.connect(options)`
+         * and it is an array of the addresses that have been attempted.
+         *
+         * Each address is a string in the form of `$IP:$PORT`.
+         * If the connection was successful, then the last address is the one that the socket is currently connected to.
+         * @since v19.4.0
+         */
+        readonly autoSelectFamilyAttemptedAddresses: string[];
         /**
          * This property shows the number of characters buffered for writing. The buffer
          * may contain strings whose length after encoding is not yet known. So this number
@@ -353,65 +372,80 @@ declare module 'net' {
          *   9. timeout
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: 'close', listener: (hadError: boolean) => void): this;
-        addListener(event: 'connect', listener: () => void): this;
-        addListener(event: 'data', listener: (data: Buffer) => void): this;
-        addListener(event: 'drain', listener: () => void): this;
-        addListener(event: 'end', listener: () => void): this;
-        addListener(event: 'error', listener: (err: Error) => void): this;
-        addListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        addListener(event: 'ready', listener: () => void): this;
-        addListener(event: 'timeout', listener: () => void): this;
+        addListener(event: "close", listener: (hadError: boolean) => void): this;
+        addListener(event: "connect", listener: () => void): this;
+        addListener(event: "data", listener: (data: Buffer) => void): this;
+        addListener(event: "drain", listener: () => void): this;
+        addListener(event: "end", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
+        addListener(event: "ready", listener: () => void): this;
+        addListener(event: "timeout", listener: () => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
-        emit(event: 'close', hadError: boolean): boolean;
-        emit(event: 'connect'): boolean;
-        emit(event: 'data', data: Buffer): boolean;
-        emit(event: 'drain'): boolean;
-        emit(event: 'end'): boolean;
-        emit(event: 'error', err: Error): boolean;
-        emit(event: 'lookup', err: Error, address: string, family: string | number, host: string): boolean;
-        emit(event: 'ready'): boolean;
-        emit(event: 'timeout'): boolean;
+        emit(event: "close", hadError: boolean): boolean;
+        emit(event: "connect"): boolean;
+        emit(event: "data", data: Buffer): boolean;
+        emit(event: "drain"): boolean;
+        emit(event: "end"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "lookup", err: Error, address: string, family: string | number, host: string): boolean;
+        emit(event: "ready"): boolean;
+        emit(event: "timeout"): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
-        on(event: 'close', listener: (hadError: boolean) => void): this;
-        on(event: 'connect', listener: () => void): this;
-        on(event: 'data', listener: (data: Buffer) => void): this;
-        on(event: 'drain', listener: () => void): this;
-        on(event: 'end', listener: () => void): this;
-        on(event: 'error', listener: (err: Error) => void): this;
-        on(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        on(event: 'ready', listener: () => void): this;
-        on(event: 'timeout', listener: () => void): this;
+        on(event: "close", listener: (hadError: boolean) => void): this;
+        on(event: "connect", listener: () => void): this;
+        on(event: "data", listener: (data: Buffer) => void): this;
+        on(event: "drain", listener: () => void): this;
+        on(event: "end", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
+        on(event: "ready", listener: () => void): this;
+        on(event: "timeout", listener: () => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'close', listener: (hadError: boolean) => void): this;
-        once(event: 'connect', listener: () => void): this;
-        once(event: 'data', listener: (data: Buffer) => void): this;
-        once(event: 'drain', listener: () => void): this;
-        once(event: 'end', listener: () => void): this;
-        once(event: 'error', listener: (err: Error) => void): this;
-        once(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        once(event: 'ready', listener: () => void): this;
-        once(event: 'timeout', listener: () => void): this;
+        once(event: "close", listener: (hadError: boolean) => void): this;
+        once(event: "connect", listener: () => void): this;
+        once(event: "data", listener: (data: Buffer) => void): this;
+        once(event: "drain", listener: () => void): this;
+        once(event: "end", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
+        once(event: "ready", listener: () => void): this;
+        once(event: "timeout", listener: () => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'close', listener: (hadError: boolean) => void): this;
-        prependListener(event: 'connect', listener: () => void): this;
-        prependListener(event: 'data', listener: (data: Buffer) => void): this;
-        prependListener(event: 'drain', listener: () => void): this;
-        prependListener(event: 'end', listener: () => void): this;
-        prependListener(event: 'error', listener: (err: Error) => void): this;
-        prependListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        prependListener(event: 'ready', listener: () => void): this;
-        prependListener(event: 'timeout', listener: () => void): this;
+        prependListener(event: "close", listener: (hadError: boolean) => void): this;
+        prependListener(event: "connect", listener: () => void): this;
+        prependListener(event: "data", listener: (data: Buffer) => void): this;
+        prependListener(event: "drain", listener: () => void): this;
+        prependListener(event: "end", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
+        prependListener(event: "ready", listener: () => void): this;
+        prependListener(event: "timeout", listener: () => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: 'close', listener: (hadError: boolean) => void): this;
-        prependOnceListener(event: 'connect', listener: () => void): this;
-        prependOnceListener(event: 'data', listener: (data: Buffer) => void): this;
-        prependOnceListener(event: 'drain', listener: () => void): this;
-        prependOnceListener(event: 'end', listener: () => void): this;
-        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
-        prependOnceListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        prependOnceListener(event: 'ready', listener: () => void): this;
-        prependOnceListener(event: 'timeout', listener: () => void): this;
+        prependOnceListener(event: "close", listener: (hadError: boolean) => void): this;
+        prependOnceListener(event: "connect", listener: () => void): this;
+        prependOnceListener(event: "data", listener: (data: Buffer) => void): this;
+        prependOnceListener(event: "drain", listener: () => void): this;
+        prependOnceListener(event: "end", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(
+            event: "lookup",
+            listener: (err: Error, address: string, family: string | number, host: string) => void,
+        ): this;
+        prependOnceListener(event: "ready", listener: () => void): this;
+        prependOnceListener(event: "timeout", listener: () => void): this;
     }
     interface ListenOptions extends Abortable {
         port?: number | undefined;
@@ -604,48 +638,48 @@ declare module 'net' {
          *   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;
+        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;
+        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;
+        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;
+        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;
+        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;
+        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;
         /**
          * Calls {@link Server.close()} and returns a promise that fulfills when the server has closed.
          * @since v20.5.0
          */
         [Symbol.asyncDispose](): Promise<void>;
     }
-    type IPVersion = 'ipv4' | 'ipv6';
+    type IPVersion = "ipv4" | "ipv6";
     /**
      * The `BlockList` object can be used with some network APIs to specify rules for
      * disabling inbound or outbound access to specific IP addresses, IP ranges, or
@@ -805,6 +839,28 @@ declare module 'net' {
     function createConnection(options: NetConnectOpts, connectionListener?: () => void): Socket;
     function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;
     function createConnection(path: string, connectionListener?: () => void): Socket;
+    /**
+     * Gets the current default value of the `autoSelectFamily` option of `socket.connect(options)`.
+     * The initial default value is `true`, unless the command line option`--no-network-family-autoselection` is provided.
+     * @since v19.4.0
+     */
+    function getDefaultAutoSelectFamily(): boolean;
+    /**
+     * Sets the default value of the `autoSelectFamily` option of `socket.connect(options)`.
+     * @since v19.4.0
+     */
+    function setDefaultAutoSelectFamily(value: boolean): void;
+    /**
+     * Gets the current default value of the `autoSelectFamilyAttemptTimeout` option of `socket.connect(options)`.
+     * The initial default value is `250`.
+     * @since v19.8.0
+     */
+    function getDefaultAutoSelectFamilyAttemptTimeout(): number;
+    /**
+     * Sets the default value of the `autoSelectFamilyAttemptTimeout` option of `socket.connect(options)`.
+     * @since v19.8.0
+     */
+    function setDefaultAutoSelectFamilyAttemptTimeout(value: number): void;
     /**
      * Returns `6` if `input` is an IPv6 address. Returns `4` if `input` is an IPv4
      * address in [dot-decimal notation](https://en.wikipedia.org/wiki/Dot-decimal_notation) with no leading zeroes. Otherwise, returns`0`.
@@ -888,6 +944,6 @@ declare module 'net' {
         readonly flowlabel: number;
     }
 }
-declare module 'node:net' {
-    export * from 'net';
+declare module "node:net" {
+    export * from "net";
 }

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

@@ -7,7 +7,7 @@
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/os.js)
  */
-declare module 'os' {
+declare module "os" {
     interface CpuInfo {
         model: string;
         speed: number;
@@ -27,18 +27,18 @@ declare module 'os' {
         cidr: string | null;
     }
     interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
-        family: 'IPv4';
+        family: "IPv4";
         scopeid?: undefined;
     }
     interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
-        family: 'IPv6';
+        family: "IPv6";
         scopeid: number;
     }
     interface UserInfo<T> {
         username: T;
         uid: number;
         gid: number;
-        shell: T;
+        shell: T | null;
         homedir: T;
     }
     type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
@@ -239,7 +239,7 @@ declare module 'os' {
      * Throws a `SystemError` if a user has no `username` or `homedir`.
      * @since v6.0.0
      */
-    function userInfo(options: { encoding: 'buffer' }): UserInfo<Buffer>;
+    function userInfo(options: { encoding: "buffer" }): UserInfo<Buffer>;
     function userInfo(options?: { encoding: BufferEncoding }): UserInfo<string>;
     type SignalConstants = {
         [key in NodeJS.Signals]: number;
@@ -400,7 +400,8 @@ declare module 'os' {
     const EOL: string;
     /**
      * Returns the operating system CPU architecture for which the Node.js binary was
-     * compiled. Possible values are `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`, `'ppc64'`, `'s390'`, `'s390x'`, and `'x64'`.
+     * compiled. Possible values are `'arm'`, `'arm64'`, `'ia32'`, `'loong64'`,`'mips'`, `'mipsel'`, `'ppc'`, `'ppc64'`, `'riscv64'`, `'s390'`, `'s390x'`,
+     * and `'x64'`.
      *
      * The return value is equivalent to `process.arch`.
      * @since v0.5.0
@@ -447,7 +448,7 @@ declare module 'os' {
      * Possible values are `'BE'` for big endian and `'LE'` for little endian.
      * @since v0.9.4
      */
-    function endianness(): 'BE' | 'LE';
+    function endianness(): "BE" | "LE";
     /**
      * Returns the scheduling priority for the process specified by `pid`. If `pid` is
      * not provided or is `0`, the priority of the current process is returned.
@@ -472,6 +473,6 @@ declare module 'os' {
     function setPriority(priority: number): void;
     function setPriority(pid: number, priority: number): void;
 }
-declare module 'node:os' {
-    export * from 'os';
+declare module "node:os" {
+    export * from "os";
 }