@psnext/slingcli 3.3.20260911-1 → 3.3.20260914-1

package/node_modules/undici-types/cache-interceptor.d.ts

@@ -0,0 +1,179 @@
+import { Readable, Writable } from 'node:stream'
+
+export default CacheHandler
+
+declare namespace CacheHandler {
+  export type CacheMethods = 'GET' | 'HEAD' | 'OPTIONS' | 'TRACE'
+
+  export interface CacheHandlerOptions {
+    store: CacheStore
+
+    cacheByDefault?: number
+
+    type?: CacheOptions['type']
+  }
+
+  export interface CacheOptions {
+    store?: CacheStore
+
+    /**
+     * The methods to cache
+     * Note we can only cache safe methods. Unsafe methods (i.e. PUT, POST)
+     *  invalidate the cache for a origin.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-respons
+     * @see https://www.rfc-editor.org/rfc/rfc9110#section-9.2.1
+     */
+    methods?: CacheMethods[]
+
+    /**
+     * RFC9111 allows for caching responses that we aren't explicitly told to
+     *  cache or to not cache.
+     * @see https://www.rfc-editor.org/rfc/rfc9111.html#section-3-5
+     * @default undefined
+     */
+    cacheByDefault?: number
+
+    /**
+     * TODO docs
+     * @default 'shared'
+     */
+    type?: 'shared' | 'private'
+
+    /**
+     * Array of origins to cache. Only requests to these origins will be cached.
+     * Supports strings (case insensitive) and RegExp patterns.
+     * @default undefined (cache all origins)
+     */
+    origins?: (string | RegExp)[]
+  }
+
+  export interface CacheControlDirectives {
+    'max-stale'?: number;
+    'min-fresh'?: number;
+    'max-age'?: number;
+    's-maxage'?: number;
+    'stale-while-revalidate'?: number;
+    'stale-if-error'?: number;
+    public?: true;
+    private?: true | string[];
+    'no-store'?: true;
+    'no-cache'?: true | string[];
+    'must-revalidate'?: true;
+    'proxy-revalidate'?: true;
+    immutable?: true;
+    'no-transform'?: true;
+    'must-understand'?: true;
+    'only-if-cached'?: true;
+  }
+
+  export interface CacheKey {
+    origin: string
+    method: string
+    path: string
+    headers?: Record<string, string | string[]>
+  }
+
+  export interface CacheValue {
+    statusCode: number
+    statusMessage: string
+    headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[] | null>
+    etag?: string
+    cacheControlDirectives?: CacheControlDirectives
+    cachedAt: number
+    staleAt: number
+    deleteAt: number
+  }
+
+  export interface DeleteByUri {
+    origin: string
+    method: string
+    path: string
+  }
+
+  type GetResult = {
+    statusCode: number
+    statusMessage: string
+    headers: Record<string, string | string[]>
+    vary?: Record<string, string | string[] | null>
+    etag?: string
+    body?: Readable | Iterable<Buffer> | AsyncIterable<Buffer> | Buffer | Iterable<string> | AsyncIterable<string> | string
+    cacheControlDirectives: CacheControlDirectives,
+    cachedAt: number
+    staleAt: number
+    deleteAt: number
+  }
+
+  /**
+   * Underlying storage provider for cached responses
+   */
+  export interface CacheStore {
+    get(key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream(key: CacheKey, val: CacheValue): Writable | undefined
+
+    delete(key: CacheKey): void | Promise<void>
+  }
+
+  export interface MemoryCacheStoreOpts {
+    /**
+       * @default Infinity
+       */
+    maxCount?: number
+
+    /**
+     * @default Infinity
+     */
+    maxSize?: number
+
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+
+    errorCallback?: (err: Error) => void
+  }
+
+  export class MemoryCacheStore implements CacheStore {
+    constructor (opts?: MemoryCacheStoreOpts)
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CacheValue): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+
+  export interface SqliteCacheStoreOpts {
+    /**
+     * Location of the database
+     * @default ':memory:'
+     */
+    location?: string
+
+    /**
+     * @default Infinity
+     */
+    maxCount?: number
+
+    /**
+     * @default Infinity
+     */
+    maxEntrySize?: number
+  }
+
+  export class SqliteCacheStore implements CacheStore {
+    constructor (opts?: SqliteCacheStoreOpts)
+
+    /**
+     * Closes the connection to the database
+     */
+    close (): void
+
+    get (key: CacheKey): GetResult | Promise<GetResult | undefined> | undefined
+
+    createWriteStream (key: CacheKey, value: CacheValue): Writable | undefined
+
+    delete (key: CacheKey): void | Promise<void>
+  }
+}

package/node_modules/undici-types/client-stats.d.ts

@@ -0,0 +1,15 @@
+import Client from './client'
+
+export default ClientStats
+
+declare class ClientStats {
+  constructor (pool: Client)
+  /** If socket has open connection. */
+  connected: boolean
+  /** Number of open socket connections in this client that do not have an active request. */
+  pending: number
+  /** Number of currently active requests of this client. */
+  running: number
+  /** Number of active, pending, or queued requests of this client. */
+  size: number
+}

package/node_modules/undici-types/client.d.ts

@@ -1,50 +1,47 @@
-import { URL } from 'url'
-import { TlsOptions } from 'tls'
+import { URL } from 'node:url'
 import Dispatcher from './dispatcher'
-import buildConnector from "./connector";
+import buildConnector from './connector'
+import TClientStats from './client-stats'
 
-type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+type ClientConnectOptions<TOpaque = null> = Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin'>
 
 /**
  * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
  */
 export class Client extends Dispatcher {
-  constructor(url: string | URL, options?: Client.Options);
+  constructor (url: string | URL, options?: Client.Options)
   /** Property to get and set the pipelining factor. */
-  pipelining: number;
+  pipelining: number
   /** `true` after `client.close()` has been called. */
-  closed: boolean;
+  closed: boolean
   /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
-  destroyed: boolean;
+  destroyed: boolean
+  /** Aggregate stats for a Client. */
+  readonly stats: TClientStats
 
   // Override dispatcher APIs.
-  override connect(
-    options: ClientConnectOptions
-  ): Promise<Dispatcher.ConnectData>;
-  override connect(
-    options: ClientConnectOptions,
-    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void;
+  override connect<TOpaque = null> (
+    options: ClientConnectOptions<TOpaque>
+  ): Promise<Dispatcher.ConnectData<TOpaque>>
+  override connect<TOpaque = null> (
+    options: ClientConnectOptions<TOpaque>,
+    callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void
+  ): void
 }
 
 export declare namespace Client {
-  export interface OptionsInterceptors {
-    Client: readonly Dispatcher.DispatchInterceptor[];
-  }
   export interface Options {
-    /** TODO */
-    interceptors?: OptionsInterceptors;
     /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
     maxHeaderSize?: number;
-    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
     headersTimeout?: number;
     /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
     socketTimeout?: never;
     /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
     requestTimeout?: never;
-    /** TODO */
+    /** The timeout for establishing a socket connection, in milliseconds. Use `0` to disable it entirely. Default: `10e3` milliseconds (10s). */
     connectTimeout?: number;
-    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
     bodyTimeout?: number;
     /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
     idleTimeout?: never;
@@ -58,40 +55,55 @@ export declare namespace Client {
     keepAliveMaxTimeout?: number;
     /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
     keepAliveTimeoutThreshold?: number;
-    /** TODO */
+    /** An IPC endpoint, either a Unix domain socket or Windows named pipe. Default: `null`. */
     socketPath?: string;
-    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Only enable values greater than `1` when the remote server is trusted. Default: `1`. */
     pipelining?: number;
     /** @deprecated use the connect option instead */
     tls?: never;
     /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
     strictContentLength?: boolean;
-    /** TODO */
+    /** Maximum number of TLS cached sessions used by the built-in connector. Use `0` to disable TLS session caching. Default: `100`. */
     maxCachedSessions?: number;
-    /** TODO */
-    maxRedirections?: number;
-    /** TODO */
-    connect?: buildConnector.BuildOptions | buildConnector.connector;
-    /** TODO */
+    /** Connector options passed to `buildConnector`, or a custom connector function. Default: `null`. */
+    connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
+    /** The maximum number of requests to send over a single connection before it is reset. Use `0` to disable this limit. Default: `null`. */
     maxRequestsPerClient?: number;
-    /** TODO */
+    /** Local IP address the socket should connect from. */
     localAddress?: string;
     /** Max response body size in bytes, -1 is disabled */
     maxResponseSize?: number;
+    /** WebSocket-specific options */
+    webSocket?: Client.WebSocketOptions;
     /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
     autoSelectFamily?: boolean;
     /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
     autoSelectFamilyAttemptTimeout?: number;
     /**
      * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
-     * @default false
-    */
+     * @default true
+     */
     allowH2?: boolean;
     /**
      * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
      * @default 100
-    */
-    maxConcurrentStreams?: number
+     */
+    maxConcurrentStreams?: number;
+    /**
+     * @description Sets the HTTP/2 stream-level flow-control window size (SETTINGS_INITIAL_WINDOW_SIZE).
+     * @default 262144
+     */
+    initialWindowSize?: number;
+    /**
+     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
+     * @default 524288
+     */
+    connectionWindowSize?: number;
+    /**
+     * @description Time interval between PING frames dispatch
+     * @default 60000
+     */
+    pingInterval?: number;
   }
   export interface SocketInfo {
     localAddress?: string
@@ -103,6 +115,20 @@ export declare namespace Client {
     bytesWritten?: number
     bytesRead?: number
   }
+  export interface WebSocketOptions {
+    /**
+     * Maximum number of fragments in a message. Set to 0 to disable the limit.
+     * @default 131072
+     */
+    maxFragments?: number;
+    /**
+     * Maximum allowed payload size in bytes for WebSocket messages.
+     * Applied to uncompressed messages, compressed frame payloads, and decompressed (permessage-deflate) messages.
+     * Set to 0 to disable the limit.
+     * @default 134217728 (128 MB)
+     */
+    maxPayloadSize?: number;
+  }
 }
 
-export default Client;
+export default Client

package/node_modules/undici-types/connector.d.ts

@@ -1,5 +1,5 @@
-import { TLSSocket, ConnectionOptions } from 'tls'
-import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'net'
+import { TLSSocket, ConnectionOptions } from 'node:tls'
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'node:net'
 
 export default buildConnector
 declare function buildConnector (options?: buildConnector.BuildOptions): buildConnector.connector
@@ -7,12 +7,14 @@ declare function buildConnector (options?: buildConnector.BuildOptions): buildCo
 declare namespace buildConnector {
   export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
     allowH2?: boolean;
+    preferH2?: boolean;
     maxCachedSessions?: number | null;
     socketPath?: string | null;
     timeout?: number | null;
     port?: number;
     keepAlive?: boolean | null;
     keepAliveInitialDelay?: number | null;
+    typeOfService?: number | null;
   }
 
   export interface Options {
@@ -22,6 +24,7 @@ declare namespace buildConnector {
     port: string
     servername?: string
     localAddress?: string | null
+    socketPath?: string | null
     httpSocket?: Socket
   }
 

package/node_modules/undici-types/cookies.d.ts

@@ -18,7 +18,7 @@ export interface Cookie {
 export function deleteCookie (
   headers: Headers,
   name: string,
-  attributes?: { name?: string, domain?: string }
+  attributes?: { path?: string, domain?: string }
 ): void
 
 export function getCookies (headers: Headers): Record<string, string>
@@ -26,3 +26,5 @@ export function getCookies (headers: Headers): Record<string, string>
 export function getSetCookies (headers: Headers): Cookie[]
 
 export function setCookie (headers: Headers, cookie: Cookie): void
+
+export function parseCookie (cookie: string): Cookie | null

package/node_modules/undici-types/diagnostics-channel.d.ts

@@ -1,7 +1,7 @@
-import { Socket } from "net";
-import { URL } from "url";
-import Connector from "./connector";
-import Dispatcher from "./dispatcher";
+import { Socket } from 'node:net'
+import { URL } from 'node:url'
+import buildConnector from './connector'
+import Dispatcher from './dispatcher'
 
 declare namespace DiagnosticsChannel {
   interface Request {
@@ -16,21 +16,29 @@ declare namespace DiagnosticsChannel {
     statusText: string;
     headers: Array<Buffer>;
   }
-  type Error = unknown;
   interface ConnectParams {
-    host: URL["host"];
-    hostname: URL["hostname"];
-    protocol: URL["protocol"];
-    port: URL["port"];
+    host: URL['host'];
+    hostname: URL['hostname'];
+    protocol: URL['protocol'];
+    port: URL['port'];
     servername: string | null;
   }
-  type Connector = Connector.connector;
+  type Connector = buildConnector.connector
   export interface RequestCreateMessage {
     request: Request;
   }
   export interface RequestBodySentMessage {
     request: Request;
   }
+
+  export interface RequestBodyChunkSentMessage {
+    request: Request;
+    chunk: Uint8Array | string;
+  }
+  export interface RequestBodyChunkReceivedMessage {
+    request: Request;
+    chunk: Buffer;
+  }
   export interface RequestHeadersMessage {
     request: Request;
     response: Response;