@hmt/svws-core 1.5.2 → 1.5.4

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

@@ -0,0 +1,2588 @@
+import { JavaObject } from '../../../java/lang/JavaObject';
+import { GostBlockungsergebnisBewertung } from '../../../core/data/gost/GostBlockungsergebnisBewertung';
+import { GostKursart } from '../../../core/types/gost/GostKursart';
+import type { List } from '../../../java/util/List';
+import { GostBlockungKurs } from '../../../core/data/gost/GostBlockungKurs';
+import { GostFachwahl } from '../../../core/data/gost/GostFachwahl';
+import { GostBlockungsergebnisKursSchuelerZuordnungUpdate } from '../../../core/data/gost/GostBlockungsergebnisKursSchuelerZuordnungUpdate';
+import { Schueler } from '../../../asd/data/schueler/Schueler';
+import { Class } from '../../../java/lang/Class';
+import type { JavaMap } from '../../../java/util/JavaMap';
+import { GostBlockungsergebnisSchiene } from '../../../core/data/gost/GostBlockungsergebnisSchiene';
+import { GostBlockungsergebnisKursSchuelerZuordnung } from '../../../core/data/gost/GostBlockungsergebnisKursSchuelerZuordnung';
+import type { JavaSet } from '../../../java/util/JavaSet';
+import { GostBlockungsergebnisKurs } from '../../../core/data/gost/GostBlockungsergebnisKurs';
+import { Logger } from '../../../core/logger/Logger';
+import { GostBlockungsergebnisKursSchienenZuordnung } from '../../../core/data/gost/GostBlockungsergebnisKursSchienenZuordnung';
+import { GostBlockungsergebnisKursSchienenZuordnungUpdate } from '../../../core/data/gost/GostBlockungsergebnisKursSchienenZuordnungUpdate';
+import { GostSchriftlichkeit } from '../../../core/types/gost/GostSchriftlichkeit';
+import { Geschlecht } from '../../../asd/types/Geschlecht';
+import { Pair } from '../../../asd/adt/Pair';
+import { GostFach } from '../../../core/data/gost/GostFach';
+import { GostBlockungsdatenManager } from '../../../core/utils/gost/GostBlockungsdatenManager';
+import { GostBlockungsergebnis } from '../../../core/data/gost/GostBlockungsergebnis';
+import { GostBlockungRegelUpdate } from '../../../core/data/gost/GostBlockungRegelUpdate';
+import { GostBlockungSchiene } from '../../../core/data/gost/GostBlockungSchiene';
+export declare class GostBlockungsergebnisManager extends JavaObject {
+    /**
+     * Zeilenumbruch.
+     */
+    private readonly lineSeparator;
+    /**
+     * Der Blockungsdaten-Manager ist das Elternteil dieses Objektes.
+     */
+    private readonly parent;
+    /**
+     * Das Blockungsergebnis ist das zugehörige Eltern-Datenobjekt.
+     */
+    private ergebnis;
+    /**
+     * Liste aller Fehlermeldungen.
+     */
+    private fehlermeldungen;
+    /**
+     * Set aller Schienen-IDs.
+     */
+    private schienenIDs;
+    /**
+     * Set aller Schienen-Nummern.
+     */
+    private schienenNRs;
+    /**
+     * Set aller Kurs-IDs.
+     */
+    private kursIDs;
+    /**
+     * Set aller Fach-IDs.
+     */
+    private fachIDs;
+    /**
+     * Set aller Schüler-IDs.
+     */
+    private schuelerIDs;
+    /**
+     * Map von Schienen-ID nach {@link GostBlockungsergebnisSchiene}.
+     */
+    private schieneByID;
+    /**
+     * Map von Schienen-NR nach {@link GostBlockungsergebnisSchiene}.
+     */
+    private schieneByNR;
+    /**
+     * Map von Kurs-ID nach {@link GostBlockungsergebnisKurs}.
+     */
+    private kursByID;
+    /**
+     * Map von Schueler-ID nach {@link Schueler}.
+     */
+    private schuelerByID;
+    /**
+     * Map von Schienen-ID nach Long-Set (von Kursen).
+     */
+    private kursIDsBySchienenID;
+    /**
+     * Map von Schueler-ID nach {@link GostBlockungsergebnisKurs}-Set (Kurse des Schüler, die aufgrund der aktuellen Fachwahlen ungültig sind).
+     */
+    private kursmengeUngueltigBySchuelerID;
+    /**
+     * Map von Kurs-ID nach Long-Set (von Schülern).
+     */
+    private schuelerIDsByKursID;
+    /**
+     * Map von Fach-ID nach {@link GostBlockungsergebnisKurs}-List.
+     */
+    private kursmengeByFachID;
+    /**
+     * Map von Kurs-ID nach {@link GostBlockungsergebnisSchiene}-Set.
+     */
+    private schienenmengeByKursID;
+    /**
+     * Map von Kurs-ID nach Integer (Anzahl der Dummy Schülerinnen und Schüler).
+     */
+    private schuelerAnzahlDummyByKursID;
+    /**
+     * Map von Fachart-ID nach {@link GostBlockungsergebnisKurs}-List (Alle Kurse der selben Fachart).
+     */
+    private kursmengeByFachartID;
+    /**
+     * Map von Schüler-ID nach {@link GostBlockungsergebnisKurs}-Set.
+     */
+    private kursmengeBySchuelerID;
+    /**
+     * Menge aller Fachart-IDs sortiert nach der aktuellen Sortiervariante.
+     */
+    private fachartIDsSortiert;
+    /**
+     * Map von Fachart-ID nach Integer (Kursdifferenz der Fachart).
+     */
+    private kursdifferenzByFachartID;
+    /**
+     * Map von Schienen-ID nach Integer (Anzahl an Kollisionen in der Schiene).
+     */
+    private kollisionenBySchienenID;
+    /**
+     * Map von Schienen-ID nach Integer (Anzahl der SuS in der Schiene).
+     */
+    private schuelerAnzahlBySchienenID;
+    /**
+     * Map von Schüler-ID nach Map von Schienen-ID nach {@link GostBlockungsergebnisKurs}-Set (Alle Kurse des Schülers in der Schiene).
+     */
+    private kursmengeBySchuelerIDAndSchienenID;
+    /**
+     * Map von Schienen-ID nach Map von Fachart-ID nach {@link GostBlockungsergebnisKurs}-List (Alle Kurse pro Schiene und Fachart).
+     */
+    private kursmengeBySchienenIDAndFachartID;
+    /**
+     * Map von Kursdifferenz nach String-List (Facharten mit dieser Kursdifferenzen).
+     */
+    private fachartBeschreibungsmengeByKursdifferenz;
+    /**
+     * Map von Schüler-ID Integer (Summe aller Kollisionen des Schülers).
+     */
+    private kollisionenBySchuelerID;
+    /**
+     * Map von (Schüler-ID, Fach-ID) nach {@link GostBlockungsergebnisKurs} (Die zugeordnete Wahl des Schülers in dem Fach, auch NULL möglich).
+     */
+    private kursOrNullBySchuelerIDAndFachID;
+    /**
+     * Von Regel-ID Regel-TYP nach List (alle Regelverletzungen des Typs als String-Menge).
+     */
+    private regelverletzungsmengeByRegelTyp;
+    /**
+     * Von Regel-ID nach String (Beschreibung der Regelverletzung).
+     */
+    private regelverletzungsBeschreibungByRegelID;
+    /**
+     * Textuelle Darstellung aller Regelverletzungen der definierten Regeln.
+     */
+    private regelverletzungenTooltipRegeln;
+    /**
+     * Textuelle Darstellung aller Regelverletzungen der Wahlkonflikte.
+     */
+    private regelverletzungenTooltipWahlkonflikte;
+    /**
+     * Textuelle Darstellung aller Regelverletzungen der Kursdifferenzen.
+     */
+    private regelverletzungenTooltipKursdifferenzen;
+    /**
+     * Textuelle Darstellung aller Regelverletzungen der Fächerparallelität.
+     */
+    private regelverletzungenTooltipFaecherparallelitaet;
+    /**
+     * Entscheidet, welcher Comparator verwendet wird mit 1 = (KURSART, FACH) andernfalls (FACH, KURSART).
+     */
+    private fachartmengeSortierArt;
+    /**
+     * Comparator für die Facharten nach (KURSART, FACH).
+     */
+    private readonly comparatorFachartByKursartAndFach;
+    /**
+     * Comparator für die Facharten nach (FACH, KURSART).
+     */
+    private readonly comparatorFachartByFachAndKursart;
+    /**
+     * Ein Comparator für Kurse der Blockung (KURSART, FACH, KURSNUMMER)
+     */
+    private readonly comparatorKursByKursartAndFachAndKursnummer;
+    /**
+     * Ein Comparator für Kurse der Blockung (FACH, KURSART, KURSNUMMER).
+     */
+    private readonly comparatorKursByFachAndKursartAndKursnummer;
+    /**
+     * Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf die Kursart LK.
+     */
+    private bewertungKursdifferenzNurLK;
+    /**
+     * Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf die Kursart GK.
+     */
+    private bewertungKursdifferenzNurGK;
+    /**
+     * Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf Kursarten die nicht LK oder GK sind.
+     */
+    private bewertungKursdifferenzRest;
+    /**
+     * Erstellt einen leeren GostBlockungsergebnisManager in Bezug auf GostBlockungsdatenManager. Die ID des leeren
+     * Ergebnisses ist -1 und muss noch gesetzt werden.
+     *
+     * @param pParent                  Das Eltern-Objekt. (Daten-Manager für die grundlegenden Definitionen der
+     *                                 Blockung)
+     * @param pGostBlockungsergebnisID Die ID des Blockungsergebnisses.
+     */
+    constructor(pParent: GostBlockungsdatenManager, pGostBlockungsergebnisID: number);
+    /**
+     * Erstellt einen neuen Manager mit den Daten aus dem übergebenen Ergebnis.
+     *
+     * @param pParent   Das Eltern-Objekt. (Daten-Manager für die grundlegenden Definitionen der Blockung)
+     * @param pErgebnis Das Ergebnis, welches kopiert wird.
+     */
+    constructor(pParent: GostBlockungsdatenManager, pErgebnis: GostBlockungsergebnis);
+    /**
+     * Baut alle Datenstrukturen neu auf.
+     */
+    stateRevalidateEverything(): void;
+    private stateClear;
+    private stateClearErgebnisTooltipRegelverletzungenBewertung;
+    private stateClearErgebnisTooltipRegelverletzungenString;
+    private stateClearErgebnisTooltipWahlkonflikteBewertung;
+    private appendNichtwahlenLinien;
+    private appendKollisionenLinien;
+    private appendKollisionVonSchuelerInSchiene;
+    private stateClearErgebnisTooltipWahlkonflikteString;
+    private stateClearErgebnisTooltipKursdifferenzenBewertung;
+    private stateClearErgebnisTooltipKursdifferenzenString;
+    private stateClearErgebnisTooltipFaecherparallelitaetBewertung;
+    private stateClearErgebnisTooltipFaecherparallelitaetString;
+    private stateClearErgebnisTooltipFaecherparallelitaetStringProSchiene;
+    private stateClearErgebnisTooltipFaecherparallelitaetStringProSchieneUndFachart;
+    private update0schienenIDsUndschienenNRs;
+    private update0kursIDs;
+    private update0fachIDs;
+    private update0schuelerIDs;
+    /**
+     * Wichtig: Die Methode muss auf gelöschte und hinzugefügt Schienen reagieren
+     * und die eigene Datenstruktur anpassen.
+     */
+    private update0schieneByIDUndschieneByNR;
+    /**
+     * Um Bugs zu verhindern, muss die DTO-Datenstruktor hier korrigiert werden,
+     * denn Multi-Schienen-Kurse existieren in der jeweiligen Schiene als Kopie.
+     * Alle Kopien müssen durch das selbe Kurs-Objekt ersetzt werden.
+     */
+    private update0kursByID;
+    private update0schuelerByID;
+    private update0kursIDsBySchienenID;
+    private update1schuelerIDsByKursIDUndkursmengeUngueltigBySchuelerID;
+    private update1schuelerAnzahlDummyByKursID;
+    private update1kursmengeByFachID;
+    private update1schienenmengeByKursID;
+    private update1kursmengeByFachartID;
+    private update2kursmengeBySchuelerID;
+    private update2fachartIDsSortiert;
+    private update2kursdifferenzByFachartID;
+    private update2kollisionenBySchienenID;
+    private update2schuelerAnzahlBySchienenID;
+    private update2kursmengeBySchuelerIDAndSchienenID;
+    private update2kursmengeBySchienenIDAndFachartID;
+    private update3fachartBeschreibungsmengeByKursdifferenz;
+    private update3kollisionenBySchuelerID;
+    private update3kursOrNullBySchuelerIDAndFachID;
+    private stateRegelvalidierung1;
+    private stateRegelvalidierung2;
+    private stateRegelvalidierung3;
+    private stateRegelvalidierung4;
+    private stateRegelvalidierung5;
+    private stateRegelvalidierung6;
+    private stateRegelvalidierung7;
+    private stateRegelvalidierung8;
+    private stateRegelvalidierung10;
+    private stateRegelvalidierung11;
+    private stateRegelvalidierung12;
+    private stateRegelvalidierung13;
+    private stateRegelvalidierung14;
+    private stateRegelvalidierung15;
+    private stateRegelvalidierung18;
+    /**
+     * Fügt den Schüler dem Kurs hinzu und revalidiert nicht den Zustand. <br>
+     * Hinweis: Ist die Wahl des Kurses für diesen Schüler ungültig, wird der Schüler nicht hinzugefügt.
+     *          Stattdessen wird die ungültige Wahl in einer Map gespeichert.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     * @param  idKurs     Die Datenbank-ID des Kurses.
+     */
+    private stateSchuelerKursHinzufuegenOhneRevalidierung;
+    /**
+     * Entfernt den Schüler aus dem Kurs und revalidiert nicht den Zustand. <br>
+     * Hinweis: Ist die Wahl des Kurses für diesen Schüler ungültig, so wird der Schüler aus der zuvor gespeichert
+     *          Zuordnung aller ungültigen Wahlen gelöscht.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     * @param  idKurs     Die Datenbank-ID des Kurses.
+     */
+    private stateSchuelerKursEntfernenOhneRevalidierung;
+    /**
+     * Fügt den Kurs der Schiene hinzu und revalidiert nicht den Zustand.
+     *
+     * @param  idKurs     Die Datenbank-ID des Kurses.
+     * @param  idSchiene  Die Datenbank-ID der Schiene.
+     */
+    private stateKursSchieneHinzufuegenOhneRegelvalidierung;
+    /**
+     * Entfernt den Kurs aus der Schiene.
+     *
+     * @param  idKurs     Die Datenbank-ID des Kurses.
+     * @param  idSchiene  Die Datenbank-ID der Schiene.
+     */
+    private stateKursSchieneEntfernenOhneRegelvalidierung;
+    /**
+     * Liefert die Anzahl an externen SuS.
+     *
+     * @return die Anzahl an externen SuS.
+     */
+    getAnzahlSchuelerExterne(): number;
+    private static dividiereUndSchneideNachZweiNachkommastellenAb;
+    /**
+     * Liefert die Kursfrequenz als String, berechnet als (Summe aller Fachwahlen) / (interne Kurse).
+     * <br>Hinweis: DummySuS werden ignoriert.
+     * <br>Hinweis: Es werden 2 Nachkommastellen maximal angezeigt.
+     *
+     * @return die Kursfrequenz als String, berechnet als (Summe aller Fachwahlen) / (interne Kurse).
+     */
+    getKursfrequenz1AsString(): string;
+    /**
+     * Liefert die Kursfrequenz als String, berechnet als (Summe aller auf interne Kurse verteilten SuS) / (interne Kurse).
+     * <br>Hinweis: DummySuS werden ignoriert.
+     * <br>Hinweis: Es werden 2 Nachkommastellen maximal angezeigt.
+     *
+     * @return die Kursfrequenz als String, berechnet als (Summe aller auf interne Kurse verteilten SuS) / (interne Kurse).
+     */
+    getKursfrequenz2AsString(): string;
+    /**
+     * Liefert die Anzahl an E-Schienen.
+     *
+     * @return die Anzahl an E-Schienen.
+     */
+    getAnzahlSchienen(): number;
+    /**
+     * Liefert die Anzahl an Dummy-SuS.
+     *
+     * @return die Anzahl an Dummy-SuS.
+     */
+    getAnzahlSchuelerDummy(): number;
+    /**
+     * Liefert die Datenbank-ID der Blockung. Das ist die ID des Elternteils.
+     *
+     * @return die Datenbank-ID der Blockung. Das ist die ID des Elternteils.
+     */
+    getBlockungsdatenID(): number;
+    /**
+     * Liefert das Blockungsergebnis, potentiell auch mit Schüler-Kurs-Zuordnungen, die nicht zu den Fachwahlen passen.
+     *
+     * @return das Blockungsergebnis, potentiell auch mit Schüler-Kurs-Zuordnungen, die nicht zu den Fachwahlen passen.
+     */
+    getErgebnis(): GostBlockungsergebnis;
+    /**
+     * Liefert die Menge (meistens eine) aller Fehlermeldungen.
+     * <br>Falls die Liste nicht leer ist, sollte die GUI den Benutzer warnen, dass die Blockung nicht vollständig geladen wurde!
+     *
+     * @return die Menge (meistens eine) aller Fehlermeldungen.
+     */
+    getFehlermeldungen(): List<string>;
+    /**
+     * Liefert den zugehörigen Daten-Manager für diesen Ergebnis-Manager.
+     *
+     * @return den zugehörigen Daten-Manager für diesen Ergebnis-Manager.
+     */
+    getParent(): GostBlockungsdatenManager;
+    /**
+     * Liefert eine Güte eines Bewertungskriteriums im Bereich [0;1], mit 0=optimal.
+     *
+     * @param value   der Wert des Bewertungskriteriums
+     *
+     * @return die Güte des Bewertungskriteriums im Bereich [0;1], mit 0=optimal.
+     */
+    private static getOfBewertungFarbcodeStatic;
+    /**
+     * Liefert den Wert des 1. Bewertungskriteriums. Darin enthalten sind: <br>
+     * - Die Anzahl der Regelverletzungen. <br>
+     * - Die Anzahl der nicht genügend gesetzten Kurse. <br>
+     *
+     * @param bewertung   die Bewertung vom Ergebnis
+     *
+     * @return Den Wert des 1. Bewertungskriteriums.
+     */
+    static getOfBewertung1WertStatic(bewertung: GostBlockungsergebnisBewertung): number;
+    /**
+     * Liefert den Wert des 1. Bewertungskriteriums. Darin enthalten sind: <br>
+     * - Die Anzahl der Regelverletzungen. <br>
+     * - Die Anzahl der nicht genügend gesetzten Kurse. <br>
+     *
+     * @return Den Wert des 1. Bewertungskriteriums.
+     */
+    getOfBewertung1Wert(): 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 bewertung  die Bewertung vom Ergebnis
+     *
+     * @return Eine Güte des 1. Bewertungskriteriums im Bereich [0;1], mit 0=optimal.
+     */
+    private static getOfBewertung1FarbcodeStatic;
+    /**
+     * 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>
+     *
+     * @return Eine Güte des 1. Bewertungskriteriums im Bereich [0;1], mit 0=optimal.
+     */
+    getOfBewertung1Farbcode(): 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 bewertung   die Bewertung vom Ergebnis
+     *
+     * @return Den Wert des 2. Bewertungskriteriums.
+     */
+    private static getOfBewertung2WertStatic;
+    /**
+     * Liefert den Wert des 2. Bewertungskriteriums. Darin enthalten sind: <br>
+     * - Die Anzahl der nicht zugeordneten Schülerfachwahlen. <br>
+     * - Die Anzahl der Schülerkollisionen. <br>
+     *
+     * @return Den Wert des 2. Bewertungskriteriums.
+     */
+    getOfBewertung2Wert(): 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 bewertung   die Bewertung vom Ergebnis
+     *
+     * @return Eine Güte des 2. Bewertungskriteriums im Bereich [0;1], mit 0=optimal.
+     */
+    private static getOfBewertung2FarbcodeStatic;
+    /**
+     * 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>
+     *
+     * @return Eine Güte des 2. Bewertungskriteriums im Bereich [0;1], mit 0=optimal.
+     */
+    getOfBewertung2Farbcode(): number;
+    /**
+     * Liefert den Wert des 3. Bewertungskriteriums (Kursdifferenz).
+     *
+     * @return den Wert des 3. Bewertungskriteriums (Kursdifferenz).
+     */
+    getOfBewertung3Wert(): number;
+    /**
+     * Liefert eine Güte des 3. Bewertungskriteriums (Kursdifferenz) im Bereich [0;1], mit 0=optimal.
+     *
+     * @return eine Güte des 3. Bewertungskriteriums (Kursdifferenz) im Bereich [0;1], mit 0=optimal.
+     */
+    getOfBewertung3Farbcode(): number;
+    /**
+     * Liefert den Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf die Kursart LK.
+     *
+     * @return den Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf die Kursart LK.
+     */
+    getOfBewertung3WertNurLk(): number;
+    /**
+     * Liefert eine Güte des 3. Bewertungskriteriums (Kursdifferenz, nur LK) im Bereich [0;1], mit 0=optimal.
+     *
+     * @return eine Güte des 3. Bewertungskriteriums (Kursdifferenz, nur LK) im Bereich [0;1], mit 0=optimal.
+     */
+    getOfBewertung3FarbcodeNurLk(): number;
+    /**
+     * Liefert den Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf die Kursart GK.
+     *
+     * @return den Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf die Kursart GK.
+     */
+    getOfBewertung3WertNurGk(): number;
+    /**
+     * Liefert eine Güte des 3. Bewertungskriteriums (Kursdifferenz, nur GK) im Bereich [0;1], mit 0=optimal.
+     *
+     * @return eine Güte des 3. Bewertungskriteriums (Kursdifferenz, nur GK) im Bereich [0;1], mit 0=optimal.
+     */
+    getOfBewertung3FarbcodeNurGk(): number;
+    /**
+     * Liefert den Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf Kursarten die nicht LK oder GK sind.
+     *
+     * @return den Wert des 3. Bewertungskriteriums (Kursdifferenz) nur bezogen auf Kursarten die nicht LK oder GK sind.
+     */
+    getOfBewertung3WertNurRest(): number;
+    /**
+     * Liefert eine Güte des 3. Bewertungskriteriums (Kursdifferenz, alles außer LK und GK) im Bereich [0;1], mit 0=optimal.
+     *
+     * @return eine Güte des 3. Bewertungskriteriums (Kursdifferenz, alles außer LK und GK) im Bereich [0;1], mit 0=optimal.
+     */
+    getOfBewertung3FarbcodeNurRest(): 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 bewertung   die Bewertung vom Ergebnis
+     *
+     * @return Den Wert des 4. Bewertungskriteriums.
+     */
+    private static getOfBewertung4WertStatic;
+    /**
+     * 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).
+     *
+     * @return Den Wert des 4. Bewertungskriteriums.
+     */
+    getOfBewertung4Wert(): 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 bewertung   die Bewertung vom Ergebnis
+     *
+     * @return Eine Güte des 4. Bewertungskriteriums im Bereich [0;1], mit 0=optimal.
+     */
+    private static getOfBewertung4FarbcodeStatic;
+    /**
+     * 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).
+     *
+     * @return Eine Güte des 4. Bewertungskriteriums im Bereich [0;1], mit 0=optimal.
+     */
+    getOfBewertung4Farbcode(): number;
+    /**
+     * Liefert die Anzahl nicht vollständig verteilter Kurse.<br>
+     * Ein Multikurse der über mehrere Schienen geht und gar nicht zugeteilt wurde, wird mehrfach gezählt.
+     *
+     * @return die Anzahl nicht vollständig verteilter Kurse.
+     */
+    getOfBewertungAnzahlNichtZugeordneterKurse(): number;
+    /**
+     * Liefert die Anzahl an Fachwahlen, die nicht zugeordnet wurden.
+     *
+     * @return die Anzahl an Fachwahlen, die nicht zugeordnet wurden.
+     */
+    getOfBewertungAnzahlNichtzugeordneterFachwahlen(): number;
+    /**
+     * Ermittelt das {@link GostFach} für die angegebene ID. Delegiert den Aufruf an den Fächer-Manager des Eltern-Objektes {@link GostBlockungsdatenManager}.<br>
+     * Wirft eine {@link DeveloperNotificationException} falls die ID unbekannt ist.
+     *
+     * @param idFach  Die Datenbank-ID des Faches.
+     *
+     * @return Das {@link GostFach}-Objekt.
+     * @throws DeveloperNotificationException falls die ID unbekannt ist.
+     */
+    getFach(idFach: number): GostFach;
+    /**
+     * Liefert die Menge aller Kurse mit dem angegebenen Fach-ID.<br>
+     *
+     * @param idFach  Die Datenbank-ID des Faches.
+     *
+     * @return die Menge aller Kurse mit dem angegebenen Fach-ID.
+     * @throws DeveloperNotificationException falls die Fach-ID unbekannt ist.
+     */
+    getOfFachKursmenge(idFach: number): List<GostBlockungsergebnisKurs>;
+    /**
+     * Liefert die Kursmenge, die zur Fachart gehört. Die Fachart-ID wird berechnet über: {@link GostKursart#getFachartID(long, int)}.<br>
+     * <br>Hinweis: Die Kursmenge pro Fachart ist sortiert nach {@link #kursSetSortierungFachKursartNummer()} oder {@link #kursSetSortierungKursartFachNummer()}.
+     * <br>Hinweis: Wirft eine {@link DeveloperNotificationException} falls die Fachart-ID unbekannt ist.
+     *
+     * @param  idFachart  Die Fachart-ID wird berechnet über: {@link GostKursart#getFachartID(long, int)}.
+     *
+     * @return die Kursmenge, die zur Fachart gehört.
+     * @throws DeveloperNotificationException falls die Fachart-ID unbekannt ist.
+     */
+    getOfFachartKursmenge(idFachart: number): List<GostBlockungsergebnisKurs>;
+    /**
+     * Liefert die Kursdifferenz der Fachart und beachtet dabei Dummy-SuS von Kursen.
+     * Die Fachart-ID wird berechnet über: {@link GostKursart#getFachartID(long, int)}.
+     * Die Methode beachtet auch Kurse mit Dummy-SuS. <br>
+     * Wirft eine {@link DeveloperNotificationException} falls die Fachart-ID unbekannt ist.
+     *
+     * @param  idFachart  Die Fachart-ID wird berechnet über: {@link GostKursart#getFachartID(long, int)}.
+     *
+     * @return die Kursdifferenz der Fachart und beachtet dabei Dummy-SuS von Kursen.
+     * @throws DeveloperNotificationException falls die Fachart-ID unbekannt ist.
+     */
+    getOfFachartKursdifferenz(idFachart: number): number;
+    /**
+     * Liefert die Kursdifferenz der Fachart, übergeben als (Fach, Kursart).
+     * Die Methode beachtet auch Kurse mit Dummy-SuS. <br>
+     * Wirft eine {@link DeveloperNotificationException} falls die Fachart-ID unbekannt ist.
+     *
+     * @param idFach     Die Datenbank-ID des Faches.
+     * @param idKursart  Die ID der Kursart.
+     *
+     * @return die Kursdifferenz der Fachart, übergeben als (Fach, Kursart).
+     * @throws DeveloperNotificationException falls die Fachart-ID unbekannt ist.
+     */
+    getOfFachOfKursartKursdifferenz(idFach: number, idKursart: number): number;
+    /**
+     * Liefert den Namen der Fachart, z. B. D-LK.
+     *
+     * @param idFachart  Die ID der Fachart.
+     *
+     * @return den Namen der Fachart, z. B. D-LK.
+     */
+    private getOfFachartName;
+    /**
+     * Ändert die aktuelle Sortierung von Facharten und Kursen.
+     * <br>Hinweis: Sortiert zuerst nach LK/GK, dann nach der Fachsortierung, zuletzt nach der Kursnummer.
+     */
+    kursSetSortierungKursartFachNummer(): void;
+    /**
+     * Ändert die aktuelle Sortierung von Facharten und Kursen.
+     * <br>Hinweis: Sortiert zuerst nach der Fachsortierung, dann nach LK/GK, zuletzt nach der Kursnummer.
+     */
+    kursSetSortierungFachKursartNummer(): void;
+    /**
+     * Liefert das {@link Schueler}-Objekt zur übergebenen ID.<br>
+     * Delegiert den Aufruf an das Eltern-Objekt {@link GostBlockungsdatenManager}.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     *
+     * @return das {@link Schueler}-Objekt zur übergebenen ID.
+     * @throws DeveloperNotificationException falls die Schüler-ID unbekannt ist.
+     */
+    private getSchuelerG;
+    /**
+     * Liefert einen Schüler-String im Format: 'Nachname, Vorname'.
+     *
+     * @param  idSchueler  Die Datenbank-ID des Schülers.
+     *
+     * @return einen Schüler-String im Format: 'Nachname, Vorname'.
+     */
+    getOfSchuelerNameVorname(idSchueler: number): string;
+    /**
+     * Liefert die Menge aller Kurse, die dem Schüler zugeordnet sind. <br>
+     * Wirft eine Exception, wenn der ID kein Schüler zugeordnet ist.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     *
+     * @return Die Menge aller Kurse, die dem Schüler zugeordnet sind.
+     */
+    getOfSchuelerKursmenge(idSchueler: number): JavaSet<GostBlockungsergebnisKurs>;
+    /**
+     * Liefert die Menge aller Kurse des Schülers mit Kollisionen.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     *
+     * @return Die Menge aller Kurse des Schülers mit Kollisionen.
+     */
+    getOfSchuelerKursmengeMitKollisionen(idSchueler: number): JavaSet<GostBlockungsergebnisKurs>;
+    /**
+     * Liefert die Menge aller Fachwahlen eines Schülers, die keinem Kurs zugeordnet sind.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     *
+     * @return die Menge aller Fachwahlen eines Schülers, die keinem Kurs zugeordnet sind.
+     */
+    getOfSchuelerFachwahlmengeOhneKurszuordnung(idSchueler: number): List<GostFachwahl>;
+    /**
+     * Liefert TRUE, falls der Schüler mindestens eine Nichtwahl hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     *
+     * @return TRUE, falls der Schüler mindestens eine Nichtwahl hat.
+     */
+    getOfSchuelerHatNichtwahl(idSchueler: number): boolean;
+    /**
+     * Liefert TRUE, falls der übergebene Schüler die entsprechende Fachwahl (Fach + Kursart) hat.
+     *
+     * @param idSchueler   Die Datenbank.ID des Schülers.
+     * @param idFach       Die Datenbank-ID des Faches der Fachwahl des Schülers.
+     * @param idKursart    Die ID der Kursart der Fachwahl des Schülers.
+     *
+     * @return TRUE, falls der übergebene Schüler die entsprechende Fachwahl (Fach + Kursart) hat.
+     */
+    getOfSchuelerHatFachwahl(idSchueler: number, idFach: number, idKursart: number): boolean;
+    /**
+     * Liefert TRUE, falls der übergebene Schüler das entsprechende Fach (unabhängig von der Kursart) 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 übergebene Schüler das entsprechende Fach (unabhängig von der Kursart) gewählt hat.
+     */
+    private getOfSchuelerHatFach;
+    /**
+     * Liefert TRUE, falls der Schüler mindestens eine Kollision hat. <br>
+     * Ein Schüler, der N>1 Mal in einer Schiene ist, erzeugt N-1 Kollisionen.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     *
+     * @return TRUE, falls der Schüler mindestens eine Kollision hat.
+     */
+    getOfSchuelerHatKollision(idSchueler: number): boolean;
+    /**
+     * Liefert die Anzahl der Schüler, die den Filterkriterien entsprechen.
+     *
+     * @param  idKurs           falls >= 0, werden Schüler des Kurses herausgefiltert.
+     * @param  idFach           falls >= 0, werden Schüler mit diesem Fach herausgefiltert.
+     * @param  idKursart        falls >= 0 und idFach >= 0, werden Schüler mit dieser Fach/Kursart Kombination herausgefiltert.
+     * @param  konfliktTyp      falls 1 = mit Kollisionen, 2 = mit Nichtwahlen, 3 = mit Kollisionen und Nichtwahlen, sonst alle Schüler.
+     * @param  subString        falls |pSubString| > 0 werden Schüler deren Vor- oder Nachname diesen String enthält herausgefiltert.
+     * @param  geschlecht       falls != null, werden die Schüler mit diesem {@link Geschlecht} herausgefiltert.
+     * @param  schriftlichkeit  falls != null, werden die Schüler mit dieser {@link GostSchriftlichkeit} herausgefiltert (isKurs oder idFach/idKursart müssen definiert sein).
+     *
+     * @return die Anzahl der Schüler, die den Filterkriterien entsprechen.
+     */
+    getOfSchuelerAnzahlGefiltert(idKurs: number, idFach: number, idKursart: number, konfliktTyp: number, subString: string, geschlecht: Geschlecht | null, schriftlichkeit: GostSchriftlichkeit | null): number;
+    /**
+     * Prüft das Nachfilter-Kriterium (Schriftlichkeit) für einen Schüler.
+     * <br>Hinweis: Sind Kurs-Filter und Fach-Filter gleichzeitig gesetzt, werden beide Schriftlichkeiten geprüft.
+     *
+     * @param idSchueler        die ID des zu prüfenden Schülers
+     * @param idKurs            die ID des Kurses (für Schriftlichkeits-Prüfung)
+     * @param idFach            die ID des Faches (für Schriftlichkeits-Prüfung)
+     * @param schriftlichkeit   die geforderte Schriftlichkeit oder null
+     *
+     * @return true, wenn der Schüler die Kriterien erfüllt
+     */
+    private getOfSchuelerErfuelltNachfilterKriterien;
+    /**
+     * Liefert die Menge der zugeordneten Kurse des Schülers in der Schiene.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idSchiene   Die Datenbank-ID der Schiene.
+     *
+     * @return die Menge der zugeordneten Kurse des Schülers in der Schiene.
+     */
+    private getOfSchuelerOfSchieneKursmenge;
+    /**
+     * Liefert TRUE, falls der Schüler in der Schiene mehr als einen Kurs belegt hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idSchiene   Die Datenbank-ID der Schiene.
+     *
+     * @return TRUE, falls der Schüler in der Schiene mehr als einen Kurs belegt hat.
+     */
+    getOfSchuelerOfSchieneHatKollision(idSchueler: number, idSchiene: number): boolean;
+    /**
+     * Liefert die zu (idSchueler, idFach) die jeweilige Kursart. <br>
+     *
+     * @param idSchueler Die Datenbank-ID des Schülers.
+     * @param idFach     Die Datenbank-ID des Faches.
+     *
+     * @return Die zu (idSchueler, idFach) die jeweilige Kursart.
+     */
+    getOfSchuelerOfFachKursart(idSchueler: number, idFach: number): GostKursart;
+    /**
+     * Liefert den zu (idSchueler, idFach) passenden Kurs oder NULL.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     * @param  idFach     Die Datenbank-ID des Faches.
+     *
+     * @return den zu (idSchueler, idFach) passenden Kurs oder NULL.
+     */
+    getOfSchuelerOfFachZugeordneterKurs(idSchueler: number, idFach: number): GostBlockungsergebnisKurs | null;
+    /**
+     * Liefert ein {@link SchuelerblockungOutput}-Objekt, welches für den Schüler eine Neuzuordnung der Kurse vorschlägt.
+     *
+     * @param idSchueler           Die ID des {@link Schueler}-Objekts.
+     * @param fixiereBelegteKurse  falls TRUE, werden alle Kurse fixiert, in denen der Schüler momentan ist.
+     *
+     * @return ein {@link SchuelerblockungOutput}-Objekt, welches für den Schüler eine Neuzuordnung der Kurse vorschlägt.
+     */
+    private getOfSchuelerNeuzuordnungMitFixierung;
+    private getOfSchuelerNeuzuordnungErzeugeKurs;
+    /**
+     * Liefert ein {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, welches für den Schüler eine berechnete Neuzuordnung der Kurse beinhaltet.
+     *
+     * @param idSchueler           Die ID des {@link Schueler}-Objekts.
+     * @param fixiereBelegteKurse  falls TRUE, werden alle Kurse fixiert, in denen der Schüler momentan ist.
+     *
+     * @return ein {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, welches für den Schüler eine Neuzuordnung der Kurse beinhaltet.
+     */
+    getOfSchuelerNeuzuordnung(idSchueler: number, fixiereBelegteKurse: boolean): GostBlockungsergebnisKursSchuelerZuordnungUpdate;
+    /**
+     * Liefert TRUE, falls der Schüler dem Kurs zugeordnet ist.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     * @param  idKurs     Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler dem Kurs zugeordnet ist.
+     */
+    getOfSchuelerOfKursIstZugeordnet(idSchueler: number, idKurs: number): boolean;
+    /**
+     * Liefert TRUE, falls der Schüler dem Kurs zugeordnet ist, aber keine entsprechende Fachwahl hat.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     * @param  idKurs     Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler dem Kurs zugeordnet ist, aber keine entsprechende Fachwahl hat.
+     */
+    getOfSchuelerOfKursIstUngueltig(idSchueler: number, idKurs: number): boolean;
+    /**
+     * Liefert TRUE, falls der Schüler im Kurs via Regel fixiert sein soll.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler im Kurs via Regel fixiert sein soll.
+     */
+    private getOfSchuelerOfKursIstFixiert;
+    /**
+     * Liefert TRUE, falls der Schüler den Kurs als LK gewählt hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler den Kurs als LK gewählt hat.
+     */
+    private getOfSchuelerOfKursIstLK;
+    /**
+     * Liefert TRUE, falls der Schüler den Kurs als AB3 gewählt hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler den Kurs als AB3 gewählt hat.
+     */
+    private getOfSchuelerOfKursIstAB3;
+    /**
+     * Liefert TRUE, falls der Schüler den Kurs als LK oder AB3 gewählt hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler den Kurs als LK oder AB3 gewählt hat.
+     */
+    private getOfSchuelerOfKursIstLKoderAB3;
+    /**
+     * Liefert TRUE, falls der Schüler den Kurs als AB4 gewählt hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler den Kurs als AB4 gewählt hat.
+     */
+    private getOfSchuelerOfKursIstAB4;
+    /**
+     * Liefert TRUE, falls der Schüler den Kurs als Abiturfach gewählt hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler den Kurs als Abiturfach gewählt hat.
+     */
+    private getOfSchuelerOfKursIstAbiturfach;
+    /**
+     * Liefert das Abiturfach des Schülers im Fach des Kurses als ID des {@link GostAbiturFach}.
+     * Der Wert 0 wird als NULL interpretiert und bedeutet, dass es kein Abiturfach ist.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return das Abiturfach als ID des {@link GostAbiturFach}; 0 bedeutet kein Abiturfach.
+     */
+    private getOfSchuelerOfKursAbiturfach;
+    /**
+     * Liefert das Abiturfach des Schülers im Fach des Kurses als ID des {@link GostAbiturFach}.
+     * Der Wert 0 wird als NULL interpretiert und bedeutet, dass es kein Abiturfach ist oder (noch) keine Fachwahl existiert.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return das Abiturfach als ID des {@link GostAbiturFach}; 0 bedeutet kein Abiturfach.
+     */
+    private getOfSchuelerOfKursAbiturfachOr0;
+    /**
+     * Liefert TRUE, falls der Schüler den Kurs als Abiturfach gewählt hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler den Kurs als Abiturfach gewählt hat.
+     */
+    private getOfSchuelerOfKursIstSchriftlich;
+    /**
+     * Liefert TRUE, falls der Schüler im Kurs via Regel gesperrt sein soll.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler im Kurs via Regel gesperrt sein soll.
+     */
+    getOfSchuelerOfKursIstGesperrt(idSchueler: number, idKurs: number): boolean;
+    /**
+     * Liefert TRUE, falls der Sub-String im Nachnamen oder im Vornamen des Schülers vorkommt (Groß- und Kleinschreibung wird dabei ignoriert).
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param subString   Der zu suchende Sub-String.
+     *
+     * @return TRUE, falls der Sub-String im Nachnamen oder im Vornamen des Schülers vorkommt (Groß- und Kleinschreibung wird dabei ignoriert).
+     */
+    private getOfSchuelerHatImNamenSubstring;
+    /**
+     * Liefert das {@link Geschlecht} des Schülers.<br>
+     * Wirft eine Exception, falls das Enum {@link Geschlecht} nicht definiert ist.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     *
+     * @return das {@link Geschlecht} des Schülers.
+     * @throws DeveloperNotificationException falls das Enum {@link Geschlecht} nicht definiert ist.
+     */
+    private getOfSchuelerGeschlechtOrException;
+    /**
+     * Liefert TRUE, falls der Schüler den Status {@link SchuelerStatus#EXTERN} hat.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     *
+     * @return TRUE, falls der Schüler den Status {@link SchuelerStatus#EXTERN} hat.
+     */
+    private getOfSchuelerHatStatusExtern;
+    /**
+     * Liefert die Fachwahl des Schülers passend zum Kurs.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     *
+     * @return die Fachwahl des Schülers passend zum Kurs.
+     */
+    getOfSchuelerOfKursFachwahl(idSchueler: number, idKurs: number): GostFachwahl;
+    /**
+     * Liefert die Fachwahl des Schülers passend zum Fach.
+     *
+     * @param idSchueler  Die Datenbank-ID des Schülers.
+     * @param idFach      Die Datenbank-ID des Faches.
+     *
+     * @return die Fachwahl des Schülers passend zum Fach.
+     */
+    private getOfSchuelerOfFachFachwahl;
+    /**
+     * Liefert eine nach Kriterien gefilterte Menge aller Schüler.
+     *
+     * @param  idKurs           falls >= 0, werden Schüler des Kurses herausgefiltert.
+     * @param  idFach           falls >= 0, werden Schüler mit diesem Fach herausgefiltert.
+     * @param  idKursart        falls >= 0 und idFach >= 0, werden Schüler mit dieser Fach/Kursart Kombination herausgefiltert.
+     * @param  konfliktTyp      falls 1 = mit Kollisionen, 2 = mit Nichtwahlen, 3 = mit Kollisionen und Nichtwahlen, sonst alle Schüler.
+     * @param  subString        falls |pSubString| > 0 werden Schüler deren Vor- oder Nachname diesen String enthält herausgefiltert.
+     *
+     * @return eine nach Kriterien gefilterte Menge aller Schüler.
+     */
+    getOfSchuelerMengeGefiltert(idKurs: number, idFach: number, idKursart: number, konfliktTyp: number, subString: string): List<Schueler>;
+    /**
+     * Liefert eine Liste aller Schüler, deren Abiturjahrgang nicht dem der Blockung entspricht.
+     * <br>Hinweis: Das kann passieren, wenn nach der Erstellung eines Blockungsergebnisses, ein Schüler nicht versetzt wird.
+     *
+     * @return eine Liste aller Schüler, deren Abiturjahrgang nicht dem der Blockung entspricht.
+     */
+    getOfSchuelerMengeMitAbweichendemAbijahrgang(): List<Schueler>;
+    /**
+     * Liefert eine nach den Basis-Kriterien gefilterte Menge aller Schüler.
+     *
+     * @param idKurs       falls >= 0, werden Schüler des Kurses herausgefiltert.
+     * @param idFach       falls >= 0, werden Schüler mit diesem Fach herausgefiltert.
+     * @param idKursart    falls >= 0 und idFach >= 0, werden Schüler mit dieser Fach/Kursart Kombination herausgefiltert.
+     * @param konfliktTyp  falls 1 = mit Kollisionen, 2 = mit Nichtwahlen, 3 = mit Kollisionen und Nichtwahlen, sonst alle Schüler.
+     * @param subString    falls der String nicht leer ist, werden Schüler deren Vor- oder Nachname diesen String enthält herausgefiltert.
+     * @param geschlecht   falls != null, werden nur Schüler mit diesem {@link Geschlecht} herausgefiltert.
+     *
+     * @return eine nach den Basis-Kriterien gefilterte Menge aller Schüler.
+     */
+    private getOfSchuelerMengeBasisGefiltert;
+    /**
+     * Prüft die Basis-Kriterien (Konflikt-Typ, String, Geschlecht, Kurs und Fach) für einen Schüler.
+     *
+     * @param idSchueler   Die Datenbank-ID des Schülers.
+     * @param idKurs       falls >= 0, muss der Schüler dem Kurs zugeordnet sein.
+     * @param idFach       falls >= 0, muss der Schüler dieses Fach haben.
+     * @param idKursart    falls >= 0 und idFach >= 0, muss der Schüler diese Fach/Kursart Kombination haben.
+     * @param konfliktTyp  falls 1 = mit Kollisionen, 2 = mit Nichtwahlen, 3 = mit Kollisionen und Nichtwahlen, sonst alle Schüler.
+     * @param subString    falls der String nicht leer ist, muss der Vor- oder Nachname diesen String enthalten.
+     * @param geschlecht   falls != null, muss der Schüler dieses {@link Geschlecht} haben.
+     *
+     * @return TRUE, falls der Schüler die Basis-Kriterien erfüllt.
+     */
+    private getOfSchuelerErfuelltBasisKriterien;
+    /**
+     * Liefert die Map, welche einer Schüler-ID die Menge aller ungültigen Kurse zuordnet. <br>
+     * Hinweis 1: Hat ein Schüler keine ungültige Kurse, dann gibt es die ID nicht. <br>
+     * Hinweis 2: Gibt es keine ungültigen Wahlen, so ist die Map leer. <br>
+     *
+     * @return Die Map, welche einer Schüler-ID die Menge aller ungültigen Kurse zuordnet.
+     */
+    getOfSchuelerMapIDzuUngueltigeKurse(): JavaMap<number, JavaSet<GostBlockungsergebnisKurs>>;
+    /**
+     * Liefert TRUE, falls der Schüler in einer Schiene des Kurses eine Kollision hat.<br>
+     * Die Methode geht davon aus, dass der Schüler dem Kurs zugeordnet ist.
+     *
+     * @param  idSchueler Die Datenbank-ID des Schülers.
+     * @param  idKurs     Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Schüler in einer Schiene des Kurses eine Kollision hat.
+     */
+    getOfSchuelerOfKursHatKollision(idSchueler: number, idKurs: number): boolean;
+    /**
+     * Liefert TRUE, falls beide Schüler bezogen auf das Fach gemeinsam im selben Kurs sind.
+     *
+     * @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 bezogen auf das Fach gemeinsam im selben Kurs sind.
+     */
+    getOfSchuelerIstZusammenMitSchuelerInFach(idSchueler1: number, idSchueler2: number, idFach: number): boolean;
+    /**
+     * Liefert die Anzahl an SuS, die mit dem Schüler im Kurs sein wollen.
+     *
+     * @param idS1    Die ID des {@link Schueler}-Objekts.
+     * @param idKurs  Die ID des {@link StundenplanKurs}-Objekts.
+     *
+     * @return die Anzahl an SuS, die mit dem Schüler im Kurs sein wollen.
+     */
+    getOfSchuelerOfKursAnzahlZusammenWuensche(idS1: number, idKurs: number): number;
+    /**
+     * Liefert die Anzahl an SuS, die mit dem Schüler nicht im Kurs sein sollen.
+     *
+     * @param idS1    Die ID des {@link Schueler}-Objekts.
+     * @param idKurs  Die ID des {@link StundenplanKurs}-Objekts.
+     *
+     * @return die Anzahl an SuS, die mit dem Schüler nicht im Kurs sein sollen.
+     */
+    getOfSchuelerOfKursAnzahlVerbotenWuensche(idS1: number, idKurs: number): number;
+    /**
+     * Liefert den {@link GostBlockungKurs} zur übergebenen ID.<br>
+     * Delegiert den Aufruf an das Eltern-Objekt {@link GostBlockungsdatenManager}.
+     * Wirft eine DeveloperNotificationException, falls die ID unbekannt ist.
+     *
+     * @param  idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return den {@link GostBlockungKurs} zur übergebenen ID.
+     * @throws DeveloperNotificationException falls die ID unbekannt ist.
+     */
+    getKursG(idKurs: number): GostBlockungKurs;
+    /**
+     * Liefert den {@link GostBlockungsergebnisKurs} zur übergebenen ID.<br>
+     * Wirft eine DeveloperNotificationException, falls die ID unbekannt ist.
+     *
+     * @param  idKurs Die Datenbank-ID des Kurses.
+     *
+     * @return den {@link GostBlockungsergebnisKurs} zur übergebenen ID.
+     * @throws DeveloperNotificationException falls die ID unbekannt ist.
+     */
+    getKursE(idKurs: number): GostBlockungsergebnisKurs;
+    /**
+     * Gibt die Menge der {@link GostBlockungsergebnisKurs} zurück.
+     *
+     * @return die Menge der {@link GostBlockungsergebnisKurs}
+     */
+    getKursmenge(): List<GostBlockungsergebnisKurs>;
+    /**
+     * Liefert den Namen des Kurses, erzeugt aus Fach, der Kursart und der Nummer, beispielsweise D-GK1.
+     *
+     * @param  idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return den Namen des Kurses, erzeugt aus Fach, der Kursart und der Nummer, beispielsweise D-GK1.
+     */
+    getOfKursName(idKurs: number): string;
+    /**
+     * Liefert TRUE, falls der Kurs der Schiene zugeordnet ist.
+     *
+     * @param  idKurs     Die Datenbank-ID des Kurses.
+     * @param  idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return TRUE, falls der Kurs der Schiene zugeordnet ist.
+     */
+    getOfKursOfSchieneIstZugeordnet(idKurs: number, idSchiene: number): boolean;
+    /**
+     * Liefert TRUE, falls der Kurs der Schiene mit der Nummer zugeordnet ist.
+     *
+     * @param  idKurs      Die Datenbank-ID des Kurses.
+     * @param  schienenNr  Die Nummer der Schiene
+     *
+     * @return TRUE, falls der Kurs der Schiene mit der Nummer zugeordnet ist.
+     */
+    private getOfKursOfSchienenNrIstZugeordnet;
+    /**
+     * Liefert zur Kurs-ID die zugehörige Menge aller Schüler-IDs.<br>
+     * Wirft eine Exception, falls der ID kein Kurs zugeordnet ist.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return zur Kurs-ID die zugehörige Menge aller Schüler-IDs.
+     * @throws DeveloperNotificationException falls der ID kein Kurs zugeordnet ist.
+     */
+    private getOfKursSchuelerIDmenge;
+    /**
+     * Liefert die Menge aller Schüler-Objekte des Kurses.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Menge aller Schüler-Objekte des Kurses.
+     */
+    getOfKursSchuelermenge(idKurs: number): List<Schueler>;
+    /**
+     * Liefert die Schienenmenge des Kurses.<br>
+     * Wirft eine Exception, falls der ID kein Kurs zugeordnet ist.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Schienenmenge des Kurses.
+     * @throws DeveloperNotificationException falls der ID kein Kurs zugeordnet ist.
+     */
+    getOfKursSchienenmenge(idKurs: number): JavaSet<GostBlockungsergebnisSchiene>;
+    /**
+     * Liefert ein Array aller Schienen-Nummern des Kurses.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return ein Array aller Schienen-Nummern des Kurses.
+     */
+    getOfKursSchienenNummern(idKurs: number): Array<number>;
+    /**
+     * Liefert TRUE, falls der Kurs mindestens eine Kollision hat. <br>
+     * Definition: Ein Schüler muss in einer Schiene des Kurses eine Kollision haben.
+     *
+     * @param  idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return TRUE, falls der Kurs mindestens eine Kollision hat.
+     */
+    private getOfKursHatKollision;
+    /**
+     * Liefert die Anzahl an Schülern des Kurses mit Kollisionen.<br>
+     * Kollision: Der Schüler muss in mindestens einer Schiene des Kurses eine Kollision haben.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Schülern des Kurses mit Kollisionen.
+     */
+    private getOfKursAnzahlKollisionen;
+    /**
+     * Liefert die Menge aller Schüler-IDs des Kurses mit Kollisionen (in den Schienen des Kurses).
+     *
+     * @param idKursID  Die Datenbank-ID des Kurses.
+     *
+     * @return die Menge aller Schüler-IDs des Kurses mit Kollisionen (in den Schienen des Kurses).
+     */
+    private getOfKursSchuelermengeMitKollisionen;
+    /**
+     * Liefert die Anzahl an Schülern die dem Kurs zugeordnet sind ohne Dummy SuS.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Schülern die dem Kurs zugeordnet sind ohne Dummy SuS.
+     */
+    getOfKursAnzahlSchueler(idKurs: number): number;
+    /**
+     * Liefert die Anzahl an Schülern die dem Kurs zugeordnet sind plus potentiell zugeordnete Dummy SuS.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Schülern die dem Kurs zugeordnet sind plus potentiell zugeordnete Dummy SuS.
+     */
+    getOfKursAnzahlSchuelerPlusDummy(idKurs: number): number;
+    /**
+     * Liefert die Anzahl an Dummy-SuS des Kurses. Dummy-SuS werden durch die Regel mit dem
+     * Typ {@link GostKursblockungRegelTyp#KURS_MIT_DUMMY_SUS_AUFFUELLEN} einem Kurs zugeordnet.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Dummy-SuS des Kurses.
+     */
+    getOfKursAnzahlSchuelerDummy(idKurs: number): number;
+    /**
+     * Liefert die Anzahl externer SuS die dem Kurs zugeordnet sind.
+     *
+     * @param  idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl externer SuS die dem Kurs zugeordnet sind.
+     */
+    getOfKursAnzahlSchuelerExterne(idKurs: number): number;
+    /**
+     * Liefert die Anzahl externer SuS und der Dummy-SuS die dem Kurs zugeordnet sind.
+     *
+     * @param  idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl externer SuS und der Dummy-SuS die dem Kurs zugeordnet sind.
+     */
+    getOfKursAnzahlSchuelerExternePlusDummies(idKurs: number): number;
+    /**
+     * Liefert die Anzahl internen SuS. Das sind alle SuS der Kursliste abzüglich der SuS mit Status "extern".
+     *
+     * @param  idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl internen SuS. Das sind alle SuS der Kursliste abzüglich der SuS mit Status "extern".
+     */
+    getOfKursAnzahlSchuelerInterne(idKurs: number): number;
+    /**
+     * Liefert die Anzahl aller Schüler des Kurses mit Schriftlichkeit {@link GostSchriftlichkeit#SCHRIFTLICH}.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl aller Schüler des Kurses mit Schriftlichkeit {@link GostSchriftlichkeit#SCHRIFTLICH}.
+     */
+    getOfKursAnzahlSchuelerSchriftlich(idKurs: number): number;
+    /**
+     * Liefert die Anzahl an Schienen in denen der Kurs gerade ist.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Schienen in denen der Kurs gerade ist.
+     */
+    getOfKursAnzahlSchienenIst(idKurs: number): number;
+    /**
+     * Liefert die Anzahl an Schienen, die der Kurs haben sollte.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Schienen, die der Kurs haben sollte.
+     */
+    getOfKursAnzahlSchienenSoll(idKurs: number): number;
+    /**
+     * Liefert die Anzahl an Schülern, die den Kurs mit Abiturfach 1 oder 2 gewählt (also LK) haben.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Schülern, die den Kurs mit Abiturfach 1 oder 2 gewählt (also LK) haben.
+     */
+    getOfKursAnzahlSchuelerAbiturLK(idKurs: number): number;
+    /**
+     * Liefert die Anzahl an Schülern, die den Kurs mit Abiturfach 3 gewählt haben.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Schülern, die den Kurs mit Abiturfach 3 gewählt haben.
+     */
+    getOfKursAnzahlSchuelerAbitur3(idKurs: number): number;
+    /**
+     * Liefert die Anzahl an Schülern, die den Kurs mit Abiturfach 4 gewählt haben.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @return die Anzahl an Schülern, die den Kurs mit Abiturfach 4 gewählt haben.
+     */
+    getOfKursAnzahlSchuelerAbitur4(idKurs: number): number;
+    /**
+     * Liefert die maximale Anzahl an SuS, die in dem Kurs sein dürfen, oder 999 falls es keine Begrenzung gibt.
+     *
+     * @param idKurs  Die ID des {@link StundenplanKurs}-Objekts.
+     *
+     * @return die maximale Anzahl an SuS, die in dem Kurs sein dürfen, oder 999 falls es keine Begrenzung gibt.
+     */
+    getOfKursMaxSuS(idKurs: number): number;
+    /**
+     * Liefert die Map, welche jedem Kurs seine Schülermenge zuordnet.
+     *
+     * @return Die Map, welche jedem Kurs seine Schülermenge zuordnet.
+     */
+    getMappingKursIDSchuelerIDs(): JavaMap<number, JavaSet<number>>;
+    /**
+     * Liefert die Map, welche jedem Kurs seine Schienenmenge zuordnet.
+     *
+     * @return Die Map, welche jedem Kurs seine Schienenmenge zuordnet.
+     */
+    getMappingKursIDSchienenmenge(): JavaMap<number, JavaSet<GostBlockungsergebnisSchiene>>;
+    /**
+     * Liefert die Map, welche der verletzten Regel-ID (long) die Beschreibung (String) zuordnet.
+     * <br>Hinweis: Nur verletzte Regel-IDs sind in der KEY-Menge enthalten.
+     *
+     * @return die Map, welche der verletzten Regel-ID (long) die Beschreibung (String) zuordnet.
+     */
+    regelGetMapRegelIdToVerletzungString(): JavaMap<number, string>;
+    /**
+     * Liefert einen Tooltip für alle Regelverletzungen der definierten Regeln.
+     *
+     * @return einen Tooltip für alle Regelverletzungen der definierten Regeln.
+     */
+    regelGetTooltipFuerRegelverletzungen(): string;
+    /**
+     * Liefert einen Tooltip für alle Regelverletzungen der Fächerparallelität.
+     *
+     * @return einen Tooltip für alle Regelverletzungen der Fächerparallelität.
+     */
+    regelGetTooltipFuerFaecherparallelitaet(): string;
+    /**
+     * Liefert einen Tooltip für alle Wahlkonflikte (Kollisionen und Nichtwahlen) ggf. gekürzt.
+     *
+     * @return einen Tooltip für alle Wahlkonflikte (Kollisionen und Nichtwahlen) ggf. gekürzt.
+     */
+    regelGetTooltipFuerWahlkonflikte(): string;
+    /**
+     * Liefert einen Tooltip für alle Kursdifferenzen.
+     *
+     * @return einen Tooltip für alle Kursdifferenzen.
+     */
+    regelGetTooltipFuerKursdifferenzen(): string;
+    private static regelupdateIsEqualPair;
+    private static regelupdateAppend;
+    /**
+     * Entfernt die Regel mit dem übergebenen Schlüssel aus dem Update, falls sie existiert.
+     *
+     * @param u          das Update, in dem die Regel entfernt werden soll
+     * @param parameter  der Schlüssel (Typ und Parameter) der zu entfernenden Regel
+     */
+    private regelupdateEntferneFallsVorhanden;
+    /**
+     * Fügt die Regel dem Update hinzu, falls sie noch nicht existiert.
+     *
+     * @param u      das Update, in dem die Regel hinzugefügt werden soll
+     * @param key    der Schlüssel (Typ und Parameter) der Regel
+     * @param regel  die hinzuzufügende Regel
+     */
+    private regelupdateHinzufuegenFallsNichtVorhanden;
+    /**
+     * Entfernt alle Regeln des Typs, deren erster Parameter mit param0 übereinstimmt, aus dem Update.
+     *
+     * @param u       das Update, in dem die Regeln entfernt werden sollen
+     * @param typ     der Typ der zu entfernenden Regeln
+     * @param param0  der erste Parameter, der übereinstimmen muss
+     */
+    private regelupdateEntferneAlleVonTypMitParameter0;
+    /**
+     * Entfernt alle Regeln des Typs, deren Parameterpaar (0,1) mit dem übergebenen Paar übereinstimmt, aus dem Update.
+     *
+     * @param u    das Update, in dem die Regeln entfernt werden sollen
+     * @param typ  der Typ der zu entfernenden Regeln
+     * @param id1  die erste ID des Paares
+     * @param id2  die zweite ID des Paares
+     */
+    private regelupdateEntferneAlleVonTypMitPair;
+    /**
+     * Prüft, ob ein Regel-Patch ausgeführt werden darf: Der Typ der alten Regel muss dem erwarteten Typ entsprechen und es darf noch
+     * keine Regel mit den neuen Parametern existieren. <br>
+     * Hinweis: Die Prüfung erfolgt bewusst vor der Berechnung des Create-Updates, damit z. B. bei falschem Regeltyp keine
+     * ungültigen Ziel-Parameter mehr ausgewertet werden.
+     *
+     * @param idRegelAlt    Die ID der alten zu modifizierenden Regel.
+     * @param typ           Der erwartete Typ der alten Regel.
+     * @param parameterNeu  Die Parameter der neuen Regel (Typ und Parameter).
+     *
+     * @return die alte Regel, falls der Patch ausgeführt werden darf, andernfalls NULL.
+     */
+    private regelupdatePatchByIdPruefe;
+    /**
+     * Baut das Update eines Regel-Patches zusammen: Übernimmt das Update uNeu und entfernt die alte Regel (falls nicht bereits
+     * durch Kaskaden gelöscht).
+     *
+     * @param u      Das Update, in das die Veränderungen eingetragen werden.
+     * @param rAlt   Die alte zu entfernende Regel.
+     * @param uNeu   Das Update mit den nötigen Veränderungen für die neue Regel.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt.
+     */
+    private static regelupdatePatchByIdZusammenbauen;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursart-Schienenmengen-Sperrung zu setzen.
+     * <br>(1) Wenn ein Kurs der Kursart im Schienen-Bereich liegt und gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn ein Kurs der Kursart im Schienen-Bereich liegt und fixiert ist, wird dies entfernt.
+     * <br>(3a) Wenn die Regel in falscher von/bis-Reihenfolge existiert, wird sie entfernt.
+     * <br>(3b) Wenn die Regel nicht bereits existiert, wird sie hinzugefügt.
+     *
+     * @param kursart        Die Kursart der Kurse für welche diese Regel gilt.
+     * @param schienenNrVon  Der Anfangsbereich der Schienen.
+     * @param schienenNrBis  Der Endbereich der Schienen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursart-Schienenmengen-Sperrung zu setzen.
+     */
+    regelupdateCreateKursartSperreSchienenVonBis(kursart: number, schienenNrVon: number, schienenNrBis: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kurs-Schienen-Fixierung einer Rechtecks-Auswahl zu realisieren.
+     * <br>(1) Wenn der Kurs markiert ist und eine Sperrung hat, wird die Sperrung entfernt.
+     * <br>(2) Wenn der Kurs markiert ist und keine Fixierung hat, wird eine Fixierung erzeugt.
+     * <br>(3) Fixierungen außerhalb der Kurslage werden vorsichtshalber gelöscht.
+     *
+     * @param setKursID      Die Menge aller Kurs-IDs.
+     * @param setSchienenNr  Die Menge aller markierten Schienen-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kurs-Schienen-Fixierung einer Rechtecks-Auswahl zu realisieren.
+     */
+    regelupdateCreateKursFixiereInSchieneMarkiert(setKursID: JavaSet<number>, setSchienenNr: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmenge komplett in ihrer Lage zu fixieren.
+     * <br>(1) Fixierungen innerhalb der Kurslage werden hinzugefügt, falls noch nicht existent.
+     * <br>(2) Fixierungen außerhalb der Kurslage werden gelöscht.
+     *
+     * @param setKursID  Die Kursmenge, die fixiert werden soll.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmenge komplett in ihrer Lage zu fixieren.
+     */
+    regelupdateCreateKursFixiereMengeInIhrenSchienen(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Kurse komplett in ihrer Lage zu fixieren.
+     * <br>(1) Fixierungen innerhalb der Kurslage werden hinzugefügt, falls noch nicht existend.
+     * <br>(2) Fixierungen außerhalb der Kurslage werden gelöscht.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Kurse komplett in ihrer Lage zu fixieren.
+     */
+    regelupdateCreateKursFixiereAlleInIhrenSchienen(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Toggle-Fixierung zu realisieren.
+     * <br>(1) Wenn der Kurs im Schienen-Bereich liegt und fixiert ist, wird die Fixierung gelöst.
+     * <br>(2) Wenn der Kurs im Schienen-Bereich liegt und nicht fixiert ist, wird er fixiert
+     * <br>(3) und falls dort eine Sperrung vorliegt, dann wird die Sperrung entfernt.
+     *
+     * @param setKursID      Die Menge aller Kurs-IDs.
+     * @param setSchienenNr  Die Menge aller Schienen-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Toggle-Fixierung zu realisieren.
+     */
+    regelupdateCreateKursFixiereInSchieneToggle(setKursID: JavaSet<number>, setSchienenNr: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um einen Kurs in einer Schiene zu fixieren.
+     * <br>(1) Wenn der Kurs in der Schiene eine Sperrung hat, wird diese entfernt.
+     * <br>(2) Wenn der Kurs bereits in der Schiene fixiert ist, passiert nichts weiteres.
+     * <br>(3) Wenn der Kurs bereits vollständig fixiert ist, werden seine alten Fixierungen entfernt.
+     * <br>(4) Andernfalls wird der Kurs in der Schiene fixiert.
+     *
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     * @param schienenNr  Die Nummer der Schiene, die fixiert werden soll.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um einen Kurs in einer Schiene zu fixieren.
+     */
+    regelupdateCreateKursFixiereInEinerSchiene(idKurs: number, schienenNr: number): GostBlockungRegelUpdate;
+    private regelupdateCreateKursFixiereInEinerSchieneHelper;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Sperrung zu setzen.
+     * <br>(1) Wenn der Kurs im Schienen-Bereich nicht gesperrt ist und keine Fixierung vorliegt, wird er gesperrt.
+     *
+     * @param setKursID      Die Menge aller Kurs-IDs.
+     * @param setSchienenNr  Die Menge aller Schienen-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Sperrung zu setzen.
+     */
+    regelupdateCreateKursSperreInSchiene(setKursID: JavaSet<number>, setSchienenNr: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Toggle-Sperrung zu realisieren.
+     * <br>(1) Wenn der Kurs im Schienen-Bereich liegt und gesperrt ist, wird die Sperrung gelöst.
+     * <br>(2) Wenn der Kurs im Schienen-Bereich liegt und nicht gesperrt ist und keine Fixierung vorliegt, wird er gesperrt.
+     *
+     * @param setKursID      Die Menge aller Kurs-IDs.
+     * @param setSchienenNr  Die Menge aller Schienen-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Toggle-Sperrung zu realisieren.
+     */
+    regelupdateCreateKursSperreInSchieneToggle(setKursID: JavaSet<number>, setSchienenNr: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermengen-Kursmengen-Fixierung zu setzen.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler bereits im Kurs fixiert ist, wird dies ignoriert.
+     * <br>(4) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param setSchuelerID  Die Menge der Schüler-IDs.
+     * @param setKursID      Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermengen-Kursmengen-Fixierung zu setzen.
+     */
+    regelupdateCreateSchuelerFixierenInKurs(setSchuelerID: JavaSet<number>, setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Schüler-Kurs-Fixierungen einer Kursmenge zu setzen.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler bereits im Kurs fixiert ist, wird dies ignoriert.
+     * <br>(4) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param setKursID  Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Schüler-Kurs-Fixierungen einer Kursmenge zu setzen.
+     */
+    regelupdateCreateSchuelerFixierenInDenKursen(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Schüler in ihren aktuellen Kursen zu fixieren.
+     * <br>Die Methode delegiert alles an {@link #regelupdateCreateSchuelerFixierenInKurs}.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Schüler in ihren aktuellen Kursen zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenInAllenKursen(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller LK-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller LK-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypLk(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle LK-Schüler einer Kursmenge zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param kursIDs  Die Menge der Kurse.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle LK-Schüler einer Kursmenge zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypLkDerKursmenge(kursIDs: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB3-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB3-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypAb3(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB3-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param kursIDs  Die Menge der Kurse.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB3-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypAb3DerKursmenge(kursIDs: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller LKs und AB3-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller LKs und AB3-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypLkUndAb3(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller LKs und AB3-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param kursIDs  Die Menge der Kurse.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller LKs und AB3-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypLkUndAb3DerKursmenge(kursIDs: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB4-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB4-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypAb4(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB4-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param kursIDs  Die Menge der Kurse.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB4-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypAb4DerKursmenge(kursIDs: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypAb(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB-Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param kursIDs  Die Menge der Kurse.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller AB-Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypAbDerKursmenge(kursIDs: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller schriftlichen Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller schriftlichen Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypSchriftlich(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller schriftlichen Schüler zu fixieren.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param kursIDs  Die Menge der Kurse.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Menge aller schriftlichen Schüler zu fixieren.
+     */
+    regelupdateCreateSchuelerFixierenTypSchriftlichDerKursmenge(kursIDs: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle GostBlockungRegelUpdate-Objekte für die Umsetzung einer Schüler-Kurs-Fixierung.
+     *
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param idSchueler             Die ID des Schülers.
+     * @param idKurs                 Die ID des Kurses.
+     *
+     * @return alle GostBlockungRegelUpdate-Objekte für die Umsetzung einer Menge von Schüler-Kurs-Fixierungen.
+     */
+    private regelupdateCreate04xSchuelerFixierenInKurs;
+    /**
+     * Liefert alle GostBlockungRegelUpdate-Objekte für die Umsetzung einer Menge von Schüler-Kurs-Fixierungen.
+     *
+     * <br>(0) Wenn der Schüler den Kurs nicht wählen kann, wird das Paar ignoriert.
+     * <br>(1) Wenn der Schüler im Kurs gesperrt ist, wird dies entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs fixiert ist, wird er fixiert.
+     * <br>(3) Wenn der Schüler im Nachbar-Kurs fixiert ist, wird dies entfernt.
+     *
+     * @param schuelerKursPaare      Die Menge aller Schüler-Kurs-Paare.
+     *
+     * @return alle GostBlockungRegelUpdate-Objekte für die Umsetzung einer Menge von Schüler-Kurs-Fixierungen.
+     */
+    private regelupdateCreateSchuelerFixierenInKursmenge;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermengen-Kursmengen-Sperrung zu setzen.
+     * <br>(1) Wenn der Schüler im Kurs fixiert ist, wird die Fixierung entfernt.
+     * <br>(2) Wenn der Schüler nicht im Kurs gesperrt ist, wird er gesperrt.
+     *
+     * @param setSchuelerID  Die Menge Schüler-IDs.
+     * @param setKursID      Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermengen-Kursmengen-Sperrung zu setzen.
+     */
+    regelupdateCreateSchuelerVerbietenInKurs(setSchuelerID: JavaSet<number>, setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursart-Schienenmengen-Allein-Zuordnung zu setzen.
+     * <br>(1) Alle Regeln der selben Kursart werden zunächst entfernt, da zwei solcher Regeln sich widersprechen würden.
+     * <br>(2) Wenn eine Kursart-Fixierung im falschen Bereich liegt, wird die Fixierung entfernt.
+     * <br>(3) Wenn eine Kursart-Sperrung im falschen Bereich liegt, wird die Sperrung entfernt.
+     * <br>(4) Zuletzt wird die Regel neu erzeugt und hinzugefügt.
+     *
+     * @param kursart        Die Kursart der Kurse für welche diese Regel gilt.
+     * @param schienenNrVon  Der Anfangsbereich der Schienen.
+     * @param schienenNrBis  Der Endbereich der Schienen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursart-Schienenmengen-Allein-Zuordnung zu setzen.
+     */
+    regelupdateCreateKursartAlleinInSchienenVonBis(kursart: number, schienenNrVon: number, schienenNrBis: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Kurs-Kurs-Verbote der Kursmenge (alle Paarungen) zu setzen.
+     * <br>(1) Wenn Kurs A mit Kurs B zusammen (Regel 8) sein soll, wird dies entfernt.
+     * <br>(2) Wenn die Regel bereits existiert, aber die IDs nicht aufsteigend sind, wird die (MaxKursID, MinKursID)-Kombination entfernt.
+     * <br>(3) Wenn die Regel nicht existiert, wird sie hinzugefügt.
+     *
+     * @param setKursID  Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Kurs-Kurs-Verbote der Kursmenge (alle Paarungen) zu setzen.
+     */
+    regelupdateCreateKursVerbietenMitKurs(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Kurs-Kurs-Zusammen-Gebote von setKursID (alle Paarungen) zu setzen.
+     * <br>(1) Wenn Kurs A mit Kurs B verboten (Regel 7) sein soll, wird dies entfernt.
+     * <br>(2) Wenn die Regel bereits existiert, aber die IDs nicht aufsteigend sind, wird die (MaxKursID, MinKursID)-Kombination entfernt.
+     * <br>(3) Wenn die Regel nicht existiert, wird sie hinzugefügt.
+     *
+     * @param setKursID  Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Kurs-Kurs-Zusammen-Gebote von setKursID (alle Paarungen) zu setzen.
+     */
+    regelupdateCreateKursZusammenMitKurs(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Anzahl der Dummy-Schüler eines Kurses zu setzen.
+     * <br>(1) Wenn die Regel bereits existiert, wird sie (zunächst) entfernt.
+     * <br>(2) Wenn danach die Anzahl einen Wert größer 0 hat, wird die Regel hinzugefügt.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     * @param anzahl  Die Anzahl an Dummy-Schülern.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Anzahl der Dummy-Schüler eines Kurses zu setzen.
+     */
+    regelupdateCreateKursMitDummySusAuffuellen(idKurs: number, anzahl: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um "Lehrkräfte beachten" zu aktivieren/deaktivieren.
+     * <br>(1) Wenn erstellen==FALSE und die Regel existiert, wird sie entfernt.
+     * <br>(2) Wenn erstellen==TRUE und die Regel existiert nicht, wird sie erzeugt.
+     *
+     * @param erstellen  Falls TRUE, wird die Regel aktiviert, andernfalls deaktiviert.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um "Lehrkräfte beachten" zu aktivieren/deaktivieren.
+     */
+    regelupdateCreateLehrkaefteBeachten(erstellen: boolean): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um zwei Schüler in einem Fach zusammen zu setzen.
+     * <br>(1) Wenn beide Schüler-IDs identisch sind, wird die Regel ignoriert.
+     * <br>(2) Wenn es eine Schüler-Schüler-Fach-Verbieten-Regel gibt, wird diese entfernt.
+     * <br>(3) Wenn es eine Schüler-Schüler-Verbieten-Regel gibt, wird diese entfernt.
+     * <br>(4) Wenn es eine Schüler-Schüler-Zusammen-Regel gibt, wird diese entfernt.
+     * <br>(5a) Wenn es eine Schüler-Schüler-Fach-Zusammen-Regel in falscher Schüler-ID-Reihenfolge gibt, wird sie entfernt.
+     * <br>(5b) Wenn es keine Schüler-Schüler-Fach-Zusammen-Regel gibt, wird sie hinzugefügt.
+     *
+     * @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 alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um zwei Schüler in einem Fach zusammen zu setzen.
+     */
+    regelupdateCreateSchuelerZusammenMitSchuelerInFach(idSchueler1: number, idSchueler2: number, idFach: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um zwei Schüler in einem Fach zu verbieten.
+     * <br>(1) Wenn beide Schüler-IDs identisch sind, wird die Regel ignoriert.
+     * <br>(2) Wenn es eine Schüler-Schüler-Fach-Zusammen-Regel gibt, wird diese entfernt.
+     * <br>(3) Wenn es eine Schüler-Schüler-Zusammen-Regel gibt, wird diese entfernt.
+     * <br>(4) Wenn es eine Schüler-Schüler-Verboten-Regel gibt, wird diese entfernt.
+     * <br>(5a) Wenn es eine Schüler-Schüler-Fach-Verboten-Regel in falscher Schüler-ID-Reihenfolge gibt, wird sie entfernt.
+     * <br>(5b) Wenn es keine Schüler-Schüler-Fach-Verboten-Regel gibt, wird sie hinzugefügt.
+     *
+     * @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 alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um zwei Schüler in einem Fach zu verbieten.
+     */
+    regelupdateCreateSchuelerVerbietenMitSchuelerInFach(idSchueler1: number, idSchueler2: number, idFach: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um zwei Schüler in jedem gemeinsamen Fach zusammen zu setzen.
+     * <br>(1) Wenn es eine Schüler-Schüler-Fach-Zusammen-Regel mit den selben Schülern gibt, wird diese entfernt.
+     * <br>(2) Wenn es eine Schüler-Schüler-Fach-Verbieten-Regel mit den selben Schülern gibt, wird diese entfernt.
+     * <br>(3) Wenn es eine Schüler-Schüler-Zusammen-Regel mit den selben Schülern gibt, wird diese entfernt (aber später hinzugefügt).
+     * <br>(4) Wenn es eine Schüler-Schüler-Verbieten-Regel mit den selben Schülern gibt, wird diese entfernt.
+     * <br>(5) Wenn die Schüler-IDs gültig sind, wird nun die Schüler-Schüler-Zusammen-Regel hinzugefügt.
+     *
+     * @param idSchueler1  Die Datenbank-ID des 1. Schülers.
+     * @param idSchueler2  Die Datenbank-ID des 2. Schülers.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um zwei Schüler in jedem gemeinsamen Fach zusammen zu setzen.
+     */
+    regelupdateCreateSchuelerZusammenMitSchueler(idSchueler1: number, idSchueler2: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um zwei Schüler in jedem gemeinsamen Fach zu verbieten.
+     * <br>(1) Wenn es eine Schüler-Schüler-Fach-Zusammen-Regel mit den selben Schülern gibt, wird diese entfernt.
+     * <br>(2) Wenn es eine Schüler-Schüler-Fach-Verbieten-Regel mit den selben Schülern gibt, wird diese entfernt.
+     * <br>(3) Wenn es eine Schüler-Schüler-Zusammen-Regel mit den selben Schülern gibt, wird diese entfernt.
+     * <br>(4) Wenn es eine Schüler-Schüler-Verbieten-Regel mit den selben Schülern gibt, wird diese entfernt (aber später hinzugefügt).
+     * <br>(5) Wenn die Schüler-IDs gültig sind, wird nun die Schüler-Schüler-Verbieten-Regel hinzugefügt.
+     *
+     * @param idSchueler1  Die Datenbank-ID des 1. Schülers.
+     * @param idSchueler2  Die Datenbank-ID des 2. Schülers.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um zwei Schüler in jedem gemeinsamen Fach zu verbieten.
+     */
+    regelupdateCreateSchuelerVerbietenMitSchueler(idSchueler1: number, idSchueler2: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die maximale Anzahl an Schülern eines Kurses zu setzen.
+     * <br>(1) Wenn die Regel bereits existiert, wird sie (zunächst) entfernt.
+     * <br>(2) Wenn danach die Anzahl einen Wert im Intervall [0;99] hat, wird die Regel hinzugefügt.
+     * <br>Hinweis: Dummy-SuS sind in der maximalen Schüleranzahl inklusive.
+     *
+     * @param idKurs  Die Datenbank-ID des Kurses.
+     * @param anzahl  Die maximale Anzahl an SuS des Kurses.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die maximale Anzahl an Schülern eines Kurses zu setzen.
+     */
+    regelupdateCreateKursMaximaleSchueleranzahl(idKurs: number, anzahl: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermenge beim Blocken zu ignorieren.
+     * <br>(1) Wenn diese Regel nicht existiert, wird sie hinzugefügt.
+     *
+     * @param setSchuelerID  Die Menge der Schüler-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermenge beim Blocken zu ignorieren.
+     */
+    regelupdateCreateSchuelerIgnorieren(setSchuelerID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmenge von Kursdifferenz-Berechnungen auszuschließen.
+     * <br>(1) Wenn diese Regel nicht existiert, wird sie hinzugefügt.
+     *
+     * @param setKursID  Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmenge von Kursdifferenz-Berechnungen auszuschließen.
+     */
+    regelupdateCreateKursKursdifferenzBeiDerVisualisierungIgnorieren(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die maximale Anzahl an Kursen einer bestimmten Fachart (in jeder Schiene) zu begrenzen.
+     * <br>(1) Falls die Regel bereits existiert, wird sie zunächst entfernt.
+     * <br>(2) Falls der "maximal"-Wert 1 ist und es Regeln KURS_VERBIETEN_MIT_KURS bei Paaren dieser Fachart gibt, werden die Regeln entfernt.
+     * <br>(3) Zuletzt wird die neue Regel hinzugefügt.
+     *
+     * @param idFach     Die Datenbank-ID des Faches.
+     * @param idKursart  Die ID der Kursart.
+     * @param maximal    Die maximale Kursanzahl dieser Fachart (in jeder Schiene). Gültige Werte sind 1 bis 9.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die maximale Anzahl an Kursen einer bestimmten Fachart (in jeder Schiene) zu begrenzen.
+     */
+    regelupdateCreateFachKursartMaximaleAnzahlProSchiene(idFach: number, idKursart: number, maximal: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermengen-Kursmengen-Definition zu setzen.
+     * <br>Es werden alle Kombinationen (Kreuzprodukt) aus der Schülermenge und der Kursmenge hinzugefügt.
+     * <br>(1) Wenn eine Kombination noch nicht als Definition existiert, wird sie hinzugefügt.
+     *
+     * @param setSchuelerID  Die Menge der Schüler-IDs.
+     * @param setKursID      Die Menge der Kurs-IDs.
+     * @param abiturfach     Das Abiturfach als ID des {@link GostAbiturFach}; 0 wird als NULL interpretiert (kein Abiturfach).
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermengen-Kursmengen-Definition zu setzen.
+     */
+    regelupdateCreateSchuelerWarImKurs(setSchuelerID: JavaSet<number>, setKursID: JavaSet<number>, abiturfach: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um für die aktuellen
+     * Schüler-Kurs-Zuordnungen der übergebenen Kursmenge die Definition "Schüler war im Kurs" zu setzen.
+     * <br>(1) Wenn eine Zuordnung noch nicht als Definition existiert, wird sie hinzugefügt.
+     * <br>Hinweis: Als Abiturfach (Parameter C) wird das aktuelle Abiturfach des Schülers im Fach des Kurses übernommen (0, falls keines).
+     *
+     * @param setKursID  Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um für die aktuellen
+     *         Schüler-Kurs-Zuordnungen der übergebenen Kursmenge die Definition "Schüler war im Kurs" zu setzen.
+     */
+    regelupdateCreateSchuelerWarImKursInDenKursen(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um für alle aktuellen
+     * Schüler-Kurs-Zuordnungen die Definition "Schüler war im Kurs" zu setzen.
+     * <br>Die Methode delegiert alles an {@link #regelupdateCreateSchuelerWarImKursInDenKursen}.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um für alle aktuellen
+     *         Schüler-Kurs-Zuordnungen die Definition "Schüler war im Kurs" zu setzen.
+     */
+    regelupdateCreateSchuelerWarImKursAusAktuellerZuordnung(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Regeln einer Schülermenge zu entfernen.
+     *
+     * @param setSchuelerID  Die Menge der Schüler-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Regeln einer Schülermenge zu entfernen.
+     */
+    regelupdateCreateSchuelermengeEntfernen(setSchuelerID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt     Die ID der alten zu modifizierenden Regel.
+     * @param kursart        Die Kursart der Kurse für welche diese Regel gilt.
+     * @param schienenNrVon  Der Anfangsbereich der Schienen.
+     * @param schienenNrBis  Der Endbereich der Schienen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdKursartSperreSchienenVonBis(idRegelAlt: number, kursart: number, schienenNrVon: number, schienenNrBis: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     * @param schienenNr  Die Nummer der Schiene, die fixiert werden soll.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdKursFixiereInEinerSchiene(idRegelAlt: number, idKurs: number, schienenNr: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt     Die ID der alten zu modifizierenden Regel.
+     * @param idKurs         Die ID des Kurses.
+     * @param schienenNr     Die Nummer der Schiene.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdKursSperreInSchiene(idRegelAlt: number, idKurs: number, schienenNr: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Wenn der Ziel-Kurs für den Schüler nicht wählbar ist (fehlende Fachwahl), bleibt das Update leer und die alte
+     * Fixierung erhalten.
+     * <br>(4) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idSchueler  Die ID des Schülers.
+     * @param idKurs      Die ID des Kurses.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     *         Das Update kann leer sein, falls der Patch nicht ausgeführt wird (siehe (2) und (3)).
+     */
+    regelupdatePatchByIdSchuelerFixierenInKurs(idRegelAlt: number, idSchueler: number, idKurs: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idSchueler  Die ID des Schülers.
+     * @param idKurs      Die ID des Kurses.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdSchuelerVerbietenInKurs(idRegelAlt: number, idSchueler: number, idKurs: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt     Die ID der alten zu modifizierenden Regel.
+     * @param kursart        Die Kursart der Kurse für welche diese Regel gilt.
+     * @param schienenNrVon  Der Anfangsbereich der Schienen.
+     * @param schienenNrBis  Der Endbereich der Schienen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdKursartAlleinInSchienenVonBis(idRegelAlt: number, kursart: number, schienenNrVon: number, schienenNrBis: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idKurs1     Die ID des 1. Kurses.
+     * @param idKurs2     Die ID des 2. Kurses.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdKursVerbietenMitKurs(idRegelAlt: number, idKurs1: number, idKurs2: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idKurs1     Die ID des 1. Kurses.
+     * @param idKurs2     Die ID des 2. Kurses.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdKursZusammenMitKurs(idRegelAlt: number, idKurs1: number, idKurs2: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idKurs      Die ID des Kurses.
+     * @param anzahl      Die Anzahl an Dummy-SuS des Kurses.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdKursMitDummySusAuffuellen(idRegelAlt: number, idKurs: number, anzahl: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @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 alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdSchuelerZusammenMitSchuelerInFach(idRegelAlt: number, idSchueler1: number, idSchueler2: number, idFach: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @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 alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdSchuelerVerbietenMitSchuelerInFach(idRegelAlt: number, idSchueler1: number, idSchueler2: number, idFach: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idSchueler1  Die Datenbank-ID des 1. Schülers.
+     * @param idSchueler2  Die Datenbank-ID des 2. Schülers.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdSchuelerZusammenMitSchueler(idRegelAlt: number, idSchueler1: number, idSchueler2: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idSchueler1  Die Datenbank-ID des 1. Schülers.
+     * @param idSchueler2  Die Datenbank-ID des 2. Schülers.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdSchuelerVerbietenMitSchueler(idRegelAlt: number, idSchueler1: number, idSchueler2: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idKurs      Die ID des Kurses.
+     * @param anzahl      Die maximale Anzahl der SuS des Kurses.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdKursMaximaleSchueleranzahl(idRegelAlt: number, idKurs: number, anzahl: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     * <br>(1) Wenn die alte Regel nicht gefunden wird, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn eine Regel mit genau den selben Parametern bereits existiert, passiert nichts.
+     * <br>(3) Andernfalls wird die alte Regel entfernt und eine neue Regel hinzugefügt.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idSchueler  Die ID des Schülers.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     */
+    regelupdatePatchByIdSchuelerIgnorieren(idRegelAlt: number, idSchueler: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Regel von einem zu einem anderen Kurs zu patchen.
+     *
+     * <br>(1) Wenn die alte Regel nicht existiert, wird eine {@link DeveloperNotificationException} geworfen.
+     * <br>(2) Wenn die neue Kurs-ID bereits existiert, passiert nichts.
+     * <br>(3) Wenn die alte Kurs-ID der neuen Kurs-ID gleicht, passiert nichts.
+     * <br>(4) Andernfalls wird die alte Regel gelöscht (idKursAlt) und eine neue Regel wird erzeugt (idKursNeu).
+     *
+     * @param idRegelAlt  Die Regel, die modifiziert wird.
+     * @param idKursNeu   Die neue Kurs-ID deren Regel hinzugefügt werden soll.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um die Regel von einem zu einem anderen Kurs zu patchen.
+     */
+    regelupdatePatchByIdKursKursdifferenzBeiDerVisualisierungIgnorieren(idRegelAlt: number, idKursNeu: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     *
+     * @param idRegelAlt  Die ID der alten zu modifizierenden Regel.
+     * @param idSchueler  Die ID des Schülers.
+     * @param idKurs      Die ID des Kurses.
+     * @param abiturfach  Das Abiturfach als ID des {@link GostAbiturFach}; 0 wird als NULL interpretiert (kein Abiturfach).
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Regel dieses Typs zu patchen.
+     *         Das Update kann leer sein, falls der Patch nicht ausgeführt wird (siehe (1)).
+     */
+    regelupdatePatchByIdSchuelerWarImKurs(idRegelAlt: number, idSchueler: number, idKurs: number, abiturfach: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Fixierung zu lösen.
+     * <br>(1) Wenn der Kurs im Schienen-Bereich liegt und bereits fixiert ist, wird die Fixierung entfernt.
+     *
+     * @param setKursID      Die Menge aller Kurs-IDs.
+     * @param setSchienenNr  Die Menge aller Schienen-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Fixierung zu lösen.
+     */
+    regelupdateRemoveKursFixiereInSchieneMarkiert(setKursID: JavaSet<number>, setSchienenNr: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Fixierung einer Kursmenge komplett zu lösen.
+     * <br>(1) Alle Fixierungen der Kursmenge werden gelöst.
+     *
+     * @param setKursID  Die Kursmenge, deren Fixierungen gelöst werden sollen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Fixierung einer Kursmenge komplett zu lösen.
+     */
+    regelupdateRemoveKursFixiereMengeInIhrenSchienen(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Kurs-Schienen-Fixierungen zu lösen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Kurs-Schienen-Fixierungen zu lösen.
+     */
+    regelupdateRemoveKursFixiereAlleInIhrenSchienen(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kurs-Schienen-Fixierung zu lösen.
+     * <br>(1) Wenn der Kurs in der Schiene fixiert ist, wird die Fixierung entfernt.
+     *
+     * @param idKurs      Die Datenbank-ID des Kurses.
+     * @param schienenNr  Die Nummer der Schiene, die gelöst werden soll.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kurs-Schienen-Fixierung zu lösen.
+     */
+    regelupdateRemoveKursFixiereInEinerSchiene(idKurs: number, schienenNr: number): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Sperrung zu lösen.
+     * <br>(1) Wenn der Kurs in dem Schienen-Bereich gesperrt ist, wird die Sperrung entfernt.
+     *
+     * @param setKursID      Die Menge aller Kurs-IDs.
+     * @param setSchienenNr  Die Menge aller Schienen-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Kursmengen-Schienemengen-Sperrung zu lösen.
+     */
+    regelupdateRemoveKursSperreInSchiene(setKursID: JavaSet<number>, setSchienenNr: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermengen-Kursmengen-Fixierung zu lösen.
+     * <br>(1) Wenn der Schüler im Kurs fixiert ist, wird die Fixierung entfernt.
+     *
+     * @param setSchuelerID  Die Menge der Schüler-IDs.
+     * @param setKursID      Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um eine Schülermengen-Kursmengen-Fixierung zu lösen.
+     */
+    regelupdateRemoveSchuelerFixierenInKurs(setSchuelerID: JavaSet<number>, setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Schüler-Kurs-Fixierungen einer Kursmenge zu lösen.
+     * <br>(1) Wenn der Schüler im Kurs fixiert ist, wird die Fixierung entfernt.
+     *
+     * @param setKursID  Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Schüler-Kurs-Fixierungen einer Kursmenge zu lösen.
+     */
+    regelupdateRemoveSchuelerFixierenInDenKursen(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Schüler-Kurs-Fixierungen zu lösen.
+     * <br>Es werden alle Regeln des Typs {@link GostKursblockungRegelTyp#SCHUELER_FIXIEREN_IN_KURS} entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Schüler-Kurs-Fixierungen zu lösen.
+     */
+    regelupdateRemoveSchuelerFixierenInAllenKursen(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Definitionen "Schüler war im Kurs"
+     * der übergebenen Kursmenge zu entfernen.
+     * <br>Es werden alle Regeln des Typs {@link GostKursblockungRegelTyp#SCHUELER_WAR_IM_KURS} entfernt, deren Kurs in der Kursmenge enthalten ist.
+     *
+     * @param setKursID  Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Definitionen "Schüler war im Kurs"
+     *         der übergebenen Kursmenge zu entfernen.
+     */
+    regelupdateRemoveSchuelerWarImKursInDenKursen(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Definitionen "Schüler war im Kurs" zu entfernen.
+     * <br>Es werden alle Regeln des Typs {@link GostKursblockungRegelTyp#SCHUELER_WAR_IM_KURS} entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um alle Definitionen "Schüler war im Kurs" zu entfernen.
+     */
+    regelupdateRemoveSchuelerWarImKursAlle(): GostBlockungRegelUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um ein Schüler-Kurs-Fixierung-Toggle zu realisieren.
+     * <br>(1) Wenn der Schüler im Kurs fixiert ist, wird die Fixierung entfernt.
+     * <br>(2) Wenn der Schüler im Kurs nicht fixiert ist, wird die Fixierung gesetzt.
+     * <br>(3) Potentielle Fixierungen in Nachbar-Kursen werden entfernt, da sie in jedem Fall falsch sind.
+     *
+     * @param setKursID  Die Menge der Kurs-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungRegelUpdate}-Objekt, um ein Schüler-Kurs-Fixierung-Toggle zu realisieren.
+     */
+    regelupdateRemoveSchuelerFixierenInDenKursenToggle(setKursID: JavaSet<number>): GostBlockungRegelUpdate;
+    /**
+     * Entfernt erst alle Regeln aus {@link GostBlockungRegelUpdate#listEntfernen} und
+     * fügt dann die neuen Regeln aus {@link GostBlockungRegelUpdate#listHinzuzufuegen} hinzu.
+     *
+     * @param update  Das {@link GostBlockungRegelUpdate}-Objekt.
+     */
+    regelupdateExecute(update: GostBlockungRegelUpdate): void;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um alle Schüler aus den derzeit zugeordneten Kursen zu entfernen.
+     * <br>(1) Wenn ein Schüler in einem Kurs ist und nicht fixiert ist, wird er entfernt.
+     * <br>(2) Wenn ein Schüler in einem Kurs ist und fixiert ist, wird er entfernt, falls entferneAuchFixierte==TRUE ist.
+     *
+     * @param entferneAuchFixierte  Falls TRUE, werden auch fixiert SuS entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um alle Schüler aus den derzeit zugeordneten Kursen zu entfernen.
+     */
+    kursSchuelerUpdateLeereAlleKurse(entferneAuchFixierte: boolean): GostBlockungsergebnisKursSchuelerZuordnungUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um alle Schüler aus der übergebenen Kursmenge zu entfernen.
+     * <br>(1) Wenn ein Schüler in einem Kurs ist und nicht fixiert ist, wird er entfernt.
+     * <br>(2) Wenn ein Schüler in einem Kurs ist und fixiert ist, wird er entfernt, falls entferneAuchFixierte==TRUE ist.
+     *
+     * @param kursIDs               Die Menge der Kurse.
+     * @param entferneAuchFixierte  Falls TRUE, werden auch fixiert SuS entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um alle Schüler aus der übergebenen Kursmenge zu entfernen.
+     */
+    kursSchuelerUpdateLeereKursmenge(kursIDs: JavaSet<number>, entferneAuchFixierte: boolean): GostBlockungsergebnisKursSchuelerZuordnungUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um eine Schülermenge aus einem Kurs zu entfernen.
+     * <br>(1) Wenn der Schüler dem Kurs zugeordnet ist und nicht fixiert ist, wird er entfernt.
+     * <br>(2) Wenn der Schüler dem Kurs zugeordnet ist und fixiert ist, wird er entfernt, falls entferneAuchFixierte==TRUE ist. Auch die Fixierungs-Regel wird entfernt.
+     * <br>Hinweis: Ungültige Zuordnungen (ohne passende Fachwahl) werden wie normale Zuordnungen entfernt.
+     *
+     * @param schuelerIDs           Die Menge der Schüler-IDs.
+     * @param idKurs                Die Datenbank-ID des Kurses aus dem die Schüler entfernt werden sollen.
+     * @param entferneAuchFixierte  Falls TRUE, werden auch fixiert SuS entfernt.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um eine Schülermenge aus einem Kurs zu entfernen.
+     */
+    kursSchuelerUpdateEntferneSchuelermengeAusKurs(schuelerIDs: JavaSet<number>, idKurs: number, entferneAuchFixierte: boolean): GostBlockungsergebnisKursSchuelerZuordnungUpdate;
+    /**
+     * Verarbeitet einen einzelnen Schüler der Methode {@link #kursSchuelerUpdateEntferneSchuelermengeAusKurs}.
+     * <br>(1) Wenn der Schüler dem Kurs zugeordnet ist und nicht fixiert ist, wird er entfernt.
+     * <br>(2) Wenn der Schüler dem Kurs zugeordnet ist und fixiert ist, wird er entfernt, falls entferneAuchFixierte==TRUE ist. Auch die Fixierungs-Regel wird entfernt.
+     *
+     * @param u                    das Update, in das die Veränderungen eingetragen werden
+     * @param idSchueler           die Datenbank-ID des Schülers
+     * @param idKurs               die Datenbank-ID des Kurses aus dem die Schüler entfernt werden sollen
+     * @param setSchulerOfKurs     die Menge der Schüler-IDs des Kurses
+     * @param entferneAuchFixierte  Falls TRUE, werden auch fixiert SuS entfernt.
+     */
+    private kursSchuelerUpdateEntferneSchuelermengeAusKursVerarbeite;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um eine Schülermenge aus allen Kursen entfernen.
+     * <br>Hinweis: Es werden keine Kurs-Fixierungs-Regeln entfernt. Dafür muss die zugehörige regelupdate-Methode aufgerufen werden.
+     *
+     * @param schuelerIDs  Die Menge der Schüler-IDs.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um eine Schülermenge aus allen Kursen entfernen.
+     */
+    kursSchuelerUpdateEntferneSchuelermengeAusAllenKursen(schuelerIDs: JavaSet<number>): GostBlockungsergebnisKursSchuelerZuordnungUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um Schüler auf Kurse zu verteilen.
+     * <br>(1) Wenn der Schüler nicht im Kurs ist, wird er hinzugefügt.
+     * <br>(2) Wenn der Schüler in einem Nachbar-Kurs ist, wird er entfernt.
+     *
+     * <br>Hinweis: Wenn der Schüler den Kurs gar nicht gewählt hat, wird dies trotzdem erlaubt. Denn bei einer Umwahl, kann eine Kurszuordnung ungültig sein!
+     *
+     * @param kursSchuelerZuordnungen  Alle Kurs-Schüler-Paare, welche hinzugefügt werden sollen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um Schüler auf Kurse zu verteilen.
+     */
+    kursSchuelerUpdateFuegeKursSchuelerPaareHinzu(kursSchuelerZuordnungen: JavaSet<GostBlockungsergebnisKursSchuelerZuordnung>): GostBlockungsergebnisKursSchuelerZuordnungUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um Schüler auf Kurse zu verteilen mit Nebenbedingungen.
+     * <br>(1) Wenn der Schüler den Ziel-Kurs nicht wählen darf (falsche Fachwahlen), dann passiert nichts.
+     * <br>(2) Wenn der Schüler aus einem fixierten Kurs verschoben werden soll, dies aber nicht erlaubt ist, dann passiert nichts.
+     * <br>(3) Der Schüler ggf. aus einem alten Kurs entfernt und die Fixier-Regel des alten Kurses wird ggf. entfernt.
+     * <br>(4) Der Schüler wird einem neuen Kurs hinzugefügt und wird ggf. im neuen Kurs fixiert.
+     *
+     * @param kursSchuelerZuordnungen           Alle Kurs-Schüler-Paare, welche hinzugefügt werden sollen.
+     * @param verschiebeFixierteDesQuellkurses  TRUE, dann werden fixierte SuS aus potentiell alten Kursen entfernt.
+     * @param fixiereImZielkurs                 TRUE, dann werden die SuS im Zielkurs fixiert.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um Schüler auf Kurse zu verteilen mit Nebenbedingungen.
+     */
+    private kursSchuelerUpdate03aVerschiebeSchuelerZuKursen;
+    /**
+     * Verarbeitet eine einzelne Kurs-Schüler-Zuordnung der Methode {@link #kursSchuelerUpdate03aVerschiebeSchuelerZuKursen}.
+     * <br>(1) Wenn der Schüler den Ziel-Kurs nicht wählen darf (falsche Fachwahlen), dann passiert nichts.
+     * <br>(2) Wenn der Schüler aus einem fixierten Kurs verschoben werden soll, dies aber nicht erlaubt ist, dann passiert nichts.
+     * <br>(3) Der Schüler ggf. aus einem alten Kurs entfernt und die Fixier-Regel des alten Kurses wird ggf. entfernt.
+     * <br>(4) Der Schüler wird einem neuen Kurs hinzugefügt und wird ggf. im neuen Kurs fixiert.
+     *
+     * @param u                                 das Update, in das die Veränderungen eingetragen werden
+     * @param z                                 die zu verarbeitende Kurs-Schüler-Zuordnung
+     * @param verschiebeFixierteDesQuellkurses  TRUE, dann werden fixierte SuS aus potentiell alten Kursen entfernt.
+     * @param fixiereImZielkurs                 TRUE, dann werden die SuS im Zielkurs fixiert.
+     */
+    private kursSchuelerUpdate03aVerschiebeSchuelerZuKursenVerarbeite;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um Schüler aus Kursen zu entfernen.
+     * <br>(1) Wenn der Schüler im Kurs ist, wird er entfernt.
+     * <br>(2) Falls es Schüler-Kurs-Fixierungen gibt, werden diese entfernt.
+     *
+     * @param kursSchuelerZuordnungen  Alle Kurs-Schüler-Paare, welche entfernt werden sollen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um Schüler aus Kursen zu entfernen.
+     */
+    kursSchuelerUpdateEntferneKursSchuelerPaare(kursSchuelerZuordnungen: JavaSet<GostBlockungsergebnisKursSchuelerZuordnung>): GostBlockungsergebnisKursSchuelerZuordnungUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um Schüler-Kerngruppe auf mehrere Kurse zu verteilen.
+     * <br>(1) Die SuS werden entsprechende der Methode {@link #kursSchuelerUpdate03aVerschiebeSchuelerZuKursen} verschoben.
+     * <br>(2) Falls "zielKurseLeeren", werden alle SuS aus dem Ziel-Kurs entfernt, die nicht zur Kerngruppe gehören.
+     *
+     * @param idQuellKurs                       Der Quell-Kurs definiert die Kerngruppe.
+     * @param idZielKurse                       Alle Ziel-Kurs-Schülermengen werden der Kerngruppe angeglichen.
+     * @param verschiebeFixierteDesQuellkurses  Falls TRUE, dann werden Fixierungen im Quell-Kurs gelöst, andernfalls wird der Schüler nicht verschoben.
+     * @param inZielKursenFixieren              Falls TRUE, wird nach der Verschiebung der Schüler im Ziel-Kurs fixiert.
+     * @param zielKurseLeeren                   Falls TRUE, werden alle SuS aus dem Ziel-Kurs entfernt, die nicht zur Kerngruppe gehören.
+     *
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt, um Schüler auf Kurse zu verteilen mit Nebenbedingungen.
+     */
+    kursSchuelerUpdateBildeKerngruppen(idQuellKurs: number, idZielKurse: JavaSet<number>, verschiebeFixierteDesQuellkurses: boolean, inZielKursenFixieren: boolean, zielKurseLeeren: boolean): GostBlockungsergebnisKursSchuelerZuordnungUpdate;
+    /**
+     * Entfernt erst alle Regeln aus {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate#listEntfernen} und
+     * fügt dann die neuen Regeln aus {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate#listHinzuzufuegen} hinzu.
+     * Macht das selbe für die potentiell enthaltenen RegelUpdates.
+     *
+     * @param update  Das {@link GostBlockungsergebnisKursSchuelerZuordnungUpdate}-Objekt.
+     */
+    kursSchuelerUpdateExecute(update: GostBlockungsergebnisKursSchuelerZuordnungUpdate): void;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchienenZuordnungUpdate}-Objekt, um Kurse in Schienen zu setzen.
+     * <br>(1) Wenn der Kurs nicht in der Schiene ist, wird er hinzugefügt.
+     *
+     * @param kursSchienenZuordnungen  Alle Kurs-Schienen-Paare, welche gesetzt werden sollen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchienenZuordnungUpdate}-Objekt, um Kurse in Schienen zu setzen.
+     */
+    kursSchienenUpdateFuegeKursSchienenPaareHinzu(kursSchienenZuordnungen: JavaSet<GostBlockungsergebnisKursSchienenZuordnung>): GostBlockungsergebnisKursSchienenZuordnungUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchienenZuordnungUpdate}-Objekt, um Kurse aus Schienen zu entfernen.
+     * <br>(1) Wenn der Kurs in der Schiene ist, wird er entfernt.
+     *
+     * @param kursSchienenZuordnungen  Alle Kurs-Schienen-Paare, welche entfernt werden sollen.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchienenZuordnungUpdate}-Objekt, um Kurse aus Schienen zu entfernen.
+     */
+    kursSchienenUpdateEntferneKursSchienenPaare(kursSchienenZuordnungen: JavaSet<GostBlockungsergebnisKursSchienenZuordnung>): GostBlockungsergebnisKursSchienenZuordnungUpdate;
+    /**
+     * Liefert alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchienenZuordnungUpdate}-Objekt, um einen Kurs von einer Schiene zu einer anderen Schiene zu verschieben.
+     *
+     * <br>(1) Wenn der Kurs nicht in der Quell-Schiene ist, passiert nichts.
+     * <br>(2) Wenn der Kurs bereits in der Ziel-Schiene ist, passiert nichts.
+     * <br>(3) Andernfalls, wird der Kurs aus der Quell-Schiene entfernt und der Ziel-Schiene hinzugefügt.
+     *
+     *
+     * @param idKurs           Die Datenbank-ID des Kurses.
+     * @param idSchieneQuelle  Die Quell-Schiene, aus der der Kurs entfernt wird.
+     * @param idSchieneZiel    Die Ziel-Schiene, zu welcher der Kurs hinzugefügt wird.
+     *
+     * @return alle nötigen Veränderungen als {@link GostBlockungsergebnisKursSchienenZuordnungUpdate}-Objekt, um einen Kurs von einer Schiene zu einer anderen Schiene zu verschieben.
+     */
+    kursSchienenUpdateVerschiebeKursVonSchieneNachSchiene(idKurs: number, idSchieneQuelle: number, idSchieneZiel: number): GostBlockungsergebnisKursSchienenZuordnungUpdate;
+    /**
+     * Entfernt erst alle Regeln aus {@link GostBlockungsergebnisKursSchienenZuordnungUpdate#listEntfernen} und
+     * fügt dann die neuen Regeln aus {@link GostBlockungsergebnisKursSchienenZuordnungUpdate#listHinzuzufuegen} hinzu.
+     * Macht das selbe für die potentiell enthaltenen RegelUpdates.
+     *
+     * @param update  Das {@link GostBlockungsergebnisKursSchienenZuordnungUpdate}-Objekt.
+     */
+    kursSchienenUpdateExecute(update: GostBlockungsergebnisKursSchienenZuordnungUpdate): void;
+    /**
+     * Liefert das zur ID zugehörige {@link GostBlockungSchiene}-Objekt.<br>
+     * Delegiert den Aufruf an den Fächer-Manager des Eltern-Objektes {@link GostBlockungsdatenManager}.<br>
+     * Wirft eine DeveloperNotificationException, falls die ID unbekannt ist.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return das zur ID zugehörige {@link GostBlockungSchiene}-Objekt.
+     * @throws DeveloperNotificationException falls die ID unbekannt ist.
+     */
+    getSchieneG(idSchiene: number): GostBlockungSchiene;
+    /**
+     * Liefert das zur ID zugehörige {@link GostBlockungsergebnisSchiene}-Objekt.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return das zur ID zugehörige {@link GostBlockungsergebnisSchiene}-Objekt.
+     * @throws DeveloperNotificationException falls die Schiene nicht existiert.
+     */
+    private getSchieneE;
+    /**
+     * Liefert TRUE, falls die Schiene keine Kurse enthält.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return TRUE, falls die Schiene keine Kurse enthält.
+     * @throws DeveloperNotificationException falls die Schiene nicht existiert.
+     */
+    getOfSchieneIstLeer(idSchiene: number): boolean;
+    /**
+     * Liefert das zur Nummer zugehörige {@link GostBlockungsergebnisSchiene}-Objekt.<br>
+     * Wirft eine {@link DeveloperNotificationException} falls eine solche Schiene nicht existiert.
+     *
+     * @param nrSchiene Die Nummer der Schiene.
+     *
+     * @return das zur Nummer zugehörige {@link GostBlockungsergebnisSchiene}-Objekt.
+     * @throws DeveloperNotificationException falls eine solche Schiene nicht existiert.
+     */
+    private getSchieneEmitNr;
+    /**
+     * Liefert die ID einer Schiene mit einer bestimmten Nummer.
+     *
+     * @param nrSchiene  Die Nummer der Schiene.
+     *
+     * @return die ID einer Schiene mit einer bestimmten Nummer.
+     * @throws DeveloperNotificationException falls eine solche Schiene nicht existiert.
+     */
+    getOfSchieneID(nrSchiene: number): number;
+    /**
+     * Liefert die Menge aller Schienen.
+     *
+     * @return Die Menge aller Schienen.
+     */
+    getMengeAllerSchienen(): List<GostBlockungsergebnisSchiene>;
+    /**
+     * Liefert TRUE, falls die E-Schiene existiert.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     * @return TRUE, falls die E-Schiene existiert.
+     */
+    getOfSchieneExists(idSchiene: number): boolean;
+    /**
+     * Liefert die Anzahl an Schülern in der Schiene mit der übergebenen ID zurück.<br>
+     * Hinweis: Falls ein Schüler mehrfach in der Schiene ist (Kollision), wird er mehrfach gezählt!
+     *
+     * @param idSchiene Die Datenbank-ID der Schiene.
+     *
+     * @return die Anzahl an Schülern in der Schiene mit der übergebenen ID zurück.
+     */
+    getOfSchieneAnzahlSchueler(idSchiene: number): number;
+    /**
+     * Liefert TRUE, falls die Schiene mindestens eine Schüler-Kollision hat.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return TRUE, falls die Schiene mindestens eine Schüler-Kollision hat.
+     */
+    getOfSchieneHatKollision(idSchiene: number): boolean;
+    /**
+     * Liefert die Anzahl an Schüler-Kollisionen der Schiene.<br>
+     * Hinweis: Ein Schüler, der N>1 Mal in einer Schiene ist, erzeugt N-1 Kollisionen.
+     *
+     * @param idSchiene Die Datenbank-ID der Schiene.
+     *
+     * @return die Anzahl an Schüler-Kollisionen der Schiene.
+     */
+    getOfSchieneAnzahlSchuelerMitKollisionen(idSchiene: number): number;
+    /**
+     * Liefert die Menge an Schüler-IDs, die in der Schiene eine Kollision haben.
+     *
+     * @param idSchiene Die Datenbank-ID der Schiene.
+     *
+     * @return Die Menge an Schüler-IDs, die in der Schiene eine Kollision haben.
+     */
+    getOfSchieneSchuelermengeMitKollisionen(idSchiene: number): JavaSet<number>;
+    /**
+     * Liefert die Menge an Kursen, die in der Schiene eine Kollision haben.
+     *
+     * @param idSchiene Die Datenbank-ID der Schiene.
+     *
+     * @return die Menge an Kursen, die in der Schiene eine Kollision haben.
+     */
+    getOfSchieneKursmengeMitKollisionen(idSchiene: number): JavaSet<GostBlockungsergebnisKurs>;
+    /**
+     * Liefert die sortierte Menge an Kursen einer bestimmten Schiene.
+     *
+     * @param idSchiene Die Datenbank-ID der Schiene.
+     *
+     * @return die sortierte Menge an Kursen einer bestimmten Schiene.
+     */
+    getOfSchieneKursmengeSortiert(idSchiene: number): List<GostBlockungsergebnisKurs>;
+    /**
+     * Liefert alle Kollisionen einer Schiene, als Liste von Liste von Kurs-Anzahl-Paaren.
+     * <br>Pro innerer Liste gilt: Das erste Paar ist der Kurs, welcher mit allen anderen verglichen wurde, zusammen mit der Kollisions-Summe.
+     * <br>Anschließend folgen alle anderen Kurse mit ihrer Kollisions-Anzahl, falls diese größer 0 ist.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return alle Kollisionen einer Schiene, als Liste von Liste von Kurs-Anzahl-Paaren.
+     */
+    getOfSchieneTooltipKurskollisionenAsData(idSchiene: number): List<List<Pair<GostBlockungsergebnisKurs, number>>>;
+    /**
+     * Liefert alle Kollisionen einer Schiene (pro Element ein Schüler).
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return alle Kollisionen einer Schiene (pro Element ein Schüler).
+     */
+    getOfSchieneTooltipSchuelerkollisionen(idSchiene: number): string;
+    private static getOfKursOfKursAnzahlGemeinsamerSchueler;
+    /**
+     * Liefert TRUE, falls ein Löschen der Schiene erlaubt ist.<br>
+     * Kriterium: Es dürfen keine Kurse der Schiene zugeordnet sein.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return TRUE, falls ein Löschen der Schiene erlaubt ist.
+     * @throws DeveloperNotificationException Falls die Schiene nicht existiert.
+     */
+    getOfSchieneRemoveAllowed(idSchiene: number): boolean;
+    /**
+     * Liefert die maximale Anzahl an Kursen, die es in einer Schiene gibt.
+     *
+     * @return die maximale Anzahl an Kursen, die es in einer Schiene gibt.
+     */
+    getOfSchieneMaxKursanzahl(): number;
+    /**
+     * Liefert die Anzahl an externen SuS der Schiene.
+     * <br>Hinweis: Ist ein Schüler mehrfach in der Schiene (Kollision) wird er auch mehrfach gezählt.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return die Anzahl an externen SuS der Schiene.
+     */
+    getOfSchieneAnzahlSchuelerExterne(idSchiene: number): number;
+    /**
+     * Liefert die Anzahl an Dummy-SuS der Schiene.
+     *
+     * @param idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @return die Anzahl an Dummy-SuS der Schiene.
+     */
+    getOfSchieneAnzahlSchuelerDummy(idSchiene: number): number;
+    /**
+     * Fügt die übergebene Schiene hinzu.
+     *
+     * @param  idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @throws DeveloperNotificationException  falls die Schiene nicht zuerst im Datenmanager hinzugefügt wurde.
+     */
+    setAddSchieneByID(idSchiene: number): void;
+    /**
+     * Löscht die übergebene Schiene.
+     *
+     * @param  idSchiene  Die Datenbank-ID der Schiene.
+     *
+     * @throws DeveloperNotificationException  falls die Schiene nicht zuerst beim Datenmanager entfernt wurde, oder
+     *                                         falls die Schiene noch Kurszuordnungen hat.
+     */
+    setRemoveSchieneByID(idSchiene: number): void;
+    /**
+     * Fügt den übergebenen Kurs hinzu.
+     *
+     * @param  idKurs  Die Datenbank-ID des Kurses.
+     *
+     * @throws DeveloperNotificationException  Falls der Kurs nicht zuerst beim Datenmanager hinzugefügt wurde.
+     */
+    setAddKursByID(idKurs: number): void;
+    /**
+     * Löscht alle übergebenen Kurse. Entfernt zuvor potentiell vorhandene Schülerinnen und Schüler aus dem Kurs.
+     *
+     * @param idKurse  Die Liste der Datenbank-IDs der Kurse.
+     *
+     * @throws DeveloperNotificationException  Falls mindestens einer der Kurse nicht zuerst beim Datenmanager entfernt wurde.
+     */
+    setRemoveKurseByID(idKurse: List<number>): void;
+    /**
+     * Verschiebt alles SuS von pKursID2delete nach pKursID1keep und
+     * löscht dann den Kurs mit der ID beim {@link GostBlockungsdatenManager},
+     * anschließend in diesem Manager.
+     *
+     * @param  idKursID1keep    Die Datenbank-ID des Kurses, der erhalten bleibt.
+     * @param  idKursID2delete  Die Datenbank-ID des Kurses, der gelöscht wird.
+     */
+    setMergeKurseByID(idKursID1keep: number, idKursID2delete: number): void;
+    /**
+     * Erzeugt einen neuen Kurs2 beim {@link GostBlockungsdatenManager},
+     * dann bei diesem Manager und
+     * verschiebt alle SuS des übergebenen Arrays von Kurs1 nach Kurs2.
+     *
+     * @param  kurs1alt     Der Kurs, der gesplittet wird.
+     * @param  kurs2neu     Der Kurs, der neu erzeugt wird.
+     * @param  susVon1nach2 Die Datenbank-IDs der Schüler, die verschoben werden sollen.
+     */
+    setSplitKurs(kurs1alt: GostBlockungKurs, kurs2neu: GostBlockungKurs, susVon1nach2: Array<number>): void;
+    /**
+     * Verändert die Schienenanzahl eines Kurses. Dies ist nur bei einer Blockungsvorlage erlaubt.
+     *
+     * @param  idKurs Die Datenbank-ID des Kurses.
+     * @param  anzahlSchienenNeu Die neue Schienenanzahl des Kurses.
+     *
+     * @throws DeveloperNotificationException Falls ein unerwarteter Fehler passiert.
+     */
+    patchOfKursSchienenAnzahl(idKurs: number, anzahlSchienenNeu: number): void;
+    /**
+     * Informiert den Manager, dass sich bei mindestens einem Kurs die Lehrkraft geändert hat.
+     * Führt zu einer Revalidierung der Bewertung des Ergebnisses.
+     */
+    patchOfKursLehrkaefteChanged(): void;
+    private createComparatorFachartKursartFach;
+    private createComparatorFachartFachKursart;
+    private createComparatorKursFachKursartNummer;
+    private createComparatorKursKursartFachNummer;
+    /**
+     * Eine Logger-Ausgabe für Debug-Zwecke.
+     *
+     * @param logger Ein Logger für Debug-Zwecke.
+     */
+    debug(logger: Logger): void;
+    transpilerCanonicalName(): string;
+    isTranspiledInstanceOf(name: string): boolean;
+    static readonly class: Class<GostBlockungsergebnisManager>;
+}
+export declare function cast_de_svws_nrw_core_utils_gost_GostBlockungsergebnisManager(obj: unknown): GostBlockungsergebnisManager;
+//# sourceMappingURL=GostBlockungsergebnisManager.d.ts.map