/// <reference types="node" />
/**
 * 下标错误
 */
declare class InvalidIndexError extends Error {
    constructor(message?: string);
}
/**
 * @public
 */
declare class DoublyLinkedList<T> {
    /**
     * 下标异常
     */
    static readonly InvalidIndexError: typeof InvalidIndexError;
    /**
     * 双向链表为空
     */
    static readonly EmptyError: {
        new (message?: string): {
            name: string;
            message: string;
            stack?: string | undefined;
        };
        captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
        stackTraceLimit: number;
    };
    /**
     * 头结点
     */
    private head;
    /**
     * 尾节点
     */
    private tail;
    /**
     * 节点数
     */
    private length;
    constructor();
    /**
     * 检查下标，如果不对就报个错
     *
     * @param index - 下标
     */
    private checkIndex;
    /**
     * 检查链表是否为空
     */
    private sizeCheck;
    /**
     * 清空
     */
    clear(): void;
    /**
     * 连接两个链表,不是纯函数
     */
    concat(linkList: DoublyLinkedList<T>): DoublyLinkedList<T>;
    /**
     * 是否包含某个值
     */
    contains(value: T): boolean;
    /**
     * 过滤出所有的值
     */
    filter(fn: (value: T, index: number, linkList: DoublyLinkedList<T>) => boolean): DoublyLinkedList<T>;
    /**
     * 查找第一个满足要求的元素, 找不到就是undefined
     */
    find(fn: (value: T, index: number, linkList: DoublyLinkedList<T>) => boolean): T | undefined;
    /**
     * 查找第一个满足要求的元素下标
     */
    findIndex(fn: (value: T, index: number, linkList: DoublyLinkedList<T>) => boolean): number;
    /**
     * 简单循环
     */
    forEach(fn: (value: T, index: number, linkList: DoublyLinkedList<T>) => void): void;
    /**
     * 获取指定下标的值
     */
    get(index: number): T;
    /**
     * 获取链表中的第一个值
     */
    getFirst(): T;
    /**
     * 获取链表中的最后一个值
     */
    getLast(): T;
    /**
     * 判断是否包含某一个值
     */
    includes(value: T): boolean;
    /**
     * 查找指定值的下标
     */
    indexOf(value: T): number;
    /**
     * 判断是否为空
     */
    isEmpty(): boolean;
    /**
     * 根据指定分隔符连接字符串
     */
    join(delimiter?: string, transfer?: (value: T, index: number, linkList: DoublyLinkedList<T>) => T): string;
    /**
     * 指定值的最大下标
     */
    lastIndexOf(value: T): number;
    /**
     * 指定条件的映射
     * 返回一个新
     */
    map(fn: (value: T, index: number, linkList: DoublyLinkedList<T>) => T): DoublyLinkedList<T>;
    /**
     * 去掉最后一个
     */
    pop(): T;
    /**
     * 向尾部添加
     */
    push(value: T): number;
    /**
     * 缩减
     */
    reduce(fn: (prev: any, currentValue: T, index: number, context: DoublyLinkedList<T>) => any, initialValue?: any): any;
    /**
     * 反向缩减
     */
    reduceRight(fn: (prev: any, currentValue: T, index: number) => any, initialValue?: any): any;
    /**
     * 移除指定下标的值
     */
    remove(index: number): T | undefined;
    /**
     * 反转， 应该要改变原来的
     * 这里不是简单改个头指针就行了
     * 需要交换每个节点的前后指针
     */
    reverse(): DoublyLinkedList<T>;
    /**
     * 设置指定位置的值
     */
    set(index: number, value: T): void;
    /**
     * 移除第一个
     */
    shift(): T | undefined;
    /**
     * 获取的长度
     */
    size(): number;
    /**
     * 获取其中的一段
     */
    slice(start?: number, end?: number): DoublyLinkedList<T>;
    /**
     * 遍历其中的一部分, 和findIndex逻辑几乎一样
     */
    some(fn: (value: T, index: number, context: DoublyLinkedList<T>) => boolean): boolean;
    /**
     * 排序,选择排序，毕竟是自己写的工具，要求不能太高
     */
    sort(fn: (item1: T, item2: T) => number): this;
    toString(): string;
    toArray(): T[];
    /**
     * 向头部添加
     */
    unshift(value: T): void;
    /**
     * 根据条件移除
     */
    removeEach(callback: (value: T, index: number, context: DoublyLinkedList<T>) => boolean): number;
    /**
     * 反向遍历
     */
    forEachReverse(callback: (value: T, index: number, context: DoublyLinkedList<T>) => boolean): void;
    /**
     * 反向查找
     */
    findReverse(fn: (value: T, index: number, linkList: DoublyLinkedList<T>) => boolean): T | undefined;
    /**
     * 返回一个迭代器
     * 为了能够for..of循环
     */
    [Symbol.iterator](): {
        next: () => {
            value: T;
            done: boolean;
        };
    };
}
export default DoublyLinkedList;