node-red-contrib-tak-registration 0.8.0 → 0.8.3

package/node_modules/@types/node/ts4.8/dgram.d.ts

@@ -538,6 +538,11 @@ declare module 'dgram' {
         prependOnceListener(event: 'error', listener: (err: Error) => void): this;
         prependOnceListener(event: 'listening', listener: () => void): this;
         prependOnceListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
+        /**
+         * Calls `socket.close()` and returns a promise that fulfills when the socket has closed.
+         * @since v20.5.0
+         */
+        [Symbol.asyncDispose](): Promise<void>;
     }
 }
 declare module 'node:dgram' {

package/node_modules/@types/node/ts4.8/events.d.ts

@@ -338,6 +338,41 @@ declare module 'events' {
          * objects.
          */
         static setMaxListeners(n?: number, ...eventTargets: Array<_DOMEventTarget | NodeJS.EventEmitter>): void;
+        /**
+         * Listens once to the `abort` event on the provided `signal`.
+         *
+         * Listening to the `abort` event on abort signals is unsafe and may
+         * lead to resource leaks since another third party with the signal can
+         * call `e.stopImmediatePropagation()`. Unfortunately Node.js cannot change
+         * this since it would violate the web standard. Additionally, the original
+         * API makes it easy to forget to remove listeners.
+         *
+         * This API allows safely using `AbortSignal`s in Node.js APIs by solving these
+         * two issues by listening to the event such that `stopImmediatePropagation` does
+         * not prevent the listener from running.
+         *
+         * Returns a disposable so that it may be unsubscribed from more easily.
+         *
+         * ```js
+         * import { addAbortListener } from 'node:events';
+         *
+         * function example(signal) {
+         *   let disposable;
+         *   try {
+         *     signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
+         *     disposable = addAbortListener(signal, (e) => {
+         *       // Do something when signal is aborted.
+         *     });
+         *   } finally {
+         *     disposable?.[Symbol.dispose]();
+         *   }
+         * }
+         * ```
+         * @since v20.5.0
+         * @experimental
+         * @return that removes the `abort` listener.
+         */
+        static addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
         /**
          * This symbol shall be used to install a listener for only monitoring `'error'`events. Listeners installed using this symbol are called before the regular`'error'` listeners are called.
          *

package/node_modules/@types/node/ts4.8/fs/promises.d.ts

@@ -456,6 +456,11 @@ declare module 'fs/promises' {
          * @return Fulfills with `undefined` upon success.
          */
         close(): Promise<void>;
+        /**
+         * An alias for {@link FileHandle.close()}.
+         * @since v20.4.0
+         */
+        [Symbol.asyncDispose](): Promise<void>;
     }
     const constants: typeof fsConstants;
     /**

package/node_modules/@types/node/ts4.8/fs.d.ts

@@ -3618,15 +3618,28 @@ declare module 'fs' {
         fd?: number | promises.FileHandle | undefined;
         mode?: number | undefined;
         autoClose?: boolean | undefined;
-        /**
-         * @default false
-         */
         emitClose?: boolean | undefined;
         start?: number | undefined;
-        highWaterMark?: number | undefined;
+        signal?: AbortSignal | null | undefined;
+    }
+    interface FSImplementation {
+        open?: (...args: any[]) => any;
+        close?: (...args: any[]) => any;
+    }
+    interface CreateReadStreamFSImplementation extends FSImplementation {
+        read: (...args: any[]) => any;
+    }
+    interface CreateWriteStreamFSImplementation extends FSImplementation {
+        write: (...args: any[]) => any;
+        writev?: (...args: any[]) => any;
     }
     interface ReadStreamOptions extends StreamOptions {
+        fs?: CreateReadStreamFSImplementation | null | undefined;
         end?: number | undefined;
+        highWaterMark?: number | undefined;
+    }
+    interface WriteStreamOptions extends StreamOptions {
+        fs?: CreateWriteStreamFSImplementation | null | undefined;
     }
     /**
      * Unlike the 16 KiB default `highWaterMark` for a `stream.Readable`, the stream
@@ -3720,7 +3733,7 @@ declare module 'fs' {
      * If `options` is a string, then it specifies the encoding.
      * @since v0.1.31
      */
-    export function createWriteStream(path: PathLike, options?: BufferEncoding | StreamOptions): WriteStream;
+    export function createWriteStream(path: PathLike, options?: BufferEncoding | WriteStreamOptions): WriteStream;
     /**
      * Forces all currently queued I/O operations associated with the file to the
      * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details. No arguments other
@@ -3900,6 +3913,31 @@ declare module 'fs' {
      * @return The number of bytes read.
      */
     export function readvSync(fd: number, buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): number;
+
+    export interface OpenAsBlobOptions {
+        /**
+         * An optional mime type for the blob.
+         *
+         * @default 'undefined'
+         */
+        type?: string | undefined;
+    }
+
+    /**
+     * Returns a Blob whose data is backed by the given file.
+     *
+     * The file must not be modified after the `Blob` is created.
+     * Any modifications will cause reading the `Blob` data to fail with a `DOMException` error.
+     * Synchronous stat operations on the file when the `Blob` is created, and before each read in order to detect whether the file data has been modified on disk.
+     *
+     * @param path
+     * @param [options]
+     *
+     * @experimental
+     * @since v19.8.0
+     */
+    export function openAsBlob(path: PathLike, options?: OpenAsBlobOptions): Promise<Blob>;
+
     export interface OpenDirOptions {
         /**
          * @default 'utf8'

package/node_modules/@types/node/ts4.8/globals.d.ts

@@ -84,6 +84,28 @@ declare var AbortSignal: typeof globalThis extends {onmessage: any; AbortSignal:
     };
 //#endregion borrowed
 
+//#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> {
     /**

package/node_modules/@types/node/ts4.8/inspector.d.ts

@@ -1,4 +1,4 @@
-// eslint-disable-next-line dt-header
+// eslint-disable-next-line @definitelytyped/dt-header
 // Type definitions for inspector
 
 // These definitions are auto-generated.

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

@@ -3,6 +3,7 @@
  */
 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
@@ -92,6 +93,108 @@ declare module 'module' {
              */
             findEntry(lineOffset: number, columnOffset: number): SourceMapping;
         }
+        interface ImportAssertions extends NodeJS.Dict<string> {
+            type?: string | undefined;
+        }
+        type ModuleFormat = 'builtin' | 'commonjs' | 'json' | 'module' | 'wasm';
+        type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
+        interface GlobalPreloadContext {
+            port: MessagePort;
+        }
+        /**
+         * Sometimes it might be necessary to run some code inside of the same global scope that the application runs in.
+         * This hook allows the return of a string that is run as a sloppy-mode script on startup.
+         *
+         * @param context Information to assist the preload code
+         * @return Code to run before application startup
+         */
+        type GlobalPreloadHook = (context: GlobalPreloadContext) => string;
+        interface ResolveHookContext {
+            /**
+             * Export conditions of the relevant `package.json`
+             */
+            conditions: string[];
+            /**
+             *  An object whose key-value pairs represent the assertions for the module to import
+             */
+            importAssertions: ImportAssertions;
+            /**
+             * The module importing this one, or undefined if this is the Node.js entry point
+             */
+            parentURL: string | undefined;
+        }
+        interface ResolveFnOutput {
+            /**
+             * A hint to the load hook (it might be ignored)
+             */
+            format?: ModuleFormat | null | undefined;
+            /**
+             * The import assertions to use when caching the module (optional; if excluded the input will be used)
+             */
+            importAssertions?: ImportAssertions | undefined;
+            /**
+             * A signal that this hook intends to terminate the chain of `resolve` hooks.
+             * @default false
+             */
+            shortCircuit?: boolean | undefined;
+            /**
+             * The absolute URL to which this input resolves
+             */
+            url: string;
+        }
+        /**
+         * The `resolve` hook chain is responsible for resolving file URL for a given module specifier and parent URL, and optionally its format (such as `'module'`) as a hint to the `load` hook.
+         * If a format is specified, the load hook is ultimately responsible for providing the final `format` value (and it is free to ignore the hint provided by `resolve`);
+         * if `resolve` provides a format, a custom `load` hook is required even if only to pass the value to the Node.js default `load` hook.
+         *
+         * @param specifier The specified URL path of the module to be resolved
+         * @param context
+         * @param nextResolve The subsequent `resolve` hook in the chain, or the Node.js default `resolve` hook after the last user-supplied resolve hook
+         */
+        type ResolveHook = (
+            specifier: string,
+            context: ResolveHookContext,
+            nextResolve: (specifier: string, context?: ResolveHookContext) => ResolveFnOutput | Promise<ResolveFnOutput>
+        ) => ResolveFnOutput | Promise<ResolveFnOutput>;
+        interface LoadHookContext {
+            /**
+             * Export conditions of the relevant `package.json`
+             */
+            conditions: string[];
+            /**
+             * The format optionally supplied by the `resolve` hook chain
+             */
+            format: ModuleFormat;
+            /**
+             *  An object whose key-value pairs represent the assertions for the module to import
+             */
+            importAssertions: ImportAssertions;
+        }
+        interface LoadFnOutput {
+            format: ModuleFormat;
+            /**
+             * A signal that this hook intends to terminate the chain of `resolve` hooks.
+             * @default false
+             */
+            shortCircuit?: boolean | undefined;
+            /**
+             * The source for Node.js to evaluate
+             */
+            source?: ModuleSource;
+        }
+        /**
+         * The `load` hook provides a way to define a custom method of determining how a URL should be interpreted, retrieved, and parsed.
+         * It is also in charge of validating the import assertion.
+         *
+         * @param url The URL/path of the module to be loaded
+         * @param context Metadata about the module
+         * @param nextLoad The subsequent `load` hook in the chain, or the Node.js default `load` hook after the last user-supplied `load` hook
+         */
+        type LoadHook = (
+            url: string,
+            context: LoadHookContext,
+            nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>
+        ) => LoadFnOutput | Promise<LoadFnOutput>;
     }
     interface Module extends NodeModule {}
     class Module {

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

@@ -639,6 +639,11 @@ declare module 'net' {
         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';
     /**