bst-typed 2.1.0 → 2.1.2

package/dist/types/data-structures/queue/queue.d.ts

@@ -1,4 +1,308 @@
-import { LinearBaseOptions } from '../base';
-export type QueueOptions<E, R> = LinearBaseOptions<E, R> & {
-    autoCompactRatio?: number;
-};
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { ElementCallback, LinearBaseOptions, QueueOptions } from '../../types';
+import { SinglyLinkedList } from '../linked-list';
+import { LinearBase } from '../base/linear-base';
+/**
+ * Array-backed queue with amortized O(1) enqueue/dequeue via an offset pointer and optional auto-compaction.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ * @template R
+ * 1. First In, First Out (FIFO): The core feature of a queue is its first in, first out nature. The element added to the queue first will be the one to be removed first.
+ * 2. Operations: The main operations include enqueue (adding an element to the end of the queue) and dequeue (removing and returning the element at the front of the queue). Typically, there is also a peek operation (looking at the front element without removing it).
+ * 3. Uses: Queues are commonly used to manage a series of tasks or elements that need to be processed in order. For example, managing task queues in a multi-threaded environment, or in algorithms for data structures like trees and graphs for breadth-first search.
+ * 4. Task Scheduling: Managing the order of task execution in operating systems or applications.
+ * 5. Data Buffering: Acting as a buffer for data packets in network communication.
+ * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store elements that are to be visited.
+ * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
+ * @example
+ * // Sliding Window using Queue
+ *     const nums = [2, 3, 4, 1, 5];
+ *     const k = 2;
+ *     const queue = new Queue<number>();
+ *
+ *     let maxSum = 0;
+ *     let currentSum = 0;
+ *
+ *     nums.forEach(num => {
+ *       queue.push(num);
+ *       currentSum += num;
+ *
+ *       if (queue.length > k) {
+ *         currentSum -= queue.shift()!;
+ *       }
+ *
+ *       if (queue.length === k) {
+ *         maxSum = Math.max(maxSum, currentSum);
+ *       }
+ *     });
+ *
+ *     console.log(maxSum); // 7
+ * @example
+ * // Breadth-First Search (BFS) using Queue
+ *     const graph: { [key in number]: number[] } = {
+ *       1: [2, 3],
+ *       2: [4, 5],
+ *       3: [],
+ *       4: [],
+ *       5: []
+ *     };
+ *
+ *     const queue = new Queue<number>();
+ *     const visited: number[] = [];
+ *
+ *     queue.push(1);
+ *
+ *     while (!queue.isEmpty()) {
+ *       const node = queue.shift()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => queue.push(neighbor));
+ *       }
+ *     }
+ *
+ *     console.log(visited); // [1, 2, 3, 4, 5]
+ */
+export declare class Queue<E = any, R = any> extends LinearBase<E, R> {
+    /**
+     * Create a Queue and optionally bulk-insert elements.
+     * @remarks Time O(N), Space O(N)
+     * @param [elements] - Iterable of elements (or raw records if toElementFn is set).
+     * @param [options] - Options such as toElementFn, maxLen, and autoCompactRatio.
+     * @returns New Queue instance.
+     */
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: QueueOptions<E, R>);
+    protected _elements: E[];
+    /**
+     * Get the underlying array buffer.
+     * @remarks Time O(1), Space O(1)
+     * @returns Backing array of elements.
+     */
+    get elements(): E[];
+    protected _offset: number;
+    /**
+     * Get the current start offset into the array.
+     * @remarks Time O(1), Space O(1)
+     * @returns Zero-based offset.
+     */
+    get offset(): number;
+    protected _autoCompactRatio: number;
+    /**
+     * Get the compaction threshold (offset/size).
+     * @remarks Time O(1), Space O(1)
+     * @returns Auto-compaction ratio in (0,1].
+     */
+    get autoCompactRatio(): number;
+    /**
+     * Set the compaction threshold.
+     * @remarks Time O(1), Space O(1)
+     * @param value - New ratio; compacts when offset/size exceeds this value.
+     * @returns void
+     */
+    set autoCompactRatio(value: number);
+    /**
+     * Get the number of elements currently in the queue.
+     * @remarks Time O(1), Space O(1)
+     * @returns Current length.
+     */
+    get length(): number;
+    /**
+     * Get the first element (front) without removing it.
+     * @remarks Time O(1), Space O(1)
+     * @returns Front element or undefined.
+     */
+    get first(): E | undefined;
+    /**
+     * Get the last element (back) without removing it.
+     * @remarks Time O(1), Space O(1)
+     * @returns Back element or undefined.
+     */
+    get last(): E | undefined;
+    /**
+     * Create a queue from an array of elements.
+     * @remarks Time O(N), Space O(N)
+     * @template E
+     * @param elements - Array of elements to enqueue in order.
+     * @returns A new queue populated from the array.
+     */
+    static fromArray<E>(elements: E[]): Queue<E>;
+    /**
+     * Check whether the queue is empty.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if length is 0.
+     */
+    isEmpty(): boolean;
+    /**
+     * Enqueue one element at the back.
+     * @remarks Time O(1), Space O(1)
+     * @param element - Element to enqueue.
+     * @returns True on success.
+     */
+    push(element: E): boolean;
+    /**
+     * Enqueue many elements from an iterable.
+     * @remarks Time O(N), Space O(1)
+     * @param elements - Iterable of elements (or raw records if toElementFn is set).
+     * @returns Array of per-element success flags.
+     */
+    pushMany(elements: Iterable<E> | Iterable<R>): boolean[];
+    /**
+     * Dequeue one element from the front (amortized via offset).
+     * @remarks Time O(1) amortized, Space O(1)
+     * @returns Removed element or undefined.
+     */
+    shift(): E | undefined;
+    /**
+     * Delete the first occurrence of a specific element.
+     * @remarks Time O(N), Space O(1)
+     * @param element - Element to remove (strict equality via Object.is).
+     * @returns True if an element was removed.
+     */
+    delete(element: E): boolean;
+    /**
+     * Get the element at a given logical index.
+     * @remarks Time O(1), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @returns Element or undefined.
+     */
+    at(index: number): E | undefined;
+    /**
+     * Delete the element at a given index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @returns Removed element or undefined.
+     */
+    deleteAt(index: number): E | undefined;
+    /**
+     * Insert a new element at a given index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @param newElement - Element to insert.
+     * @returns True if inserted.
+     */
+    addAt(index: number, newElement: E): boolean;
+    /**
+     * Replace the element at a given index.
+     * @remarks Time O(1), Space O(1)
+     * @param index - Zero-based index from the front.
+     * @param newElement - New element to set.
+     * @returns True if updated.
+     */
+    setAt(index: number, newElement: E): boolean;
+    /**
+     * Reverse the queue in-place by compacting then reversing.
+     * @remarks Time O(N), Space O(N)
+     * @returns This queue.
+     */
+    reverse(): this;
+    /**
+     * Remove all elements and reset offset.
+     * @remarks Time O(1), Space O(1)
+     * @returns void
+     */
+    clear(): void;
+    /**
+     * Compact storage by discarding consumed head elements.
+     * @remarks Time O(N), Space O(N)
+     * @returns True when compaction performed.
+     */
+    compact(): boolean;
+    /**
+     * Remove and/or insert elements at a position (array-like).
+     * @remarks Time O(N + M), Space O(M)
+     * @param start - Start index (clamped to [0, length]).
+     * @param [deleteCount] - Number of elements to remove (default 0).
+     * @param [items] - Elements to insert after `start`.
+     * @returns A new queue containing the removed elements (typed as `this`).
+     */
+    splice(start: number, deleteCount?: number, ...items: E[]): this;
+    /**
+     * Deep clone this queue and its parameters.
+     * @remarks Time O(N), Space O(N)
+     * @returns A new queue with the same content and options.
+     */
+    clone(): this;
+    /**
+     * Filter elements into a new queue of the same class.
+     * @remarks Time O(N), Space O(N)
+     * @param predicate - Predicate (element, index, queue) → boolean to keep element.
+     * @param [thisArg] - Value for `this` inside the predicate.
+     * @returns A new queue with kept elements.
+     */
+    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this;
+    /**
+     * Map each element to a new element in a possibly different-typed queue.
+     * @remarks Time O(N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param callback - Mapping function (element, index, queue) → newElement.
+     * @param [options] - Options for the output queue (e.g., toElementFn, maxLen, autoCompactRatio).
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new Queue with mapped elements.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, options?: QueueOptions<EM, RM>, thisArg?: unknown): Queue<EM, RM>;
+    /**
+     * Map each element to a new value of the same type.
+     * @remarks Time O(N), Space O(N)
+     * @param callback - Mapping function (element, index, queue) → element.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new queue with mapped elements (same element type).
+     */
+    mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;
+    /**
+     * (Protected) Set the internal auto-compaction ratio.
+     * @remarks Time O(1), Space O(1)
+     * @param value - New ratio to assign.
+     * @returns void
+     */
+    protected _setAutoCompactRatio(value: number): void;
+    /**
+     * (Protected) Iterate elements from front to back.
+     * @remarks Time O(N), Space O(1)
+     * @returns Iterator of E.
+     */
+    protected _getIterator(): IterableIterator<E>;
+    /**
+     * (Protected) Iterate elements from back to front.
+     * @remarks Time O(N), Space O(1)
+     * @returns Iterator of E.
+     */
+    protected _getReverseIterator(): IterableIterator<E>;
+    /**
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind queue instance.
+     */
+    protected _createInstance(options?: LinearBaseOptions<E, R>): this;
+    /**
+     * (Protected) Create a like-kind queue and seed it from an iterable.
+     * @remarks Time O(N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param [elements] - Iterable used to seed the new queue.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind Queue instance.
+     */
+    protected _createLike<EM = E, RM = R>(elements?: Iterable<EM> | Iterable<RM>, options?: QueueOptions<EM, RM>): Queue<EM, RM>;
+}
+/**
+ * Queue implemented over a singly linked list; preserves head/tail operations with linear scans for queries.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ * @template R
+ * @example examples will be generated by unit test
+ */
+export declare class LinkedListQueue<E = any, R = any> extends SinglyLinkedList<E, R> {
+    /**
+     * Deep clone this linked-list-based queue.
+     * @remarks Time O(N), Space O(N)
+     * @returns A new queue with the same sequence of elements.
+     */
+    clone(): this;
+}

package/dist/types/data-structures/stack/stack.d.ts

@@ -1,2 +1,306 @@
-import { IterableElementBaseOptions } from '../base';
-export type StackOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+/**
+ * data-structure-typed
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { ElementCallback, IterableElementBaseOptions, StackOptions } from '../../types';
+import { IterableElementBase } from '../base';
+/**
+ * LIFO stack with array storage and optional record→element conversion.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ * @template R
+ * 1. Last In, First Out (LIFO): The core characteristic of a stack is its last in, first out nature, meaning the last element added to the stack will be the first to be removed.
+ * 2. Uses: Stacks are commonly used for managing a series of tasks or elements that need to be processed in a last in, first out manner. They are widely used in various scenarios, such as in function calls in programming languages, evaluation of arithmetic expressions, and backtracking algorithms.
+ * 3. Performance: Stack operations are typically O(1) in time complexity, meaning that regardless of the stack's size, adding, removing, and viewing the top element are very fast operations.
+ * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
+ * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.
+ * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
+ * @example
+ * // Balanced Parentheses or Brackets
+ *     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';
+ *
+ *     const stack = new Stack<string>();
+ *     const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];
+ *     const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };
+ *     for (const char of input) {
+ *       if ('([{'.includes(char)) {
+ *         stack.push(char);
+ *       } else if (')]}'.includes(char)) {
+ *         if (stack.pop() !== matches[char]) {
+ *           fail('Parentheses are not balanced');
+ *         }
+ *       }
+ *     }
+ *     console.log(stack.isEmpty()); // true
+ * @example
+ * // Expression Evaluation and Conversion
+ *     const stack = new Stack<number>();
+ *     const expression = [5, 3, '+']; // Equivalent to 5 + 3
+ *     expression.forEach(token => {
+ *       if (typeof token === 'number') {
+ *         stack.push(token);
+ *       } else {
+ *         const b = stack.pop()!;
+ *         const a = stack.pop()!;
+ *         stack.push(token === '+' ? a + b : 0); // Only handling '+' here
+ *       }
+ *     });
+ *     console.log(stack.pop()); // 8
+ * @example
+ * // Depth-First Search (DFS)
+ *     const stack = new Stack<number>();
+ *     const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
+ *     const visited: number[] = [];
+ *     stack.push(1);
+ *     while (!stack.isEmpty()) {
+ *       const node = stack.pop()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => stack.push(neighbor));
+ *       }
+ *     }
+ *     console.log(visited); // [1, 3, 5, 2, 4]
+ * @example
+ * // Backtracking Algorithms
+ *     const stack = new Stack<[number, number]>();
+ *     const maze = [
+ *       ['S', ' ', 'X'],
+ *       ['X', ' ', 'X'],
+ *       [' ', ' ', 'E']
+ *     ];
+ *     const start: [number, number] = [0, 0];
+ *     const end = [2, 2];
+ *     const directions = [
+ *       [0, 1], // To the right
+ *       [1, 0], // down
+ *       [0, -1], // left
+ *       [-1, 0] // up
+ *     ];
+ *
+ *     const visited = new Set<string>(); // Used to record visited nodes
+ *     stack.push(start);
+ *     const path: number[][] = [];
+ *
+ *     while (!stack.isEmpty()) {
+ *       const [x, y] = stack.pop()!;
+ *       if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes
+ *       visited.add(`${x},${y}`);
+ *
+ *       path.push([x, y]);
+ *
+ *       if (x === end[0] && y === end[1]) {
+ *         break; // Find the end point and exit
+ *       }
+ *
+ *       for (const [dx, dy] of directions) {
+ *         const nx = x + dx;
+ *         const ny = y + dy;
+ *         if (
+ *           maze[nx]?.[ny] === ' ' || // feasible path
+ *           maze[nx]?.[ny] === 'E' // destination
+ *         ) {
+ *           stack.push([nx, ny]);
+ *         }
+ *       }
+ *     }
+ *
+ *     expect(path).toContainEqual(end);
+ * @example
+ * // Function Call Stack
+ *     const functionStack = new Stack<string>();
+ *     functionStack.push('main');
+ *     functionStack.push('foo');
+ *     functionStack.push('bar');
+ *     console.log(functionStack.pop()); // 'bar'
+ *     console.log(functionStack.pop()); // 'foo'
+ *     console.log(functionStack.pop()); // 'main'
+ * @example
+ * // Simplify File Paths
+ *     const stack = new Stack<string>();
+ *     const path = '/a/./b/../../c';
+ *     path.split('/').forEach(segment => {
+ *       if (segment === '..') stack.pop();
+ *       else if (segment && segment !== '.') stack.push(segment);
+ *     });
+ *     console.log(stack.elements.join('/')); // 'c'
+ * @example
+ * // Stock Span Problem
+ *     const stack = new Stack<number>();
+ *     const prices = [100, 80, 60, 70, 60, 75, 85];
+ *     const spans: number[] = [];
+ *     prices.forEach((price, i) => {
+ *       while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
+ *         stack.pop();
+ *       }
+ *       spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
+ *       stack.push(i);
+ *     });
+ *     console.log(spans); // [1, 1, 1, 2, 1, 4, 6]
+ */
+export declare class Stack<E = any, R = any> extends IterableElementBase<E, R> {
+    protected _equals: (a: E, b: E) => boolean;
+    /**
+     * Create a Stack and optionally bulk-push elements.
+     * @remarks Time O(N), Space O(N)
+     * @param [elements] - Iterable of elements (or raw records if toElementFn is set).
+     * @param [options] - Options such as toElementFn and equality function.
+     * @returns New Stack instance.
+     */
+    constructor(elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>);
+    protected _elements: E[];
+    /**
+     * Get the backing array of elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Internal elements array.
+     */
+    get elements(): E[];
+    /**
+     * Get the number of stored elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Current size.
+     */
+    get size(): number;
+    /**
+     * Create a stack from an array of elements.
+     * @remarks Time O(N), Space O(N)
+     * @template E
+     * @template R
+     * @param this - The constructor (subclass) to instantiate.
+     * @param elements - Array of elements to push in order.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A new Stack populated from the array.
+     */
+    static fromArray<E, R = any>(this: new (elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>) => any, elements: E[], options?: StackOptions<E, R>): any;
+    /**
+     * Check whether the stack is empty.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if size is 0.
+     */
+    isEmpty(): boolean;
+    /**
+     * Get the top element without removing it.
+     * @remarks Time O(1), Space O(1)
+     * @returns Top element or undefined.
+     */
+    peek(): E | undefined;
+    /**
+     * Push one element onto the top.
+     * @remarks Time O(1), Space O(1)
+     * @param element - Element to push.
+     * @returns True when pushed.
+     */
+    push(element: E): boolean;
+    /**
+     * Pop and return the top element.
+     * @remarks Time O(1), Space O(1)
+     * @returns Removed element or undefined.
+     */
+    pop(): E | undefined;
+    /**
+     * Push many elements from an iterable.
+     * @remarks Time O(N), Space O(1)
+     * @param elements - Iterable of elements (or raw records if toElementFn is set).
+     * @returns Array of per-element success flags.
+     */
+    pushMany(elements: Iterable<E> | Iterable<R>): boolean[];
+    /**
+     * Delete the first occurrence of a specific element.
+     * @remarks Time O(N), Space O(1)
+     * @param element - Element to remove (using the configured equality).
+     * @returns True if an element was removed.
+     */
+    delete(element: E): boolean;
+    /**
+     * Delete the element at an index.
+     * @remarks Time O(N), Space O(1)
+     * @param index - Zero-based index from the bottom.
+     * @returns True if removed.
+     */
+    deleteAt(index: number): boolean;
+    /**
+     * Delete the first element that satisfies a predicate.
+     * @remarks Time O(N), Space O(1)
+     * @param predicate - Function (value, index, stack) → boolean to decide deletion.
+     * @returns True if a match was removed.
+     */
+    deleteWhere(predicate: (value: E, index: number, stack: this) => boolean): boolean;
+    /**
+     * Remove all elements and reset storage.
+     * @remarks Time O(1), Space O(1)
+     * @returns void
+     */
+    clear(): void;
+    /**
+     * Deep clone this stack.
+     * @remarks Time O(N), Space O(N)
+     * @returns A new stack with the same content.
+     */
+    clone(): this;
+    /**
+     * Filter elements into a new stack of the same class.
+     * @remarks Time O(N), Space O(N)
+     * @param predicate - Predicate (value, index, stack) → boolean to keep value.
+     * @param [thisArg] - Value for `this` inside the predicate.
+     * @returns A new stack with kept values.
+     */
+    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this;
+    /**
+     * Map values into a new stack of the same element type.
+     * @remarks Time O(N), Space O(N)
+     * @param callback - Mapping function (value, index, stack) → newValue.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new stack with mapped values.
+     */
+    mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;
+    /**
+     * Map values into a new stack (possibly different element type).
+     * @remarks Time O(N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param callback - Mapping function (value, index, stack) → newElement.
+     * @param [options] - Options for the output stack (e.g., toElementFn).
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new Stack with mapped elements.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, options?: IterableElementBaseOptions<EM, RM>, thisArg?: unknown): Stack<EM, RM>;
+    /**
+     * Set the equality comparator used by delete/search operations.
+     * @remarks Time O(1), Space O(1)
+     * @param equals - Equality predicate (a, b) → boolean.
+     * @returns This stack.
+     */
+    setEquality(equals: (a: E, b: E) => boolean): this;
+    /**
+     * (Protected) Find the index of a target element using the equality function.
+     * @remarks Time O(N), Space O(1)
+     * @param target - Element to search for.
+     * @returns Index or -1 if not found.
+     */
+    protected _indexOfByEquals(target: E): number;
+    /**
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind stack instance.
+     */
+    protected _createInstance(options?: StackOptions<E, R>): this;
+    /**
+     * (Protected) Create a like-kind stack and seed it from an iterable.
+     * @remarks Time O(N), Space O(N)
+     * @template T
+     * @template RR
+     * @param [elements] - Iterable used to seed the new stack.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind Stack instance.
+     */
+    protected _createLike<T = E, RR = R>(elements?: Iterable<T> | Iterable<RR>, options?: StackOptions<T, RR>): Stack<T, RR>;
+    /**
+     * (Protected) Iterate elements from bottom to top.
+     * @remarks Time O(N), Space O(1)
+     * @returns Iterator of elements.
+     */
+    protected _getIterator(): IterableIterator<E>;
+}

package/dist/types/data-structures/tree/tree.d.ts

@@ -1 +1,62 @@
-export {};
+export declare class TreeNode<V = any> {
+    /**
+     * The constructor function initializes a TreeNode object with a key, optional value, and optional
+     * children.
+     * @param {string} key - A string representing the key of the tree node.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the node. If no value is provided, it defaults to `undefined`.
+     * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
+     * objects. It represents the child nodes of the current node. If no children are provided, the
+     * default value is an empty array.
+     */
+    constructor(key: string, value?: V, children?: TreeNode<V>[]);
+    protected _key: string;
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key(): string;
+    /**
+     * The above function sets the value of a protected variable called "key".
+     * @param {string} value - The value parameter is a string that represents the value to be assigned
+     * to the key.
+     */
+    set key(value: string);
+    protected _value?: V | undefined;
+    /**
+     * The function returns the value stored in a variable, or undefined if the variable is empty.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value(): V | undefined;
+    /**
+     * The function sets the value of a variable.
+     * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
+     * can accept a value of type "V" or it can be undefined.
+     */
+    set value(value: V | undefined);
+    protected _children?: TreeNode<V>[] | undefined;
+    /**
+     * The function returns an array of TreeNode objects or undefined.
+     * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
+     * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
+     */
+    get children(): TreeNode<V>[] | undefined;
+    /**
+     * The function sets the value of the children property of a TreeNode object.
+     * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
+     * undefined. This means that it can accept an array of TreeNode objects or undefined.
+     */
+    set children(value: TreeNode<V>[] | undefined);
+    /**
+     * The function `addChildren` adds one or more child nodes to the current node.
+     * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
+     * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
+     */
+    addChildren(children: TreeNode<V> | TreeNode<V>[]): void;
+    /**
+     * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
+     * breadth-first search.
+     * @returns the maximum depth or height of the tree.
+     */
+    getHeight(): number;
+}