import { a as Comparator, D as DoublyNode, C as CircularNode } from '../node-CC6ueIns.js';

declare class ArrayList<T> {
    private items;
    get size(): number;
    get(index: number): T | undefined;
    set(index: number, value: T): boolean;
    push(value: T): void;
    pop(): T | undefined;
    insertAt(index: number, value: T): boolean;
    removeAt(index: number): T | undefined;
    search(value: T): number;
    clear(): void;
    toArray(): T[];
}

declare class Stack<T> {
    protected items: T[];
    get size(): number;
    push(value: T): void;
    pop(): T | undefined;
    peek(): T | undefined;
    isEmpty(): boolean;
    contains(value: T): boolean;
    clear(): void;
}

declare class MinStack<T> {
    private readonly compare;
    private values;
    private mins;
    constructor(compare?: Comparator<T>);
    get size(): number;
    push(value: T): void;
    pop(): T | undefined;
    peek(): T | undefined;
    min(): T | undefined;
    isEmpty(): boolean;
    clear(): void;
}

declare class Queue<T> {
    private items;
    private head;
    private tail;
    get size(): number;
    enqueue(value: T): void;
    dequeue(): T | undefined;
    peek(): T | undefined;
    isEmpty(): boolean;
    contains(value: T): boolean;
    clear(): void;
}

declare class Deque<T> {
    private head?;
    private tail?;
    private count;
    get size(): number;
    addFront(value: T): void;
    addBack(value: T): void;
    removeFront(): T | undefined;
    removeBack(): T | undefined;
    peekFront(): T | undefined;
    peekBack(): T | undefined;
    isEmpty(): boolean;
    contains(value: T): boolean;
    clear(): void;
}

declare class LinkedList<T> {
    private head?;
    private tail?;
    private count;
    get size(): number;
    prepend(value: T): void;
    append(value: T): void;
    removeHead(): T | undefined;
    headValue(): T | undefined;
    tailValue(): T | undefined;
    insertAt(index: number, value: T): boolean;
    removeAt(index: number): T | undefined;
    indexOf(value: T): number;
    clear(): void;
    toArray(): T[];
}

declare class DoublyLinkedList<T> {
    private head?;
    private tail?;
    private count;
    get size(): number;
    prepend(value: T): DoublyNode<T>;
    append(value: T): DoublyNode<T>;
    removeHead(): T | undefined;
    removeTail(): T | undefined;
    removeNode(node: DoublyNode<T>): T;
    peekHead(): T | undefined;
    peekTail(): T | undefined;
    find(value: T): DoublyNode<T> | undefined;
    insertAt(index: number, value: T): DoublyNode<T> | undefined;
    clear(): void;
    toArray(): T[];
    private unlinkNode;
}

declare class CircularLinkedList<T> {
    private tail?;
    private count;
    get size(): number;
    append(value: T): void;
    prepend(value: T): void;
    removeHead(): T | undefined;
    peekHead(): T | undefined;
    peekTail(): T | undefined;
    rotate(): T | undefined;
    find(value: T): CircularNode<T> | undefined;
    removeByValue(value: T): boolean;
    clear(): void;
    toArray(): T[];
    private createNode;
}

declare class MySet<T> {
    private items;
    get size(): number;
    add(value: T): boolean;
    has(value: T): boolean;
    delete(value: T): boolean;
    clear(): void;
    values(): T[];
    union(other: MySet<T>): MySet<T>;
    intersection(other: MySet<T>): MySet<T>;
    difference(other: MySet<T>): MySet<T>;
    isSubsetOf(other: MySet<T>): boolean;
}

declare class Dictionary<K, V> {
    private table;
    get size(): number;
    set(key: K, value: V): void;
    get(key: K): V | undefined;
    has(key: K): boolean;
    delete(key: K): boolean;
    clear(): void;
    keys(): K[];
    values(): V[];
    entries(): Array<[K, V]>;
    forEach(callback: (key: K, value: V) => void): void;
}

declare class HashTable<K, V> {
    private buckets;
    private count;
    private capacity;
    private readonly maxLoadFactor;
    constructor();
    get size(): number;
    put(key: K, value: V): void;
    get(key: K): V | undefined;
    has(key: K): boolean;
    remove(key: K): boolean;
    clear(): void;
    private findEntry;
    private upsert;
    private resize;
    private bucketForHashKey;
    private createBuckets;
}

declare class HashSet<T> {
    private table;
    get size(): number;
    add(value: T): boolean;
    has(value: T): boolean;
    delete(value: T): boolean;
    clear(): void;
}

declare class BinarySearchTree<K, V = K> {
    private readonly compare;
    private root?;
    private count;
    constructor(compare?: Comparator<K>);
    get size(): number;
    insert(key: K, value: V): void;
    get(key: K): V | undefined;
    has(key: K): boolean;
    min(): V | undefined;
    max(): V | undefined;
    remove(key: K): boolean;
    inOrder(): V[];
    private minNode;
    private detachMin;
}

declare class AvlTree<K, V = K> {
    private readonly compare;
    private root?;
    private count;
    constructor(compare?: Comparator<K>);
    get size(): number;
    insert(key: K, value: V): void;
    get(key: K): V | undefined;
    has(key: K): boolean;
    min(): V | undefined;
    max(): V | undefined;
    remove(key: K): boolean;
    inOrder(): V[];
    private detachMin;
    private minNode;
    private rebalance;
    private rotateLeft;
    private rotateRight;
    private height;
    private withUpdatedHeight;
    private balanceFactor;
}

declare class PriorityQueue<T> {
    private readonly compare;
    private heap;
    private indexMap;
    constructor(compare?: Comparator<T>);
    get size(): number;
    insert(value: T): void;
    peek(): T | undefined;
    extract(): T | undefined;
    update(value: T): boolean;
    remove(value: T): boolean;
    clear(): void;
    private removeAt;
    private siftUp;
    private siftDown;
    private swap;
    private parentIndex;
    private leftIndex;
    private rightIndex;
    private addIndex;
    private removeIndex;
    private firstIndexFor;
}

declare class Trie {
    private root;
    private count;
    get size(): number;
    insert(word: string): boolean;
    has(word: string): boolean;
    startsWith(prefix: string): boolean;
    delete(word: string): boolean;
    wordsWithPrefix(prefix: string): string[];
    clear(): void;
    private findNode;
}

declare class Graph<V> {
    private adjacency;
    private edges;
    get vertexCount(): number;
    get edgeCount(): number;
    addVertex(vertex: V): boolean;
    addEdge(a: V, b: V): void;
    removeVertex(vertex: V): boolean;
    removeEdge(a: V, b: V): boolean;
    hasVertex(vertex: V): boolean;
    hasEdge(a: V, b: V): boolean;
    neighbors(vertex: V): V[];
    bfs(start: V): V[];
    dfs(start: V): V[];
    clear(): void;
}

export { ArrayList, AvlTree, BinarySearchTree, CircularLinkedList, Deque, Dictionary, DoublyLinkedList, Graph, HashSet, HashTable, LinkedList, MinStack, MySet, PriorityQueue, Queue, Stack, Trie };