import type { JavaFunction } from '../../../java/util/function/JavaFunction';
import type { JavaMapEntry } from '../../../java/util/JavaMapEntry';
import type { NavigableSet } from '../../../java/util/NavigableSet';
import type { JavaSet } from '../../../java/util/JavaSet';
import type { NavigableMap } from '../../../java/util/NavigableMap';
import { ArrayList } from '../../../java/util/ArrayList';
import type { SortedSet } from '../../../java/util/SortedSet';
import type { Comparator } from '../../../java/util/Comparator';
import { AVLMapNode } from '../../../core/adt/map/AVLMapNode';
import type { JavaIterator } from '../../../java/util/JavaIterator';
import { AVLMapIntervall } from '../../../core/adt/map/AVLMapIntervall';
import { AVLMap } from '../../../core/adt/map/AVLMap';
import type { SortedMap } from '../../../java/util/SortedMap';
import type { Collection } from '../../../java/util/Collection';
import { JavaObject } from '../../../java/lang/JavaObject';
import { Class } from '../../../java/lang/Class';
import type { JavaMap } from '../../../java/util/JavaMap';
export declare class AVLMapSubMap<K, V> extends JavaObject implements NavigableMap<K, V> {
    /**
     *  Die {@link AVLMap} auf der diese Sup-Map operiert.
     */
    private readonly _par;
    /**
     *  Das {@link AVLMapIntervall} auf das sich diese Sub-Map bezieht.
     */
    private readonly _iv;
    /**
     *  Falls TRUE wird die {@link AVLMap} aufsteigend, andernfalls absteigend interpretiert.
     */
    private readonly _asc;
    /**
     * Erstellt eine neue Sub-Map relativ zur übergebenen {@link AVLMap}.
     *
     * @param parent    Die {@link AVLMap} auf der diese Sup-Map operiert.
     * @param intervall Das {@link AVLMapIntervall} auf das sich diese Sub-Map bezieht.
     * @param asc       Falls TRUE wird die {@link AVLMap} aufsteigend, andernfalls absteigend interpretiert.
     */
    constructor(parent: AVLMap<K, V>, intervall: AVLMapIntervall<K>, asc: boolean);
    toString(): string;
    equals(o: unknown | null): boolean;
    hashCode(): number;
    comparator(): Comparator<K>;
    firstKey(): K;
    lastKey(): K;
    keySet(): JavaSet<K>;
    values(): Collection<V>;
    entrySet(): JavaSet<JavaMapEntry<K, V>>;
    size(): number;
    isEmpty(): boolean;
    containsKey(key: unknown): boolean;
    containsValue(value: unknown): boolean;
    get(key: unknown): V | null;
    put(key: K, value: V): V | null;
    remove(key: unknown): V | null;
    putAll(map: JavaMap<K, V>): void;
    clear(): void;
    lowerEntry(key: K): JavaMapEntry<K, V> | null;
    lowerKey(key: K): K | null;
    floorEntry(key: K): JavaMapEntry<K, V> | null;
    floorKey(key: K): K | null;
    ceilingEntry(key: K): JavaMapEntry<K, V> | null;
    ceilingKey(key: K): K | null;
    higherEntry(key: K): JavaMapEntry<K, V> | null;
    higherKey(key: K): K | null;
    firstEntry(): JavaMapEntry<K, V> | null;
    lastEntry(): JavaMapEntry<K, V> | null;
    pollFirstEntry(): JavaMapEntry<K, V> | null;
    pollLastEntry(): JavaMapEntry<K, V> | null;
    descendingMap(): NavigableMap<K, V>;
    navigableKeySet(): NavigableSet<K>;
    descendingKeySet(): NavigableSet<K>;
    subMap(fromKey: K, fromInclusive: boolean, toKey: K, toInclusive: boolean): NavigableMap<K, V>;
    subMap(fromKey: K, toKey: K): SortedMap<K, V>;
    headMap(toKey: K, inclusive: boolean): NavigableMap<K, V>;
    headMap(toKey: K): SortedMap<K, V>;
    tailMap(fromKey: K, inclusive: boolean): NavigableMap<K, V>;
    tailMap(fromKey: K): SortedMap<K, V>;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#add(Object)}. Fügt einen Schlüssel (Key) dieser Datenstruktur hinzu.
     *
     * @param e Der einzufügende Schlüssel (Key).
     *
     * @return TRUE, falls der Schlüssel (Key) noch nicht existierte, sonst FALSE.
     */
    bcAddKey(e: K): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#addAll(Collection)}. Fügt alle Schlüssel (Keys) der Collection dieser
     * Datenstruktur hinzu.
     *
     * @param c Die Collection mit den einzufügenden Schlüsseln (Keys).
     *
     * @return TRUE, falls mindestens ein Schlüssel (Key) noch nicht existierte und somit hinzugefügt wurde.
     */
    bcAddAllKeys(c: Collection<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#add(java.util.Map.Entry)}. Fügt ein Entry der Datenstruktur hinzu.
     *
     * @param e Das einzufügende Entry.
     *
     * @return TRUE, falls das Entry (e.getKey(), e.getValue()) neu war und somit hinzugefügt wurde.
     */
    bcAddEntryReturnBool(e: JavaMapEntry<K, V>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#addAll(Collection)}. Fügt alle Entries der Collection dieser
     * Datenstruktur hinzu.
     *
     * @param c Die Collection mit den einzufügenden Entries.
     *
     * @return TRUE, falls mindestens ein Entry neu war und somit hinzugefügt wurde.
     */
    bcAddAllEntries(c: Collection<JavaMapEntry<K, V>>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#containsAll(Collection)}. Überprüft, ob alle Schlüssel (Keys) der
     * Collection in dieser Datenstruktur existieren.
     *
     * @param c Die Collection mit allen Schlüsseln (Keys) welche überprüft werden sollen.
     *
     * @return TRUE, falls alle Schlüssel (Keys) der Collection in dieser Datenstruktur existieren.
     */
    bcContainsAllKeys(c: Collection<any>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#contains(Object)}. Überprüft, ob das übergebene Entry in dieser
     * Datenstruktur existiert.
     *
     * @param o Das Entry (Schlüssel-Wert-Paar) nach dem gesucht wird.
     *
     * @return TRUE, falls das übergebene Entry bereits in dieser Datenstruktur existiert.
     */
    bcContainsEntry(o: unknown): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#containsAll(Collection)}. Überprüft, ob alle Entries der Collection
     * in dieser Datenstruktur existieren.
     *
     * @param c Die Collection mit den Entries welche überprüft werden sollen.
     *
     * @return TRUE, falls alle Entries in dieser Datenstruktur existieren.
     */
    bcContainsAllEntries(c: Collection<any>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubCollection#containsAll(Collection)}. Überprüft, ob alle Werte (Values) aus
     * der Collection in dieser Datenstruktur vorkommen. Diese Methode sollte NICHT verwendet werden, da sie
     * quadratische Laufzeit hat.
     *
     * @param c Die Collection deren Werte (Values) überprüft werden sollen.
     *
     * @return TRUE, falls alle Werte (Values) der Collection in dieser Datenstruktur existieren.
     */
    bcContainsAllValues(c: Collection<any>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#remove(Object)}. Entfernt einen Schlüssel (Key) aus dieser
     * Datenstruktur.
     *
     * @param o Der Schlüssel (Key) der entfernt werden soll.
     *
     * @return TRUE, falls der Schlüssel existierte und somit entfernt wurde.
     */
    bcRemoveKeyReturnBool(o: unknown): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#removeAll(Collection)}. Entfernt alle Schlüssel (Keys) aus dieser
     * Datenstruktur.
     *
     * @param c Die Collection mit allen Schlüsseln (Keys) die entfernt werden sollen.
     *
     * @return TRUE, falls mindestens ein Schlüssel (Key) entfernt wurde.
     */
    bcRemoveAllKeys(c: Collection<any>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#remove(Object)}. Entfernt das Entry aus dieser Datenstruktur.
     *
     * @param o Das Entry, welches entfernt werden soll.
     *
     * @return TRUE, falls das Entry in der Datenstruktur existierte und somit entfernt wurde.
     */
    bcRemoveEntry(o: unknown): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#removeAll(Collection)}. Entfernt alle Entries der Collection aus
     * dieser Datenstruktur.
     *
     * @param c Die Collection mit den Entries, welche entfernt werden sollen.
     *
     * @return TRUE, falls mindestens ein Entry entfernt wurde.
     */
    bcRemoveAllEntries(c: Collection<any>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#pollFirst()}. Entfernt und liefert den ersten Schlüssel (Key) dieser
     * Datenstruktur. Dabei wird beachtet, ob diese Sub-Map aufsteigend oder absteigend zu interpretieren ist.
     *
     * @return Entfernt und liefert den ersten Schlüssel (Key) dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcPollFirstKeyOrNull(): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#pollLast()}. Entfernt und liefert den letzten Schlüssel (Key) dieser
     * Datenstruktur. Dabei wird beachtet, ob diese Sub-Map aufsteigend oder absteigend zu interpretieren ist.
     *
     * @return Entfernt und liefert den letzten Schlüssel (Key) dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcPollLastKeyOrNull(): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#retainAll(Collection)}. Entfernt alle Schlüssel (Keys) aus dieser
     * Datenstruktur, außer sie sind in der Collection enthalten.
     *
     * @param c Die Collection deren Schlüssel (Keys) nicht entfernt werden dürfen.
     *
     * @return TRUE, falls mindestens ein Schlüssel (Key) entfernt wurde.
     */
    bcRetainAllKeys(c: Collection<any>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#retainAll(Collection)}. Entfernt alle Entries aus dieser
     * Datenstruktur, außer sie sind in der Collection enthalten.
     *
     * @param c Die Collection deren Entries nicht entfernt werden dürfen.
     *
     * @return TRUE, falls mindestens ein Entry entfernt wurde.
     */
    bcRetainAllEntries(c: Collection<any>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubCollectionIterator} und {@link AVLMapSubKeySetIterator}. Liefert das erste
     * Entry als {@link AVLMapNode}, um über diese Datenstruktur zu iterieren. Dabei wird beachtet, ob diese Sub-Map
     * aufsteigend oder absteigend zu interpretieren ist.
     *
     * @return Das erste Entry als {@link AVLMapNode} dieser Datenstruktur.
     */
    bcGetFirstEntryAsNode(): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubCollectionIterator} und {@link AVLMapSubKeySetIterator}. Liefert das nächste
     * Entry relativ zu einem übergebenen Entry. Dabei wird beachtet, ob diese Sub-Map aufsteigend oder absteigend zu
     * interpretieren ist.
     *
     * @param node Das Entry dessen Nachfolger verlangt wird.
     *
     * @return Das nächste Entry relativ zu einem übergebenen Entry.
     */
    bcGetNextEntryOrNull(node: AVLMapNode<K, V>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#floor(Object)}. Liefert den größten Schlüssel (Key) welcher kleiner
     * oder gleich dem übergebenen Schlüssel (Key) ist. Somit der selbe Schlüssel (Key) falls vorhanden, andernfalls den
     * Vorgänger-Schlüssel (Key) falls vorhanden, andernfalls NULL. Dabei wird beachtet, ob diese Sub-Map aufsteigend
     * oder absteigend zu interpretieren ist.
     *
     * @param e Der Schlüssel (Key) der gesucht wird bzw. sein Vorgänger-Schlüssel.
     *
     * @return Den selben Schlüssel (Key) falls vorhanden, andernfalls sein Vorgänger-Schlüssel falls vorhanden,
     *         andernfalls NULL.
     */
    bcGetFloorKeyOrNull(e: K): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#ceiling(Object)}. Liefert den kleinsten Schlüssel (Key) welcher größer
     * oder gleich dem übergebenen Schlüssel (Key) ist. Somit der selbe Schlüssel (Key) falls vorhanden, andernfalls
     * sein Nachfolger-Schlüssel (Key) falls vorhanden, andernfalls NULL. Dabei wird beachtet, ob diese Sub-Map
     * aufsteigend oder absteigend zu interpretieren ist.
     *
     * @param e Der Schlüssel (Key) der gesucht wird bzw. sein Nachfolger-Schlüssel.
     *
     * @return Den selben Schlüssel (Key) falls vorhanden, andernfalls sein Nachfolger-Schlüssel falls vorhanden,
     *         andernfalls NULL.
     */
    bcGetCeilingKeyOrNull(e: K): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#lower(Object)}. Liefert den größten Schlüssel (Key) welcher kleiner
     * ist als der übergebene Schlüssel (Key), somit den Vorgänger-Schlüssel des Schlüssels (Key). Dabei wird beachtet,
     * ob diese Sub-Map aufsteigend oder absteigend zu interpretieren ist.
     *
     * @param e Der Schlüssel (Key) dessen Vorgänger gesucht wird.
     *
     * @return Den Vorgänger-Schlüssel des übergebenen Schlüssels (Key) falls vorhanden, sonst NULL.
     */
    bcGetLowerKeyOrNull(e: K): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#higher(Object)}. Liefert den kleinsten Schlüssel (Key) welcher größer
     * ist als der übergebene Schlüssel (Key), somit den Nachfolger-Schlüssel des übergebenen Schlüssels (Key). Dabei
     * wird beachtet, ob diese Sub-Map aufsteigend oder absteigend zu interpretieren ist.
     *
     * @param e Der Schlüssel (Key) dessen Nachfolger-Schlüssel gesucht wird.
     *
     * @return Den Nachfolger-Schlüssel des übergebenen Schlüssels (Key) falls vorhanden, sonst NULL.
     */
    bcGetHigherKeyOrNull(e: K): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#toArray()} und {@link AVLMapSubKeySet#toArray(Object[])}. Liefert
     * einen {@link ArrayList} der alle Schlüssel (Keys) dieser Sub-Map beinhaltet.
     *
     * @return Ein {@link ArrayList} der alle Schlüssel (Keys) dieser Sub-Map beinhaltet.
     */
    bcGetArrayListOfKeys(): ArrayList<K>;
    /**
     * Wird aufgerufen von {@link AVLMapSubCollection#toArray()} und {@link AVLMapSubCollection#toArray(Object[])}.
     * Liefert einen {@link ArrayList} der alle Werte (Values) dieser Sub-Map beinhaltet.
     *
     * @return Ein {@link ArrayList} der alle Werte (Values) dieser Sub-Map beinhaltet.
     */
    bcGetArrayListOfValues(): ArrayList<V>;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#toArray()} und {@link AVLMapSubEntrySet#toArray(Object[])}. Liefert
     * einen {@link ArrayList} der alle Entries dieser Sub-Map beinhaltet.
     *
     * @return Ein {@link ArrayList} der alle Entries dieser Sub-Map beinhaltet.
     */
    bcGetArrayListOfEntries(): ArrayList<JavaMapEntry<K, V>>;
    /**
     * Wird aufgerufen von {@link AVLMapSubKeySet#iterator()}. Liefert einen {@link Iterator} von Schlüsseln (Keys)
     * relativ zu dieser Sub-Map.
     *
     * @return Einen {@link Iterator} von Schlüsseln (Keys) relativ zu dieser Sub-Map.
     */
    bcGetSubKeySetIterator(): JavaIterator<K>;
    /**
     * Wird aufgerufen von {@link AVLMapSubCollection#iterator()}. Liefert einen {@link Iterator} von Werten (Values)
     * relativ zu dieser Sub-Map.
     *
     * @return Einen {@link Iterator} von Werten (Values) relativ zu dieser Sub-Map.
     */
    bcGetSubCollectionIterator(): JavaIterator<V>;
    /**
     * Wird aufgerufen von {@link AVLMapSubEntrySet#iterator()}. Liefert einen {@link Iterator} von Entries relativ zu
     * dieser Sub-Map.
     *
     * @return Ein {@link Iterator} von Entries relativ zu dieser Sub-Map.
     */
    bcGetSubEntrySetIterator(): JavaIterator<JavaMapEntry<K, V>>;
    /**
     * Wird aufgerufen und von {@link AVLMapSubKeySet#descendingSet()}. Liefert ein {@link NavigableSet} von Schlüsseln
     * (Keys) relativ zu dieser <strong>absteigenden</strong> Sub-Map.
     *
     * @return Ein {@link NavigableSet} von Schlüsseln (Keys) relativ zu dieser <strong>absteigenden</strong> Sub-Map.
     */
    bcGetSubKeySetDescending(): NavigableSet<K>;
    /**
     * Wird aufgerufen und von {@link AVLMapSubKeySet#descendingIterator()}. Liefert einen {@link Iterator} von
     * Schlüsseln (Keys) relativ zu dieser <strong>absteigenden</strong> Sub-Map.
     *
     * @return Ein {@link Iterator} von Schlüsseln (Keys) relativ zu dieser <strong>absteigenden</strong> Sub-Map.
     */
    bcGetSubKeySetDescendingIterator(): JavaIterator<K>;
    /**
     * Wird aufgerufen und von {@link AVLMapSubKeySet#subSet(Object, boolean, Object, boolean)}. Liefert ein
     * {@link NavigableSet} von Schlüsseln (Keys) relativ zu dieser Sub-Map.
     *
     * @param fromElement   Die linke (von) Intervallsgrenze.
     * @param fromInclusive Gibt an, ob die linke (von) Intervallsgrenze inklusive ist.
     * @param toElement     Die rechte (bis) Intervallsgrenze.
     * @param toInclusive   Gibt an, ob die rechte (bis) Intervallsgrenze inklusive ist.
     *
     * @return Ein {@link NavigableSet} von Schlüsseln (Keys) relativ zu dieser Sub-Map.
     */
    bcGetSubKeySet(fromElement: K, fromInclusive: boolean, toElement: K, toInclusive: boolean): NavigableSet<K>;
    /**
     * Wird aufgerufen und von {@link AVLMapSubKeySet#subSet(Object, Object)}. Liefert ein {@link NavigableSet} von
     * Schlüsseln (Keys) relativ zu dieser Sub-Map.
     *
     * Äquivalent zu {@link #bcGetSubKeySet(Object, boolean, Object, boolean)} mit den Werten (fromElement, true,
     * toElement, false).
     *
     * @param fromElement Die linke (von) Intervallsgrenze <strong>inklusive</strong>.
     * @param toElement   Die rechte (bis) Intervallsgrenze <strong>exklusive</strong>.
     *
     * @return Ein {@link NavigableSet} von Schlüsseln (Keys) relativ zu dieser Sub-Map.
     */
    bcGetSubKeySet(fromElement: K, toElement: K): SortedSet<K>;
    /**
     * Wird aufgerufen und von {@link AVLMapSubKeySet#headSet(Object, boolean)}. Liefert ein {@link NavigableSet} von
     * Schlüsseln (Keys) relativ zu dieser Sub-Map.
     *
     * @param toElement Die rechte (bis) Intervallsgrenze.
     * @param inclusive Gibt an, ob die rechte (bis) Intervallsgrenze inklusive ist.
     *
     * @return Ein {@link NavigableSet} von Schlüsseln (Keys) relativ zu dieser Sub-Map.
     */
    bcGetSubKeyHeadSet(toElement: K, inclusive: boolean): NavigableSet<K>;
    /**
     * Wird aufgerufen und von {@link AVLMapSubKeySet#headSet(Object)}. Liefert ein {@link NavigableSet} von Schlüsseln
     * (Keys) relativ zu dieser Sub-Map.
     *
     * Äquivalent zu {@link #bcGetSubKeyHeadSet(Object, boolean)} mit den Werten (toElement, false).
     *
     * @param toElement Die rechte (bis) Intervallsgrenze <strong>exklusive</strong>.
     *
     * @return Ein {@link NavigableSet} von Schlüsseln (Keys) relativ zu dieser Sub-Map.
     */
    bcGetSubKeyHeadSet(toElement: K): SortedSet<K>;
    /**
     * Wird aufgerufen und von {@link AVLMapSubKeySet#tailSet(Object, boolean)}. Liefert ein {@link NavigableSet} von
     * Schlüsseln (Keys) relativ zu dieser Sub-Map.
     *
     * @param fromElement Die linke (von) Intervallsgrenze.
     * @param inclusive   Gibt an, ob die linke (von) Intervallsgrenze inklusive ist.
     *
     * @return Ein {@link NavigableSet} von Schlüsseln (Keys) relativ zu dieser Sub-Map.
     */
    bcGetSubKeyTailSet(fromElement: K, inclusive: boolean): NavigableSet<K>;
    /**
     * Wird aufgerufen und von {@link AVLMapSubKeySet#tailSet(Object)}. Liefert ein {@link NavigableSet} von Schlüsseln
     * (Keys) relativ zu dieser Sub-Map.
     *
     * Äquivalent zu {@link #bcGetSubKeyTailSet(Object, boolean)} mit den Werten (fromElement, true).
     *
     * @param fromElement Die linke (von) Intervallsgrenze <strong>inklusive</strong>.
     *
     * @return Ein {@link NavigableSet} von Schlüsseln (Keys) relativ zu dieser Sub-Map.
     */
    bcGetSubKeyTailSet(fromElement: K): SortedSet<K>;
    private _createMap;
    private _createSet;
    transpilerCanonicalName(): string;
    isTranspiledInstanceOf(name: string): boolean;
    static class: Class<AVLMapSubMap<any, any>>;
    reversed(): NavigableMap<K, V>;
    computeIfAbsent(key: K, mappingFunction: JavaFunction<K, V>): V | null;
}
export declare function cast_de_svws_nrw_core_adt_map_AVLMapSubMap<K, V>(obj: unknown): AVLMapSubMap<K, V>;
//# sourceMappingURL=AVLMapSubMap.d.ts.map