motion-master-client 0.0.338 → 0.0.340

package/src/lib/util.d.ts

@@ -1,72 +1,120 @@
-import { OperatorFunction } from 'rxjs';
 import { SystemLogLine } from './system-log-line';
 import { IMotionMasterMessage, MotionMasterMessage, Ipv4 } from './types';
 /**
- * Parses a single line of system log into a structured `SystemLogLine` object.
+ * Parses a single line of a system log into a structured `SystemLogLine` object.
  *
- * This function uses a regular expression to extract key parts of a log line: the timestamp, uptime, ID,
- * file, log level, and message. If the line matches the expected format, it returns an object with these
- * extracted properties. If the line doesn't match the format, it returns `undefined`.
+ * The function expects the log line to follow the format:
+ * ```
+ * YYYY-MM-DD HH:MM:SS.sss (uptime) [id]file:linelevel|message
+ * ```
+ * where the `id` part is optional.
  *
- * **Note:** The regular expression uses the `s` flag (dot-all mode), which may not be supported in all browsers.
- * This is suppressed with `@ts-ignore`.
+ * @param line - A single system log line as a string.
+ * @returns A `SystemLogLine` object with parsed fields, or `undefined` if the line cannot be parsed.
  *
- * @param {string} line - A single log line to parse.
- * @returns {SystemLogLine | undefined} A `SystemLogLine` object with the parsed data, or `undefined` if the line doesn't match the expected format.
+ * @example
+ * const line = '2025-12-05 10:01:23.123 (12:34:56) [device1]main.ts:123INFO|Started';
+ * const parsed = parseSystemLogLine(line);
+ * console.log(parsed?.date);    // → Date object for '2025-12-05 10:01:23.123'
+ * console.log(parsed?.uptime);  // → '12:34:56'
+ * console.log(parsed?.id);      // → 'device1'
+ * console.log(parsed?.message); // → 'Started'
+ *
+ * @remarks
+ * - Uses a regular expression with the `s` (dotAll) flag; this may not be supported in all browsers.
+ * - If parsing fails, the function returns `undefined`.
+ * - The returned object includes the original line for reference.
  */
 export declare function parseSystemLogLine(line: string): SystemLogLine | undefined;
 /**
- * Parses the content of a system log into an array of `SystemLogLine` objects.
+ * Parses a system log string into an array of structured `SystemLogLine` objects.
+ *
+ * Each log entry is expected to start with a timestamp in the format `YYYY-MM-DD HH:MM:SS.sss`.
+ * The function uses a regular expression to split the content into individual log entries,
+ * then parses each entry into a `SystemLogLine` using `parseSystemLogLine`.
  *
- * This function uses a regular expression to split the log content into individual log lines. It then parses
- * each log line into a structured `SystemLogLine` object. The function also filters out any empty lines
- * and ensures only valid `SystemLogLine` objects are returned.
+ * @param content - The full system log content as a string.
+ * @returns An array of `SystemLogLine` objects representing each parsed log entry.
  *
- * **Note:** The regular expression uses the `s` flag, which may not be supported in all browsers. This is suppressed
- * with `@ts-ignore` to allow the use of dot-all mode in the regex.
+ * @example
+ * const logContent = '2025-12-05 10:01:23.123 Info: started\n2025-12-05 10:01:24.456 Error: failed';
+ * const lines = parseSystemLogContent(logContent);
+ * console.log(lines[0].timestamp); // → Date object for '2025-12-05 10:01:23.123'
  *
- * @param {string} content - The raw system log content to parse.
- * @returns {SystemLogLine[]} An array of `SystemLogLine` objects parsed from the log content.
+ * @remarks
+ * - Entries that cannot be parsed by `parseSystemLogLine` are ignored.
+ * - The regular expression uses the `s` (dotAll) flag, which may not be supported in all browsers;
+ *   a `@ts-ignore` is used to suppress TypeScript warnings.
  */
 export declare function parseSystemLogContent(content: string): SystemLogLine[];
 /**
- * Differs two system log contents and returns the new content after the last matching line.
+ * Computes the difference between two system log contents by returning only the new lines
+ * added after the last known line from the old content.
+ *
+ * @param oldContent - The previous log content.
+ * @param newContent - The current log content.
+ * @param lineSeparator - Optional string used to split lines (default: `'\n'`).
+ * @param lastLineIndex - Optional index of the line in `oldContent` to use as the reference point
+ *                        (default: `-2`, i.e., the second-to-last line).
+ * @returns A string containing only the new lines from `newContent` that come after the reference
+ *          line from `oldContent`. If the reference line is not found, returns the entire `newContent`.
  *
- * This function compares two log contents, `oldContent` and `newContent`, and returns the portion of
- * the `newContent` that appears after the last matching line in the `oldContent`. It splits the content
- * based on the provided `lineSeparator` and uses the `lastLineIndex` to find the line to compare.
+ * @example
+ * const oldLog = 'line1\nline2\nline3';
+ * const newLog = 'line1\nline2\nline3\nline4\nline5';
+ * const diff = diffSystemLogContents(oldLog, newLog);
+ * console.log(diff); // → 'line4\nline5'
  *
- * @param {string} oldContent - The original system log content to compare against.
- * @param {string} newContent - The new system log content to find the difference from the old content.
- * @param {string} [lineSeparator='\n'] - The character(s) used to separate lines in the content (default is newline).
- * @param {number} [lastLineIndex=-2] - The index of the last line to compare, negative index can be used (default is -2, the second-to-last line).
- * @returns {string} The portion of `newContent` after the last matching line in `oldContent`. If no match is found, returns the entire `newContent`.
+ * @remarks
+ * - Useful for incremental log processing where only newly appended lines need to be handled.
+ * - Handles negative indexing for selecting the reference line from the end of `oldContent`.
  */
 export declare function diffSystemLogContents(oldContent: string, newContent: string, lineSeparator?: string, lastLineIndex?: number): string;
 /**
- * Converts a `MotionMasterMessage` to a plain JavaScript object with specific field handling options.
+ * Converts a `MotionMasterMessage` instance into a plain JavaScript object with full defaults
+ * and JSON-compatible values.
  *
- * This function utilizes the `MotionMasterMessage.toObject()` method to create a plain object
- * from the provided `MotionMasterMessage`. It includes various options for how fields are processed,
- * such as handling arrays, default values, and JSON compatibility.
+ * The conversion uses `MotionMasterMessage.toObject` with options that:
+ * - Convert bytes fields to standard arrays.
+ * - Include default values for missing fields.
+ * - Initialize empty arrays for repeated fields and empty objects for map fields.
+ * - Include virtual `oneof` properties indicating which field is set.
+ * - Apply JSON-compatible conversions (e.g., NaN and Infinity to strings).
  *
- * **Note:** The function includes a fix for the error `TypeError: Cannot freeze array buffer views with elements in NgRx`.
+ * @param motionMasterMessage - The `MotionMasterMessage` instance to convert.
+ * @returns A plain object representation of the message with all fields populated and JSON-safe.
  *
- * @param {MotionMasterMessage} motionMasterMessage - The `MotionMasterMessage` instance to convert.
- * @returns {object} A plain JavaScript object representing the message with the specified options applied.
+ * @example
+ * const plainObject = createPlainObjectFromMotionMasterMessage(message);
+ * console.log(plainObject.status); // → fully populated status object
+ *
+ * @remarks
+ * - Useful for logging, serialization, or transferring messages over standard JSON APIs.
+ * - Ensures that all optional, repeated, and map fields are represented in the resulting object.
  */
 export declare function createPlainObjectFromMotionMasterMessage(motionMasterMessage: MotionMasterMessage): IMotionMasterMessage;
 /**
- * Converts a `motionMasterMessage` into a logger context object.
+ * Converts a `IMotionMasterMessage` into a structured context object suitable for logging.
+ *
+ * The resulting object includes:
+ * - `namespace`: a string identifying the logging context (default: `'reqResMessage'`),
+ * - `motionMasterMessage`: the original message,
+ * - `type`: either `'request'` or `'status'` depending on the message content,
+ * - `name`: a comma-separated string of the keys in the request or status object.
  *
- * This function extracts relevant details from the provided `motionMasterMessage` and
- * constructs an object to be used as context in logging. It determines whether the message
- * is a request or status type and stores the associated keys from the respective properties.
+ * @param motionMasterMessage - The Motion Master message to convert.
+ * @param namespace - Optional namespace for the logging context (default is `'reqResMessage'`).
+ * @returns An object containing the logging context with type, name, namespace, and original message.
+ *
+ * @example
+ * const context = convertMotionMasterMessageToLoggerContext(message, 'motion');
+ * console.log(context.namespace); // → 'motion'
+ * console.log(context.type);      // → 'request' or 'status'
+ * console.log(context.name);      // → comma-separated keys of the message content
  *
- * @param {IMotionMasterMessage} motionMasterMessage - The message to convert into a logger context.
- * @param {string} [namespace='reqResMessage'] - The namespace to associate with the context (default is 'reqResMessage').
- * @returns {object} An object containing the `namespace`, the original `motionMasterMessage`, the `type` of message
- *                   (either 'request' or 'status'), and the `name` (a string of keys from the request or status).
+ * @remarks
+ * - Determines type by checking the presence of `request` or `status` in the message.
+ * - Useful for structured logging or telemetry where message metadata is required.
  */
 export declare function convertMotionMasterMessageToLoggerContext(motionMasterMessage: IMotionMasterMessage, namespace?: string): {
     namespace: string;
@@ -75,153 +123,242 @@ export declare function convertMotionMasterMessageToLoggerContext(motionMasterMe
     name: string;
 };
 /**
- * Decodes a `Uint8Array` of text content into a string.
+ * Decodes a `Uint8Array` of bytes into a string using UTF-8 encoding.
  *
- * This function uses the `TextDecoder` API to decode the given `Uint8Array` (representing
- * text encoded in a specific encoding, such as UTF-8) into a readable string.
+ * @param content - The byte array to decode.
+ * @returns The decoded string representation of the input bytes.
  *
- * @param {Uint8Array} content - The `Uint8Array` containing the encoded text.
- * @returns {string} The decoded string.
+ * @example
+ * const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+ * const text = decodeTextContent(bytes); // → "Hello"
+ *
+ * @remarks
+ * - Uses the standard `TextDecoder` API with UTF-8 encoding.
+ * - Creates a copy of the input array before decoding, so the original `Uint8Array` is not modified.
  */
 export declare function decodeTextContent(content: Uint8Array): string;
 /**
- * Resolves a promise after a specified delay.
+ * Returns a promise that resolves with the specified value after a given delay.
+ *
+ * @typeParam T - The type of the value to resolve.
+ * @param ms - The delay in milliseconds before the promise resolves.
+ * @param value - Optional value to resolve the promise with (defaults to `undefined` if not provided).
+ * @returns A `Promise` that resolves to `value` after `ms` milliseconds.
  *
- * This function returns a promise that resolves after the given number of milliseconds (`ms`),
- * optionally resolving with a provided value.
+ * @example
+ * await resolveAfter(1000, 'hello'); // resolves with 'hello' after 1 second
+ * await resolveAfter(500);           // resolves with undefined after 0.5 seconds
  *
- * @param {number} ms - The number of milliseconds to wait before resolving the promise.
- * @param {unknown} [value] - The value to resolve with once the delay has passed. Default is `undefined`.
- * @returns {Promise<unknown>} A promise that resolves with the specified value after the delay.
+ * @remarks
+ * - Useful for simulating delays or asynchronous timing in tests or animations.
+ * - The function does not reject; it always resolves after the specified timeout.
  */
 export declare function resolveAfter<T>(ms: number, value?: T): Promise<T | undefined>;
 /**
- * Converts a 24-bit RGB color value to a format used by LED controllers.
+ * Converts a standard 24-bit RGB color value into a format suitable for certain LED controllers.
+ *
+ * The conversion swaps the red and green channels, producing a new 24-bit integer where:
+ * - Original green becomes the most significant byte,
+ * - Original red becomes the middle byte,
+ * - Original blue remains the least significant byte.
  *
- * This function takes an RGB color value (represented as a single 24-bit number)
- * and rearranges the color channels to match a typical LED color format, which may
- * require swapping the red and green channels.
+ * @param value - A 24-bit RGB color represented as a number (0xRRGGBB).
+ * @returns The converted 24-bit LED color value with swapped red and green channels.
+ *
+ * @example
+ * const rgb = 0x112233;
+ * const ledColor = convertRgbToLedColor(rgb); // → 0x221133
  *
- * @param {number} value - A 24-bit integer representing the RGB color value (0xRRGGBB).
- * @returns {number} A new integer representing the color in the LED format (0xGRB).
+ * @remarks
+ * - Useful when interfacing with LED hardware that expects a different channel ordering.
+ * - Input and output are standard JavaScript numbers representing 24-bit colors.
  */
 export declare function convertRgbToLedColor(value: number): number;
 /**
- * Generates a random hex color code with a specified brightness.
+ * Generates a random hexadecimal color string with a specified minimum brightness.
  *
- * This function creates a random color by generating random values for the red, green, and blue
- * color channels. The brightness parameter ensures the generated color is not too dark by
- * limiting the possible range for each channel.
+ * @param brightness - Minimum value for each RGB channel (0–255). Higher values produce lighter colors.
+ * @returns A random color string in `#RRGGBB` format.
  *
- * @param {number} brightness - The minimum brightness of the generated color. Should be between 0 and 255.
- * @returns {string} A random hex color code, in the form of `#RRGGBB`.
+ * @example
+ * createRandomColor(100); // → '#c48f7a' (example output)
+ * createRandomColor(200); // → '#e5f0ff' (example output)
  *
- * @throws {Error} Throws an error if the brightness is not between 0 and 255.
+ * @remarks
+ * - Each color channel (red, green, blue) is independently randomized between `brightness` and 255.
+ * - Ensures that no channel is darker than the specified brightness.
+ * - Useful for generating visually distinct colors while avoiding very dark shades.
  */
 export declare function createRandomColor(brightness: number): string;
 /**
- * Retrieves the first key from a `Map` that matches a given value.
+ * Finds the first key in a `Map` that corresponds to the specified value.
+ *
+ * @typeParam K - The type of keys in the map.
+ * @typeParam V - The type of values in the map.
+ * @param map - The map to search.
+ * @param searchValue - The value to find the corresponding key for.
+ * @returns The first key whose value strictly equals (`===`) the searchValue, or `undefined` if no match is found.
  *
- * This function iterates over the entries of the map and returns the first key
- * whose corresponding value strictly equals (`===`) the provided `searchValue`.
- * If no matching value is found, it returns `undefined`.
+ * @example
+ * const myMap = new Map<string, number>([['a', 1], ['b', 2], ['c', 1]]);
+ * getMapKeyByValue(myMap, 1); // → 'a'
+ * getMapKeyByValue(myMap, 3); // → undefined
  *
- * @template K - The type of the map's keys.
- * @template V - The type of the map's values.
- * @param {Map<K, V>} map - The map to search through.
- * @param {V} searchValue - The value to find the corresponding key for.
- * @returns {K | undefined} The key associated with the given value, or `undefined` if not found.
+ * @remarks
+ * - Only the first matching key is returned; subsequent keys with the same value are ignored.
+ * - Comparison uses strict equality (`===`).
  */
 export declare function getMapKeyByValue<K, V>(map: Map<K, V>, searchValue: V): K | undefined;
 /**
- * Finds and returns the duplicate elements in an array.
+ * Identifies duplicate elements in an array and returns them as a new array.
  *
- * This function iterates through the array and identifies elements that appear more than once.
- * It preserves only one instance of each duplicate in the output.
+ * @typeParam T - The type of elements in the array.
+ * @param arr - The array to check for duplicate values.
+ * @returns An array containing all elements that appear more than once in the input array.
+ *          Each duplicate element appears only once in the returned array, regardless of how many times it occurs.
  *
- * @template T - The type of elements in the array.
- * @param {T[]} arr - The input array to search for duplicates.
- * @returns {T[]} An array of the duplicate elements, without repetition.
+ * @example
+ * findDuplicates([1, 2, 3, 2, 4, 3, 5]); // → [2, 3]
+ * findDuplicates(['a', 'b', 'a', 'c']);   // → ['a']
+ *
+ * @remarks
+ * - Uses `Set` internally for efficient duplicate detection.
+ * - Preserves the insertion order of first detected duplicates.
  */
 export declare function findDuplicates<T>(arr: T[]): T[];
 /**
- * Converts a camelCase string into a space-separated lowercase string.
+ * Converts a camelCase or PascalCase string into a space-separated, lowercase string.
+ *
+ * @param str - The input string in camelCase or PascalCase format.
+ * @returns A new string where each uppercase letter is preceded by a space and all letters are lowercase.
  *
- * This function inserts spaces before each uppercase letter in the string (except the first one)
- * and converts the entire string to lowercase.
+ * @example
+ * camelCaseToWords('camelCaseString'); // → 'camel case string'
+ * camelCaseToWords('PascalCase');      // → 'pascal case'
  *
- * @param {string} str - The camelCase string to convert.
- * @returns {string} A space-separated, lowercase version of the input string.
+ * @remarks
+ * - Useful for converting identifiers into human-readable words.
+ * - Leading spaces are preserved if the string starts with an uppercase letter.
  */
 export declare function camelCaseToWords(str: string): string;
 /**
- * Sets the specified bit in the given number to 0.
+ * Clears (sets to 0) the bit at the specified position in a number.
+ *
+ * @param value - The original number whose bit is to be cleared.
+ * @param position - Zero-based bit position to clear (0 = least-significant bit).
+ * @returns A new number with the bit at the specified position cleared to 0.
  *
- * @param {number} value - The original number whose bit will be modified.
- * @param {number} position - The position of the bit to set to 0 (0-based index).
- * @returns {number} The modified number with the specified bit set to 0.
+ * @example
+ * setBitLow(0b1011, 1); // → 0b1001 (clears bit 1)
+ * setBitLow(0b1111, 3); // → 0b0111 (clears bit 3)
+ *
+ * @remarks
+ * - Only the bit at the given position is affected; all other bits remain unchanged.
+ * - Works with any 32-bit integer representable in JavaScript.
  */
 export declare function setBitLow(value: number, position: number): number;
 /**
- * Sets the specified bit in the given number to 1.
+ * Sets (changes to 1) the bit at the specified position in a number.
+ *
+ * @param value - The original number whose bit is to be set.
+ * @param position - Zero-based bit position to set (0 = least-significant bit).
+ * @returns A new number with the bit at the specified position set to 1.
  *
- * @param {number} value - The original number whose bit will be modified.
- * @param {number} position - The position of the bit to set to 1 (0-based index).
- * @returns {number} The modified number with the specified bit set to 1.
+ * @example
+ * setBitHigh(0b1001, 1); // → 0b1011 (sets bit 1)
+ * setBitHigh(0b0111, 3); // → 0b1111 (sets bit 3)
+ *
+ * @remarks
+ * - Only the bit at the given position is affected; all other bits remain unchanged.
+ * - Works with any 32-bit integer representable in JavaScript.
  */
 export declare function setBitHigh(value: number, position: number): number;
 /**
- * Returns the bit at the specified position in a number.
+ * Retrieves the value of the bit at the specified position in a number.
  *
- * This function performs a bitwise AND operation to isolate the bit at the `k`th position.
- * If the bit is 0, it returns `0`; otherwise, it returns `1`.
+ * @param n - The number from which to retrieve the bit.
+ * @param k - Zero-based bit position to retrieve (0 = least-significant bit).
+ * @returns `1` if the bit at position `k` is set, otherwise `0`.
+ *
+ * @example
+ * getBit(0b1010, 1); // → 1 (bit 1 is set)
+ * getBit(0b1010, 0); // → 0 (bit 0 is clear)
  *
- * @param {number} n - The number whose bit will be retrieved.
- * @param {number} k - The position of the bit to retrieve (0-indexed).
- * @returns {number} The bit at position `k` (either 0 or 1).
+ * @remarks
+ * - Works with any 32-bit integer representable in JavaScript.
+ * - Does not modify the original number.
  */
 export declare function getBit(n: number, k: number): number;
 /**
- * Checks if the bit at the specified position is on (1).
+ * Checks whether the bit at the specified position in a number is set (1).
  *
- * This function performs a bitwise AND operation to check if the bit at the `k`th position is set to `1`.
- * It returns `true` if the bit is set, otherwise `false`.
+ * @param n - The number to check.
+ * @param k - Zero-based bit position to check (0 = least-significant bit).
+ * @returns `true` if the bit at position `k` is 1, otherwise `false`.
  *
- * @param {number} n - The number to check.
- * @param {number} k - The position of the bit to check (0-indexed).
- * @returns {boolean} `true` if the bit is on (1), otherwise `false`.
+ * @example
+ * isBitOn(0b1010, 1); // → true  (bit 1 is set)
+ * isBitOn(0b1010, 0); // → false (bit 0 is clear)
+ *
+ * @remarks
+ * - Works with any 32-bit integer representable in JavaScript.
+ * - Does not modify the original number.
  */
 export declare function isBitOn(n: number, k: number): boolean;
 /**
- * Sets the bit at the specified position to 1.
+ * Sets (changes to 1) the bit at the specified position in a number.
  *
- * This function performs a bitwise OR operation to ensure that the bit at the `k`th position is set to `1`.
+ * The original number is not mutated; a new number is returned with the bit set.
  *
- * @param {number} n - The number in which the bit will be set.
- * @param {number} k - The position of the bit to set (0-indexed).
- * @returns {number} The new number with the bit at position `k` set to 1.
+ * @param n - The original number whose bit is to be set.
+ * @param k - Zero-based bit position to set (0 = least-significant bit).
+ * @returns A new number equal to `n` with bit `k` set.
+ *
+ * @example
+ * setBit(0b1001, 1); // → 0b1011 (sets bit 1)
+ * setBit(0b0111, 3); // → 0b1111 (sets bit 3)
+ *
+ * @remarks
+ * - Only the bit at position `k` is affected; all other bits remain unchanged.
+ * - Works with any 32-bit integer representable in JavaScript.
  */
 export declare function setBit(n: number, k: number): number;
 /**
- * Clears the bit at the specified position (sets it to 0).
+ * Clears (sets to 0) the bit at the specified position in a number.
+ *
+ * The original number is not mutated; a new number is returned with the bit cleared.
  *
- * This function performs a bitwise AND operation with a mask to ensure that the bit at the `k`th position is set to `0`.
+ * @param n - The original number whose bit is to be cleared.
+ * @param k - Zero-based bit position to clear (0 = least-significant bit).
+ * @returns A new number equal to `n` with bit `k` cleared.
+ *
+ * @example
+ * clearBit(0b1011, 1); // → 0b1001 (clears bit 1)
+ * clearBit(0b1111, 3); // → 0b0111 (clears bit 3)
  *
- * @param {number} n - The number in which the bit will be cleared.
- * @param {number} k - The position of the bit to clear (0-indexed).
- * @returns {number} The new number with the bit at position `k` cleared (set to 0).
+ * @remarks
+ * - Only the bit at position `k` is affected; all other bits remain unchanged.
+ * - Works with any 32-bit integer representable in JavaScript.
  */
 export declare function clearBit(n: number, k: number): number;
 /**
- * Updates the bit at the specified position with the given value.
+ * Updates the bit at position `k` in the given number `n` to the specified value.
  *
- * This function updates the bit at the `k`th position to either `1` or `0` depending on the provided value.
- * If the value is a boolean, it will be normalized to `1` (true) or `0` (false).
+ * The original number is not mutated; instead, a new number is returned with the bit updated.
+ *
+ * @param n - The original number whose bit is being modified.
+ * @param k - Zero-based bit position to update (0 = least-significant bit).
+ * @param value - Boolean or numeric value indicating whether the bit should be set (`true` / `1`)
+ *                or cleared (`false` / `0`).
+ * @returns A new number equal to `n` with bit `k` updated.
+ *
+ * @example
+ * updateBit(0b1010, 1, true);   // → 0b1011 (set bit 1)
+ * updateBit(0b1011, 3, false);  // → 0b0011 (clear bit 3)
  *
- * @param {number} n - The number in which the bit will be updated.
- * @param {number} k - The position of the bit to update (0-indexed).
- * @param {number | boolean} value - The value to set the bit to (1 or 0, or `true`/`false`).
- * @returns {number} The new number with the bit at position `k` updated.
+ * @remarks
+ * - Values other than `0` or `false` result in bit being set to `1`.
+ * - Works with any 32-bit integer representable in JavaScript.
  */
 export declare function updateBit(n: number, k: number, value: number | boolean): number;
 /**
@@ -234,15 +371,20 @@ export declare function updateBit(n: number, k: number, value: number | boolean)
  */
 export declare function toFixedFormat(x: number | string, n?: number, rightTrimZero?: boolean): string;
 /**
- * Converts a `Blob` into a Base64-encoded string.
+ * Converts a `Blob` object into a Base64-encoded string.
  *
- * This function reads the provided `Blob` using `FileReader` and extracts the Base64 content
- * from the resulting data URL.
+ * @param blob - The `Blob` to convert.
+ * @returns A `Promise` that resolves to the Base64 string representation of the blob.
  *
- * @param {Blob} blob - The `Blob` to convert into a Base64 string.
- * @returns {Promise<string>} A promise that resolves with the Base64 string representation of the blob.
+ * @example
+ * const blob = new Blob(['Hello, world!'], { type: 'text/plain' });
+ * const base64 = await convertBlobToBase64(blob);
+ * console.log(base64); // → 'SGVsbG8sIHdvcmxkIQ=='
  *
- * @throws {string} If the blob cannot be read (e.g., due to an error), the promise rejects with an error message.
+ * @remarks
+ * - Internally uses `FileReader.readAsDataURL` to serialize the blob.
+ * - The returned Base64 string excludes the data URL prefix (e.g., `data:text/plain;base64,`).
+ * - The promise is rejected if the blob cannot be read.
  */
 export declare function convertBlobToBase64(blob: Blob): Promise<string>;
 /**
@@ -277,12 +419,17 @@ export declare function isElectronContext(): boolean;
  *
  * The function uses bitwise operations to isolate each byte from the 32-bit integer.
  *
- * @param {number} value - The 32-bit integer to be parsed.
- * @returns {Object} An object containing the extracted components:
+ * @param value - The 32-bit integer to be parsed.
+ * @returns An object containing the extracted components:
  *   - `prefix`: The extracted prefix byte (8 bits).
  *   - `numerator`: The extracted numerator byte (8 bits).
  *   - `denominator`: The extracted denominator byte (8 bits).
  *   - `reserved`: The extracted reserved byte (8 bits).
+ *
+ * @example
+ * const parsed = parseUnitValue(0x12345678);
+ * console.log(parsed);
+ * // → { prefix: 0x12, numerator: 0x34, denominator: 0x56, reserved: 0x78 }
  */
 export declare function parseUnitValue(value: number): {
     prefix: number;
@@ -293,21 +440,34 @@ export declare function parseUnitValue(value: number): {
 /**
  * Merges multiple `Uint8Array` instances into a single `Uint8Array`.
  *
- * This function concatenates all provided `Uint8Array` instances in the order they are given,
- * producing a new array containing all their bytes sequentially.
+ * @param ary - One or more `Uint8Array` instances to merge.
+ * @returns A new `Uint8Array` containing all elements from the input arrays in order.
+ *
+ * @example
+ * const a = new Uint8Array([1, 2]);
+ * const b = new Uint8Array([3, 4]);
+ * const merged = mergeUint8Arrays(a, b); // → Uint8Array [1, 2, 3, 4]
  *
- * @param {...Uint8Array[]} ary - An array of `Uint8Array` instances to merge.
- * @returns {Uint8Array} A new `Uint8Array` containing the concatenated bytes from all input arrays.
+ * @remarks
+ * - Preserves the order of elements from each input array.
+ * - Efficiently concatenates arrays without creating intermediate arrays for each element.
+ * - Returns a new `Uint8Array`; the input arrays are not modified.
  */
 export declare function mergeUint8Arrays(...ary: Uint8Array[]): Uint8Array;
 /**
- * Returns an array of unique items by removing duplicates from the given array.
+ * Returns a new array containing only the unique elements from the input array, preserving their order.
+ *
+ * @typeParam T - The type of elements in the array.
+ * @param items - The array from which to remove duplicates.
+ * @returns A new array with duplicate elements removed.
  *
- * This function utilizes the `Set` object to remove duplicate values, ensuring that only unique items
- * remain in the returned array. The order of items in the resulting array is preserved as in the input.
+ * @example
+ * uniqueItems([1, 2, 2, 3, 1]); // → [1, 2, 3]
+ * uniqueItems(['a', 'b', 'a']); // → ['a', 'b']
  *
- * @param {Array<T>} items - The array from which duplicates will be removed.
- * @returns {Array<T>} A new array containing only the unique items from the input array.
+ * @remarks
+ * - Uses a `Set` internally for efficient duplicate removal.
+ * - Original array is not modified.
  */
 export declare function uniqueItems<T>(items: Array<T>): Array<T>;
 /**
@@ -450,27 +610,6 @@ export interface NotificationEntry {
     message: string;
     timeDifference: number;
 }
-/**
- * Custom RxJS operator that accumulates notifications with their
- * elapsed time relative to a provided start time.
- *
- * Each emitted notification string is converted into a `NotificationEntry`
- * object, and the operator maintains an array of all previous entries.
- *
- * @param startTime - The timestamp (in milliseconds) to use as the reference
- *   point for calculating elapsed time. Typically obtained via `performance.now()`.
- * @returns An OperatorFunction that transforms an Observable of strings into
- *   an Observable of `NotificationEntry[]`.
- *
- * @example
- * ```ts
- * const startTime = performance.now();
- * notifications$.pipe(withTimeDifference(startTime)).subscribe(entries => {
- *   console.log(entries); // Array of NotificationEntry objects with elapsed time
- * });
- * ```
- */
-export declare function withTimeDifference(startTime: number): OperatorFunction<string, NotificationEntry[]>;
 /**
  * Analyzes an array of measured time durations and returns useful statistics
  * both for the full dataset and for outlier-filtered data.