@hmt/svws-core 1.5.2 → 1.5.4

package/dist/core/utils/gost/GostBlockungsdatenManager.d.ts

@@ -0,0 +1,1378 @@
+import { JavaObject } from '../../../java/lang/JavaObject';
+import { GostBlockungsergebnisManager } from '../../../core/utils/gost/GostBlockungsergebnisManager';
+import type { JavaSet } from '../../../java/util/JavaSet';
+import { GostFaecherManager } from '../../../core/utils/gost/GostFaecherManager';
+import { LongArrayKey } from '../../../core/adt/LongArrayKey';
+import { GostBlockungRegel } from '../../../core/data/gost/GostBlockungRegel';
+import { GostKursart } from '../../../core/types/gost/GostKursart';
+import { GostKursblockungRegelTyp } from '../../../core/types/kursblockung/GostKursblockungRegelTyp';
+import { GostHalbjahr } from '../../../core/types/gost/GostHalbjahr';
+import type { List } from '../../../java/util/List';
+import { GostBlockungKurs } from '../../../core/data/gost/GostBlockungKurs';
+import { GostFach } from '../../../core/data/gost/GostFach';
+import { GostBlockungKursLehrer } from '../../../core/data/gost/GostBlockungKursLehrer';
+import { GostFachwahl } from '../../../core/data/gost/GostFachwahl';
+import { GostBlockungsergebnis } from '../../../core/data/gost/GostBlockungsergebnis';
+import { GostBlockungsdaten } from '../../../core/data/gost/GostBlockungsdaten';
+import { Schueler } from '../../../asd/data/schueler/Schueler';
+import { GostBlockungSchiene } from '../../../core/data/gost/GostBlockungSchiene';
+import { Class } from '../../../java/lang/Class';
+import type { JavaMap } from '../../../java/util/JavaMap';
+export declare class GostBlockungsdatenManager extends JavaObject {
+    /**
+     * Damit man nicht immer "\n" schreibt.
+     */
+    private readonly lineSeparator;
+    /**
+     * Die Blockungsdaten, die im Manager vorhanden sind.
+     */
+    private readonly dtoDaten;
+    /**
+     * Der Fächermanager mit den Fächern der gymnasialen Oberstufe.
+     */
+    private readonly manFaecher;
+    /**
+     * Ein Comparator für Kurse der Blockung. Dieser vergleicht nur die Kursnummern!
+     */
+    private readonly compKursnummer;
+    /**
+     * Ein Comparator für Schienen der Blockung
+     */
+    private readonly compSchiene;
+    /**
+     * Ein Comparator für die Lehrkräfte eines Kurses
+     */
+    private readonly compLehrkraefte;
+    /**
+     * Ein Comparator für die Ergebnisse sortiert nach ID.
+     */
+    private readonly compErgebnisseNachID;
+    /**
+     * Ein Comparator für die Schüler.
+     */
+    private readonly compSchueler;
+    /**
+     * Ein Comparator für die Fachwahlen (SCHÜLERID, FACH, KURSART)
+     */
+    private readonly compFachwahlen;
+    /**
+     * Ein Comparator für die {@link GostBlockungsergebnis} nach ihrer Bewertung.
+     */
+    private readonly compErgebnisse;
+    /**
+     * Ein Comparator für Kurse der Blockung (KURSART, FACH, KURSNUMMER)
+     */
+    private readonly compKurs1kursart2fach3kursnummer;
+    /**
+     * Ein Comparator für Kurse der Blockung (FACH, KURSART, KURSNUMMER).
+     */
+    private readonly compKurs1fach2kursart3kursnummer;
+    /**
+     * Ein Comparator für Regeln der Blockung
+     */
+    private readonly compRegel;
+    /**
+     * Eine interne Hashmap zum schnellen Zugriff auf die Kurse anhand ihrer Datenbank-ID.
+     */
+    private readonly kursById;
+    /**
+     * Eine interne Hashmap zum schnellen Zugriff auf die Listen der Kurse, welche Fach und Kursart gemeinsam haben, anhand der beiden IDs.
+     */
+    private readonly kursmengeByFachIdAndKursartId;
+    /**
+     * Eine interne Hashmap zum schnellen Zugriff auf die Listen der Fachwahlen, welche Fach und Kursart gemeinsam haben, anhand der beiden IDs.
+     */
+    private readonly fachwahlmengeByFachIdAndKursartId;
+    /**
+     * Eine interne Hashmap zum schnellen Zugriff auf die Schienen anhand ihrer Datenbank-ID.
+     */
+    private readonly schieneById;
+    /**
+     * Eine interne Hashmap zum schnellen Zugriff auf die Regeln anhand ihrer Datenbank-ID.
+     */
+    private readonly regelById;
+    /**
+     * Eine interne Hashmap zum schnellen Zugriff auf die Regeln eines bestimmten {@link GostKursblockungRegelTyp}.
+     */
+    private readonly regelmengeByRegeltyp;
+    /**
+     * Eine interne Hashmap zum Multi-Key-Zugriff auf die Regeln eines bestimmten {@link GostKursblockungRegelTyp}.
+     */
+    private readonly regelByMultikey;
+    /**
+     * Eine interne Hashmap zum schnellen Zugriff auf die Schüler anhand ihrer Datenbank-ID.
+     */
+    private readonly schuelerById;
+    /**
+     * Schüler-ID --> List<Fachwahl> = Die Fachwahlen des Schülers der jeweiligen Fachart.
+     */
+    private readonly fachwahlmengeBySchuelerId;
+    /**
+     * (Schüler-ID, Fach-ID) --> Kursart = Die Fachwahl des Schülers die dem Fach die Kursart zuordnet.
+     */
+    private readonly fachwahlBySchuelerIdAndFachId;
+    /**
+     * Fachart-ID --> List<Fachwahl> = Die Fachwahlen einer Fachart.
+     */
+    private readonly fachwahlmengeByFachartId;
+    /**
+     * Ergebnis-ID --> {@link GostBlockungsergebnis}
+     */
+    private readonly ergebnisById;
+    /**
+     * Ergebnis-ID --> {@link GostBlockungsergebnisManager}
+     */
+    private readonly ergebnisManagerByErgebnisId;
+    /**
+     * Eine sortierte, gecachte Menge der Kurse nach: (FACH, KURSART, KURSNUMMER).
+     */
+    private readonly kursmengeSortiertNachFachKursartKursnummer;
+    /**
+     * Eine sortierte, gecachte Menge der Kurse nach: (KURSART, FACH, KURSNUMMER)
+     */
+    private readonly kursmengeSortiertNachKursartFachKursnummer;
+    /**
+     * Die maximale Zeit in Millisekunden die der Blockungsalgorithmus verwenden darf.
+     */
+    private maxTimeMillis;
+    /**
+     * Map ungültiger Regeln, bei denen Fehlern vorliegen und Map die den jeweiligen Fehler beschreibt.
+     */
+    private readonly regelUngueltigById;
+    private readonly regelUngueltigBeschreibungById;
+    /**
+     * Erstellt einen neuen Manager mit den angegebenen Blockungsdaten und dem Fächer-Manager.
+     *
+     * @param daten            die Blockungsdaten
+     * @param faecherManager   der Fächer-Manager
+     */
+    constructor(daten: GostBlockungsdaten, faecherManager: GostFaecherManager);
+    /**
+     * Liefert eine Kurzdarstellung der Kursart mit der übergebenen ID.
+     *
+     * @param kursart   die ID der Kursart
+     *
+     * @return eine Kurzdarstellung der Kursart
+     */
+    toStringKursartSimple(kursart: number): string;
+    /**
+     * Liefert möglichst viele Informationen zum Kurs mit der übergebenen ID.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return möglichst viele Informationen zum Kurs
+     */
+    toStringKurs(idKurs: number): string;
+    /**
+     * Liefert eine Kurzdarstellung des Kurses mit der übergebenen ID.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return eine Kurzdarstellung des Kurses
+     */
+    toStringKursSimple(idKurs: number): string;
+    /**
+     * Liefert eine Kurzdarstellung des Kurses (ohne ID, außer der ID ist kein Kurs zugeordnet).
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return eine Kurzdarstellung des Kurses (ohne ID, außer der ID ist kein Kurs zugeordnet)
+     */
+    toStringKursSimpleOhneID(idKurs: number): string;
+    /**
+     * Liefert eine Kurzdarstellung des Faches mit der übergebenen ID.
+     *
+     * @param idFach   die Datenbank-ID des Faches
+     *
+     * @return eine Kurzdarstellung des Faches
+     */
+    toStringFachSimple(idFach: number): string;
+    /**
+     * Liefert eine Kurzdarstellung der Fachart (Fach, Kursart).
+     *
+     * @param idFach    die Datenbank-ID des Faches
+     * @param kursart   die Datenbank-ID der Kursart
+     *
+     * @return eine Kurzdarstellung der Fachart (Fach, Kursart)
+     */
+    toStringFachartSimple(idFach: number, kursart: number): string;
+    /**
+     * Liefert eine Kurzdarstellung der Fachart (Fach, Kursart).
+     *
+     * @param idFachart   die Fachart (zusammengesetzt aus Fach und Kursart)
+     *
+     * @return eine Kurzdarstellung der Fachart (Fach, Kursart)
+     */
+    toStringFachartSimpleByFachartID(idFachart: number): string;
+    /**
+     * Liefert möglichst viele Informationen zum Schüler mit der übergebenen ID.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     *
+     * @return möglichst viele Informationen zum Schüler
+     */
+    toStringSchueler(idSchueler: number): string;
+    /**
+     * Liefert eine Kurzdarstellung des Schüler mit der übergebenen ID.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     *
+     * @return eine Kurzdarstellung des Schülers
+     */
+    toStringSchuelerSimple(idSchueler: number): string;
+    /**
+     * Liefert möglichst viele Informationen zur Schiene mit der übergebenen ID.
+     *
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return möglichst viele Informationen zur Schiene
+     */
+    toStringSchiene(idSchiene: number): string;
+    /**
+     * Liefert eine Kurzdarstellung zur Schiene mit der übergebenen ID.
+     *
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return eine Kurzdarstellung zur Schiene
+     */
+    toStringSchieneSimple(idSchiene: number): string;
+    /**
+     * Liefert möglichst viele Informationen zur Lehrkraft mit der übergebenen ID.
+     *
+     * @param idKurs        die Datenbank-ID des Kurses
+     * @param idLehrkraft   die Datenbank-ID der Lehrkraft
+     *
+     * @return möglichst viele Informationen zur Lehrkraft
+     */
+    toStringKursLehrkraft(idKurs: number, idLehrkraft: number): string;
+    /**
+     * Liefert eine Kurzdarstellung zur übergebenen Fachwahl eines Schülers.
+     *
+     * @param gFachwahl   das {@link GostFachwahl}-Objekt
+     *
+     * @return eine Kurzdarstellung zur Fachwahl eines Schülers
+     */
+    toStringFachwahlSimple(gFachwahl: GostFachwahl): string | null;
+    /**
+     * Liefert möglichst viele Informationen zur Regel mit der übergebenen ID.
+     *
+     * @param idRegel   die Datenbank-ID der Regel
+     *
+     * @return möglichst viele Informationen zur Regel
+     */
+    toStringRegel(idRegel: number): string;
+    private createComparatorRegeln;
+    private createComparatorSchueler;
+    private createComparatorFachwahlen;
+    private createComparatorKurs1Fach2Kursart3Nummer;
+    private createComparatorKurs1Kursart2Fach3Nummer;
+    private compareRegel1Kurs2Id;
+    private compareRegel1Kurs2Nummer3Id;
+    private compareRegelSchueler;
+    private compareRegel1Schueler2Kurs;
+    private compareRegel1Kurs2Kurs;
+    private compareRegel1Schueler2Schueler3Fach;
+    private compareRegel1Schueler2Schueler;
+    private compareSchueler1Nachname2Vorname3Id;
+    private compareFach;
+    private compareKurs1Kursart2Fach3Nummer4Id;
+    /**
+     * Fügt das übergebenen Ergebnis der Blockung hinzu.
+     *
+     * @param ergebnis   das {@link GostBlockungsergebnis}-Objekt, welches hinzugefügt wird
+     *
+     * @throws DeveloperNotificationException Falls in den Daten Inkonsistenzen sind.
+     */
+    ergebnisAdd(ergebnis: GostBlockungsergebnis): void;
+    /**
+     * Fügt die Menge an Ergebnissen {@link GostBlockungsergebnis} hinzu.
+     *
+     * @param ergebnismenge   die Menge an Ergebnissen
+     *
+     * @throws DeveloperNotificationException Falls in den Daten Inkonsistenzen sind.
+     */
+    ergebnisAddListe(ergebnismenge: List<GostBlockungsergebnis>): void;
+    /**
+     * Liefert einen {@link GostBlockungsergebnis} aus der Liste der Ergebnisse.
+     * Wirft eine Exception, falls es keinen Listeneintrag mit dieser ID gibt.
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return einen {@link GostBlockungsergebnis}
+     * @throws DeveloperNotificationException Falls es keinen Listeneintrag mit dieser ID gibt.
+     */
+    ergebnisGet(idErgebnis: number): GostBlockungsergebnis;
+    /**
+     * Liefert einen {@link GostBlockungsergebnisManager} für das Ergebnis mit der übergebenen ID.
+     * Wirft eine Exception, falls es keinen Manager für ein Ergebnis mit dieser ID gibt.
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return einen {@link GostBlockungsergebnisManager}
+     * @throws DeveloperNotificationException Falls es keinen Manager für ein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisManagerGet(idErgebnis: number): GostBlockungsergebnisManager;
+    /**
+     * Liefert TRUE, falls ein {@link GostBlockungsergebnisManager}-Objekt mit der ID existiert.
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return true, falls ein {@link GostBlockungsergebnisManager}-Objekt mit der ID existiert
+     */
+    ergebnisManagerExists(idErgebnis: number): boolean;
+    /**
+     * Liefert die sortierte Menge aller {@link GostBlockungsergebnisManager}.
+     *
+     * @return die sortierte Menge aller {@link GostBlockungsergebnisManager}
+     */
+    ergebnisManagerGetListeUnsortiert(): List<GostBlockungsergebnisManager>;
+    /**
+     * Liefert eine sortierte Menge der {@link GostBlockungsergebnis} nach ihrer Bewertung.
+     *
+     * @return eine sortierte Menge der {@link GostBlockungsergebnis} nach ihrer Bewertung
+     */
+    ergebnisGetListeSortiertNachBewertung(): List<GostBlockungsergebnis>;
+    /**
+     * Liefert eine sortierte Menge der {@link GostBlockungsergebnis} nach ihrer ID.
+     *
+     * @return eine sortierte Menge der {@link GostBlockungsergebnis} nach ihrer ID
+     */
+    ergebnisGetListeSortiertNachID(): List<GostBlockungsergebnis>;
+    /**
+     * Entfernt die Menge an {@link GostBlockungsergebnis}-Objekten anhand ihrer ID.
+     *
+     * @param listeDerErgebnisIDs   die IDs der Ergebnisse
+     *
+     * @throws DeveloperNotificationException Falls es keine Ergebnisse mit diesen IDs gibt.
+     */
+    ergebnisRemoveListeByIDs(listeDerErgebnisIDs: JavaSet<number>): void;
+    /**
+     * Entfernt die Menge an {@link GostBlockungsergebnis}-Objekten.
+     *
+     * @param ergebnismenge   die Menge an Ergebnissen
+     *
+     * @throws DeveloperNotificationException Falls es keine Ergebnisse mit diesen IDs gibt.
+     */
+    ergebnisRemoveListe(ergebnismenge: List<GostBlockungsergebnis>): void;
+    /**
+     * Entfernt das Ergebnis mit der übergebenen ID aus der Blockung.
+     *
+     * @param idErgebnis   die Datenbank-ID des zu entfernenden Ergebnisses
+     *
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisRemoveByID(idErgebnis: number): void;
+    /**
+     * Entfernt das übergebenen Ergebnis aus der Blockung.
+     *
+     * @param ergebnis   das zu entfernende Ergebnis
+     *
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisRemove(ergebnis: GostBlockungsergebnis): void;
+    /**
+     * Sortiert alle Ergebnisse neu (nach ihrer Bewertung).
+     *
+     * @param ergebnis   das Ergebnis mit der neuen Bewertung
+     *
+     * @throws DeveloperNotificationException falls die Daten inkonsistent sind.
+     */
+    ergebnisUpdateBewertung(ergebnis: GostBlockungsergebnis): void;
+    /**
+     * Revalidiert alle Ergebnisse. Dies führt zur Aktualisierung aller Ergebnisse.
+     */
+    ergebnisAlleRevalidieren(): void;
+    /**
+     * Liefert die aktuelle Anzahl an Ergebnissen, die im Manager gespeichert sind.
+     *
+     * @return die Anzahl an Ergebnissen
+     */
+    ergebnisGetAnzahl(): number;
+    /**
+     * Liefert den Wert des 1. Bewertungskriteriums. Darin enthalten sind: <br>
+     * - Die Anzahl der nicht genügend gesetzten Kurse. <br>
+     * - Die Anzahl der Regelverletzungen. <br>
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return den Wert des 1. Bewertungskriteriums
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisGetBewertung1Wert(idErgebnis: number): number;
+    /**
+     * Liefert eine Güte des 1. Bewertungskriteriums im Bereich [0;1], mit 0=optimal. Darin enthalten sind: <br>
+     * - Die Anzahl der Regelverletzungen. <br>
+     * - Die Anzahl der nicht genügend gesetzten Kurse. <br>
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return eine Güte des 1. Bewertungskriteriums im Bereich [0;1], mit 0=optimal
+     * @throws DeveloperNotificationException Falls es keinen Listeneintrag mit dieser ID gibt.
+     */
+    ergebnisGetBewertung1Intervall(idErgebnis: number): number;
+    /**
+     * Liefert den Wert des 2. Bewertungskriteriums. Darin enthalten sind: <br>
+     * - Die Anzahl der nicht zugeordneten Schülerfachwahlen. <br>
+     * - Die Anzahl der Schülerkollisionen. <br>
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return den Wert des 2. Bewertungskriteriums
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisGetBewertung2Wert(idErgebnis: number): number;
+    /**
+     * Liefert eine Güte des 2. Bewertungskriteriums im Bereich [0;1], mit 0=optimal. Darin enthalten sind: <br>
+     * - Die Anzahl der nicht zugeordneten Schülerfachwahlen. <br>
+     * - Die Anzahl der Schülerkollisionen. <br>
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return eine Güte des 2. Bewertungskriteriums im Bereich [0;1], mit 0=optimal
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisGetBewertung2Intervall(idErgebnis: number): number;
+    /**
+     * Liefert den Wert des 3. Bewertungskriteriums. Darin enthalten sind: <br>
+     * - Die Größte Kursdifferenz. <br>
+     * Der Wert 0 und 1 werden unterschieden, sind aber von der Bewertung her Äquivalent.
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return den Wert des 3. Bewertungskriteriums
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisGetBewertung3Wert(idErgebnis: number): number;
+    /**
+     * Liefert eine Güte des 3. Bewertungskriteriums im Bereich [0;1], mit 0=optimal. Darin enthalten sind: <br>
+     * - Die Größte Kursdifferenz. <br>
+     * Der Wert 0 und 1 werden unterschieden, sind aber von der Bewertung her Äquivalent.
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return eine Güte des 3. Bewertungskriteriums im Bereich [0;1], mit 0=optimal
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisGetBewertung3Intervall(idErgebnis: number): number;
+    /**
+     * Liefert den Wert des 4. Bewertungskriteriums. Darin enthalten sind: <br>
+     * - Die Anzahl an Kursen mit gleicher Fachart (Fach, Kursart) in einer Schiene. <br>
+     * Dieses Bewertungskriterium wird teilweise absichtlich verletzt, wenn z. B. Schienen erzeugt werden mit dem selben
+     * Fach (Sport-Schiene). Nichtsdestotrotz möchte man häufig nicht die selben Fächer in einer Schiene, aufgrund von
+     * Raumkapazitäten (Fachräume).
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return den Wert des 4. Bewertungskriteriums
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisGetBewertung4Wert(idErgebnis: number): number;
+    /**
+     * Liefert eine Güte des 4. Bewertungskriteriums im Bereich [0;1], mit 0=optimal. Darin enthalten sind: <br>
+     * - Die Anzahl an Kursen mit gleicher Fachart (Fach, Kursart) in einer Schiene. <br>
+     * Dieses Bewertungskriterium wird teilweise absichtlich verletzt, wenn z. B. Schienen erzeugt werden mit dem selben
+     * Fach (Sport-Schiene). Nichtsdestotrotz möchte man häufig nicht die selben Fächer in einer Schiene, aufgrund von
+     * Raumkapazitäten (Fachräume).
+     *
+     * @param idErgebnis   die Datenbank-ID des Ergebnisses
+     *
+     * @return eine Güte des 4. Bewertungskriteriums im Bereich [0;1], mit 0=optimal
+     * @throws DeveloperNotificationException Falls es kein Ergebnis mit dieser ID gibt.
+     */
+    ergebnisGetBewertung4Intervall(idErgebnis: number): number;
+    private kursAddKursOhneSortierung;
+    /**
+     * Fügt den übergebenen Kurs zu der Blockung hinzu.
+     *
+     * @param kurs   das {@link GostBlockungKurs}-Objekt, welches hinzugefügt wird
+     *
+     * @throws DeveloperNotificationException falls die Daten des Kurses inkonsistent sind.
+     */
+    kursAdd(kurs: GostBlockungKurs): void;
+    /**
+     * Fügt die Menge an Kursen hinzu.
+     *
+     * @param kursmenge   die Menge an Kursen
+     *
+     * @throws DeveloperNotificationException Falls die Daten der Kurse inkonsistent sind.
+     */
+    kursAddListe(kursmenge: List<GostBlockungKurs>): void;
+    /**
+     * Liefert TRUE, falls der Kurs mit der übergebenen ID existiert.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return true, falls der Kurs mit der übergebenen ID existiert
+     */
+    kursGetExistiert(idKurs: number): boolean;
+    /**
+     * Liefert die Anzahl an Kursen.
+     *
+     * @return die Anzahl an Kursen
+     */
+    kursGetAnzahl(): number;
+    /**
+     * Liefert die Anzahl an Kursen, die keine KOOP-Kurse sind.
+     *
+     * @return die Anzahl an Kursen, die keine KOOP-Kurse sind
+     */
+    kursGetAnzahlIntener(): number;
+    /**
+     * Liefert den Namen des Kurses der Form [Fach]-[Kursart][Kursnummer][-Suffix], beispielsweise D-GK1.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return den Namen des Kurses der Form [Fach]-[Kursart][Kursnummer][-Suffix], beispielsweise D-GK1
+     * @throws DeveloperNotificationException Falls der Kurs nicht in der Blockung existiert.
+     */
+    kursGetName(idKurs: number): string;
+    /**
+     * Liefert den Namen des Kurses der Form [Fach]-[Kursart][Kursnummer] ohne den potentiellen Suffix, beispielsweise D-GK1.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return den Namen des Kurses der Form [Fach]-[Kursart][Kursnummer] ohne den potentiellen Suffix, beispielsweise D-GK1
+     * @throws DeveloperNotificationException Falls der Kurs nicht in der Blockung existiert.
+     */
+    kursGetNameOhneSuffix(idKurs: number): string;
+    /**
+     * Liefert das {@link GostBlockungKurs}-Objekt mit der übergebenen ID.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return das {@link GostBlockungKurs}-Objekt
+     * @throws DeveloperNotificationException Falls der Kurs nicht in der Blockung existiert.
+     */
+    kursGet(idKurs: number): GostBlockungKurs;
+    /**
+     * Liefert die Lehrkraft des Kurses, welche die angegebene Nummer hat. <br>
+     * Wirft eine Exception, falls es eine solche Lehrkraft nicht gibt.
+     *
+     * @param idKurs          die Datenbank-ID des Kurses
+     * @param reihenfolgeNr   die Lehrkraft mit der Nummer, die gesucht wird
+     *
+     * @return die Lehrkraft des Kurses mit der Nummer
+     * @throws DeveloperNotificationException Falls es eine solche Lehrkraft nicht gibt.
+     */
+    kursGetLehrkraftMitNummer(idKurs: number, reihenfolgeNr: number): GostBlockungKursLehrer | null;
+    /**
+     * Liefert die Lehrkraft des Kurses, welche die angegebene ID hat.
+     *
+     * @param idKurs        die Datenbank-ID des Kurses
+     * @param idLehrkraft   die Datenbank-ID der gesuchten Lehrkraft
+     *
+     * @return die Lehrkraft des Kurses mit der ID
+     * @throws DeveloperNotificationException Falls es eine solche Lehrkraft nicht gibt.
+     */
+    kursGetLehrkraftMitID(idKurs: number, idLehrkraft: number): GostBlockungKursLehrer | null;
+    /**
+     * Liefert TRUE, falls im Kurs die Lehrkraft mit der Nummer existiert.
+     *
+     * @param idKurs          die Datenbank-ID des Kurses
+     * @param reihenfolgeNr   die Lehrkraft mit der Nummer, die gesucht wird
+     *
+     * @return true, falls im Kurs die Lehrkraft mit der Nummer existiert
+     * @throws DeveloperNotificationException  Falls der Kurs nicht in der Blockung existiert.
+     */
+    kursGetLehrkraftMitNummerExists(idKurs: number, reihenfolgeNr: number): boolean;
+    /**
+     * Liefert TRUE, falls im Kurs die Lehrkraft mit der ID existiert.
+     *
+     * @param idKurs        die Datenbank-ID des Kurses
+     * @param idLehrkraft   die Datenbank-ID der gesuchten Lehrkraft
+     *
+     * @return true, falls im Kurs die Lehrkraft mit der ID existiert
+     */
+    kursGetLehrkraftMitIDExists(idKurs: number, idLehrkraft: number): boolean;
+    /**
+     * Liefert alle Lehrkräfte eines Kurses sortiert nach {@link GostBlockungKursLehrer#reihenfolge}.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return alle Lehrkräfte eines Kurses sortiert nach {@link GostBlockungKursLehrer#reihenfolge}
+     * @throws DeveloperNotificationException Falls der Kurs nicht in der Blockung existiert.
+     */
+    kursGetLehrkraefteSortiert(idKurs: number): List<GostBlockungKursLehrer>;
+    /**
+     * Fügt die übergebene Lehrkraft zum Kurs hinzu.
+     *
+     * @param idKurs          die Datenbank-ID des Kurses
+     * @param neueLehrkraft   das {@link GostBlockungKursLehrer}-Objekt
+     *
+     * @throws DeveloperNotificationException falls der Kurs nicht existiert oder die Lehrkraft oder die ReihenfolgeNr bereits im Kurs existiert.
+     */
+    kursAddLehrkraft(idKurs: number, neueLehrkraft: GostBlockungKursLehrer): void;
+    /**
+     * Löscht aus dem übergebenen Kurs die angegebene Lehrkraft.
+     *
+     * @param idKurs            die Datenbank-ID des Kurses
+     * @param idAlteLehrkraft   die Datenbank-ID des {@link GostBlockungKursLehrer}-Objekt
+     *
+     * @throws DeveloperNotificationException falls der Kurs nicht existiert oder es eine solche Lehrkraft im Kurs nicht gibt.
+     */
+    kursRemoveLehrkraft(idKurs: number, idAlteLehrkraft: number): void;
+    /**
+     * Liefert eine nach 'Fach, Kursart, Kursnummer' sortierte Kopie der Menge der Kurse.
+     *
+     * @return eine nach 'Fach, Kursart, Kursnummer' sortierte Liste der Kurse
+     */
+    kursGetListeSortiertNachFachKursartNummer(): List<GostBlockungKurs>;
+    /**
+     * Liefert eine nach 'Kursart, Fach, Kursnummer' sortierte Kopie der Menge der Kurse.
+     *
+     * @return eine nach 'Kursart, Fach, Kursnummer' sortierte Liste der Kurse
+     */
+    kursGetListeSortiertNachKursartFachNummer(): List<GostBlockungKurs>;
+    /**
+     * Liefert eine nach Kursnummer sortierte Liste der Kurse für das angegebene Fach und die angegebene Kursart.
+     *
+     * @param idFach      die ID des Fachs
+     * @param idKursart   die ID der Kursart
+     *
+     * @return die sortierte Liste der Kurse für das Fach und die Kursart
+     */
+    kursGetListeByFachUndKursart(idFach: number, idKursart: number): List<GostBlockungKurs>;
+    /**
+     * Liefert TRUE, falls ein Löschen des Kurses erlaubt ist. <br>
+     * Kriterium: Der Kurs muss existieren und das aktuelle Ergebnis muss eine Vorlage sein.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return true, falls ein Löschen des Kurses erlaubt ist
+     * @throws DeveloperNotificationException Falls der Kurs nicht in der Blockung existiert.
+     */
+    kursGetIsRemoveAllowed(idKurs: number): boolean;
+    /**
+     * Liefert TRUE, falls der Kurs aufgrund von Regeln in der angegebenen Schiene verboten ist.
+     *
+     * @param idKurs      die Datenbank-ID des Kurses
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return true, falls der Kurs in der angegebenen Schiene verboten ist
+     * @throws DeveloperNotificationException falls der Kurs oder die Schiene in der Blockung nicht existiert.
+     */
+    kursGetIstVerbotenInSchiene(idKurs: number, idSchiene: number): boolean;
+    private kursGetIstVerbotenInSchieneDurchTyp06;
+    private kursGetIstVerbotenInSchieneDurchTyp01;
+    /**
+     * Liefert TRUE, falls der Kurs aufgrund der Regel {@link GostKursblockungRegelTyp#KURS_SPERRE_IN_SCHIENE} in der angegebenen Schiene gesperrt ist.
+     *
+     * @param idKurs      die Datenbank-ID des Kurses
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return true, falls der Kurs aufgrund der Regel {@link GostKursblockungRegelTyp#KURS_SPERRE_IN_SCHIENE} in der angegebenen Schiene gesperrt ist
+     * @throws DeveloperNotificationException falls der Kurs oder die Schiene nicht existiert.
+     */
+    kursGetHatSperrungInSchiene(idKurs: number, idSchiene: number): boolean;
+    /**
+     * Liefert die Regel, welche den Kurs in einer Schiene gesperrt hat.
+     *
+     * @param idKurs      die Datenbank-ID des Kurses
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return die Regel, die den Kurs in der Schiene sperrt
+     * @throws DeveloperNotificationException falls die Schiene oder die Regel nicht existiert.
+     */
+    kursGetRegelGesperrtInSchiene(idKurs: number, idSchiene: number): GostBlockungRegel;
+    /**
+     * Liefert TRUE, falls der Kurs aufgrund der Regel {@link GostKursblockungRegelTyp#KURS_FIXIERE_IN_SCHIENE} in der angegebenen Schiene fixiert ist.
+     *
+     * @param idKurs      die Datenbank-ID des Kurses
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return true, falls der Kurs aufgrund der Regel {@link GostKursblockungRegelTyp#KURS_FIXIERE_IN_SCHIENE} in der angegebenen Schiene fixiert ist
+     * @throws DeveloperNotificationException falls die Schiene nicht existiert.
+     */
+    kursGetHatFixierungInSchiene(idKurs: number, idSchiene: number): boolean;
+    /**
+     * Liefert die Regel, welche den Kurs in einer Schiene fixiert hat.
+     *
+     * @param idKurs      die Datenbank-ID des Kurses
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return die Regel, die den Kurs in der Schiene fixiert
+     * @throws DeveloperNotificationException falls die Schiene oder die Regel nicht existiert.
+     */
+    kursGetRegelFixierungInSchiene(idKurs: number, idSchiene: number): GostBlockungRegel;
+    /**
+     * Liefert TRUE, falls der Kurs nicht vollständig fixiert ist.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return true, falls der Kurs nicht vollständig fixiert ist
+     * @throws DeveloperNotificationException falls der Kurs nicht existiert.
+     */
+    kursIstWeitereFixierungErlaubt(idKurs: number): boolean;
+    /**
+     * Liefert die Regel, welche die Anzahl der DummySuS eines Kurses definiert oder NULL.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return die Regel, welche die Anzahl der DummySuS eines Kurses definiert oder NULL
+     */
+    kursGetRegelDummySchuelerOrNull(idKurs: number): GostBlockungRegel | null;
+    /**
+     * Liefert ein Set aller Kurs-IDs.
+     *
+     * @return ein Set aller Kurs-IDs
+     */
+    kursmengeGetSetDerIDs(): JavaSet<number>;
+    /**
+     * Entfernt alle Kurse mit den übergebenen IDs aus der Blockung.
+     * <br>(1) Überprüft, ob es eine Blockungsvorlage ist und ob alle IDs existieren, sonst Exception.
+     * <br>(2) Entfernt dann alle Kurse aus den Datenstrukturen.
+     * <br>(3) Entfernt dann alle Regeln, die einen der Kurse tangieren.
+     * <br>(4) Dann muss der Client den ErgebnisManager über die Löschung des Kurses informieren.
+     *
+     * @param idKurse   die Datenbank-IDs der zu entfernenden Kurse
+     *
+     * @throws DeveloperNotificationException Falls der Kurs nicht existiert oder es sich nicht um eine Blockungsvorlage handelt.
+     */
+    kurseRemoveByID(idKurse: JavaSet<number>): void;
+    /**
+     * Entfernt den Kurs mit der übergebenen ID aus der Blockung.
+     *
+     * @param idKurs   die Datenbank-ID des zu entfernenden Kurses
+     *
+     * @throws DeveloperNotificationException Falls der Kurs nicht in der Blockung existiert.
+     */
+    kursRemoveByID(idKurs: number): void;
+    /**
+     * Entfernt den übergebenen Kurs aus der Blockung.
+     *
+     * @param kurs   der zu entfernende Kurs
+     *
+     * @throws DeveloperNotificationException falls der Kurs nicht existiert.
+     */
+    kursRemove(kurs: GostBlockungKurs): void;
+    /**
+     * Entfernt alle {@link GostBlockungKurs}-Objekte.
+     *
+     * @param kurse   die zu entfernenden {@link GostBlockungKurs}-Objekte
+     *
+     * @throws DeveloperNotificationException falls einer der Kurse nicht existiert oder es sich nicht um eine Blockungsvorlage handelt.
+     */
+    kurseRemove(kurse: List<GostBlockungKurs>): void;
+    /**
+     * Kombiniert zwei Kurse zu einem Kurs. Die Regel  {@link GostKursblockungRegelTyp#KURS_MIT_DUMMY_SUS_AUFFUELLEN}
+     * muss dabei ggf. auch kombiniert werden, wobei eine existierende Regel recycled wird.
+     *
+     * @param idKursID1keep     die Kurs-ID des Ziel-Kurses (wird nicht gelöscht)
+     * @param idKursID2delete   die Kurs-ID des Quell-Kurses (wird gelöscht)
+     * @throws DeveloperNotificationException falls es keine Blockungsvorlage ist, oder die Kurse nicht existieren, oder die Kurse identisch sind.
+     */
+    kursMerge(idKursID1keep: number, idKursID2delete: number): void;
+    /**
+     * Setzt den Suffix des Kurses.
+     *
+     * @param idKurs   die Datenbank-ID des Kurses
+     * @param suffix   der neue Suffix des Kurses
+     *
+     * @throws DeveloperNotificationException falls der Kurs nicht in der Blockung existiert.
+     */
+    kursSetSuffix(idKurs: number, suffix: string): void;
+    /**
+     * Fügt die übergebene Schiene zu der Blockung hinzu.
+     * <br>: Wichtig: Beim Ergebnismanager müssen danach die Schienen auch hinzugefügt werden!
+     *
+     * @param schiene   die hinzuzufügende Schiene
+     * @throws DeveloperNotificationException Falls die Schienen-Daten inkonsistent sind.
+     */
+    schieneAdd(schiene: GostBlockungSchiene): void;
+    /**
+     * Fügt die Menge an Schienen hinzu.
+     * <br>: Wichtig: Beim Ergebnismanager müssen danach die Schienen auch hinzugefügt werden!
+     *
+     * @param schienenmenge   die Menge an Schienen
+     * @throws DeveloperNotificationException Falls die Schienen-Daten inkonsistent sind.
+     */
+    schieneAddListe(schienenmenge: List<GostBlockungSchiene>): void;
+    /**
+     * Gibt die Schiene der Blockung anhand von deren ID zurück.
+     *
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return das zugehörige {@link GostBlockungSchiene}-Objekt
+     * @throws DeveloperNotificationException Falls die Schiene nicht in der Blockung existiert.
+     */
+    schieneGet(idSchiene: number): GostBlockungSchiene;
+    /**
+     * Liefert TRUE, falls eine Schiene mit der übergebenen ID existiert.
+     *
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return true, falls die Schiene existiert
+     */
+    schieneGetExistiert(idSchiene: number): boolean;
+    /**
+     * Liefert die aktuelle Menge aller Schienen sortiert nach der Schienen-Nummer.
+     *
+     * @return die Menge aller Schienen sortiert nach der Nummer
+     */
+    schieneGetListe(): List<GostBlockungSchiene>;
+    /**
+     * Liefert TRUE, falls ein Löschen der Schiene erlaubt ist.
+     *
+     * @param idSchiene   die Datenbank-ID der Schiene
+     *
+     * @return true, falls ein Löschen der Schiene erlaubt ist
+     * @throws DeveloperNotificationException Falls die ID der Schiene nicht existiert.
+     */
+    schieneGetIsRemoveAllowed(idSchiene: number): boolean;
+    /**
+     * Ändert das Attribut {@link GostBlockungSchiene#bezeichnung} der Schiene mit der jeweiligen ID.
+     *
+     * @param idSchiene     die Datenbank-ID der Schiene
+     * @param bezeichnung   die neue Bezeichnung
+     *
+     * @throws DeveloperNotificationException Falls die ID der Schiene nicht existiert.
+     */
+    schienePatchBezeichnung(idSchiene: number, bezeichnung: string): void;
+    /**
+     * Ändert das Attribut {@link GostBlockungSchiene#wochenstunden} der Schiene mit der jeweiligen ID.
+     *
+     * @param idSchiene       die Datenbank-ID der Schiene
+     * @param wochenstunden   die neuen Wochenstunden
+     */
+    schienePatchWochenstunden(idSchiene: number, wochenstunden: number): void;
+    /**
+     * Entfernt die Schiene mit der übergebenen ID aus der Blockung.
+     * Konsequenz: <br>
+     * (1) Das Löschen der Schiene muss erlaubt sein und die Schiene muss existieren, sonst Exception. <br>
+     * (2) Die Schiene wird entfernt und Schienen mit größerer Nr. werden um 1 reduziert. <br>
+     * (3) Die Regeln müssen bei Schienen-Nummern angepasst werden. <br>
+     *
+     * @param idSchiene   die Datenbank-ID der zu entfernenden Schiene
+     *
+     * @throws DeveloperNotificationException Falls die Schiene nicht existiert oder ein Löschen nicht erlaubt ist.
+     */
+    schieneRemoveByID(idSchiene: number): void;
+    /**
+     * Entfernt die übergebene Schiene aus der Blockung.
+     * <br>Hinweis: Es muss nicht dasselbe Objekt sein, nur die ID muss übereinstimmen.
+     *
+     * @param schiene   die zu entfernende Schiene
+     *
+     * @throws DeveloperNotificationException Falls die Schiene nicht existiert oder ein Löschen nicht erlaubt ist.
+     */
+    schieneRemove(schiene: GostBlockungSchiene): void;
+    /**
+     * Liefert die Anzahl an Schienen.
+     *
+     * @return die Anzahl an Schienen
+     */
+    schieneGetAnzahl(): number;
+    /**
+     * Liefert die Default-Anzahl an Schienen zurück, die für eine neue Blockung verwendet wird.
+     *
+     * @param halbjahr   das Halbjahr, für welches die Blockung angelegt werden soll
+     *
+     * @return die Default-Anzahl an Schienen für eine neue Blockung
+     */
+    static schieneGetDefaultAnzahl(halbjahr: GostHalbjahr): number;
+    private regelAddOhneSortierung;
+    /**
+     * Fügt die übergebene Regel zu der Blockung hinzu.
+     *
+     * @param regel   die hinzuzufügende Regel
+     *
+     * @throws DeveloperNotificationException Falls die Daten der Regel inkonsistent sind.
+     */
+    regelAdd(regel: GostBlockungRegel): void;
+    /**
+     * Fügt eine Menge an Regeln hinzu.
+     *
+     * @param regelmenge   die Menge an Regeln
+     *
+     * @throws DeveloperNotificationException Falls die Daten der Regeln inkonsistent sind.
+     */
+    regelAddListe(regelmenge: List<GostBlockungRegel>): void;
+    private regelAddListeOhneRevalidierung;
+    private regelGetWarnung;
+    private regelCheckTyp01;
+    private regelCheckTyp02und03;
+    private regelCheckTyp04und05;
+    private regelCheckTyp06;
+    private regelCheckTyp07und08;
+    private regelCheckTyp09;
+    private regelCheckTyp10;
+    private regelCheckTyp11und12;
+    private regelCheckTyp13und14;
+    private regelCheckTyp15;
+    private regelCheckTyp16;
+    private regelCheckTyp17;
+    private regelCheckTyp18;
+    private regelCheckTyp19;
+    private regelCheckReferenzSchuelerID;
+    private regelCheckReferenzKursID;
+    private regelCheckReferenzSchienenNr;
+    private regelCheckReferenzFachID;
+    private regelCheckReferenzKursart;
+    /**
+     * Liefert die Anzahl an Regeln.
+     *
+     * @return die Anzahl an Regeln
+     */
+    regelGetAnzahl(): number;
+    /**
+     * Liefert die Regel mit der übergebenen ID zurück.
+     *
+     * @param idRegel   die Datenbank-ID der Regel
+     *
+     * @return die Regel mit der übergebenen ID
+     * @throws DeveloperNotificationException Falls die Regel nicht existiert.
+     */
+    regelGet(idRegel: number): GostBlockungRegel;
+    /**
+     * Liefert die {@link GostBlockungRegel} anhand des {@link LongArrayKey}-Schlüssels, oder NULL falls keine existiert.
+     *
+     * @param key   der {@link LongArrayKey}-Schlüssel
+     *
+     * @return die {@link GostBlockungRegel} zum {@link LongArrayKey}-Schlüssel, oder null
+     */
+    regelGetByLongArrayKeyOrNull(key: LongArrayKey): GostBlockungRegel | null;
+    /**
+     * Liefert die aktuelle Menge aller Regeln.
+     * Das ist die interne Referenz zur Liste der Regeln im {@link GostBlockungsdaten}-Objekt.
+     * Diese Liste ist stets sortiert nach (TYP, ID).
+     *
+     * @return die Menge aller Regeln sortiert nach (TYP, id)
+     */
+    regelGetListe(): List<GostBlockungRegel>;
+    /**
+     * Liefert die aktuelle Menge aller Regeln eines bestimmten {@link GostKursblockungRegelTyp}.
+     *
+     * @param typ   der {@link GostKursblockungRegelTyp}
+     *
+     * @return die Menge aller Regeln eines {@link GostKursblockungRegelTyp}
+     */
+    regelGetListeOfTyp(typ: GostKursblockungRegelTyp): List<GostBlockungRegel>;
+    /**
+     * Liefert die Regel, welche den Kurs in einer Schiene sperrt, oder die Dummy-Regel (ID negativ), falls die Regel nicht existiert.
+     *
+     * @param idKurs      die Datenbank-ID des Kurses
+     * @param nrSchiene   die Nummer der Schiene
+     *
+     * @return die Regel, welche den Kurs in einer Schiene sperrt, oder die Dummy-Regel (ID negativ), falls die Regel nicht existiert
+     */
+    regelGetRegelOrDummyKursGesperrtInSchiene(idKurs: number, nrSchiene: number): GostBlockungRegel;
+    /**
+     * Liefert die Regel, welche den Kurs in einer Schiene fixiert, oder die Dummy-Regel (ID negativ), falls die Regel nicht existiert.
+     *
+     * @param idKurs      die Datenbank-ID des Kurses
+     * @param nrSchiene   die Nummer der Schiene
+     *
+     * @return die Regel, welche den Kurs in einer Schiene fixiert, oder die Dummy-Regel (ID negativ), falls die Regel nicht existiert
+     */
+    regelGetRegelOrDummyKursFixierungInSchiene(idKurs: number, nrSchiene: number): GostBlockungRegel;
+    /**
+     * Liefert die Regel, welche den Schüler in einem Kurs fixiert, oder die Dummy-Regel (ID negativ), falls die Regel nicht existiert.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idKurs       die Datenbank-ID des Kurses
+     *
+     * @return die Regel, welche den Schüler in einem Kurs fixiert, oder die Dummy-Regel (ID negativ), falls die Regel nicht existiert
+     */
+    regelGetRegelOrDummySchuelerInKursFixierung(idSchueler: number, idKurs: number): GostBlockungRegel;
+    /**
+     * Liefert TRUE, falls die Regel mit der übergebenen ID existiert.
+     *
+     * @param idRegel   die Datenbank-ID der Regel
+     *
+     * @return true, falls die Regel mit der übergebenen ID existiert
+     */
+    regelGetExistiert(idRegel: number): boolean;
+    /**
+     * Liefert TRUE, falls ein Löschen der Regel erlaubt ist.
+     * <br> Hinweis: Die alte Implementierung verlangte noch, dass es sich um eine Blockungsvorlage handelt,
+     *               nun reicht es, dass die Regel existiert.
+     *
+     * @param idRegel   die Datenbank-ID der Regel
+     *
+     * @return true, falls ein Löschen der Regel erlaubt ist
+     */
+    regelGetIsRemoveAllowed(idRegel: number): boolean;
+    private regelGetKursMitDummySusAuffuellen;
+    /**
+     * Liefert TRUE, falls der übergebene Kurs in der übergebenen Regeln enthalten ist.
+     *
+     * @param regel    das {@link GostBlockungRegel}-Objekt
+     * @param idKurs   die Datenbank-ID des Kurses
+     *
+     * @return true, falls der Kurs in der Regel enthalten ist
+     */
+    private static regelGetHatKursIDs;
+    /**
+     * Liefert alle Regeln, die aufgrund von Fehlern ungültig sind.
+     *
+     * @return alle Regeln, die aufgrund von Fehlern ungültig sind
+     */
+    regelGetMapUngueltig(): JavaMap<number, GostBlockungRegel>;
+    /**
+     * Liefert die Beschreibung der jeweiligen ungültigen Regeln.
+     *
+     * @return die Beschreibung der jeweiligen ungültigen Regeln
+     */
+    regelGetMapUngueltigBeschreibung(): JavaMap<number, string>;
+    /**
+     * Entfernt die Regel mit der übergebenen ID aus der Blockung.
+     *
+     * @param idRegel   die Datenbank-ID der zu entfernenden Regel
+     *
+     * @throws DeveloperNotificationException Falls die Regel nicht existiert.
+     */
+    regelRemoveByID(idRegel: number): void;
+    /**
+     * Entfernt eine Menge von Regeln.
+     *
+     * @param regelmenge   die Menge an Regeln, die entfernt werden soll
+     *
+     * @throws DeveloperNotificationException Falls die Daten der Regeln inkonsistent sind.
+     */
+    regelRemoveListe(regelmenge: List<GostBlockungRegel>): void;
+    private regelRemoveListeByIDsOhneRevalidierung;
+    /**
+     * Löscht eine Menge an Regeln anhand ihrer IDs.
+     *
+     * @param regelmenge   die Menge der IDs der Regeln
+     *
+     * @throws DeveloperNotificationException falls mindestens eine Regel nicht existiert.
+     */
+    regelRemoveListeByIDs(regelmenge: JavaSet<number>): void;
+    private static regelToMultikey;
+    /**
+     * Entfernt die übergebene Regel aus der Blockung.
+     *
+     * @param regel   die zu entfernende Regel
+     *
+     * @throws DeveloperNotificationException Falls die Regel nicht existiert.
+     */
+    regelRemove(regel: GostBlockungRegel): void;
+    /**
+     * Liefert die Menge aller Kursarten des Faches, welche in Kursen oder Fachwahlen vorkommen.
+     *
+     * @param idFach   die Datenbank-ID des Faches
+     *
+     * @return die Menge aller Kursarten des Faches, welche in Kursen oder Fachwahlen vorkommen
+     */
+    fachGetMengeKursarten(idFach: number): List<GostKursart>;
+    /**
+     * Fügt eine Fachwahl hinzu.
+     *
+     * @param fachwahl   die Fachwahl, die hinzugefügt wird
+     *
+     * @throws DeveloperNotificationException Falls die Fachwahl-Daten inkonsistent sind.
+     */
+    fachwahlAdd(fachwahl: GostFachwahl): void;
+    /**
+     * Fügt alle Fachwahlen hinzu.
+     *
+     * @param fachwahlmenge   die Menge an Fachwahlen
+     *
+     * @throws DeveloperNotificationException Falls die Fachwahl-Daten inkonsistent sind.
+     */
+    fachwahlAddListe(fachwahlmenge: List<GostFachwahl>): void;
+    /**
+     * Liefert die Anzahl an Fachwahlen.
+     *
+     * @return die Anzahl an Fachwahlen
+     */
+    fachwahlGetAnzahl(): number;
+    /**
+     * Liefert den Namen der Fachwahl (Fach-Kursart), beispielsweise 'M-GK'.
+     * <br> Die Information über den Schüler dieser Fachwahl wird nicht dargestellt.
+     *
+     * @param fachwahl   das Fachwahl-Objekt
+     *
+     * @return den Namen der Fachwahl (Fach-Kursart), beispielsweise 'M-GK'
+     * @throws DeveloperNotificationException falls die Fach-Referenz oder die Kursart-Referenz nicht existiert.
+     */
+    fachwahlGetName(fachwahl: GostFachwahl): string;
+    /**
+     * Liefert die sortierte Menge aller {@link GostFachwahl} einer bestimmten Fachart-ID.
+     * <br> Die Fachart-ID lässt sich mit {@link GostKursart#getFachartID} berechnen.
+     *
+     * @param idFachart   die Fachart-ID berechnet aus Fach-ID und Kursart-ID
+     *
+     * @return die sortierte Menge aller {@link GostFachwahl} einer bestimmten Fachart-ID
+     */
+    fachwahlGetListeOfFachart(idFachart: number): List<GostFachwahl>;
+    /**
+     * Liefert die Anzahl verschiedenen Kursarten.
+     *
+     * @return die Anzahl verschiedener Kursarten
+     */
+    fachwahlGetAnzahlVerwendeterKursarten(): number;
+    /**
+     * Fügt einen Schüler hinzu.<br>
+     * Wirft eine Exception, falls die Schüler Daten inkonsistent sind.
+     *
+     * @param schueler   der Schüler, der hinzugefügt wird
+     *
+     * @throws DeveloperNotificationException Falls die Schüler Daten inkonsistent sind.
+     */
+    private schuelerAddOhneSortierung;
+    /**
+     * Fügt einen Schüler hinzu.
+     *
+     * @param schueler   der Schüler, der hinzugefügt wird
+     *
+     * @throws DeveloperNotificationException Falls die Schüler-Daten inkonsistent sind.
+     */
+    schuelerAdd(schueler: Schueler): void;
+    /**
+     * Fügt alle Schüler hinzu.
+     *
+     * @param schuelermenge   die Menge an Schülern
+     *
+     * @throws DeveloperNotificationException Falls die Schüler-Daten inkonsistent sind.
+     */
+    schuelerAddListe(schuelermenge: List<Schueler>): void;
+    /**
+     * Liefert die Anzahl an Schülern, die mindestens eine Fachwahl haben.
+     *
+     * @return die Anzahl an Schülern, die mindestens eine Fachwahl haben
+     */
+    schuelerGetAnzahlMitMindestensEinerFachwahl(): number;
+    /**
+     * Liefert die Anzahl an Schülern.
+     *
+     * @return die Anzahl an Schülern
+     */
+    schuelerGetAnzahl(): number;
+    /**
+     * Ermittelt den Schüler für die angegebene ID.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     *
+     * @return das zugehörige {@link Schueler}-Objekt
+     * @throws DeveloperNotificationException  Falls die Schüler-ID unbekannt ist.
+     */
+    schuelerGet(idSchueler: number): Schueler;
+    /**
+     * Ermittelt den Schüler für die angegebene ID. <br>
+     * Gibt null zurück, falls die Schüler-ID unbekannt ist.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     *
+     * @return das zugehörige {@link Schueler}-Objekt oder null
+     */
+    schuelerGetOrNull(idSchueler: number): Schueler | null;
+    /**
+     * Liefert die aktuelle Menge aller Schüler.
+     * Das ist die interne Referenz zur Liste der Schüler im {@link GostBlockungsdaten}-Objekt.
+     *
+     * @return die Menge aller Schüler
+     */
+    schuelerGetListe(): List<Schueler>;
+    /**
+     * Liefert zum Tupel (Schüler, Fach) die jeweilige Kursart.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idFach       die Datenbank-ID des Faches
+     *
+     * @return zum Tupel (Schüler, Fach) jeweilige {@link GostKursart}
+     * @throws DeveloperNotificationException falls der Schüler das Fach nicht gewählt hat.
+     */
+    schuelerGetOfFachKursart(idSchueler: number, idFach: number): GostKursart;
+    /**
+     * Liefert zum Tupel (Schüler, Fach) die jeweilige Fachwahl.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idFach       die Datenbank-ID des Faches
+     *
+     * @return zum Tupel (Schüler, Fach) jeweilige {@link GostFachwahl}
+     * @throws DeveloperNotificationException falls der Schüler das Fach nicht gewählt hat.
+     */
+    schuelerGetOfFachFachwahl(idSchueler: number, idFach: number): GostFachwahl;
+    /**
+     * Liefert zum Tupel (Schüler, Fach) die jeweilige Fachwahl. <br>
+     * Gibt null zurück, falls der Schüler das Fach nicht gewählt hat.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idFach       die Datenbank-ID des Faches
+     *
+     * @return zum Tupel (Schüler, Fach) jeweilige {@link GostFachwahl} oder null
+     */
+    schuelerGetOfFachFachwahlOrNull(idSchueler: number, idFach: number): GostFachwahl | null;
+    /**
+     * Liefert TRUE, falls der übergebene Schüler das entsprechende Fach gewählt hat.
+     *
+     * @param idSchueler   die Datenbank.ID des Schülers
+     * @param idFach       die Datenbank-ID des Faches der Fachwahl des Schülers
+     *
+     * @return true, falls der Schüler das Fach gewählt hat
+     */
+    schuelerGetHatFach(idSchueler: number, idFach: number): boolean;
+    /**
+     * Liefert TRUE, falls beide Schüler bezogen auf das Fach die selbe Kursart haben oder eine Exception.
+     *
+     * @param idSchueler1   die Datenbank-ID des 1. Schülers
+     * @param idSchueler2   die Datenbank-ID des 2. Schülers
+     * @param idFach        die Datenbank-ID des Faches
+     *
+     * @return true, falls beide Schüler im Fach die selbe Kursart haben
+     * @throws DeveloperNotificationException falls einer der beiden Schüler das Fach nicht gewählt hat.
+     */
+    schuelerGetHatDieSelbeKursartMitSchuelerInFach(idSchueler1: number, idSchueler2: number, idFach: number): boolean;
+    /**
+     * Liefert TRUE, falls es den Schüler mit der entsprechenden Fachwahl (Fach + Kursart) gibt.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idFach       die Datenbank-ID des Faches der Fachwahl des Schülers
+     * @param idKursart    die Datenbank-ID der Kursart der Fachwahl des Schülers
+     *
+     * @return true, falls der Schüler die Fachwahl (Fach + Kursart) hat
+     */
+    schuelerGetHatFachart(idSchueler: number, idFach: number, idKursart: number): boolean;
+    /**
+     * Liefert die Menge aller {@link GostFachwahl} des Schülers.
+     * <br> Bei ungültiger Schüler-ID wird eine leere Liste geliefert.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     *
+     * @return die Menge aller {@link GostFachwahl} des Schülers
+     */
+    schuelerGetListeOfFachwahlen(idSchueler: number): List<GostFachwahl>;
+    /**
+     * Liefert eine Liste der gemeinsamen Fächer (auch in der Kursart übereinstimmend) beider Schüler.
+     *
+     * @param idSchueler1   die Datenbank-ID des 1. Schülers
+     * @param idSchueler2   die Datenbank-ID des 2. Schülers
+     *
+     * @return eine Liste der gemeinsamen Fächer (auch in der Kursart übereinstimmend) beider Schüler
+     */
+    schuelerGetFachListeGemeinsamerFacharten(idSchueler1: number, idSchueler2: number): List<GostFach>;
+    /**
+     * Liefert TRUE, falls der Schüler aufgrund der Regel {@link GostKursblockungRegelTyp#SCHUELER_VERBIETEN_IN_KURS} im angegebenen Kurs verboten ist.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idKurs       die Datenbank-ID des Kurses
+     *
+     * @return true, falls der Schüler aufgrund der Regel {@link GostKursblockungRegelTyp#SCHUELER_VERBIETEN_IN_KURS} im angegebenen Kurs verboten ist
+     */
+    schuelerGetIstVerbotenInKurs(idSchueler: number, idKurs: number): boolean;
+    /**
+     * Liefert die Regel, welche den Schüler in einem Kurs verbietet.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idKurs       die Datenbank-ID des Kurses
+     *
+     * @return die Regel, welche den Schüler in einem Kurs verbietet
+     * @throws DeveloperNotificationException falls der Schüler oder der Kurs in der Blockung nicht existiert.
+     */
+    schuelerGetRegelVerbotenInKurs(idSchueler: number, idKurs: number): GostBlockungRegel;
+    /**
+     * Liefert TRUE, falls der Schüler aufgrund der Regel {@link GostKursblockungRegelTyp#SCHUELER_FIXIEREN_IN_KURS} im angegebenen Kurs fixiert ist.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idKurs       die Datenbank-ID des Kurses
+     *
+     * @return true, falls der Schüler aufgrund der Regel {@link GostKursblockungRegelTyp#SCHUELER_FIXIEREN_IN_KURS} im angegebenen Kurs fixiert ist
+     */
+    schuelerGetIstFixiertInKurs(idSchueler: number, idKurs: number): boolean;
+    /**
+     * Liefert die Regel, welche den Schüler in einem Kurs fixiert.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     * @param idKurs       die Datenbank-ID des Kurses
+     *
+     * @return die Regel, welche den Schüler in einem Kurs fixiert
+     * @throws DeveloperNotificationException falls der Schüler oder der Kurs in der Blockung nicht existiert.
+     */
+    schuelerGetRegelFixiertInKurs(idSchueler: number, idKurs: number): GostBlockungRegel;
+    /**
+     * Liefert TRUE, falls der Schüler aufgrund der Regel {@link GostKursblockungRegelTyp#SCHUELER_IGNORIEREN} bei der Blockung ignoriert wird.
+     *
+     * @param idSchueler   die Datenbank-ID des Schülers
+     *
+     * @return true, falls der Schüler aufgrund der Regel {@link GostKursblockungRegelTyp#SCHUELER_IGNORIEREN} ignoriert wird
+     */
+    schuelerGetIstIgnoriert(idSchueler: number): boolean;
+    /**
+     * Gibt die ID der Blockung zurück.
+     *
+     * @return die ID der Blockung
+     */
+    getID(): number;
+    /**
+     * Setzt die ID dieser Blockung.
+     *
+     * @param idNeu   die Datenbank-ID, welche der Blockung zugewiesen wird
+     * @throws DeveloperNotificationException Falls die übergebene ID ungültig ist.
+     */
+    setID(idNeu: number): void;
+    /**
+     * Liefert die maximale Blockungszeit in Millisekunden.
+     *
+     * @return die maximale Blockungszeit in Millisekunden
+     */
+    getMaxTimeMillis(): number;
+    /**
+     * Setzt die maximale Blockungszeit in Millisekunden.
+     *
+     * @param blockungszeit   die maximale Blockungszeit in Millisekunden
+     * @throws DeveloperNotificationException falls der Wert nicht positiv ist.
+     */
+    setMaxTimeMillis(blockungszeit: number): void;
+    /**
+     * Liefert den Namen der Blockung.
+     *
+     * @return den Namen der Blockung
+     */
+    getName(): string;
+    /**
+     * Setzt den Namen der Blockung
+     *
+     * @param name   der Name, welcher der Blockung zugewiesen wird
+     * @throws UserNotificationException Falls der übergebene String leer ist.
+     */
+    setName(name: string): void;
+    /**
+     * Liefert das Halbjahr der gymnasialen Oberstufe, für welches die Blockung angelegt wurde.
+     *
+     * @return das Halbjahr der gymnasialen Oberstufe
+     */
+    getHalbjahr(): GostHalbjahr;
+    /**
+     * Setzt das Halbjahr der gymnasialen Oberstufe, für welches die Blockung angelegt wurde.
+     *
+     * @param halbjahr   das Halbjahr der gymnasialen Oberstufe
+     */
+    setHalbjahr(halbjahr: GostHalbjahr): void;
+    /**
+     * Liefert TRUE, falls in dieser Blockung genau 1 Ergebnis (die Blockungsvorlage) vorhanden ist.
+     *
+     * @return true, falls in dieser Blockung genau 1 Ergebnis (die Blockungsvorlage) vorhanden ist
+     */
+    getIstBlockungsVorlage(): boolean;
+    /**
+     * Liefert die Anzahl an Fächern.
+     *
+     * @return die Anzahl an Fächern
+     */
+    getFaecherAnzahl(): number;
+    /**
+     * Gibt den Fächer-Manager zurück, der für die Blockungsdaten verwendet wird.
+     *
+     * @return der Fächer-Manager (siehe {@link GostFaecherManager})
+     */
+    faecherManager(): GostFaecherManager;
+    /**
+     * Gibt die Blockungsdaten zurück.
+     *
+     * @return die Blockungsdaten (siehe {@link GostBlockungsdaten})
+     */
+    daten(): GostBlockungsdaten;
+    /**
+     * Liefert eine String-Representation vieler Daten.
+     *
+     * @return eine String-Representation vieler Daten
+     */
+    getDebugString(): string;
+    transpilerCanonicalName(): string;
+    isTranspiledInstanceOf(name: string): boolean;
+    static readonly class: Class<GostBlockungsdatenManager>;
+}
+export declare function cast_de_svws_nrw_core_utils_gost_GostBlockungsdatenManager(obj: unknown): GostBlockungsdatenManager;
+//# sourceMappingURL=GostBlockungsdatenManager.d.ts.map