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 { AVLMapIntervall } from '../../../core/adt/map/AVLMapIntervall';
import type { Comparator } from '../../../java/util/Comparator';
import { AVLMapNode } from '../../../core/adt/map/AVLMapNode';
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 AVLMap<K, V> extends JavaObject implements NavigableMap<K, V> {
    /**
     *  Ein Dummy-Element für den Schlüsselwert "-Unendlich".
     */
    private readonly _infinityMinus;
    /**
     *  Ein Dummy-Element für den Schlüsselwert "+Unendlich".
     */
    private readonly _infinityPlus;
    /**
     *  Ein Dummy-Element für ein Pseudo-Mapping.
     */
    private readonly _dummyValue;
    /**
     *  Alle Anfragen werden an die Sub-Map delegiert. Diese hat einen Bereich von "-Unendlich" bis "+Unendlich" und
     *  beinhaltet somit alle Elemente.
     */
    private readonly _sub;
    /**
     *  Der {@link Comparator}, der zum Vergleichen der Schlüsselwerte genutzt wird.
     */
    private readonly _comparator;
    /**
     *  Der {@link Comparator}, der zum Vergleichen der Schlüsselwerte genutzt wird, wenn eine natürliche Ordnung über
     *  das {@link Comparable} - Interface verwendet wird.
     */
    private readonly _comparatorNatural;
    /**
     *  Die Wurzel des Baumes. Bei einem leeren Baum ist diese Referenz NULL.
     */
    private _root;
    /**
     *  Gibt an, ob das Hinzufügen von KEYs ohne VALUE erlaubt ist. Falls TRUE, dann wird der KEY einer Pseudo-VALUE
     *  zugeordnet.
     */
    private _allowKeyAlone;
    /**
     * Erzeugt einen leere Map, welche bei den Schlüsselwerten die natürliche Ordnung des {@link Comparable} - Interface
     * nutzt.
     */
    constructor();
    /**
     * Erstellt eine neue leere Map und nutzt dabei die angegeben Ordnung der Schlüssel.
     *
     * @param comparator Die Ordnung für die Schlüssel.
     */
    constructor(comparator: Comparator<K>);
    /**
     * Erstellt eine neue Map mit den Daten aus der angegebenen Map und nutzt dabei die Ordnung dieser Map.
     *
     * @param map Die Map mit den Daten.
     */
    constructor(map: SortedMap<K, V>);
    toString(): string;
    /**
     * Bewirkt, dass das Hinzufügen von Keys ohne Value durch {@link AVLMapSubKeySet} erlaubt ist. Die Keys werden auf
     * einen Dummy-Wert gemapped.
     *
     * @param b Falls TRUE, dürfen KEYs ohne VALUE hinzugefügt werden.
     */
    allowKeyAlone(b: boolean): void;
    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(m: 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 AVLMapSubMap}. Fügt ein Entry der Datenstruktur hinzu.
     *
     * @param e  Das einzufügende Entry.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls das Entry (e.getKey(), e.getValue()) neu war und somit hinzugefügt wurde.
     */
    bcAddEntryReturnBool(e: JavaMapEntry<K, V>, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Fügt ein Entry bzw. ein Key-Value-Paar der Datenstruktur hinzu.
     *
     * @param key   Der Schlüssel (Key) des Entrys.
     * @param value Der zum Schlüssel (Key) zugehörige Wert (Value).
     * @param iv    Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Den alten Wert (Value), falls ein zugehöriger Schlüssel (Key) existierte, sonst NULL.
     */
    bcAddEntryReturnOldValueOrNull(key: K, value: V, iv: AVLMapIntervall<K>): V | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Fügt alle Entries der Collection der Datenstruktur hinzu.
     *
     * @param c  Die Collection mit den einzufügenden Entries.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls mindestens ein Entry neu war und somit hinzugefügt wurde.
     */
    bcAddAllEntries(c: Collection<JavaMapEntry<K, V>>, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Fügt alle Entrys der übergebenen Map dieser Datenstruktur hinzu.
     *
     * @param map Die Map, deren Entries dieser Datenstruktur hinzugefügt werden soll.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     */
    bcAddAllEntriesOfMap(map: JavaMap<K, V>, iv: AVLMapIntervall<K>): void;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Bei dem Versuch einen Schlüssel (Key) ohne Wert (Value) hinzuzufügen,
     * kann es zu einer {@link UnsupportedOperationException} kommen, wenn das Attribut {@link #_allowKeyAlone} auf
     * FALSE gesetzt ist. Andernfalls wird dem Schlüssel (Key) ein Dummy-Wert {@link #_dummyValue} zugeordnet. Der
     * Schlüssel (Key) wird jedoch nur dann hinzugefügt, falls er noch nicht existierte.
     *
     * @param e  Der Schlüssel (Key) der hinzugefügt werden soll.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls der Schlüssel (Key) noch nicht existierte und somit hinzugefügt wurde.
     * @throws UnsupportedOperationException wenn ein alleiniges Hinzufügen eines Schlüssels nicht erlaubt ist.
     */
    bcAddKey(e: K, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Versucht alle Schlüssel (Keys) der Collection hinzuzufügen. Ob das
     * Hinzufügen eines Schlüssels (Key) ohne Wert (Value) erlaubt ist, hängt vom Attribut {@link #_allowKeyAlone} ab.
     *
     * @param c  Die Collection mit allen Schlüsseln (Keys) die hinzugefügt werden sollen.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls mindestens ein Schlüssel (Key) noch nicht existierte und somit hinzugefügt wurde.
     * @throws UnsupportedOperationException wenn ein alleiniges Hinzufügen eines Schlüssels nicht erlaubt ist.
     */
    bcAddAllKeys(c: Collection<K>, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Überprüft, ob ein Schlüssel (Key) in dieser Datenstruktur existiert.
     *
     * @param objKey Der Schlüssel (Key) nach dem gesucht wird.
     * @param iv     Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls der Schlüssel (Key) in dieser Datenstruktur existiert.
     */
    bcContainsKey(objKey: unknown, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Ü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.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls alle Schlüssel (Keys) der Collection in dieser Datenstruktur existieren.
     */
    bcContainsAllKeys(c: Collection<any>, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Überprüft, ob ein Wert (Value) in dieser Datenstruktur existiert. Die
     * Laufzeit ist linear, da die gesamte Datenstruktur überprüft werden muss.
     *
     * @param objValue Der Wert (Value) nach dem gesucht wird.
     * @param iv       Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls der Wert (Value) in dieser Datenstruktur existiert.
     */
    bcContainsValue(objValue: unknown, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Ü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.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls alle Werte (Values) der Collection in dieser Datenstruktur existieren.
     */
    bcContainsAllValues(c: Collection<any>, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Überprüft, ob das übergebene Entry in dieser Datenstruktur existiert.
     *
     * @param o  Das Entry (Schlüssel-Wert-Paar) nach dem gesucht wird.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls das übergebene Entry in dieser Datenstruktur existiert.
     */
    bcContainsEntry(o: unknown, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Überprüft, ob alle Entries der Collection in dieser Datenstruktur
     * existieren.
     *
     * @param c  Die Collection mit den Entries welche überprüft werden sollen.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls alle Entries in dieser Datenstruktur existieren.
     */
    bcContainsAllEntries(c: Collection<any>, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Versucht einen Schlüssel (Key) aus dieser Datenstruktur zu entfernen.
     * In dieser Implementierung kann ein Schlüssel (Key) keinem NULL-Wert zugeordnet sein. Ist das Ergebnis NULL,
     * bedeutet dies, dass der Schlüssel (Key) definitiv nicht existierte.
     *
     * @param obj Der Schlüssel (Key), welcher entfernt werden soll.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert den zum Schlüssel (Key) zugehörigen Wert (Value), falls es eine Zuordnung gab, andernfalls NULL.
     */
    bcRemoveKeyReturnOldValueOrNull(obj: unknown, iv: AVLMapIntervall<K>): V | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Entfernt einen Schlüssel (Key) aus dieser Datenstruktur.
     *
     * @param o  Der Schlüssel (Key) der entfernt werden soll.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls der Schlüssel existierte und somit entfernt wurde.
     */
    bcRemoveKeyReturnBool(o: unknown, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Entfernt alle Schlüssel (Keys) der Collection aus dieser Datenstruktur.
     *
     * @param c  Die Collection mit allen Schlüsseln (Keys) die entfernt werden sollen.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls mindestens ein Schlüssel (Key) entfernt wurde.
     */
    bcRemoveAllKeys(c: Collection<any>, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Entfernt das Entry aus dieser Datenstruktur.
     *
     * @param o  Das Entry, welches entfernt werden soll.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls das Entry in der Datenstruktur existierte und somit entfernt wurde.
     */
    bcRemoveEntry(o: unknown, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Entfernt alle Entries der Collection aus dieser Datenstruktur.
     *
     * @param c  Die Collection mit den Entries, welche entfernt werden sollen.
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls mindestens ein Entry entfernt wurde.
     */
    bcRemoveAllEntries(c: Collection<any>, iv: AVLMapIntervall<K>): boolean;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Entfernt und liefert das erste Entry dieser Datenstruktur.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Entfernt und liefert das erste Entry dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcPollFirstEntryOrNull(iv: AVLMapIntervall<K>): JavaMapEntry<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Entfernt und liefert den ersten Schlüssel (Key) dieser Datenstruktur.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Entfernt und liefert den ersten Schlüssel (Key) dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcPollFirstKeyOrNull(iv: AVLMapIntervall<K>): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Entfernt und liefert das letzte Entry dieser Datenstruktur.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Entfernt und liefert das letzte Entry dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcPollLastEntryOrNull(iv: AVLMapIntervall<K>): JavaMapEntry<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Entfernt und liefert den letzten Schlüssel (Key) dieser Datenstruktur.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Entfernt und liefert den letzten Schlüssel (Key) dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcPollLastKeyOrNull(iv: AVLMapIntervall<K>): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert die Anzahl der Elemente innerhalb des übergebenen Intervalls.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert die Anzahl der Elemente innerhalb des übergebenen Intervalls.
     */
    bcGetSize(iv: AVLMapIntervall<K>): number;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Überprüft, ob die Datenstruktur innerhalb des Intervalls leer ist.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls die Datenstruktur innerhalb des Intervalls leer ist.
     */
    bcIsEmpty(iv: AVLMapIntervall<K>): boolean;
    /**
     * Liefert den Comparator dieser Map.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert den Comparator dieser Map.
     */
    bcGetComparator(iv: AVLMapIntervall<K>): Comparator<K>;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert das erste Entry dieser Datenstruktur.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Das erste Entry dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcGetFirstEntryOrNull(iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert den ersten Schlüssel (Key) dieser Datenstruktur.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert den ersten Schlüssel (Key) dieser Datenstruktur, falls vorhanden.
     * @throws NoSuchElementException falls es kein erstes Element gibt.
     */
    bcGetFirstKeyOrException(iv: AVLMapIntervall<K>): K;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert das letzte Entry dieser Datenstruktur.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert das letzte Entry dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcGetLastEntryOrNull(iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert den letzten Schlüssel (Key) dieser Datenstruktur.
     *
     * @param iv Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert den letzten Schlüssel (Key) dieser Datenstruktur falls vorhanden.
     * @throws NoSuchElementException falls es kein letztes Element gibt.
     */
    bcGetLastKeyOrException(iv: AVLMapIntervall<K>): K;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert das nächste Entry dieser Datenstruktur.
     *
     * @param current Das aktuelle Entry .
     * @param iv      Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert das nächste Entry dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcGetNextEntryOrNull(current: AVLMapNode<K, V>, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert das vorherige Entry dieser Datenstruktur.
     *
     * @param current Das aktuelle Entry.
     * @param iv      Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert das vorherige Entry dieser Datenstruktur falls vorhanden, andernfalls NULL.
     */
    bcGetPrevEntryOrNull(current: AVLMapNode<K, V>, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert den Wert (Value) eines bestimmten Schlüssels (Key).
     *
     * @param objKey Der Schlüssel (Key) dessen Wert (Value) angefordert wird.
     * @param iv     Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Den Wert (Value) eines bestimmten Schlüssels (Key) falls vorhanden, sonst NULL.
     */
    bcGetValueOfKeyOrNull(objKey: unknown, iv: AVLMapIntervall<K>): V | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert das größte Entry welches kleiner ist als der übergebene
     * Schlüssel (Key), somit den Vorgänger-Entry des Schlüssels (Key).
     *
     * @param key Der Schlüssel (Key) dessen Vorgänger-Entry gesucht wird.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert den Vorgänger-Entry des Schlüssels (Key) falls vorhanden, sonst NULL.
     */
    bcGetLowerEntryOrNull(key: K, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. 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).
     *
     * @param key Der Schlüssel (Key) dessen Vorgänger gesucht wird.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Den Vorgänger-Schlüssel des übergebenen Schlüssels (Key) falls vorhanden, sonst NULL.
     */
    bcGetLowerKeyOrNull(key: K, iv: AVLMapIntervall<K>): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert das größte Entry welches kleiner oder gleich dem übergebenen
     * Schlüssel (Key) ist. Somit das zugehörige Entry des Schlüssels (Key) falls vorhanden, andernfalls den
     * Vorgänger-Entry falls vorhanden, andernfalls NULL.
     *
     * @param key Der Schlüssel (Key) dessen Entry bzw. Vorgänger-Entry gesucht wird.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Das zugehörige Entry des Schlüssels (Key) falls vorhanden, andernfalls den Vorgänger-Entry falls
     *         vorhanden, andernfalls NULL.
     */
    bcGetFloorEntryOrNull(key: K, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. 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.
     *
     * @param key Der Schlüssel (Key) der gesucht wird bzw. sein Vorgänger-Schlüssel.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Den selben Schlüssel (Key) falls vorhanden, andernfalls sein Vorgänger-Schlüssel falls vorhanden,
     *         andernfalls NULL.
     */
    bcGetFloorKeyOrNull(key: K, iv: AVLMapIntervall<K>): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert das kleinste Entry welches größer oder gleich dem übergebenen
     * Schlüssel (Key) ist. Somit das zugehörige Entry des Schlüssels (Key) falls vorhanden, andernfalls den
     * Nachfolger-Entry falls vorhanden, andernfalls NULL.
     *
     * @param key Der Schlüssel (Key) dessen Entry bzw. Nachfolger-Entry gesucht wird.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Das zugehörige Entry des Schlüssels (Key) falls vorhanden, andernfalls den Nachfolger-Entry falls
     *         vorhanden, andernfalls NULL.
     */
    bcGetCeilingEntryOrNull(key: K, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. 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.
     *
     * @param key Der Schlüssel (Key) der gesucht wird bzw. sein Nachfolger-Schlüssel.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Den selben Schlüssel (Key) falls vorhanden, andernfalls sein Nachfolger-Schlüssel falls vorhanden,
     *         andernfalls NULL.
     */
    bcGetCeilingKeyOrNull(key: K, iv: AVLMapIntervall<K>): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Liefert das kleinste Entry welches größer ist als der übergebene
     * Schlüssel (Key), somit den Nachfolger-Entry des Schlüssels (Key).
     *
     * @param key Der Schlüssel (Key) dessen Nachfolger-Entry gesucht wird.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Liefert den Nachfolger-Entry des Schlüssels (Key) falls vorhanden, sonst NULL.
     */
    bcGetHigherEntryOrNull(key: K, iv: AVLMapIntervall<K>): AVLMapNode<K, V> | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. 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).
     *
     * @param key Der Schlüssel (Key) dessen Nachfolger-Schlüssel gesucht wird.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return Den Nachfolger-Schlüssel des übergebenen Schlüssels (Key) falls vorhanden, sonst NULL.
     */
    bcGetHigherKeyOrNull(key: K, iv: AVLMapIntervall<K>): K | null;
    /**
     * Wird aufgerufen von {@link AVLMapSubMap}. Überprüft, ob ein übergebener Schlüssel sich außerhalb des Bereichs des
     * übergebenen Intervalls befindet. Der Parameter {@code inc} gibt an, auf der übergebene Schlüssel selbst inklusive
     * zu interpretieren ist.
     *
     * @param key Der gesuchte Schlüssel.
     * @param inc Falls TRUE, dann ist der Schlüssel key inklusive zu interpretieren.
     * @param iv  Das Intervall der {@link AVLMapSubMap}.
     *
     * @return TRUE, falls der übergebene Schlüssel außerhalb des übergebenen Intervalls ist.
     */
    bcCheckOutOfIntervall(key: K, inc: boolean, iv: AVLMapIntervall<K>): boolean;
    private _keyOrNull;
    private _valEquals;
    private _keyOrExeption;
    private _compare;
    private _isOutOfRange;
    private _nodeFirstOrNull;
    private _nodeLastOrNull;
    private _nodeCeilingOrNull;
    private _nodeHigherOrNull;
    private _nodeFloorOrNull;
    private _nodeLowerOrNull;
    private _nodeNextOrNull;
    private _nodePrevOrNull;
    private _nodeGetOrNull;
    private _nodeIndexOf;
    private _nodeDeepestOrNull;
    private _nodePutRecursive;
    private _nodeCreateLeaf;
    private _nodeRemoveKeyRecursive;
    private _nodeReplaceReferencesFromAwithB;
    private _nodeRemovePrevNext;
    /**
     * Aktualisiert {@link node} und liefert, wenn es zur Rotation kommt, eine neue Sub-Wurzel.
     *
     * @param node Der Knoten, der revalidiert werden soll.
     *
     * @return node, oder die neue Sub-Wurzel, wenn es zur Rotation kam.
     */
    private _nodeRevalidate;
    private _nodeRotateLeft;
    private _nodeRotateRight;
    private _nodeRevalidateHeightAndSize;
    private _nodeGetHeightBalance;
    transpilerCanonicalName(): string;
    isTranspiledInstanceOf(name: string): boolean;
    static class: Class<AVLMap<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_AVLMap<K, V>(obj: unknown): AVLMap<K, V>;
//# sourceMappingURL=AVLMap.d.ts.map