@angular-wave/angular.ts 0.15.0 → 0.15.1

package/@types/services/stream/stream.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared Stream Connection Manager
+ * Handles reconnect, heartbeat, and event callbacks for SSE or WebSocket
+ */
+export class StreamConnection {
+  /**
+   * @param {() => EventSource | WebSocket} createFn - Function that creates a new EventSource or WebSocket.
+   * @param {ng.StreamConnectionConfig} config - Configuration object with callbacks, retries, heartbeat, transformMessage.
+   * @param {ng.LogService} log - Optional logger (default: console).
+   */
+  constructor(
+    createFn: () => EventSource | WebSocket,
+    config?: ng.StreamConnectionConfig,
+    log?: ng.LogService,
+  );
+  /** @private @type {() => EventSource | WebSocket} */
+  private _createFn;
+  _config: {
+    onOpen?: (event: Event) => void;
+    onMessage?: (data: any, event: Event | MessageEvent) => void;
+    onError?: (err: any) => void;
+    onReconnect?: (attempt: number) => void;
+    retryDelay: number;
+    maxRetries: number;
+    heartbeatTimeout: number;
+    transformMessage: (data: string) => any;
+  };
+  _log: import("../log/interface.ts").LogService;
+  _retryCount: number;
+  _closed: boolean;
+  _heartbeatTimer: number;
+  /** @type {EventSource | WebSocket | null} */
+  _connection: EventSource | WebSocket | null;
+  /**
+   * Establishes a new connection using the provided createFn.
+   * Closes any existing connection before creating a new one.
+   */
+  connect(): void;
+  /**
+   * Sends data over a WebSocket connection.
+   * Logs a warning if called on a non-WebSocket connection.
+   * @param {any} data - Data to send.
+   */
+  send(data: any): void;
+  /**
+   * Closes the connection manually and clears the heartbeat timer.
+   */
+  close(): void;
+  /**
+   * @private
+   * Binds event handlers to the underlying connection (EventSource or WebSocket)
+   * for open, message, error, and close events.
+   */
+  private _bindEvents;
+  /**
+   * @private
+   * Handles the open event from the connection.
+   * @param {Event} event - The open event.
+   */
+  private _handleOpen;
+  /**
+   * @private
+   * Handles incoming messages, applies the transformMessage function,
+   * and calls the onMessage callback.
+   * @param {any} data - Raw message data.
+   * @param {Event} event - The message event.
+   */
+  private _handleMessage;
+  /**
+   * @private
+   * Handles errors emitted from the connection.
+   * Calls onError callback and schedules a reconnect.
+   * @param {any} err - Error object or message.
+   */
+  private _handleError;
+  /**
+   * @private
+   * Handles close events for WebSocket connections.
+   * Triggers reconnect logic.
+   */
+  private _handleClose;
+  /**
+   * @private
+   * Schedules a reconnect attempt based on retryCount and config.maxRetries.
+   * Calls onReconnect callback if reconnecting.
+   */
+  private _scheduleReconnect;
+  /**
+   * @private
+   * Resets the heartbeat timer. If the timer expires, the connection is closed
+   * and a reconnect is attempted.
+   */
+  private _resetHeartbeat;
+  /**
+   * @private
+   */
+  private _closeInternal;
+}

package/@types/shared/common.d.ts

@@ -113,10 +113,10 @@ export function applyPairs(memo: any, keyValTuple: any): any;
 /**
  * Returns the last element of an array, or undefined if the array is empty.
  * @template T
- * @param {T[]} arr - The input array.
+ * @param {any[]|string} arr - The input array.
  * @returns {T | undefined} The last element or undefined.
  */
-export function tail<T>(arr: T[]): T | undefined;
+export function tail<T>(arr: any[] | string): T | undefined;
 /**
  * shallow copy from src to dest
  */

package/@types/shared/dom.d.ts

@@ -37,16 +37,6 @@ export function getExpando(
  * @returns {boolean} True if the string is plain text, false if it contains HTML tags or entities.
  */
 export function isTextNode(html: string): boolean;
-/**
- * @param {string} html
- * @returns {DocumentFragment}
- */
-export function buildFragment(html: string): DocumentFragment;
-/**
- * @param {string} html
- * @returns {NodeListOf<ChildNode> | HTMLElement[]}
- */
-export function parseHtml(html: string): NodeListOf<ChildNode> | HTMLElement[];
 /**
  * @param {Element} element
  * @param {boolean} [onlyDescendants]
@@ -144,18 +134,6 @@ export function getController(
  * @returns
  */
 export function getInheritedData(element: Node, name: string): any;
-/**
- *
- * @param {Node} element
- * @param {string|string[]} name
- * @param {any} [value]
- * @returns {any|undefined}
- */
-export function setInheritedData(
-  element: Node,
-  name: string | string[],
-  value?: any,
-): any | undefined;
 /**
  *
  * @param {Element} element
@@ -172,9 +150,9 @@ export function startingTag(elementOrStr: string | Element | Node): string;
 /**
  * Return the DOM siblings between the first and last node in the given array.
  * @param {Array<Node>} nodes An array-like object
- * @returns {Element} the inputted object or a JQLite collection containing the nodes
+ * @returns {*[]|Array<Node>} the inputted object or a JQLite collection containing the nodes
  */
-export function getBlockNodes(nodes: Array<Node>): Element;
+export function getBlockNodes(nodes: Array<Node>): any[] | Array<Node>;
 /**
  * Gets the name of a boolean attribute if it exists on a given element.
  *
@@ -210,26 +188,11 @@ export function createElementFromHTML(htmlString: string): Element;
  * @returns {NodeList} - The parsed DOM element.
  */
 export function createNodelistFromHTML(htmlString: string): NodeList;
-/**
- * Appends nodes or an HTML string to a given DOM element.
- * @param {Element} element - The element to append nodes to.
- * @param {Node | Node[] | string} nodes - Nodes or HTML string to append.
- */
-export function appendNodesToElement(
-  element: Element,
-  nodes: Node | Node[] | string,
-): void;
 /**
  * Remove element from the DOM and clear Cache data, associated with the node.
  * @param {Element} element
  */
 export function emptyElement(element: Element): void;
-/**
- * Checks if the element is root
- * @param {Element} element
- * @returns {boolean}
- */
-export function isRoot(element: Element): boolean;
 /**
  * Inserts a DOM element before or at the beginning of a parent element.
  *
@@ -239,7 +202,7 @@ export function isRoot(element: Element): boolean;
  * @param {HTMLElement | Element} parentElement
  *   The parent element that will receive the inserted element.
  *
- * @param {HTMLElement | Element | null} [afterElement]
+ * @param {ChildNode | Element | null} [afterElement]
  *   An optional sibling element — if present and valid, `element`
  *   will be inserted after it. If omitted or invalid, `element`
  *   is prepended to `parentElement`.
@@ -249,15 +212,31 @@ export function isRoot(element: Element): boolean;
 export function domInsert(
   element: HTMLElement | Element,
   parentElement: HTMLElement | Element,
-  afterElement?: HTMLElement | Element | null,
+  afterElement?: ChildNode | Element | null,
+): void;
+/**
+ * @param {HTMLElement} element
+ * @param {HTMLElement} parent
+ * @param {ChildNode | null | undefined} after
+ */
+export function animatedomInsert(
+  element: HTMLElement,
+  parent: HTMLElement,
+  after: ChildNode | null | undefined,
 ): void;
-export function animatedomInsert(element: any, parent: any, after: any): void;
 /**
  * Returns the base href of the document.
  *
  * @returns {string} The base href.
  */
 export function getBaseHref(): string;
+/**
+ * Expando cache for adding properties to DOM nodes with JavaScript.
+ * This used to be an Object in JQLite decorator, but swapped out for a Map
+ *
+ * @type {Map<number, import('../interface.ts').ExpandoStore>}
+ */
+export const Cache: Map<number, import("../interface.ts").ExpandoStore>;
 /**
  * A list of boolean attributes in HTML.
  * @type {string[]}

package/@types/shared/hof.d.ts

@@ -36,17 +36,10 @@
  *
  * ```
  *
- * @param fn
+ * @param {Function} fn
  * @returns {*|function(): (*|any)}
  */
-export function curry(fn: any): any | (() => any | any);
-/**
- * Given a varargs list of functions, returns a function that composes the argument functions, right-to-left
- * given: f(x), g(x), h(x)
- * let composed = compose(f,g,h)
- * then, composed is: f(g(h(x)))
- */
-export function compose(...fns: any[]): (...args: any[]) => any;
+export function curry(fn: Function): any | (() => any | any);
 /**
  * Given a class constructor, returns a predicate function that checks
  * whether a given object is an instance of that class.
@@ -69,33 +62,30 @@ export function is(ctor: new (...args: any[]) => any): (obj: any) => boolean;
  * of size 2: [ predicate, mapFn ]
  *
  * These 2-tuples should be put in an outer array.
- *
- * @example
- * ```
- *
- * // Here's a 2-tuple where the first element is the isString predicate
- * // and the second element is a function that returns a description of the input
- * let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
- *
- * // Second tuple: predicate "isNumber", mapfn returns a description
- * let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
- *
- * let third = [ (input) => input === null,  (input) => `Oh, null...` ];
- *
- * let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
- *
- * let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
- *
- * console.log(descriptionOf(undefined)); // 'notdefined'
- * console.log(descriptionOf(55)); // '(55) That's a number!'
- * console.log(descriptionOf("foo")); // 'Here's your string foo'
- * ```
- *
- * @param struct A 2D array.  Each element of the array should be an array, a 2-tuple,
- * with a Predicate and a mapping/output function
- * @returns {function(any): *}
+ * @example ```
+
+// Here's a 2-tuple where the first element is the isString predicate
+// and the second element is a function that returns a description of the input
+let firstTuple = [ angular.isString, (input) => `Heres your string ${input}` ];
+
+// Second tuple: predicate "isNumber", mapfn returns a description
+let secondTuple = [ angular.isNumber, (input) => `(${input}) That's a number!` ];
+
+let third = [ (input) => input === null,  (input) => `Oh, null...` ];
+
+let fourth = [ (input) => input === undefined,  (input) => `notdefined` ];
+
+let descriptionOf = pattern([ firstTuple, secondTuple, third, fourth ]);
+
+console.log(descriptionOf(undefined)); // 'notdefined'
+console.log(descriptionOf(55)); // '(55) That's a number!'
+console.log(descriptionOf("foo")); // 'Here's your string foo'
+```
+ * @param {string | any[]} struct A 2D array.  Each element of the array should be an array, a 2-tuple,
+with a Predicate and a mapping/output function
+ * @returns {function(any):*}
  */
-export function pattern(struct: any): (arg0: any) => any;
+export function pattern(struct: string | any[]): (arg0: any) => any;
 /**
  * Given a property name and a value, returns a function that returns a boolean based on whether
  * the passed object has a property that matches the value
@@ -104,5 +94,5 @@ export function pattern(struct: any): (arg0: any) => any;
  * getName(obj) === true
  */
 export const propEq: any;
-export function parse(path: any): (obj: any) => any;
-export function val(value: any): () => any;
+export function parse(path: string): (/** @type {any} */ obj: any) => any;
+export function val<T>(value: T): () => T;

package/@types/shared/noderef.d.ts

@@ -9,11 +9,11 @@ export class NodeRef {
    * @throws {Error} If the argument is invalid or cannot be wrapped properly.
    */
   constructor(element: Node | Element | string | NodeList | Node[]);
-  /** @private @type {Node | ChildNode | null} */
+  /** @private @type {Node | ChildNode | undefined} */
   private _node;
   /** @type {Element | undefined} */
   _element: Element | undefined;
-  /** @private @type {Array<Node> | undefined} a stable list on nodes */
+  /** @private @type {Array<Node>} a stable list on nodes */
   private _nodes;
   /** @type {boolean} */
   _isList: boolean;

package/@types/shared/strings.d.ts

@@ -34,7 +34,11 @@ export function functionToString(fn: Function): string;
  * @returns {string}
  */
 export function fnToString(fn: [] | Function): string;
-export function stringify(value: any): any;
+/**
+ * @param {any} value
+ * @returns {string|*|string}
+ */
+export function stringify(value: any): string | any | string;
 /**
  * Splits on a delimiter, but returns the delimiters in the array
  *
@@ -44,8 +48,11 @@ export function stringify(value: any): any;
  * splitOnSlashes("/foo"); // ["/", "foo"]
  * splitOnSlashes("/foo/"); // ["/", "foo", "/"]
  * ```
+ * @param {string} delim
  */
-export function splitOnDelim(delim: any): (str: any) => any;
+export function splitOnDelim(
+  delim: string,
+): (/** @type {string} */ str: string) => string[];
 /**
  * Reduce fn that joins neighboring strings
  *
@@ -57,6 +64,8 @@ export function splitOnDelim(delim: any): (str: any) => any;
  * let arr = ["foo", "bar", 1, "baz", "", "qux" ];
  * arr.reduce(joinNeighborsR, []) // ["foobar", 1, "bazqux" ]
  * ```
+ * @param {string | any[]} acc
+ * @param {unknown} str
  */
-export function joinNeighborsR(acc: any, str: any): any;
-export function stripLastPathElement(str: any): any;
+export function joinNeighborsR(acc: string | any[], str: unknown): any;
+export function stripLastPathElement(str: string): string;

package/@types/shared/utils.d.ts

@@ -68,7 +68,7 @@ export function isArray<T>(array: any): array is T[];
  * @param {new (...args: any[]) => T} type  The constructor to test against
  * @returns {val is T}
  */
-export function isIntanceOf<T>(
+export function isInstanceOf<T>(
   val: any,
   type: new (...args: any[]) => T,
 ): val is T;
@@ -90,11 +90,10 @@ export function isObject<T>(value: T): value is T & object;
 export function isBlankObject(value: any): boolean;
 /**
  * Determines if a reference is a `string`.
- *
- * @param value - The value to check.
+ * @param {unknown} value - The value to check.
  * @returns {value is string} True if `value` is a string.
  */
-export function isString(value: any): value is string;
+export function isString(value: unknown): value is string;
 /**
  * Determines if a reference is a null.
  *
@@ -211,13 +210,23 @@ export function isArrayBuffer(obj: any): boolean;
  * @returns {string | *}
  */
 export function trim(value: any): string | any;
-export function snakeCase(name: any, separator: any): any;
+/**
+ * @param {string} name
+ * @param {string} separator
+ */
+export function snakeCase(name: string, separator: string): string;
 /**
  * Set or clear the hashkey for an object.
- * @param obj object
- * @param hashkey the hashkey (!truthy to delete the hashkey)
+ * @param {{ [x: string]: any; _hashKey?: any; }} obj object
+ * @param {any} hashkey the hashkey (!truthy to delete the hashkey)
  */
-export function setHashKey(obj: any, hashkey: any): void;
+export function setHashKey(
+  obj: {
+    [x: string]: any;
+    _hashKey?: any;
+  },
+  hashkey: any,
+): void;
 /**
  * Deeply extends a destination object with one or more source objects.
  * Safely handles Dates, RegExps, DOM nodes, arrays, and nested objects.
@@ -262,17 +271,25 @@ export function isNumberNaN(num: any): boolean;
  * @returns {Object}
  */
 export function inherit(parent: any, extra: any): any;
-export function hasCustomToString(obj: any): boolean;
+/**
+ * @param {{ toString: () => string; }} obj
+ * @returns {boolean}
+ */
+export function hasCustomToString(obj: { toString: () => string }): boolean;
 /**
  * Returns a string appropriate for the type of node.
  *
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/nodeName)
  *
  * @param {Element} element
- * @returns
+ * @returns {string}
  */
 export function getNodeName(element: Element): string;
-export function includes(array: any, obj: any): boolean;
+/**
+ * @param {any} array
+ * @param {string} obj
+ */
+export function includes(array: any, obj: string): boolean;
 /**
  * Removes the first occurrence of a specified value from an array.
  *
@@ -282,7 +299,11 @@ export function includes(array: any, obj: any): boolean;
  * @returns {number} - The index of the removed value, or -1 if the value was not found.
  */
 export function arrayRemove<T>(array: Array<T>, value: T): number;
-export function simpleCompare(val1: any, val2: any): boolean;
+/**
+ * @param {unknown} val1
+ * @param {unknown} val2
+ */
+export function simpleCompare(val1: unknown, val2: unknown): boolean;
 /**
  * Determines if two objects or two values are equivalent. Supports value types, regular
  * expressions, arrays and objects.
@@ -347,14 +368,34 @@ export function equals(o1: any, o2: any): boolean;
  * @param  {string} context the context in which the name is used, such as module or directive
  */
 export function assertNotHasOwnProperty(name: string, context: string): void;
-export function stringify(value: any): any;
+/**
+ * @param {unknown} value
+ * @returns {string | unknown}
+ */
+export function stringify(value: unknown): string | unknown;
 /**
  * @param {Number} maxDepth
  * @return {boolean}
  */
 export function isValidObjectMaxDepth(maxDepth: number): boolean;
-export function concat(array1: any, array2: any, index: any): any;
-export function sliceArgs(args: any, startIndex: any): any;
+/**
+ * @param {any[]} array1
+ * @param {IArguments | any[] | NodeListOf<ChildNode>} array2
+ * @param {number | undefined} [index]
+ */
+export function concat(
+  array1: any[],
+  array2: IArguments | any[] | NodeListOf<ChildNode>,
+  index?: number | undefined,
+): any[];
+/**
+ * @param {IArguments | [string, ...any[]]} args
+ * @param {number} startIndex
+ */
+export function sliceArgs(
+  args: IArguments | [string, ...any[]],
+  startIndex: number,
+): any;
 /**
  * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
  * `fn`). You can supply optional `args` that are prebound to the function. This feature is also
@@ -367,62 +408,53 @@ export function sliceArgs(args: any, startIndex: any): any;
  */
 export function bind(context: any, fn: any, ...args: any[]): Function;
 /**
- * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
- * stripped since AngularTS uses this notation internally.
- *
- * @param {Object|Array|Date|string|number|boolean} obj Input to be serialized into JSON.
- * @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace.
- *    If set to an integer, the JSON output will contain that many spaces per indentation.
- * @returns {string|undefined} JSON-ified string representing `obj`.
- * @knownIssue
- *
- * The Safari browser throws a `RangeError` instead of returning `null` when it tries to stringify a `Date`
- * object with an invalid date value. The only reliable way to prevent this is to monkeypatch the
- * `Date.prototype.toJSON` method as follows:
- *
- * ```
- * let _DatetoJSON = Date.prototype.toJSON;
- * Date.prototype.toJSON = function() {
- *   try {
- *     return _DatetoJSON.call(this);
- *   } catch(e) {
- *     if (e instanceof RangeError) {
- *       return null;
- *     }
- *     throw e;
- *   }
- * };
- * ```
- *
- * See https://github.com/angular/angular.js/pull/14221 for more information.
+ * Serializes input into a JSON-formatted string. Properties with leading `$$` characters
+ * will be stripped since AngularTS uses this notation internally.
+ *
+ * @param {Object|Array<any>|Date|string|number|boolean} obj
+ *   Input to be serialized into JSON.
+ * @param {boolean|number} [pretty=2]
+ *   If `true`, the JSON output will contain newlines and whitespace (2 spaces).
+ *   If a number, the JSON output will contain that many spaces per indentation.
+ * @returns {string|undefined}
+ *   JSON-ified string representing `obj`, or `undefined` if `obj` is undefined.
  */
 export function toJson(
-  obj: any | any[] | Date | string | number | boolean,
+  obj: any | Array<any> | Date | string | number | boolean,
   pretty?: boolean | number,
 ): string | undefined;
 /**
  * Deserializes a JSON string.
  *
  * @param {string} json JSON string to deserialize.
- * @returns {Object|Array|string|number} Deserialized JSON string.
+ * @returns {Object|Array<any>|string|number} Deserialized JSON string.
+ */
+export function fromJson(json: string): any | Array<any> | string | number;
+/**
+ * @param {Date} date
+ * @param {number} minutes
  */
-export function fromJson(json: string): any | any[] | string | number;
-export function timezoneToOffset(timezone: any, fallback: any): any;
-export function addDateMinutes(date: any, minutes: any): Date;
-export function convertTimezoneToLocal(
-  date: any,
-  timezone: any,
-  reverse: any,
-): Date;
+export function addDateMinutes(date: Date, minutes: number): Date;
 /**
  * Parses an escaped url query string into key-value pairs.
  * @param {string} keyValue
- * @returns {Object.<string,boolean|Array>}
+ * @returns {Object.<string,boolean|Array<any>>}
  */
 export function parseKeyValue(keyValue: string): {
   [x: string]: boolean | any[];
 };
-export function toKeyValue(obj: any): string;
+/**
+ * @param {string | { [s: string]: any; } | ArrayLike<any> | null} obj
+ */
+export function toKeyValue(
+  obj:
+    | string
+    | {
+        [s: string]: any;
+      }
+    | ArrayLike<any>
+    | null,
+): string;
 /**
  * Tries to decode the URI component without throwing an exception.
  *
@@ -453,14 +485,27 @@ export function encodeUriSegment(val: string): string;
  *    pct-encoded   = "%" HEXDIG HEXDIG
  *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
  *                     / "*" / "+" / "," / ";" / "="
+ * @param {string | number | boolean} val
+ * @param {boolean | undefined} [pctEncodeSpaces]
  */
-export function encodeUriQuery(val: any, pctEncodeSpaces: any): string;
+export function encodeUriQuery(
+  val: string | number | boolean,
+  pctEncodeSpaces?: boolean | undefined,
+): string;
 /**
- * Creates a shallow copy of an object, an array or a primitive.
+ * Creates a shallow copy of an object, an array, or returns primitives as-is.
  *
- * Assumes that there are no proto properties for objects.
+ * Assumes there are no proto properties.
+ *
+ * @template T
+ * @param {T} src
+ * @param {T extends any[] ? T : Record<string, unknown>} [dst]
+ * @returns {T}
  */
-export function shallowCopy(src: any, dst: any): any;
+export function shallowCopy<T>(
+  src: T,
+  dst?: T extends any[] ? T : Record<string, unknown>,
+): T;
 /**
  * Throw error if the argument is false
  * @param {boolean} argument
@@ -469,13 +514,25 @@ export function shallowCopy(src: any, dst: any): any;
 export function assert(argument: boolean, errorMsg?: string): void;
 /**
  * Throw error if the argument is falsy.
+ * @param {string | boolean | Object} arg
+ * @param {string} name
+ * @param {string | undefined} [reason]
+ */
+export function assertArg(
+  arg: string | boolean | any,
+  name: string,
+  reason?: string | undefined,
+): any;
+/**
+ * @param {string | Function | any[]} arg
+ * @param {string} name
+ * @param {boolean | undefined} [acceptArrayAnnotation]
  */
-export function assertArg(arg: any, name: any, reason: any): any;
 export function assertArgFn(
-  arg: any,
-  name: any,
-  acceptArrayAnnotation: any,
-): any;
+  arg: string | Function | any[],
+  name: string,
+  acceptArrayAnnotation?: boolean | undefined,
+): string | Function | any[];
 /**
  * Configure several aspects of error handling if used as a setter or return the
  * current configuration if used as a getter.
@@ -527,8 +584,8 @@ export function toDebugString<T>(obj: T | ng.Scope): string;
  * Hash of a:
  *  string is string
  *  number is number as string
- *  object is either result of calling $$hashKey function on the object or uniquely generated id,
- *         that is also assigned to the $$hashKey property of the object.
+ *  object is either result of calling _hashKey function on the object or uniquely generated id,
+ *         that is also assigned to the _hashKey property of the object.
  *
  * @param {*} obj
  * @returns {string} hash string such that the same input will have the same hash string.

package/@types/shared/validate.d.ts

@@ -31,6 +31,13 @@ export function validateArray(arg: any, name: string): any;
  * @throws {TypeError} If the value does not satisfy the validator.
  */
 export function validateIsString(arg: any, name: string): any;
+/**
+ * @param {*} arg - The value to validate.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {number} The validated value.
+ * @throws {TypeError} If the value is not a number.
+ */
+export function validateIsNumber(arg: any, name: string): number;
 /**
  * @template T
  * @param {unknown} arg - The value to validate.