type Factory<T, A extends unknown[]> = (...args: A) => T;
interface QueueOptions<T, A extends unknown[]> {
    initValues?: T[];
    factory?: Factory<T, A>;
}
declare class Queue<T, A extends unknown[] = unknown[]> {
    #private;
    constructor({ initValues, factory }?: QueueOptions<T, A>);
    [Symbol.iterator](): IterableIterator<T>;
    rbegin(): IterableIterator<T>;
    begin(): IterableIterator<T>;
    push(value: T): void;
    pop(): T | undefined;
    emplace(...args: A): void;
    isEmpty(): boolean;
    clear(): void;
    toArray(): T[];
    assign(count: number, value: T): void;
    assign(values: T[], start?: number, end?: number): void;
    forEach(callback: (value: T, index: number, stack: Queue<T, A>) => void | false, thisArg?: unknown): void;
    peekFirst(): T | undefined;
    peekLast(): T | undefined;
    clone(deepCloneFn?: (val: T) => T): Queue<T, A>;
    get length(): number;
    get front(): T | undefined;
    set front(val: T);
    get back(): T | undefined;
    set back(val: T);
    static equals<U, V extends unknown[] = unknown[]>(queue1: Queue<U, V>, queue2: Queue<U, V>, comparator?: (a: U, b: U) => boolean): boolean;
    static swap<U, V extends unknown[] = unknown[]>(queue1: Queue<U, V>, queue2: Queue<U, V>): void;
}

export { Queue };