type Factory<T, A extends unknown[]> = (...args: A) => T;
interface DequeOptions<T, A extends unknown[]> {
    initValues?: T[];
    factory?: Factory<T, A>;
}
declare class Deque<T, A extends unknown[] = [T]> {
    #private;
    constructor({ initValues, factory }?: DequeOptions<T, A>);
    [Symbol.iterator](): IterableIterator<T>;
    rbegin(): IterableIterator<T>;
    begin(): IterableIterator<T>;
    pushFront(value: T): void;
    pushBack(value: T): void;
    popFront(): T | undefined;
    popBack(): T | undefined;
    isEmpty(): boolean;
    clear(): void;
    emplaceFront(...args: A): void;
    emplaceBack(...args: A): void;
    static swap<U, V extends unknown[] = [U]>(queue1: Deque<U, V>, queue2: Deque<U, V>): void;
    get length(): number;
    get front(): T | undefined;
    set front(val: T);
    get back(): T | undefined;
    set back(val: T);
    at(index: number): T | undefined;
    toArray(): T[];
    assign(count: number, value: T): void;
    assign(values: T[], start?: number, end?: number): void;
    forEach(callback: (value: T, index: number, deque: Deque<T, A>) => void | false, thisArg?: unknown): void;
}

export { Deque };