@psnext/slingcli 3.1.20260904-1 → 3.3.20260911-1

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

@@ -1,4 +1,28 @@
-declare module "node:diagnostics_channel" {
+/**
+ * The `node:diagnostics_channel` module provides an API to create named channels
+ * to report arbitrary message data for diagnostics purposes.
+ *
+ * It can be accessed using:
+ *
+ * ```js
+ * import diagnostics_channel from 'node:diagnostics_channel';
+ * ```
+ *
+ * It is intended that a module writer wanting to report diagnostics messages
+ * will create one or many top-level channels to report messages through.
+ * Channels may also be acquired at runtime but it is not encouraged
+ * due to the additional overhead of doing so. Channels may be exported for
+ * convenience, but as long as the name is known it can be acquired anywhere.
+ *
+ * If you intend for your module to produce diagnostics data for others to
+ * consume it is recommended that you include documentation of what named
+ * channels are used along with the shape of the message data. Channel names
+ * should generally include the module name to avoid collisions with data from
+ * other modules.
+ * @since v15.1.0, v14.17.0
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/diagnostics_channel.js)
+ */
+declare module "diagnostics_channel" {
     import { AsyncLocalStorage } from "node:async_hooks";
     /**
      * Check if there are active subscribers to the named channel. This is helpful if
@@ -33,10 +57,7 @@ declare module "node:diagnostics_channel" {
      * @param name The channel name
      * @return The named channel object
      */
-    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-    function channel<ContextType = any, StoreType = ContextType>(
-        name: string | symbol,
-    ): Channel<ContextType, StoreType>;
+    function channel(name: string | symbol): Channel;
     type ChannelListener = (message: unknown, name: string | symbol) => void;
     /**
      * Register a message handler to subscribe to this channel. This message handler
@@ -99,39 +120,12 @@ declare module "node:diagnostics_channel" {
      * @param nameOrChannels Channel name or object containing all the `TracingChannel Channels`
      * @return Collection of channels to trace with
      */
-    function tracingChannel<ContextType extends object = object, StoreType = ContextType>(
-        nameOrChannels: string | TracingChannelCollection<ContextType, StoreType>,
-    ): TracingChannel<ContextType, StoreType>;
-    /**
-     * Creates a {@link BoundedChannel} wrapper for the given channels. If a name is
-     * given, the corresponding channels will be created in the form of
-     * `tracing:${name}:${eventType}` where `eventType` is `start` or `end`.
-     *
-     * A `BoundedChannel` is a simplified version of {@link TracingChannel} that only
-     * traces synchronous operations. It only has `start` and `end` events, without
-     * `asyncStart`, `asyncEnd`, or `error` events, making it suitable for tracing
-     * operations that don't involve asynchronous continuations or error handling.
-     *
-     * ```js
-     * import { boundedChannel, channel } from 'node:diagnostics_channel';
-     *
-     * const wc = boundedChannel('my-operation');
-     *
-     * // or...
-     *
-     * const wc2 = boundedChannel({
-     *   start: channel('tracing:my-operation:start'),
-     *   end: channel('tracing:my-operation:end'),
-     * });
-     * ```
-     * @since v26.1.0
-     * @experimental
-     * @param nameOrChannels Channel name or
-     * object containing all the [BoundedChannel Channels](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#boundedchannel-channels)
-     */
-    function boundedChannel<ContextType extends object = object, StoreType = ContextType>(
-        nameOrChannels: string | BoundedChannelCollection<ContextType, StoreType>,
-    ): BoundedChannel<ContextType, StoreType>;
+    function tracingChannel<
+        StoreType = unknown,
+        ContextType extends object = StoreType extends object ? StoreType : object,
+    >(
+        nameOrChannels: string | TracingChannelCollection<StoreType, ContextType>,
+    ): TracingChannel<StoreType, ContextType>;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is used to track subscribers and to publish messages when there
@@ -141,8 +135,7 @@ declare module "node:diagnostics_channel" {
      * with `new Channel(name)` is not supported.
      * @since v15.1.0, v14.17.0
      */
-    class Channel<ContextType = any, StoreType = ContextType> {
-        private constructor();
+    class Channel<StoreType = unknown, ContextType = StoreType> {
         readonly name: string | symbol;
         /**
          * Check if there are active subscribers to this channel. This is helpful if
@@ -163,6 +156,7 @@ declare module "node:diagnostics_channel" {
          * @since v15.1.0, v14.17.0
          */
         readonly hasSubscribers: boolean;
+        private constructor(name: string | symbol);
         /**
          * Publish a message to any subscribers to the channel. This will trigger
          * message handlers synchronously so they will execute within the same context.
@@ -307,48 +301,7 @@ declare module "node:diagnostics_channel" {
             thisArg?: ThisArg,
             ...args: Args
         ): Result;
-        /**
-         * Creates a disposable scope that binds the given data to any AsyncLocalStorage
-         * instances bound to the channel and publishes it to subscribers. The scope
-         * automatically restores the previous storage contexts when disposed.
-         *
-         * This method enables the use of JavaScript's explicit resource management
-         * (`using` syntax with `Symbol.dispose`) to manage store contexts without
-         * closure wrapping.
-         *
-         * ```js
-         * import { channel } from 'node:diagnostics_channel';
-         * import { AsyncLocalStorage } from 'node:async_hooks';
-         *
-         * const store = new AsyncLocalStorage();
-         * const ch = channel('my-channel');
-         *
-         * ch.bindStore(store, (message) => {
-         *   return { ...message, timestamp: Date.now() };
-         * });
-         *
-         * {
-         *   using scope = ch.withStoreScope({ request: 'data' });
-         *   // Store is entered, data is published
-         *   console.log(store.getStore()); // { request: 'data', timestamp: ... }
-         * }
-         * // Store is automatically restored on scope exit
-         * ```
-         * @since v26.1.0
-         * @experimental
-         */
-        withStoreScope(data: ContextType): RunStoresScope;
     }
-    /**
-     * The class `RunStoresScope` represents a disposable scope created by
-     * `channel.withStoreScope(data)`. It manages the lifecycle of store
-     * contexts and ensures they are properly restored when the scope exits.
-     *
-     * The scope must be used with the `using` syntax to ensure proper disposal.
-     * @since v26.1.0
-     * @experimental
-     */
-    interface RunStoresScope extends Disposable {}
     interface TracingChannelSubscribers<ContextType extends object> {
         start: (message: ContextType) => void;
         end: (
@@ -375,12 +328,12 @@ declare module "node:diagnostics_channel" {
             },
         ) => void;
     }
-    interface TracingChannelCollection<ContextType extends object = object, StoreType = ContextType> {
-        start: Channel<ContextType, StoreType>;
-        end: Channel<ContextType, StoreType>;
-        asyncStart: Channel<ContextType, StoreType>;
-        asyncEnd: Channel<ContextType, StoreType>;
-        error: Channel<ContextType, StoreType>;
+    interface TracingChannelCollection<StoreType = unknown, ContextType = StoreType> {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
     }
     /**
      * The class `TracingChannel` is a collection of `TracingChannel Channels` which
@@ -391,9 +344,12 @@ declare module "node:diagnostics_channel" {
      * @since v19.9.0
      * @experimental
      */
-    interface TracingChannel<ContextType extends object = object, StoreType = ContextType>
-        extends TracingChannelCollection<ContextType, StoreType>
-    {
+    class TracingChannel<StoreType = unknown, ContextType extends object = {}> implements TracingChannelCollection {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
         /**
          * Helper to subscribe a collection of functions to the corresponding channels.
          * This is the same as calling `channel.subscribe(onMessage)` on each channel
@@ -426,7 +382,7 @@ declare module "node:diagnostics_channel" {
          * @experimental
          * @param subscribers Set of `TracingChannel Channels` subscribers
          */
-        subscribe(subscribers: NodeJS.PartialOptions<TracingChannelSubscribers<ContextType>>): void;
+        subscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
         /**
          * Helper to unsubscribe a collection of functions from the corresponding channels.
          * This is the same as calling `channel.unsubscribe(onMessage)` on each channel
@@ -460,7 +416,7 @@ declare module "node:diagnostics_channel" {
          * @param subscribers Set of `TracingChannel Channels` subscribers
          * @return `true` if all handlers were successfully unsubscribed, and `false` otherwise.
          */
-        unsubscribe(subscribers: NodeJS.PartialOptions<TracingChannelSubscribers<ContextType>>): void;
+        unsubscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
         /**
          * Trace a synchronous function call. This will always produce a `start event` and `end event` around the execution and may produce an `error event` if the given function throws an error.
          * This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
@@ -495,20 +451,12 @@ declare module "node:diagnostics_channel" {
             ...args: Args
         ): Result;
         /**
-         * Trace an asynchronous function call which returns a `Promise` or
-         * [thenable object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#thenables). This will always produce a [`start` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#startevent) and
-         * [`end` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#endevent) around the synchronous portion of the function execution, and
-         * will produce an [`asyncStart` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#asyncstartevent) and [`asyncEnd` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#asyncendevent) when the
-         * returned promise is resolved or rejected. It may also produce an
-         * [`error` event](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html#errorevent) if the given function throws an error or the returned promise
-         * is rejected. This will run the given function using
-         * [`channel.runStores(context, ...)`](https://nodejs.org/docs/latest-v26.x/api/diagnostics_channel.html##channelrunstorescontext-fn-thisarg-args) on the `start` channel which ensures all
+         * Trace a promise-returning function call. This will always produce a `start event` and `end event` around the synchronous portion of the
+         * function execution, and will produce an `asyncStart event` and `asyncEnd event` when a promise continuation is reached. It may also
+         * produce an `error event` if the given function throws an error or the
+         * returned promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
          * events should have any bound stores set to match this trace context.
          *
-         * If the value returned by `fn` is not a Promise or thenable, then it will be
-         * returned with a warning, and no `asyncStart` or `asyncEnd` events will be
-         * produced.
-         *
          * To ensure only correct trace graphs are formed, events will only be published if subscribers are present prior to starting the trace. Subscriptions
          * which are added after the trace begins will not receive future events from that trace, only future traces will be seen.
          *
@@ -525,21 +473,18 @@ declare module "node:diagnostics_channel" {
          * ```
          * @since v19.9.0
          * @experimental
-         * @param fn Function to wrap a trace around
+         * @param fn Promise-returning function to wrap a trace around
          * @param context Shared object to correlate trace events through
          * @param thisArg The receiver to be used for the function call
          * @param args Optional arguments to pass to the function
-         * @returns The return value of the given function, or the result of
-         * calling `.then(...)` on the return value if the tracing channel has active
-         * subscribers. If the return value is not a Promise or thenable, then
-         * it is returned as-is and a warning is emitted.
+         * @return Chained from promise returned by the given function
          */
-        tracePromise<ThisArg = any, Args extends any[] = any[], Result extends PromiseLike<unknown> = any>(
-            fn: (this: ThisArg, ...args: Args) => Result,
+        tracePromise<ThisArg = any, Args extends any[] = any[], Result = any>(
+            fn: (this: ThisArg, ...args: Args) => Promise<Result>,
             context?: ContextType,
             thisArg?: ThisArg,
             ...args: Args
-        ): Result;
+        ): Promise<Result>;
         /**
          * Trace a callback-receiving function call. This will always produce a `start event` and `end event` around the synchronous portion of the
          * function execution, and will produce a `asyncStart event` and `asyncEnd event` around the callback execution. It may also produce an `error event` if the given function throws an error or
@@ -625,170 +570,7 @@ declare module "node:diagnostics_channel" {
          */
         readonly hasSubscribers: boolean;
     }
-    interface BoundedChannelSubscribers<ContextType extends object> {
-        start: (message: ContextType) => void;
-        end: (message: ContextType) => void;
-    }
-    interface BoundedChannelCollection<ContextType extends object = object, StoreType = ContextType> {
-        start: Channel<ContextType, StoreType>;
-        end: Channel<ContextType, StoreType>;
-    }
-    /**
-     * The class `BoundedChannel` is a simplified version of {@link TracingChannel} that
-     * only traces synchronous operations. It consists of two channels (`start` and
-     * `end`) instead of five, omitting the `asyncStart`, `asyncEnd`, and `error`
-     * events. This makes it suitable for tracing operations that don't involve
-     * asynchronous continuations or error handling.
-     *
-     * Like `TracingChannel`, it is recommended to create and reuse a single
-     * `BoundedChannel` at the top-level of the file rather than creating them
-     * dynamically.
-     * @since v26.1.0
-     * @experimental
-     */
-    interface BoundedChannel<ContextType extends object = object, StoreType = ContextType>
-        extends BoundedChannelCollection<ContextType, StoreType>
-    {
-        /**
-         * Check if any of the `start` or `end` channels have subscribers.
-         *
-         * ```js
-         * import { boundedChannel } from 'node:diagnostics_channel';
-         *
-         * const wc = boundedChannel('my-operation');
-         *
-         * if (wc.hasSubscribers) {
-         *   // There are subscribers, perform traced operation
-         * }
-         * ```
-         * @since v26.1.0
-         */
-        readonly hasSubscribers: boolean;
-        /**
-         * Subscribe to the bounded channel events. This is equivalent to calling
-         * [`channel.subscribe(onMessage)`][] on each channel individually.
-         *
-         * ```mjs
-         * import { boundedChannel } from 'node:diagnostics_channel';
-         *
-         * const wc = boundedChannel('my-operation');
-         *
-         * wc.subscribe({
-         *   start(message) {
-         *     // Handle start
-         *   },
-         *   end(message) {
-         *     // Handle end
-         *   },
-         * });
-         * ```
-         * @since v26.1.0
-         * @param handlers Set of channel subscribers
-         */
-        subscribe(handlers: NodeJS.PartialOptions<BoundedChannelSubscribers<ContextType>>): void;
-        /**
-         * Unsubscribe from the bounded channel events. This is equivalent to calling
-         * [`channel.unsubscribe(onMessage)`][] on each channel individually.
-         *
-         * ```js
-         * import { boundedChannel } from 'node:diagnostics_channel';
-         *
-         * const wc = boundedChannel('my-operation');
-         *
-         * const handlers = {
-         *   start(message) {},
-         *   end(message) {},
-         * };
-         *
-         * wc.subscribe(handlers);
-         * wc.unsubscribe(handlers);
-         * ```
-         * @since v26.1.0
-         * @param handlers Set of channel subscribers
-         * @returns `true` if all handlers were successfully unsubscribed,
-         * `false` otherwise.
-         */
-        unsubscribe(handlers: NodeJS.PartialOptions<BoundedChannelSubscribers<ContextType>>): boolean;
-        /**
-         * Trace a synchronous function call. This will produce a `start` event and `end`
-         * event around the execution. This runs the given function using
-         * [`channel.runStores(context, ...)`][] on the `start` channel which ensures all
-         * events have any bound stores set to match this trace context.
-         *
-         * ```js
-         * import { boundedChannel } from 'node:diagnostics_channel';
-         *
-         * const wc = boundedChannel('my-operation');
-         *
-         * const result = wc.run({ operationId: '123' }, () => {
-         *   // Perform operation
-         *   return 42;
-         * });
-         * ```
-         * @since v26.1.0
-         * @param context Shared object to correlate events through
-         * @param fn Function to wrap a trace around
-         * @param thisArg The receiver to be used for the function call
-         * @param args Optional arguments to pass to the function
-         * @returns The return value of the given function
-         */
-        run<ThisArg = any, Args extends any[] = any[], Result = any>(
-            fn: (this: ThisArg, ...args: Args) => Result,
-            context?: ContextType,
-            thisArg?: ThisArg,
-            ...args: Args
-        ): Result;
-        /**
-         * Create a disposable scope for tracing a synchronous operation using JavaScript's
-         * explicit resource management (`using` syntax). The scope automatically publishes
-         * `start` and `end` events, enters bound stores, and handles cleanup when disposed.
-         *
-         * ```js
-         * import { boundedChannel } from 'node:diagnostics_channel';
-         *
-         * const wc = boundedChannel('my-operation');
-         *
-         * const context = { operationId: '123' };
-         * {
-         *   using scope = wc.withScope(context);
-         *   // Stores are entered, start event is published
-         *
-         *   // Perform work and set result on context
-         *   context.result = 42;
-         * }
-         * // End event is published, stores are restored automatically
-         * ```
-         * @since v26.1.0
-         * @param context Shared object to correlate events through
-         * @returns Disposable scope object
-         */
-        withScope(context: ContextType): BoundedChannelScope;
-    }
-    /**
-     * The class `BoundedChannelScope` represents a disposable scope created by
-     * `boundedChannel.withScope(context)`. It manages the lifecycle of a traced
-     * operation, automatically publishing events and managing store contexts.
-     *
-     * The scope must be used with the `using` syntax to ensure proper disposal.
-     *
-     * ```js
-     * import { boundedChannel } from 'node:diagnostics_channel';
-     *
-     * const wc = boundedChannel('my-operation');
-     *
-     * const context = {};
-     * {
-     *   using scope = wc.withScope(context);
-     *   // Start event is published, stores are entered
-     *   context.result = performOperation();
-     *   // End event is automatically published at end of block
-     * }
-     * ```
-     * @since v26.1.0
-     * @experimental
-     */
-    interface BoundedChannelScope extends Disposable {}
 }
-declare module "diagnostics_channel" {
-    export * from "node:diagnostics_channel";
+declare module "node:diagnostics_channel" {
+    export * from "diagnostics_channel";
 }

package/node_modules/@types/node/dns/promises.d.ts

@@ -1,4 +1,10 @@
-declare module "node:dns/promises" {
+/**
+ * The `dns.promises` API provides an alternative set of asynchronous DNS methods
+ * that return `Promise` objects rather than using callbacks. The API is accessible
+ * via `import { promises as dnsPromises } from 'node:dns'` or `import dnsPromises from 'node:dns/promises'`.
+ * @since v10.6.0
+ */
+declare module "dns/promises" {
     import {
         AnyRecord,
         CaaRecord,
@@ -183,7 +189,7 @@ declare module "node:dns/promises" {
      *     refresh: 900,
      *     retry: 900,
      *     expire: 1800,
-     *     minttl: 60 } ];
+     *     minttl: 60 } ]
      * ```
      * @since v10.6.0
      */
@@ -226,7 +232,7 @@ declare module "node:dns/promises" {
      *   regexp: '',
      *   replacement: '_sip._udp.example.com',
      *   order: 30,
-     *   preference: 100,
+     *   preference: 100
      * }
      * ```
      * @since v10.6.0
@@ -265,7 +271,7 @@ declare module "node:dns/promises" {
      *   refresh: 10000,
      *   retry: 2400,
      *   expire: 604800,
-     *   minttl: 3600,
+     *   minttl: 3600
      * }
      * ```
      * @since v10.6.0
@@ -285,7 +291,7 @@ declare module "node:dns/promises" {
      *   priority: 10,
      *   weight: 5,
      *   port: 21223,
-     *   name: 'service.example.com',
+     *   name: 'service.example.com'
      * }
      * ```
      * @since v10.6.0
@@ -306,10 +312,10 @@ declare module "node:dns/promises" {
      *   certUsage: 3,
      *   selector: 1,
      *   match: 1,
-     *   data: [ArrayBuffer],
+     *   data: [ArrayBuffer]
      * }
      * ```
-     * @since v23.9.0, v22.15.0
+     * @since v22.15.0
      */
     function resolveTlsa(hostname: string): Promise<TlsaRecord[]>;
     /**
@@ -492,6 +498,6 @@ declare module "node:dns/promises" {
         setServers: typeof setServers;
     }
 }
-declare module "dns/promises" {
-    export * from "node:dns/promises";
+declare module "node:dns/promises" {
+    export * from "dns/promises";
 }