import { Node } from './node.js';
/**
 * Lista doblemente enlazada con inserción y eliminación O(1) en ambos extremos.
 * "Doblemente enlazada" significa que cada nodo conoce tanto al siguiente como al anterior,
 * lo que permite recorrerla en ambas direcciones.
 * @template T - El tipo de los valores almacenados en la lista.
 */
export declare class DoublyLinkedList<T> {
    head: Node<T> | null;
    tail: Node<T> | null;
    private length;
    /**
     * Alias de length para compatibilidad con Map y Set.
     */
    get size(): number;
    /**
     * Indica si la lista está vacía.
     */
    isEmpty(): boolean;
    /**
     * Agrega un nuevo nodo al final de la lista.
     * @param value - El valor a agregar (primitivo u objeto).
     * @returns La instancia de la lista (permite encadenamiento).
     */
    push(value: T): this;
    /**
     * Elimina y retorna el valor del nodo al final de la lista.
     * Gracias al puntero prev, opera en O(1).
     * @returns El valor del nodo eliminado, o undefined si la lista está vacía.
     */
    pop(): T | undefined;
    /**
     * Agrega un nuevo nodo al inicio de la lista.
     * @param value - El valor a agregar (primitivo u objeto).
     * @returns La instancia de la lista (permite encadenamiento).
     */
    unshift(value: T): this;
    /**
     * Elimina y retorna el valor del nodo al inicio de la lista.
     * Opera en O(1) porque this.head apunta directamente al primer nodo.
     * @returns El valor del nodo eliminado, o undefined si la lista está vacía.
     */
    shift(): T | undefined;
    /**
     * Retorna el nodo en el índice dado sin eliminarlo.
     * Si el índice está en la segunda mitad, recorre desde tail hacia atrás — O(n/2).
     * @param index - Índice base cero del nodo a obtener.
     * @throws {RangeError} Si el índice está fuera de rango.
     * @returns El nodo en ese índice.
     */
    get(index: number): Node<T>;
    /**
     * Actualiza el valor del nodo en el índice dado.
     * @param index - Índice base cero del nodo a actualizar.
     * @param value - El nuevo valor.
     * @throws {RangeError} Si el índice está fuera de rango.
     */
    set(index: number, value: T): void;
    /**
     * Inserta un nuevo nodo en el índice especificado.
     * Delega a push/unshift en los extremos para mantener O(1).
     * @param index - Índice base cero donde insertar.
     * @param value - El valor a insertar.
     * @throws {RangeError} Si el índice está fuera de rango.
     */
    insert(index: number, value: T): void;
    /**
     * Elimina el nodo en el índice especificado y retorna su valor.
     * Delega a pop/shift en los extremos para mantener O(1).
     * @param index - Índice base cero del nodo a eliminar.
     * @throws {RangeError} Si el índice está fuera de rango.
     * @returns El valor del nodo eliminado.
     */
    remove(index: number): T;
    /**
     * Elimina un nodo directamente por referencia, sin buscar por índice — O(1).
     * Es el primitivo clave para estructuras avanzadas como caché LRU, grafos y schedulers.
     * Advertencia: pasar un nodo que pertenece a otra lista produce comportamiento indefinido.
     * @param node - El nodo a eliminar.
     * @throws {TypeError} Si el nodo es null o undefined.
     * @returns El valor del nodo eliminado.
     */
    removeNode(node: Node<T>): T;
    /**
     * Busca el primer nodo cuyo valor satisface el predicado dado.
     * Funciona con objetos porque el predicado tiene control total sobre la comparación.
     * @param predicate - Función que recibe (value, index) y retorna boolean.
     * @returns El nodo que cumple el predicado, o undefined si no hay ninguno.
     */
    findNode(predicate: (value: T, index: number) => boolean): Node<T> | undefined;
    /**
     * Busca el primer valor que satisface el predicado dado.
     * @param predicate - Función que recibe (value, index) y retorna boolean.
     * @returns El valor del primer nodo que cumple el predicado, o undefined si no hay ninguno.
     */
    find(predicate: (value: T, index: number) => boolean): T | undefined;
    /**
     * Retorna el índice del primer nodo con el valor dado, usando comparación estricta.
     * Para objetos, usar findNode() con un predicado personalizado.
     * @param value - El valor a buscar.
     * @returns El índice del nodo, o -1 si no existe.
     */
    indexOf(value: T): number;
    /**
     * Indica si la lista contiene al menos un nodo con el valor dado.
     * Para objetos, usar findNode() con un predicado personalizado.
     * @param value - El valor a buscar.
     */
    contains(value: T): boolean;
    /**
     * Retorna un array con todos los valores de la lista, de cabeza a cola.
     */
    toArray(): T[];
    /**
     * Vacía la lista en O(1), soltando todas las referencias para que el GC pueda liberarlas.
     */
    clear(): void;
    /**
     * Hace la lista iterable con for...of, spread y destructuring.
     */
    [Symbol.iterator](): Iterator<T>;
}
//# sourceMappingURL=doubly-linked-list.d.ts.map