cmpstr 2.0.2 → 3.0.0

package/dist/types/phonetic/Phonetic.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Abstract Phonetic
+ * src/phonetic/Phonetic.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Phonetic_algorithm
+ *
+ * A phonetic algorithm refers to a method for indexing words according to their
+ * pronunciation. When the algorithm relies on orthography, it is significantly
+ * influenced by the spelling conventions of the language for which it is intended:
+ * since the majority of phonetic algorithms were created for English, they tend
+ * to be less effective for indexing words in other languages.
+ *
+ * Phonetic search has numerous applications, and one of the initial use cases has
+ * been in trademark searches to verify that newly registered trademarks do not
+ * pose a risk of infringing upon existing trademarks due to their pronunciation.
+ *
+ * This module provides an abstract class for generating phonetic indices based
+ * on mappings and rules. It allows for the implementation of various phonetic
+ * algorithms by extending the abstract class.
+ *
+ * @module Phonetic
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { PhoneticMap, PhoneticOptions, RegistryService, PhoneticMappingService } from '../utils/Types';
+/**
+ * Abstract class representing a phonetic algorithm.
+ *
+ * The protected methods `applyRules`, `encode`, `mapChar`, `equalLen`, `word2Chars`,
+ * `exitEarly`, `adjustCode`, `loop` and `loopAsync` can be overridden in subclasses
+ * to implement specific phonetic algorithms.
+ *
+ * @abstract
+ */
+export declare abstract class Phonetic {
+    private static cache;
+    /**
+     * Default phonetic options.
+     *
+     * This object contains default settings for phonetic algorithms,
+     * implemented in the subclass.
+     */
+    protected static default: PhoneticOptions;
+    private readonly algo;
+    protected readonly options: PhoneticOptions;
+    protected readonly map: PhoneticMap;
+    /**
+     * Static method to clear the cache of indexed words.
+     */
+    static clear(): void;
+    /**
+     * Constructor for the Phonetic class.
+     *
+     * Initializes the phonetic algorithm with the specified options and mapping.
+     *
+     * @param {string} algo - The name of the algorithm (e.g. 'soundex')
+     * @param {PhoneticOptions} [opt] - Options for the phonetic algorithm
+     * @throws {Error} - If the requested mapping is not declared
+     */
+    constructor(algo: string, opt?: PhoneticOptions);
+    /**
+     * Applies phonetic rules to a character in a word context.
+     *
+     * This method is designed to be generic and efficient for all phonetic algorithms.
+     * It checks all rule types (prev, next, prevNot, nextNot, position, etc.) and
+     * returns either the appropriate code (string) or undefined.
+     *
+     * @param {string} char - The current character
+     * @param {number} i - The current position within the word
+     * @param {string[]} chars - The word as an array of characters
+     * @param {number} charLen - The total length of the word
+     * @returns {string|undefined} - The rule code or undefined if no rule applies
+     */
+    protected applyRules(char: string, i: number, chars: string[], charLen: number): string | undefined;
+    /**
+     * Generates the phonetic code for a given word.
+     *
+     * This method processes the word character by character, applying phonetic rules
+     * and mappings to generate a phonetic code.
+     *
+     * @param {string} word - The input word to be converted into a phonetic code
+     * @returns {string} - The generated phonetic code
+     */
+    protected encode(word: string): string;
+    /**
+     * Converts a character to its phonetic code based on the mapping and rules.
+     *
+     * @param {string} char - The current character
+     * @param {number} i - The current position within the word
+     * @param {string[]} chars - The word as an array of characters
+     * @param {number} charLen - The total length of the word
+     * @param {string|null} lastCode - The last code generated (to avoid duplicates)
+     * @param {Record<string, string>} map - The phonetic mapping
+     * @returns {string|undefined} - The phonetic code or undefined if no code applies
+     */
+    protected mapChar(char: string, i: number, chars: string[], charLen: number, lastCode: string | null, map: Record<string, string>): string | undefined;
+    /**
+     * Ensures the phonetic code has a fixed length by padding or truncating.
+     *
+     * @param {string} input - The input string to be adjusted
+     * @returns {string} - The adjusted string with fixed length
+     */
+    protected equalLen(input: string): string;
+    /**
+     * Converts a word into an array of characters.
+     *
+     * @param {string} word - The input word to be converted
+     * @returns {string[]} - An array of characters from the input word
+     */
+    protected word2Chars(word: string): string[];
+    /**
+     * Determines whether to exit early based on the current phonetic code length.
+     *
+     * @param {string} code - The current phonetic code
+     * @param {number} i - The current index in the word
+     * @returns {boolean} - True if the code length exceeds the specified limit, false otherwise
+     */
+    protected exitEarly(code: string, i: number): boolean;
+    /**
+     * Adjusts the phonetic code.
+     *
+     * @param {string} code - The phonetic code to be adjusted
+     * @param {string[]} chars - Characters to be removed from the code
+     * @returns {string} - The adjusted phonetic code
+     */
+    protected adjustCode(code: string, chars: string[]): string;
+    /**
+     * Processes an array of words to generate their phonetic indices.
+     *
+     * This method iterates over each word, generates its phonetic code,
+     * and ensures that the resulting codes are of equal length.
+     *
+     * @param {string[]} words - An array of words to be processed
+     * @returns {string[]} - An array of phonetic indices for the input words
+     */
+    protected loop(words: string[]): string[];
+    /**
+     * Asynchronously processes an array of words to generate their phonetic indices.
+     *
+     * This method iterates over each word, generates its phonetic code asynchronously,
+     * and ensures that the resulting codes are of equal length.
+     *
+     * @param {string[]} words - An array of words to be processed
+     * @returns {Promise<string[]>} - A promise that resolves to an array of phonetic indices for the input words
+     */
+    protected loopAsync(words: string[]): Promise<string[]>;
+    /**
+     * Get the name of the phonetic algorithm.
+     *
+     * @returns {string} - The name of the algorithm
+     */
+    getAlgoName(): string;
+    /**
+     * Generates a phonetic index for the given input string.
+     *
+     * @param {string} input - The input string to be indexed
+     * @returns {string[]} - An array of phonetic indices for the input words
+     */
+    getIndex(input: string): string[];
+    /**
+     * Asynchronously generates a phonetic index for the given input string.
+     *
+     * @param {string} input - The input string to be indexed
+     * @returns {Promise<string[]>} - A promise that resolves to an array of phonetic indices for the input words
+     */
+    getIndexAsync(input: string): Promise<string[]>;
+}
+/**
+ * Phonetic registry service for managing phonetic implementations.
+ *
+ * This registry allows for dynamic registration and retrieval of phonetic classes,
+ * enabling the use of various phonetic algorithms in a consistent manner.
+ */
+export declare const PhoneticRegistry: RegistryService<Phonetic>;
+/**
+ * Type definition for the Phonetic class constructor.
+ *
+ * This type is used to create instances of the Phonetic class, allowing for
+ * dynamic instantiation of phonetic algorithms.
+ */
+export type PhoneticCls = new (...args: any[]) => Phonetic;
+/**
+ * Phonetic Mapping Service
+ *
+ * This service provides a simple interface to manage phonetic mappings across
+ * different phonetic algorithms. It allows adding, removing, checking existence,
+ * retrieving, and listing phonetic mappings for specified algorithms.
+ */
+export declare const PhoneticMappingRegistry: PhoneticMappingService;

package/dist/types/phonetic/Soundex.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Soundex Phonetic Algorithm
+ * src/phonetic/Soudex.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Soundex
+ *
+ * Soundex is a phonetic algorithm for indexing names by sound. It is used to
+ * encode words into a phonetic representation, allowing for the comparison of
+ * words based on their pronunciation rather than their spelling. This works
+ * by mapping letters to digits, ignoring certain letters, and applying specific
+ * rules to handle character combinations.
+ *
+ * It is particularly useful for matching names that may be spelled differently
+ * but sound similar and commonly used in genealogical research and databases
+ * to find similar-sounding names.
+ *
+ * The Soundex algorithm is not case-sensitive and ignores vowels and certain
+ * consonants. It outputs an array of strings that represents the phonetic code
+ * of the input, typically limited to the length of four characters.
+ *
+ * @module Phonetic/Soundex
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { PhoneticOptions } from '../utils/Types';
+import { Phonetic } from './Phonetic';
+/**
+ * Soundex class extends the Phonetic class to implement the Soundex phonetic algorithm.
+ */
+export declare class Soundex extends Phonetic {
+    protected static default: PhoneticOptions;
+    /**
+     * Constructor for the Soundex class.
+     *
+     * Initializes the Soundex phonetic algorithm with the mapping and options.
+     *
+     * @param {PhoneticOptions} [opt] - Options for the Soundex phonetic algorithm
+     */
+    constructor(opt?: PhoneticOptions);
+    /**
+     * Adjusts the phonetic code by removing leading zeros and ensuring the
+     * first character is uppercase.
+     *
+     * @param {string} code - The phonetic code to adjust
+     * @param {string[]} chars - The characters used in the phonetic code
+     * @returns {string} - The adjusted phonetic code
+     */
+    protected adjustCode(code: string, chars: string[]): string;
+}

package/dist/types/phonetic/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Phonetic Registry Loader
+ * src/phonetic/index.ts
+ *
+ * This module serves as the central loader and registry for all phonetic algorithms
+ * available in the CmpStr library. It ensures that all phonetic implementations are
+ * registered with the PhoneticRegistry and available for use throughout the
+ * application.
+ *
+ * Each phonetic algorithm (such as Soundex, Cologne, Metaphone, etc.) is defined
+ * in its own module and is automatically registered with the PhoneticRegistry upon
+ * import. This design allows for easy extensibility: new phonetic algorithms can be
+ * added simply by creating a new module and importing it here. The registry pattern
+ * enables dynamic lookup, instantiation, and management of all available phonetic
+ * algorithms at runtime.
+ *
+ * Features:
+ *  - Centralized registration of all built-in phonetic algorithms
+ *  - Automatic registration via side-effect imports
+ *  - Extensible: custom phonetic algorithms can be registered at runtime
+ *  - Consistent interface for accessing, listing, and managing phonetic algorithms
+ *  - Ensures that all phonetic algorithms are available for use in the CmpStr API
+ *
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import './Cologne';
+import './Metaphone';
+import './Soundex';
+export { PhoneticRegistry, PhoneticMappingRegistry, Phonetic, PhoneticCls } from './Phonetic';

package/dist/types/utils/DeepMerge.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Deep Merge Utility
+ * src/utils/DeepMerge.ts
+ *
+ * This module provides utility functions for deep merging objects, getting values by path,
+ * and setting values by path in a deeply nested object structure.
+ *
+ * It supports dot and bracket notation (e.g. `a.b[0].c`) as well as escaped keys.
+ *
+ * Included functions:
+ *  - `get`:   Retrieve a deeply nested value by path
+ *  - `set`:   Assign a value to a nested path
+ *  - `merge`: Deeply merge two objects
+ *  - `has`:   Check whether a path exists
+ *  - `rmv`:   Delete a value at a path
+ *
+ * @module Utils/DeepMerge
+ * @author Paul Köhler
+ * @license MIT
+ */
+/**
+ * Deeply get a value from an object by a path string.
+ *
+ * @template T - The type of the object to get the value from
+ * @param {T} t - The object to get the value from
+ * @param {string} path - The path string, e.g. `a.b.c`
+ * @param {any} fallback - The default value to return if the path does not exist
+ * @returns {T|R|undefined} - The value at the specified path, otherwise the default value
+ */
+export declare function get<T extends Record<string, any>, R = any>(t: T, path: string, fallback?: any): T | R | undefined;
+/**
+ * Check if a path exists in an object.
+ *
+ * @template T - The type of the object to get the value from
+ * @param {T} t - The object to check
+ * @param {string} path - The path string, e.g. `a.b.c`
+ * @returns {boolean} - True if the path exists, otherwise false
+ */
+export declare function has<T extends Record<string, any>>(t: T, path: string): boolean;
+/**
+ * Deeply set a value in an object by a path string.
+ *
+ * @template T - The type of the object to get the value from
+ * @param {T} t - The object to set the value in
+ * @param {string} path - The path string, e.g. `a.b.c`
+ * @param {any} value - The value to set at the specified path
+ * @returns {T} - The modified object with the value set at the specified path
+ * @throws {Error} - Throws an error if the key is not a valid identifier
+ */
+export declare function set<T extends Record<string, any>>(t: T, path: string, value: any): T;
+/**
+ * Deeply merge two objects, where the second object overrides the first.
+ *
+ * @template T - The type of the object to get the value from
+ * @param {T} t - The target object to merge into
+ * @param {T} o - The source object to merge from
+ * @param {boolean} [mergeUndefined=false] - Whether to merge undefined values
+ * @returns {T} - The merged object
+ */
+export declare function merge<T extends Record<string, any>>(t?: T | undefined, o?: T | undefined, mergeUndefined?: boolean): T;
+/**
+ * Delete a value at a specified path in an object.
+ *
+ * @template T - The type of the object to get the value from
+ * @param {T} t - The object to delete the value from
+ * @param {string} path - The path string, e.g. `a.b.c`
+ * @param {boolean} [preserveEmpty=false] - Whether to preserve empty objects/arrays
+ * @returns {T} - The modified object with the value deleted at the specified path
+ */
+export declare function rmv<T extends Record<string, any>>(t: T, path: string, preserveEmpty?: boolean): T;

package/dist/types/utils/DiffChecker.d.ts

@@ -0,0 +1,137 @@
+/**
+ * DiffChecker Utility
+ * src/utils/DiffChecker.ts
+ *
+ * The DiffChecker class provides a robust and efficient utility for comparing two
+ * texts and extracting their differences (full lines or word mode). It supports
+ * context-aware grouping of changes, unified diff output (with CLI color or ASCII
+ * markup), and detailed change magnitude metrics. The class is highly configurable,
+ * allowing users to choose the diff granularity, case sensitivity, context lines,
+ * grouping, and output style. It is suitable for text comparison, code review
+ * tools, document versioning, and any application requiring precise and human-
+ * readable difference reporting.
+ *
+ * Features:
+ *  - Line and word-based diffing
+ *  - Case-insensitive comparison option
+ *  - Context lines and grouping of adjacent changes
+ *  - Unified diff output (ASCII or colored CLI)
+ *  - Highlighting of changed segments within lines
+ *  - Change magnitude calculation (relative to group or line)
+ *  - Expand-all mode for full file context
+ *
+ * @module Utils/DiffChecker
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { DiffOptions, DiffLine, DiffGroup } from './Types';
+/**
+ * The DiffChecker class provides methods to compare two texts and generate
+ * structured diffs, grouped diffs, and unified diff outputs.
+ */
+export declare class DiffChecker {
+    private readonly a;
+    private readonly b;
+    private readonly options;
+    private entries;
+    private grouped;
+    private diffRun;
+    /**
+     * Constructs a new DiffChecker instance for comparing two texts.
+     *
+     * @param {string} a - The first (original) text
+     * @param {string} b - The second (modified) text
+     * @param {DiffOptions} [opt] - Optional diff configuration
+     */
+    constructor(a: string, b: string, opt?: DiffOptions);
+    /**
+     * Splits both input texts into arrays of lines and returns them
+     * with the maximum line count.
+     *
+     * @returns { linesA: string[], linesB: string[], maxLen: number }
+     */
+    private text2lines;
+    /**
+     * Tokenizes a string according to the current diff mode (line or word).
+     *
+     * @param {string} input - The string to tokenize
+     * @returns {string[]} - Array of tokens
+     */
+    private tokenize;
+    /**
+     * Concatenates an array of tokens back into a string, respecting the diff mode.
+     *
+     * @param {string[]} input - Array of tokens
+     * @returns {string} - Concatenated string
+     */
+    private concat;
+    /**
+     * Computes the diff between the two input texts and populates the
+     * entries and grouped arrays.
+     */
+    private computeDiff;
+    /**
+     * Compares two lines and records their differences at the configured granularity.
+     *
+     * @param {string} a - Line from the first text
+     * @param {string} b - Line from the second text
+     * @param {number} line - Line number
+     */
+    private lineDiff;
+    /**
+     * Finds all minimal diff blocks between two tokenized strings,
+     * returning original text and positions.
+     *
+     * @param {string} a - Original line (case preserved)
+     * @param {string} A - Original line (possibly lowercased)
+     * @param {string} b - Modified line (case preserved)
+     * @param {string} B - Modified line (possibly lowercased)
+     * @returns {DiffEntry[]} - Array of diff entries for this line
+     */
+    private preciseDiff;
+    /**
+     * Groups adjacent changed lines together, including context lines,
+     * and calculates group metrics.
+     */
+    private findGroups;
+    /**
+     * Calculates the change magnitude string for a group or line.
+     *
+     * @param {number} del - Number of deleted characters
+     * @param {number} ins - Number of inserted characters
+     * @param {number} baseLen - Base length for normalization
+     * @returns {string} - Magnitude string (e.g. "++-")
+     */
+    private magnitude;
+    /**
+     * Generates a unified diff output as a string, with optional CLI coloring.
+     *
+     * @param {boolean} cli - If true, use CLI colors; otherwise, ASCII markup
+     * @returns {string} - Unified diff output
+     */
+    private output;
+    /**
+     * Returns the structured diff as an array of DiffLine objects.
+     *
+     * @returns {DiffLine[]} - Array of line-level diffs
+     */
+    getStructuredDiff(): DiffLine[];
+    /**
+     * Returns the grouped diff as an array of DiffGroup objects.
+     *
+     * @returns {DiffGroup[]} - Array of grouped diffs
+     */
+    getGroupedDiff(): DiffGroup[];
+    /**
+     * Returns the unified diff as a plain ASCII string.
+     *
+     * @returns {string} - Unified diff (ASCII)
+     */
+    getASCIIDiff(): string;
+    /**
+     * Returns the unified diff as a CLI-colored string.
+     *
+     * @returns {string} - Unified diff (CLI colors)
+     */
+    getCLIDiff(): string;
+}

package/dist/types/utils/Filter.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Filter Utility
+ * src/utils/Filter.ts
+ *
+ * This module provides a Filter class that allows for the management and application of
+ * filters to strings based on hooks. Filters can be added, removed, paused, resumed, and
+ * applied to input strings. Each filter has an id, a function, a priority, and options
+ * for activation and overrideability.
+ *
+ * @module Utils/Filter
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+import type { FilterFn, FilterOptions } from './Types';
+/**
+ * The Filter class provides a way to manage and apply filters to strings based on hooks.
+ */
+export declare class Filter {
+    /**
+     * A static map to hold all filters.
+     * The key is the hook name, and the value is an array of FilterEntry objects.
+     */
+    private static filters;
+    /**
+     * Finds a filter by its hook and id.
+     *
+     * @param {string} hook - The name of the hook
+     * @param {string} id - The id of the filter
+     * @returns {FilterEntry|undefined} - The FilterEntry if found, otherwise undefined
+     */
+    private static find;
+    /**
+     * Adds a filter to the specified hook.
+     *
+     * @param {string} hook - The name of the hook
+     * @param {string} id - The id of the filter
+     * @param {FilterFn} fn - The filter function
+     * @param {FilterOptions} [opt] - Additional options for the filter
+     * @returns {boolean} - Returns true if the filter was added, false if it was not added due to override restrictions
+     */
+    static add(hook: string, id: string, fn: FilterFn, opt?: FilterOptions): boolean;
+    /**
+     * Removes a filter by its hook and id.
+     *
+     * @param {string} hook - The name of the hook
+     * @param {string} id - The id of the filter
+     * @returns {boolean} - Returns true if the filter was removed, false if it was not found
+     */
+    static remove(hook: string, id: string): boolean;
+    /**
+     * Pauses a filter by its hook and id.
+     *
+     * @param {string} hook - The name of the hook
+     * @param {string} id - The id of the filter
+     * @returns {boolean} - Returns true if the filter was paused, false if it was not found
+     */
+    static pause(hook: string, id: string): boolean;
+    /**
+     * Resumes a filter by its hook and id.
+     *
+     * @param {string} hook - The name of the hook
+     * @param {string} id - The id of the filter
+     * @returns {boolean} - Returns true if the filter was resumed, false if it was not found
+     */
+    static resume(hook: string, id: string): boolean;
+    /**
+     * Lists all filters for a given hook.
+     *
+     * @param {string} hook - The name of the hook
+     * @param {boolean} active - If true, only list active filters
+     * @returns {string[]} - An array of filter ids
+     */
+    static list(hook: string, active?: boolean): string[];
+    /**
+     * Applies all active filters for a given hook to the input string(s).
+     *
+     * @param {string} hook - The name of the hook
+     * @param {string|string[]} input - The input string(s) to be filtered
+     * @returns {string|string[]} - The filtered string(s)
+     */
+    static apply(hook: string, input: string | string[]): string | string[];
+    /**
+     * Applies all active filters for a given hook to the input string(s) asynchronously.
+     * Each filter function may return a Promise or a plain string; all are awaited in order.
+     *
+     * @param {string} hook - The name of the hook
+     * @param {string|string[]} input - The input string(s) to be filtered
+     * @returns {Promise<string|string[]>} - The filtered string(s)
+     */
+    static applyAsync(hook: string, input: string | string[]): Promise<string | string[]>;
+    /**
+     * Clears all filters or filters for a specific hook.
+     *
+     * @param {string} [hook] - Optional name of the hook to clear filters for
+     */
+    static clear(hook?: string): void;
+}

package/dist/types/utils/HashTable.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Hash Table Utility
+ * src/utils/HashTable.ts
+ *
+ * @see https://en.wikipedia.org/wiki/Fowler–Noll–Vo_hash_function
+ * @see https://en.wikipedia.org/wiki/Hash_table
+ *
+ * This module implements an instantiable hash table/cache using the FNV-1a hash algorithm.
+ * It allows for multiple independent caches (e.g. for metrics, normalization, etc.) with
+ * type safety and high performance. The FNV-1a algorithm is factored out into its own
+ * static utility class to avoid code duplication and memory overhead.
+ *
+ * The key() method supports any number of string arguments, enabling flexible cache keys
+ * for different use cases (e.g. normalization, metrics, etc.).
+ *
+ * @module Utils/HashTable
+ * @author Paul Köhler (komed3)
+ * @license MIT
+ */
+/**
+ * HashTable class implements an instantiable hash table/cache.
+ * Allows for multiple independent caches with type safety and high performance.
+ *
+ * @template K - The type of the label for the key (e.g. string, MetricName, …)
+ * @template T - The type of value to be stored in the hash table (e.g. MetricCompute, string, …)
+ */
+export declare class HashTable<K extends string, T> {
+    private static readonly MAX_LEN;
+    private static readonly TABLE_SIZE;
+    /**
+     * The internal map to store entries.
+     * The key is a string generated from the label and any number of hashed strings.
+     * The value is of type T.
+     */
+    private table;
+    /**
+     * Generates a unique hash key for any number of string arguments.
+     * The key is in the format "label-H1-H2-H3-..."
+     *
+     * @param {K} label - Label for this key (e.g. metric name, normalization flags, …)
+     * @param {string[]} strs - Array of strings to hash (e.g. input, params, …)
+     * @param {boolean} [sorted=false] - Whether to sort the hashes before creating the key
+     * @returns {string|false} - A unique hash key or false if any string is too long
+     */
+    key(label: K, strs: string[], sorted?: boolean): string | false;
+    /**
+     * Checks if a key exists in the hash table.
+     *
+     * @param {string} key - The key to check
+     * @returns {boolean} - True if the key exists, false otherwise
+     */
+    has(key: string): boolean;
+    /**
+     * Retrieves the entry from the hash table by its key.
+     *
+     * @param {string} key - The key to look up
+     * @returns {T|undefined} - The entry if found, undefined otherwise
+     */
+    get(key: string): T | undefined;
+    /**
+     * Adds an entry to the hash table.
+     *
+     * @param {string} key - The hashed key for the entry
+     * @param {T} entry - The entry itself to add
+     * @param {boolean} [update=true] - Whether to update the entry if it already exists
+     * @returns {boolean} - True if added successfully, false if the table is full
+     */
+    set(key: string, entry: T, update?: boolean): boolean;
+    /**
+     * Deletes an entry from the hash table by its key.
+     *
+     * @param {string} key - The key of the entry to delete
+     */
+    delete(key: string): void;
+    /**
+     * Clears the hash table.
+     * This method removes all entries from the hash table.
+     */
+    clear(): void;
+    /**
+     * Returns the current size of the hash table.
+     *
+     * @returns {number} - The number of entries in the hash table
+     */
+    size(): number;
+}