import { Deque } from '../../../java/util/Deque';
import { LinkedCollectionElement } from '../../../core/adt/collection/LinkedCollectionElement';
import { Comparator } from '../../../java/util/Comparator';
import { JavaIterator } from '../../../java/util/JavaIterator';
import { Collection } from '../../../java/util/Collection';
import { Cloneable } from '../../../java/lang/Cloneable';
import { JavaObject } from '../../../java/lang/JavaObject';
export declare class LinkedCollection<E> extends JavaObject implements Deque<E>, Cloneable {
    _head: LinkedCollectionElement<E> | null;
    _tail: LinkedCollectionElement<E> | null;
    private _size;
    _modCount: number;
    /**
     * Erzeugt eine neue LinkedCollection.
     */
    constructor();
    /**
     * Erzeugt eine neue LinkedCollection als Kopie der übergebenen
     * LinkedCollection
     *
     * @param c   die LinkedCollection, die kopiert wird
     */
    constructor(c: LinkedCollection<E> | null);
    size(): number;
    isEmpty(): boolean;
    contains(obj: unknown | null): boolean;
    iterator(): JavaIterator<E>;
    toArray(): Array<unknown>;
    toArray<T>(a: Array<T>): Array<T>;
    add(e: E | null): boolean;
    /**
     * Entfernt das übergebene Element.
     *
     * @param elem   das zu entfernende Element
     *
     * @return true, falls das Element erfolgreich entfernt wurde, und false, falls null übergeben wurde.
     */
    private removeElement;
    remove(obj: unknown | null): boolean;
    remove(): E;
    containsAll(c: Collection<unknown> | null): boolean;
    addAll(c: Collection<E> | null): boolean;
    removeAll(c: Collection<unknown> | null): boolean;
    retainAll(c: Collection<unknown> | null): boolean;
    clear(): void;
    hashCode(): number;
    equals(obj: unknown | null): boolean;
    clone(): unknown;
    toString(): String;
    /**
     * Diese Methode ist eine Hilfsmethode für die Methode sort(). Sie mischt die beiden über die prev-Zeiger
     * verketteten Listen left und right zu einer kombinierten, über die prev-Zeiger verketteten Liste.
     *
     * @param comparator   ein {@link Comparator} zum Vergleichen zweier Elemente
     * @param left         die erste sortierte Liste
     * @param right        die zweite sortierte Liste
     *
     * @return die kombinierte sortierte Liste
     */
    private merge;
    /**
     * Sortiert den Inhalte dieser Liste mithilfe des übergebenen {@link Comparator}-Objekts.
     *
     * @param comparator   ein {@link Comparator} zum Vergleichen zweier Elemente
     *
     * @return true, falls eine Sortierung erfolgreich war
     */
    sort(comparator: Comparator<E> | null): boolean;
    /**
     * Sucht das Element an der Stelle Index.
     *
     * @param index   die Stelle des gesuchten Elements
     *
     * @return das Element an der gesuchten Stelle
     *
     * @throws IndexOutOfBoundsException   wenn der Index nicht im gültigen Bereich liegt (index >= 0) && (index < size()))
     */
    private find;
    /**
     * Sucht ein LinkedCollectionElement in der Collection mit dem Wert obj
     * und gibt es zurück
     *
     * @param obj   der Wert der in der LinkedCollection gesucht werden soll
     *
     * @return  ein LinkedCollectionElement<E> falls der Wert in der Collection
     * 			enthalten ist und das Element dessen , ansonsten null
     */
    private findFirst;
    /**
     * Sucht ein LinkedCollectionElement in der Collection mit dem Wert obj
     * und gibt es zurück
     *
     * @param obj   der Wert der in der LinkedCollection gesucht werden soll
     *
     * @return  ein LinkedCollectionElement<E> falls der Wert in der Collection
     * 			enthalten ist und das Element dessen, ansonsten null
     */
    private findLast;
    offer(e: E | null): boolean;
    poll(): E | null;
    element(): E;
    peek(): E | null;
    addFirst(e: E | null): void;
    addLast(e: E | null): void;
    offerFirst(e: E | null): boolean;
    offerLast(e: E | null): boolean;
    removeFirst(): E;
    removeLast(): E;
    pollFirst(): E | null;
    pollLast(): E | null;
    getFirst(): E;
    getLast(): E;
    peekFirst(): E | null;
    peekLast(): E | null;
    removeFirstOccurrence(obj: unknown | null): boolean;
    removeLastOccurrence(obj: unknown | null): boolean;
    push(e: E): void;
    pop(): E;
    descendingIterator(): JavaIterator<E>;
    /**
     * Gibt den Wert an der Stelle index zurück.
     *
     * @param index   der Index
     *
     * @return der Wert
     *
     * @throws IndexOutOfBoundsException   wenn der Index nicht im gültigen Bereich liegt {@code (index >= 0) && (index < size()))}
     */
    get(index: number): E;
    /**
     * Ersetzt den Wert an der Stelle index mit dem neuen übergebenen Wert.
     *
     * @param index     die Stelle, wo der Wert ersetzt werden soll
     * @param element   der neue Wert für die Stelle
     *
     * @return der alte Wert an der Stelle
     *
     * @throws IndexOutOfBoundsException   wenn der Index nicht im gültigen Bereich liegt {@code (index >= 0) && (index < size()))}
     */
    set(index: number, element: E): E;
    isTranspiledInstanceOf(name: string): boolean;
    [Symbol.iterator](): Iterator<E>;
}
export declare function cast_de_nrw_schule_svws_core_adt_collection_LinkedCollection<E>(obj: unknown): LinkedCollection<E>;
