@hmt/svws-core 1.5.2 → 1.5.3

package/dist/core/utils/gost/klausuren/GostKlausurplanManager.d.ts

@@ -0,0 +1,3055 @@
+import { JavaObject } from '../../../../java/lang/JavaObject';
+import { SchuelerListeEintrag } from '../../../../core/data/schueler/SchuelerListeEintrag';
+import { GostKursklausur } from '../../../../core/data/gost/klausuren/GostKursklausur';
+import { GostFaecherManager } from '../../../../core/utils/gost/GostFaecherManager';
+import { GostSchuelerklausurterminRich } from '../../../../core/data/gost/klausuren/GostSchuelerklausurterminRich';
+import { StundenplanKurs } from '../../../../core/data/stundenplan/StundenplanKurs';
+import { GostKursart } from '../../../../core/types/gost/GostKursart';
+import { GostKlausurenAlleKlausurdaten } from '../../../../core/data/gost/klausuren/GostKlausurenAlleKlausurdaten';
+import type { List } from '../../../../java/util/List';
+import { GostKlausurraumRich } from '../../../../core/data/gost/klausuren/GostKlausurraumRich';
+import { GostKlausurtermin } from '../../../../core/data/gost/klausuren/GostKlausurtermin';
+import { GostKlausurenHalbjahresdaten } from '../../../../core/data/gost/klausuren/GostKlausurenHalbjahresdaten';
+import { StundenplanRaum } from '../../../../core/data/stundenplan/StundenplanRaum';
+import { GostKlausurvorgabe } from '../../../../core/data/gost/klausuren/GostKlausurvorgabe';
+import { PairNN } from '../../../../asd/adt/PairNN';
+import type { Collection } from '../../../../java/util/Collection';
+import { Class } from '../../../../java/lang/Class';
+import { Wochentag } from '../../../../core/types/Wochentag';
+import type { JavaMap } from '../../../../java/util/JavaMap';
+import type { JavaSet } from '../../../../java/util/JavaSet';
+import { GostSchuelerklausurtermin } from '../../../../core/data/gost/klausuren/GostSchuelerklausurtermin';
+import { KursDaten } from '../../../../asd/data/kurse/KursDaten';
+import { KursManager } from '../../../../core/utils/KursManager';
+import { LehrerListeEintrag } from '../../../../core/data/lehrer/LehrerListeEintrag';
+import { GostHalbjahr } from '../../../../core/types/gost/GostHalbjahr';
+import { StundenplanKalenderwochenzuordnung } from '../../../../core/data/stundenplan/StundenplanKalenderwochenzuordnung';
+import { GostFach } from '../../../../core/data/gost/GostFach';
+import { GostKlausurenPatchResponseData } from '../../../../core/data/gost/klausuren/GostKlausurenPatchResponseData';
+import { StundenplanManager } from '../../../../core/utils/stundenplan/StundenplanManager';
+import { GostSchuelerklausur } from '../../../../core/data/gost/klausuren/GostSchuelerklausur';
+import { GostKlausurraumstunde } from '../../../../core/data/gost/klausuren/GostKlausurraumstunde';
+import { GostKlausurenRaumdaten } from '../../../../core/data/gost/klausuren/GostKlausurenRaumdaten';
+import { StundenplanZeitraster } from '../../../../core/data/stundenplan/StundenplanZeitraster';
+import { GostSchuelerklausurterminraumstunde } from '../../../../core/data/gost/klausuren/GostSchuelerklausurterminraumstunde';
+import { GostKlausurenKlausurdaten } from '../../../../core/data/gost/klausuren/GostKlausurenKlausurdaten';
+import { GostKlausurraum } from '../../../../core/data/gost/klausuren/GostKlausurraum';
+export declare class GostKlausurplanManager extends JavaObject {
+    /**
+     * Sentinel für technische Map-Keys, wenn eine optionale ID fachlich <code>null</code> ist.
+     */
+    private static readonly _ID_OHNE_ZUORDNUNG;
+    private readonly _faechermanager_by_abijahr;
+    private readonly _kursManager;
+    private readonly _stundenplanmanager_by_schuljahresabschnitt_and_datum;
+    private readonly _stundenplanmanager_by_schuljahresabschnitt_and_kw;
+    private readonly _stundenplanmanagermenge_by_schuljahresabschnitt;
+    private readonly _lehrerMap;
+    private readonly _schuelerlisteeintrag_by_id;
+    private readonly _schuljahresabschnitt_by_abijahr_and_halbjahr;
+    private _vorgabenInitialized;
+    private _klausurenInitialized;
+    private readonly _terminidmenge_manager_enthaelt_raumdaten;
+    private readonly _klausurdatenEnthalten;
+    private readonly _fehlenddatenEnthalten;
+    private readonly _compVorgabe;
+    private static readonly _compTermin;
+    private readonly _compKursklausur;
+    private readonly _compSchuelerklausur;
+    private readonly _compSchuelerklausurByDatumHT;
+    private readonly _compSchuelerklausurtermin;
+    private readonly _compSchuelerListeEintrag;
+    private readonly _compSchuelerWochenkonflikt;
+    private static readonly _compRaumstundeMitZeitraster;
+    private static readonly _compRaumstundeOhneZeitraster;
+    private readonly _compKursklausurKonflikt;
+    private readonly _compKwSchuelerWochenkonflikt;
+    private readonly _compSchuelerklausurterminWochenkonflikt;
+    private static readonly _compStundenplanManager;
+    private static readonly _compRaum;
+    private readonly _vorgabenfehlendmenge;
+    private readonly _vorgabefehlend_by_abijahr_and_halbjahr_and_quartal_and_kursartAllg_and_idFach;
+    private readonly _kursklausurfehlendmenge;
+    private readonly _kursklausurfehlend_by_abijahr_and_halbjahr_and_quartal_and_idVorgabe_and_idKurs;
+    private readonly _schuelerklausurfehlendmenge;
+    private readonly _schuelerklausurfehlendmenge_by_abijahr_and_halbjahr_and_quartal_and_idSchueler_and_idKursklausur;
+    private readonly _vorgabe_by_id;
+    private readonly _vorgabenmenge;
+    private _vorgabe_by_abijahr_and_halbjahr_and_quartal_and_kursartAllg_and_idFach;
+    private readonly _kursklausur_by_id;
+    private readonly _kursklausurmenge;
+    private _kursklausur_by_idVorgabe_and_idKurs;
+    private _kursklausurmenge_by_abijahr_and_halbjahr_and_idTermin_and_quartal;
+    private readonly _termin_by_id;
+    private readonly _terminmenge;
+    private _terminmenge_by_abijahr_and_halbjahr_and_quartal;
+    private _terminmenge_by_jahr_and_kw_and_abijahr;
+    private _terminmenge_by_datum_and_abijahr;
+    private readonly _schuelerklausur_by_id;
+    private readonly _schuelerklausurmenge;
+    private _schuelerklausur_by_idKursklausur_and_idSchueler;
+    private readonly _schuelerklausurmenge_by_abijahr_and_idSchueler;
+    private readonly _schuelerklausurtermin_by_id;
+    private readonly _schuelerklausurterminmenge;
+    private readonly _schuelerklausurterminaktuellmenge;
+    private readonly _schuelerklausurterminaktuell_by_idSchuelerklausur;
+    private readonly _schuelerklausurterminmenge_by_idSchuelerklausur;
+    private readonly _schuelerklausurterminmenge_by_idTermin;
+    private readonly _schuelerklausurterminmenge_by_idKursklausur;
+    private _schuelerklausurterminaktuellmenge_by_idTermin_and_idKursklausur;
+    private _schuelerklausurterminntaktuellmenge_by_abijahr_and_halbjahr_and_quartal_and_idTermin;
+    private _schuelerklausurterminaktuellmenge_by_idRaum_and_idTermin;
+    private _schuelerklausurterminaktuellmenge_by_idRaum_and_idKursklausur;
+    private readonly _schuelerklausurterminaktuellmenge_by_abijahr_and_jahr_and_kw_and_schuelerId;
+    private readonly _raum_by_id;
+    private readonly _raummenge;
+    private readonly _raummenge_by_idTermin;
+    private _raum_by_idTermin_and_idStundenplanraum;
+    private readonly _klausurraum_by_idSchuelerklausurtermin;
+    private _raummenge_by_idTermin_and_idKursklausur;
+    private readonly _raumstunde_by_id;
+    private readonly _raumstundenmenge;
+    private readonly _raumstundenmenge_by_idRaum;
+    private _raumstunde_by_idRaum_and_idZeitraster;
+    private readonly _raumstundenmenge_by_idSchuelerklausurtermin;
+    private readonly _schuelerklausurraumstunde_by_idSchuelerklausurtermin_and_idRaumstunde;
+    private readonly _schuelerklausurterminraumstundenmenge;
+    private readonly _schuelermenge_by_abijahr;
+    /**
+     * Erstellt einen leeren Manager.
+     */
+    constructor();
+    /**
+     * Erstellt einen neuen Manager mit den als Liste angegebenen {@link GostKlausurvorgabe}n
+     *
+     * @param listVorgaben die Liste der {@link GostKlausurvorgabe}n
+     */
+    constructor(listVorgaben: Collection<GostKlausurvorgabe>);
+    /**
+     * Erstellt einen neuen Manager mit den als Liste angegebenen {@link GostKlausurvorgabe}n und dem übergebenen {@link GostFaecherManager}, der für den Vorlagen-Jahrgang (ID = -1) gilt
+     *
+     * @param faecherManagerVorgaben der GostFaecherManager, der für den Vorlagen-Jahrgang gilt
+     * @param listVorgaben 	die Liste der GostKlausurvorgaben
+     */
+    constructor(faecherManagerVorgaben: GostFaecherManager | null, listVorgaben: List<GostKlausurvorgabe>);
+    /**
+     * Erstellt einen neuen Manager mit den als Liste angegebenen {@link GostKlausurvorgabe}n, {@link GostKursklausur}en, {@link GostKlausurtermin}en,
+     * {@link GostSchuelerklausur}en und {@link GostSchuelerklausurtermin}en
+     *
+     * @param listVorgaben 			die Liste der {@link GostKlausurvorgabe}n
+     * @param listKlausuren         die Liste der {@link GostKursklausur}en
+     * @param listTermine           die Liste der {@link GostKlausurtermin}e
+     * @param listSchuelerklausuren die Liste der {@link GostSchuelerklausur}en
+     * @param listSchuelerklausurtermine die Liste der {@link GostSchuelerklausurtermin}e
+     */
+    constructor(listVorgaben: Collection<GostKlausurvorgabe>, listKlausuren: Collection<GostKursklausur>, listTermine: Collection<GostKlausurtermin>, listSchuelerklausuren: Collection<GostSchuelerklausur>, listSchuelerklausurtermine: Collection<GostSchuelerklausurtermin>);
+    /**
+     * Erstellt einen neuen Manager mit den übergebenen {@link GostKlausurenAlleKlausurdaten} enthaltenen Daten
+     *
+     * @param allData            das {@link GostKlausurenAlleKlausurdaten}-Objekt, das alle Informationen enthält
+     */
+    constructor(allData: GostKlausurenAlleKlausurdaten);
+    /**
+     * Erstellt einen neuen Manager mit den übergebenen {@link GostKlausurenKlausurdaten} enthaltenen Daten
+     *
+     * @param data            das {@link GostKlausurenKlausurdaten}-Objekt, das alle Informationen enthält
+     */
+    constructor(data: GostKlausurenKlausurdaten);
+    /**
+     * Fügt dem Manager alle im übergebenen {@link GostKlausurenAlleKlausurdaten}-Objekt enthaltenen Daten hinzu
+     *
+     * @param allData            das {@link GostKlausurenAlleKlausurdaten}-Objekt, das alle Informationen enthält
+     */
+    addAllData(allData: GostKlausurenAlleKlausurdaten): void;
+    /**
+     * Fügt dem Manager alle im übergebenen {@link GostKlausurenAlleKlausurdaten}-Objekt enthaltenen Klausurdaten hinzu ({@link GostKlausurvorgabe}n, {@link GostKursklausur}en, {@link GostKlausurtermin}e, {@link GostSchuelerklausur}en, {@link GostSchuelerklausurtermin}e)
+     *
+     * @param allData            das {@link GostKlausurenAlleKlausurdaten}-Objekt, das alle Informationen enthält
+     */
+    addKlausurData(allData: GostKlausurenKlausurdaten): void;
+    /**
+     * Fügt dem Manager alle im übergebenen {@link GostKlausurenRaumdaten}-Objekt enthaltenen Raumplanungsdaten hinzu
+     *
+     * @param raumData            das {@link GostKlausurenRaumdaten}-Objekt, das Raumplanungsdaten enthält
+     */
+    addRaumData(raumData: GostKlausurenRaumdaten): void;
+    private addRaumDataOhneUpdate;
+    private addRaumDataListenOhneUpdate;
+    private addRaumAllDataOhneUpdate;
+    private static removeDuplicatesFromSet;
+    private addMetadata;
+    private addKlausurDataListenOhneUpdate;
+    private addKlausurAllDataOhneUpdate;
+    private addKlausurDataFehlendOhneUpdate;
+    /**
+     * Setzt die Problemdaten der Klausurplanung für einen bestimmten Abiturjahrgang und ein bestimmtes Halbjahr
+     *
+     * @param fehlendData die {@link GostKlausurenHalbjahresdaten} mit den fehlenden Klausurdaten
+     */
+    setKlausurDataFehlend(fehlendData: GostKlausurenHalbjahresdaten): void;
+    /**
+     * Liefert <code>true</code>, falls der Manager Klausurvorgaben enthält.
+     *
+     * @return <code>true</code>, falls der Manager Klausurvorgaben enthält.
+     */
+    isVorgabenInitialized(): boolean;
+    /**
+     * Liefert <code>true</code>, falls der Manager Klausurdaten enthält.
+     *
+     * @return <code>true</code>, falls der Manager Klausurdaten enthält.
+     */
+    isKlausurenInitialized(): boolean;
+    /**
+     * Liefert <code>true</code>, falls der Manager Raumplanungsdaten zum übergebenen Termin enthält.
+     *
+     * @param termin der {@link GostKlausurtermin}, für den geprüft werden soll.
+     *
+     * @return <code>true</code>, falls der Manager Raumplanungsdaten zum übergebenen Termin enthält.
+     */
+    hasRaumdataZuTermin(termin: GostKlausurtermin): boolean;
+    /**
+     * Liefert <code>true</code>, falls der Manager Klausurdaten zum übergebenen Abiturjahrgang und Halbjahr enthält.
+     *
+     * @param abiturjahrgang der Abiturjahrgang
+     * @param halbjahr das Halbjahr
+     *
+     * @return <code>true</code>, falls der Manager Klausurdaten zum übergebenen Abiturjahrgang und Halbjahr enthält.
+     */
+    hasKlausurdatenZuAbijahrUndHalbjahr(abiturjahrgang: number, halbjahr: GostHalbjahr): boolean;
+    /**
+     * Liefert <code>true</code>, falls der Manager Fehlenddaten zum übergebenen Abiturjahrgang und Halbjahr enthält.
+     *
+     * @param abiturjahrgang der Abiturjahrgang
+     * @param halbjahr das Halbjahr
+     *
+     * @return <code>true</code>, falls der Manager Fehlenddaten zum übergebenen Abiturjahrgang und Halbjahr enthält.
+     */
+    hasFehlenddatenZuAbijahrUndHalbjahr(abiturjahrgang: number, halbjahr: GostHalbjahr): boolean;
+    /**
+     * Setzt den {@link GostFaecherManager}
+     *
+     * @param abiturjahrgang der Abiturjahrgang, zu dem der {@link GostFaecherManager} gehört
+     * @param faecherManager der {@link GostFaecherManager}
+     */
+    setFaecherManager(abiturjahrgang: number, faecherManager: GostFaecherManager): void;
+    /**
+     * Liefert den {@link GostFaecherManager} zum übergebenen Abiturjahr, falls dieser gesetzt ist, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     *
+     * @param abiturjahrgang der Abiturjahrgang, zu dem der {@link GostFaecherManager} geliefert werden soll
+     *
+     * @return den {@link GostFaecherManager}
+     */
+    getFaecherManager(abiturjahrgang: number): GostFaecherManager;
+    /**
+     * Liefert den {@link GostFaecherManager} zum übergebenen Abiturjahr, falls dieser gesetzt ist, sonst <code>null</code>.
+     *
+     * @param abiturjahrgang der Abiturjahrgang, zu dem der {@link GostFaecherManager} geliefert wird
+     *
+     * @return den {@link GostFaecherManager} oder <code>null</code>
+     */
+    getFaecherManagerOrNull(abiturjahrgang: number): GostFaecherManager | null;
+    /**
+     * Liefert den {@link KursManager}.
+     *
+     * @return den {@link KursManager}
+     */
+    getKursManager(): KursManager;
+    /**
+     * Liefert die Map mit den {@link SchuelerListeEintrag}enn
+     *
+     * @return die Map mit den {@link SchuelerListeEintrag}en
+     */
+    getSchuelerMap(): JavaMap<number, SchuelerListeEintrag>;
+    /**
+     * Prüft, ob zu dem angegebenen Schuljahresabschnitt bereits die StundenplanManager aus der Datenbank geladen wurden.
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @return true, wenn der StundenplanManager bereits geladen wurde, sonst false
+     */
+    stundenplanManagerGeladenByAbschnitt(idSchuljahresabschnitt: number): boolean;
+    /**
+     * Prüft, ob zu den angegebenen Parametern ein StundenplanManager existiert. Falls noch keine StundenplanManager für den angegebenen Schuljahresabschnitt geladen wurden, wird eine {@link DeveloperNotificationException} geworfen
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @return true, wenn ein StundenplanManager existiert, sonst false
+     */
+    stundenplanManagerExistsByAbschnitt(idSchuljahresabschnitt: number): boolean;
+    /**
+     * Prüft, ob zu den angegebenen Parametern ein StundenplanManager existiert.
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @return true, wenn ein StundenplanManager existiert, sonst false
+     */
+    stundenplanManagerGeladenAndExistsByAbschnitt(idSchuljahresabschnitt: number): boolean;
+    /**
+     * Prüft, ob zu den angegebenen Parametern ein StundenplanManager existiert. Falls noch keine StundenplanManager für den angegebenen Schuljahresabschnitt geladen wurden, wird eine {@link DeveloperNotificationException} geworfen
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param datum das Datum
+     * @return true, wenn ein StundenplanManager existiert, sonst false
+     */
+    stundenplanManagerExistsByAbschnittAndDatum(idSchuljahresabschnitt: number, datum: string): boolean;
+    private static gibIntkeyJahrUndKwDesDatumsISO8601;
+    private static gibIntkeyJahrUndKw;
+    /**
+     * Prüft, ob zu den angegebenen Parametern ein StundenplanManager existiert. Falls noch keine StundenplanManager für den angegebenen Schuljahresabschnitt geladen wurden, wird eine {@link DeveloperNotificationException} geworfen
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param jahr das Jahr
+     * @param kw die Kalenderwoche
+     * @return true, wenn ein StundenplanManager existiert, sonst false
+     */
+    stundenplanManagerExistsByAbschnittAndJahrAndKw(idSchuljahresabschnitt: number, jahr: number, kw: number): boolean;
+    /**
+     * Setzt die {@link StundenplanManager} für den angegebenen Schuljahresabschnitt
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param stundenplanManagerList die Liste der {@link StundenplanManager}
+     */
+    stundenplanManagerAddAllBySchuljahresabschnittsid(idSchuljahresabschnitt: number, stundenplanManagerList: List<StundenplanManager>): void;
+    /**
+     * Setzt den {@link StundenplanManager}
+     *
+     * @param stundenplanManager der {@link StundenplanManager}
+     */
+    stundenplanManagerAdd(stundenplanManager: StundenplanManager): void;
+    /**
+     * Setzt den {@link StundenplanManager} für die übergebenen Parameter
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param datum das Datum, zu dem der Stundenplan gültig ist
+     * @param stundenplanManager der {@link StundenplanManager}
+     */
+    private stundenplanManagerAddByAbschnittAndDatum;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param datum das Datum, zu dem der gesuchte Stundenplan gültig ist
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     */
+    stundenplanManagerGetByAbschnittAndDatumOrNull(idSchuljahresabschnitt: number, datum: string): StundenplanManager | null;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param jahr das Jahr
+     * @param kw die Kalenderwoche, zu der der gesuchte Stundenplan gültig ist
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     */
+    stundenplanManagerGetByAbschnittAndKwOrNull(idSchuljahresabschnitt: number, jahr: number, kw: number): StundenplanManager | null;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param datum das Datum, zu dem der gesuchte Stundenplan gültig ist
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     */
+    stundenplanManagerGetByAbschnittAndDatumOrClosest(idSchuljahresabschnitt: number, datum: string): StundenplanManager;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst eine DeveloperNotificationException.
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param datum das Datum, zu dem der gesuchte Stundenplan gültig ist. Wird kein gültiger Plan gefunden, soll der Plan geliefert werden, der vor dem Datum gültig war.
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern.
+     */
+    stundenplanManagerGetByAbschnittAndDatumOrBeforeOrNull(idSchuljahresabschnitt: number, datum: string): StundenplanManager | null;
+    /**
+     * Liefert eine Liste mit allen {@link StundenplanKalenderwochenzuordnung}-Objekten, die zu dem übergebenen Schuljahresabschnitt gehören.
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     *
+     * @return eine Liste mit allen {@link StundenplanKalenderwochenzuordnung}-Objekten, die zu dem übergebenen Schuljahresabschnitt gehören.
+     */
+    stundenplanManagerKalenderwochenzuordnungenGetMengeByAbschnitt(idSchuljahresabschnitt: number): List<StundenplanKalenderwochenzuordnung>;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst eine DeveloperNotificationException.
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param datum das Datum, zu dem der gesuchte Stundenplan gültig ist. Wird kein gültiger Plan gefunden, soll der Plan geliefert werden, der nach dem Datum gültig war.
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     */
+    stundenplanManagerGetByAbschnittAndDatumOrAfterOrNull(idSchuljahresabschnitt: number, datum: string): StundenplanManager | null;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param datum das Datum, zu dem der gesuchte Stundenplan gültig ist
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     */
+    stundenplanManagerGetByAbschnittAndDatumOrException(idSchuljahresabschnitt: number, datum: string): StundenplanManager;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     *
+     * @param idSchuljahresabschnitt die ID des Schuljahresabschnitts
+     * @param jahr das Jahr
+     * @param kw die Kalenderwoche, zu der der gesuchte Stundenplan gültig ist
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     */
+    stundenplanManagerGetByAbschnittAndKwOrException(idSchuljahresabschnitt: number, jahr: number, kw: number): StundenplanManager;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     *
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern, sonst null.
+     */
+    stundenplanManagerGetByTerminOrNull(termin: GostKlausurtermin): StundenplanManager | null;
+    /**
+     * Liefert den {@link StundenplanManager}, zu den übergebenen Parametern, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     *
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return den {@link StundenplanManager}, zu den übergebenen Parametern, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     */
+    stundenplanManagerGetByTerminOrException(termin: GostKlausurtermin): StundenplanManager;
+    private stundenplanManagerGetByDatumLinearSearch;
+    /**
+     * Liefert die LehrerMap, eine Map von Lehrer-ID (Long) -> {@link LehrerListeEintrag}, falls diese gesetzt ist, sonst wird eine
+     * {@link DeveloperNotificationException} geworfen.
+     *
+     * @return die LehrerMap, eine Map von Lehrer-ID (Long) -> {@link LehrerListeEintrag}
+     */
+    getLehrerMap(): JavaMap<number, LehrerListeEintrag>;
+    /**
+     * Liefert den {@link SchuelerListeEintrag} zur übergebenen Schüler-ID, falls dieser existiert, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     *
+     * @param id die Schüler-ID
+     *
+     * @return den {@link SchuelerListeEintrag} zur übergebenen Schüler-ID, falls dieser existiert, sonst wird eine {@link DeveloperNotificationException} geworfen.
+     */
+    schuelerGetByIdOrException(id: number): SchuelerListeEintrag;
+    /**
+     * Setzt die Maps, die zu den {@link SchuelerListeEintrag}en gehören.
+     *
+     * @param listSchueler Liste von {@link SchuelerListeEintrag}en
+     * @param ignoreExists wenn true, wird bei bereits existierenden Schülern kein Fehler geworfen und der alte Eintrag wird beibehalten
+     */
+    private schuelerAddAllOhneUpdate;
+    private addSchuljahr;
+    private addSchuljahresPaare;
+    /**
+     * Berechnet zu den Parametern die Liste von {@link GostKlausurenHalbjahresdaten}-Objekten, für die Klausurdaten geladen werden.
+     *
+     * @param abiturjahr das Jahr, in welchem der Jahrgang Abitur machen wird
+     * @param halbjahr das aktuell betrachtete GostHalbjahr
+     * @return die Liste von {@link GostKlausurenHalbjahresdaten} -Objekten
+     */
+    getMissingHjKlausurdata(abiturjahr: number, halbjahr: number): List<GostKlausurenHalbjahresdaten>;
+    private static datumStringToLong;
+    private update_all;
+    private update_schuelermenge_by_abijahr;
+    private update_vorgabe_by_halbjahr_and_quartal_and_kursartAllg_and_idFach;
+    private update_kursklausurmenge_by_idVorgabe_and_idKurs;
+    private update_kursklausurmenge_by_halbjahr_and_quartal_and_idTermin;
+    private update_terminmenge_by_halbjahr_and_quartal;
+    private update_terminmenge_by_jahr_and_kw_and_abijahr;
+    private update_terminmenge_by_datum;
+    private update_schuelerklausurterminaktuellmenge;
+    private update_schuelerklausurterminaktuell_by_idSchuelerklausur;
+    private update_schuelerklausurmenge_by_idKursklausur;
+    private update_schuelerklausurmenge_by_abijahr_and_idSchueler;
+    private update_schuelerklausurterminaktuellmenge_by_jahr_and_kw_and_abijahr_and_schuelerId;
+    private update_schuelerklausurterminmenge_by_idSchuelerklausur;
+    private update_schuelerklausurterminmenge_by_idTermin;
+    private update_schuelerklausurterminmenge_by_idKursklausur;
+    private update_schuelerklausurterminaktuellmenge_by_idTermin_and_idKursklausur;
+    private update_schuelerklausurterminntaktuellmenge_by_halbjahr_and_idTermin_and_quartal;
+    private update_raum_by_idTermin_and_idStundenplanraum;
+    private update_raummenge_by_idTermin;
+    private update_raummenge_by_idTermin_and_idKursklausur;
+    private update_raumstundenmenge_by_idRaum;
+    private update_raumstunde_by_idRaum_and_idZeitraster;
+    private update_raumstundenmenge_by_idSchuelerklausurtermin;
+    private update_schuelerklausurterminaktuellmenge_by_idRaum_and_idTermin;
+    private update_schuelerklausurterminaktuellmenge_by_idRaum_and_idKursklausur;
+    private update_klausurraum_by_idSchuelerklausurtermin;
+    private update_vorgabemenge;
+    /**
+     * Fügt ein {@link GostKlausurvorgabe}-Objekt hinzu.
+     *
+     * @param vorgabe Das {@link GostKlausurvorgabe}-Objekt, welches hinzugefügt
+     *                    werden soll.
+     */
+    vorgabeAdd(vorgabe: GostKlausurvorgabe): void;
+    private vorgabeAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKlausurvorgabe}-Objekte hinzu.
+     *
+     * @param listVorgaben Die Menge der {@link GostKlausurvorgabe}-Objekte,
+     *                          welche hinzugefügt werden soll.
+     */
+    vorgabeAddAll(listVorgaben: Collection<GostKlausurvorgabe>): void;
+    private static vorgabeCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link GostKlausurvorgabe}-Objekt. <br>
+     * Laufzeit: O(1)
+     *
+     * @param idVorgabe Die ID des angefragten-Objektes.
+     *
+     * @return das zur ID zugehörige {@link GostKlausurvorgabe}-Objekt.
+     */
+    vorgabeGetByIdOrException(idVorgabe: number): GostKlausurvorgabe;
+    /**
+     * Liefert eine Liste aller {@link GostKlausurvorgabe}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKlausurvorgabe}-Objekte.
+     */
+    vorgabeGetMengeAsList(): List<GostKlausurvorgabe>;
+    /**
+     * Aktualisiert das vorhandene {@link GostKlausurvorgabe}-Objekt durch das neue
+     * Objekt.
+     *
+     * @param vorgabe Das neue {@link GostKlausurvorgabe}-Objekt.
+     */
+    vorgabePatchAttributes(vorgabe: GostKlausurvorgabe): void;
+    private vorgabeRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link GostKlausurvorgabe}-Objekt.
+     *
+     * @param idVorgabe Die ID des {@link GostKlausurvorgabe}-Objekts.
+     */
+    vorgabeRemoveById(idVorgabe: number): void;
+    /**
+     * Entfernt alle {@link GostKlausurvorgabe}-Objekte.
+     *
+     * @param listVorgaben Die Liste der zu entfernenden
+     *                          {@link GostKlausurvorgabe}-Objekte.
+     */
+    vorgabeRemoveAll(listVorgaben: List<GostKlausurvorgabe>): void;
+    private update_vorgabefehlendmenge;
+    /**
+     * Fügt ein {@link GostKlausurvorgabe}-Objekt hinzu.
+     *
+     * @param vorgabe Das {@link GostKlausurvorgabe}-Objekt, welches hinzugefügt
+     *                    werden soll.
+     */
+    vorgabefehlendAdd(vorgabe: GostKlausurvorgabe): void;
+    private vorgabefehlendAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKlausurvorgabe}-Objekte hinzu.
+     *
+     * @param listVorgaben Die Menge der {@link GostKlausurvorgabe}-Objekte,
+     *                          welche hinzugefügt werden soll.
+     */
+    vorgabefehlendAddAll(listVorgaben: List<GostKlausurvorgabe>): void;
+    /**
+     * Liefert eine Liste aller {@link GostKlausurvorgabe}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKlausurvorgabe}-Objekte.
+     */
+    vorgabefehlendGetMengeAsList(): List<GostKlausurvorgabe>;
+    private vorgabefehlendRemoveOhneUpdate;
+    /**
+     * Entfernt ein existierendes {@link GostKlausurvorgabe}-Objekt.
+     *
+     * @param vorgabe die zu löschende {@link GostKlausurvorgabe}
+     */
+    vorgabefehlendRemove(vorgabe: GostKlausurvorgabe): void;
+    /**
+     * Entfernt alle {@link GostKlausurvorgabe}-Objekte.
+     *
+     * @param listVorgaben Die Liste der zu entfernenden
+     *                          {@link GostKlausurvorgabe}-Objekte.
+     */
+    vorgabefehlendRemoveAll(listVorgaben: List<GostKlausurvorgabe>): void;
+    private update_kursklausurmenge;
+    /**
+     * Fügt ein {@link GostKursklausur}-Objekt hinzu.
+     *
+     * @param kursklausur Das {@link GostKursklausur}-Objekt, welches hinzugefügt
+     *                    werden soll.
+     */
+    kursklausurAdd(kursklausur: GostKursklausur): void;
+    private kursklausurAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKursklausur}-Objekte hinzu.
+     *
+     * @param listKursklausuren Die Menge der {@link GostKursklausur}-Objekte,
+     *                          welche hinzugefügt werden soll.
+     */
+    kursklausurAddAll(listKursklausuren: List<GostKursklausur>): void;
+    private static kursklausurCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link GostKursklausur}-Objekt. <br>
+     * Laufzeit: O(1)
+     *
+     * @param idKursklausur Die ID des angefragten-Objektes.
+     *
+     * @return das zur ID zugehörige {@link GostKursklausur}-Objekt.
+     */
+    kursklausurGetByIdOrException(idKursklausur: number): GostKursklausur;
+    /**
+     * Liefert eine Liste aller {@link GostKursklausur}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKursklausur}-Objekte.
+     */
+    kursklausurGetMengeAsList(): List<GostKursklausur>;
+    /**
+     * Aktualisiert das vorhandene {@link GostKursklausur}-Objekt durch das neue
+     * Objekt.
+     *
+     * @param kursklausur Das neue {@link GostKursklausur}-Objekt.
+     */
+    kursklausurPatchAttributes(kursklausur: GostKursklausur): void;
+    /**
+     * Aktualisiert das vorhandene {@link GostKursklausur}-Objekt durch das neue
+     * Objekt.
+     *
+     * @param kursklausur Das neue {@link GostKursklausur}-Objekt.
+     */
+    private kursklausurPatchAttributesOhneUpdate;
+    /**
+     * Aktualisiert das vorhandene {@link GostKursklausur}-Objekt durch das neue
+     * Objekt.
+     *
+     * @param kursklausurMenge Das neue {@link GostKursklausur}-Objekt.
+     */
+    kursklausurMengePatchAttributes(kursklausurMenge: List<GostKursklausur>): void;
+    private kursklausurRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link GostKursklausur}-Objekt.
+     *
+     * @param idKursklausur Die ID des {@link GostKursklausur}-Objekts.
+     */
+    kursklausurRemoveById(idKursklausur: number): void;
+    /**
+     * Entfernt alle {@link GostKursklausur}-Objekte.
+     *
+     * @param listKursklausuren Die Liste der zu entfernenden
+     *                          {@link GostKursklausur}-Objekte.
+     */
+    kursklausurRemoveAll(listKursklausuren: List<GostKursklausur>): void;
+    private update_kursklausurfehlendmenge;
+    /**
+     * Fügt ein {@link GostKursklausur}-Objekt hinzu.
+     *
+     * @param kursklausur Das {@link GostKursklausur}-Objekt, welches hinzugefügt
+     *                    werden soll.
+     */
+    kursklausurfehlendAdd(kursklausur: GostKursklausur): void;
+    private kursklausurfehlendAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKursklausur}-Objekte hinzu.
+     *
+     * @param listKursklausuren Die Menge der {@link GostKursklausur}-Objekte,
+     *                          welche hinzugefügt werden soll.
+     */
+    kursklausurfehlendAddAll(listKursklausuren: List<GostKursklausur>): void;
+    /**
+     * Liefert eine Liste aller {@link GostKursklausur}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKursklausur}-Objekte.
+     */
+    kursklausurfehlendGetMengeAsList(): List<GostKursklausur>;
+    private kursklausurfehlendRemoveOhneUpdate;
+    /**
+     * Entfernt ein existierendes {@link GostKursklausur}-Objekt.
+     *
+     * @param kursklausur das zu löschende {@link GostKursklausur}-Objekt.
+     */
+    kursklausurfehlendRemove(kursklausur: GostKursklausur): void;
+    private update_terminmenge;
+    /**
+     * Fügt ein {@link GostKlausurtermin}-Objekt hinzu.
+     *
+     * @param termin Das {@link GostKlausurtermin}-Objekt, welches hinzugefügt
+     *               werden soll.
+     */
+    terminAdd(termin: GostKlausurtermin): void;
+    private terminAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKlausurtermin}-Objekte hinzu.
+     *
+     * @param listTermine Die Menge der {@link GostKlausurtermin}-Objekte, welche
+     *                    hinzugefügt werden soll.
+     */
+    terminAddAll(listTermine: List<GostKlausurtermin>): void;
+    private static terminCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link GostKlausurtermin}-Objekt. <br>
+     * Laufzeit: O(1)
+     *
+     * @param idTermin Die ID des angefragten-Objektes.
+     *
+     * @return das zur ID zugehörige {@link GostKlausurtermin}-Objekt.
+     */
+    terminGetByIdOrException(idTermin: number): GostKlausurtermin;
+    /**
+     * Liefert das zum {@link GostKlausurraum} zugehörige {@link GostKlausurtermin}-Objekt. <br>
+     * Laufzeit: O(1)
+     *
+     * @param raum das {@link GostKlausurtermin}-Objekt.
+     *
+     * @return das zum Parameter zugehörige {@link GostKlausurtermin}-Objekt.
+     */
+    terminGetByRaumOrException(raum: GostKlausurraum): GostKlausurtermin;
+    /**
+     * Liefert das zur ID zugehörige {@link GostKlausurtermin}-Objekt oder null.
+     * <br>
+     * Laufzeit: O(1)
+     *
+     * @param idTermin Die ID des angefragten-Objektes.
+     *
+     * @return das zur ID zugehörige {@link GostKlausurtermin}-Objekt oder null.
+     */
+    terminGetByIdOrNull(idTermin: number): GostKlausurtermin | null;
+    /**
+     * Liefert eine Liste aller {@link GostKlausurtermin}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKlausurtermin}-Objekte.
+     */
+    terminGetMengeAsList(): List<GostKlausurtermin>;
+    private terminPatchAttributesOhneUpdate;
+    /**
+     * Aktualisiert das vorhandene {@link GostKlausurtermin}-Objekt durch das neue
+     * Objekt.
+     *
+     * @param termin Das neue {@link GostKlausurtermin}-Objekt.
+     */
+    terminPatchAttributes(termin: GostKlausurtermin): void;
+    private terminRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link GostKlausurtermin}-Objekt.
+     *
+     * @param idTermin Die ID des {@link GostKlausurtermin}-Objekts.
+     */
+    terminRemoveById(idTermin: number): void;
+    /**
+     * Entfernt alle {@link GostKlausurtermin}-Objekte.
+     *
+     * @param listTermine Die Liste der zu entfernenden
+     *                    {@link GostKlausurtermin}-Objekte.
+     */
+    terminRemoveAll(listTermine: List<GostKlausurtermin>): void;
+    private update_schuelerklausurmenge;
+    /**
+     * Fügt ein {@link GostSchuelerklausur}-Objekt hinzu.
+     *
+     * @param kursklausur Das {@link GostSchuelerklausur}-Objekt, welches
+     *                    hinzugefügt werden soll.
+     */
+    schuelerklausurAdd(kursklausur: GostSchuelerklausur): void;
+    private schuelerklausurAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKursklausur}-Objekte hinzu.
+     *
+     * @param listKursklausuren Die Menge der {@link GostKursklausur}-Objekte,
+     *                          welche hinzugefügt werden soll.
+     */
+    schuelerklausurAddAll(listKursklausuren: List<GostSchuelerklausur>): void;
+    private static schuelerklausurCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link GostSchuelerklausur}-Objekt. <br>
+     * Laufzeit: O(1)
+     *
+     * @param idSchuelerklausur Die ID des angefragten-Objektes.
+     *
+     * @return das zur ID zugehörige {@link GostSchuelerklausur}-Objekt.
+     */
+    schuelerklausurGetByIdOrException(idSchuelerklausur: number): GostSchuelerklausur;
+    /**
+     * Liefert eine Liste aller {@link GostKursklausur}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKursklausur}-Objekte.
+     */
+    schuelerklausurGetMengeAsList(): List<GostSchuelerklausur>;
+    /**
+     * Aktualisiert das vorhandene {@link GostKursklausur}-Objekt durch das neue
+     * Objekt.
+     *
+     * @param kursklausur Das neue {@link GostKursklausur}-Objekt.
+     */
+    schuelerklausurPatchAttributes(kursklausur: GostSchuelerklausur): void;
+    private schuelerklausurRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link GostKursklausur}-Objekt.
+     *
+     * @param idSchuelerklausur Die ID des {@link GostSchuelerklausur}-Objekts.
+     */
+    schuelerklausurRemoveById(idSchuelerklausur: number): void;
+    /**
+     * Entfernt alle {@link GostSchuelerklausur}-Objekte.
+     *
+     * @param listSchuelerklausuren Die Liste der zu entfernenden
+     *                          {@link GostSchuelerklausur}-Objekte.
+     */
+    private schuelerklausurRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link GostSchuelerklausur}-Objekte.
+     *
+     * @param listSchuelerklausuren Die Liste der zu entfernenden
+     *                          {@link GostSchuelerklausur}-Objekte.
+     */
+    schuelerklausurRemoveAll(listSchuelerklausuren: List<GostSchuelerklausur>): void;
+    private update_schuelerklausurfehlendmenge;
+    /**
+     * Fügt ein {@link GostSchuelerklausur}-Objekt hinzu.
+     *
+     * @param kursklausur Das {@link GostSchuelerklausur}-Objekt, welches
+     *                    hinzugefügt werden soll.
+     */
+    schuelerklausurfehlendAdd(kursklausur: GostSchuelerklausur): void;
+    private schuelerklausurfehlendAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKursklausur}-Objekte hinzu.
+     *
+     * @param listKursklausuren Die Menge der {@link GostKursklausur}-Objekte,
+     *                          welche hinzugefügt werden soll.
+     */
+    schuelerklausurfehlendAddAll(listKursklausuren: List<GostSchuelerklausur>): void;
+    /**
+     * Liefert eine Liste aller {@link GostKursklausur}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKursklausur}-Objekte.
+     */
+    schuelerklausurfehlendGetMengeAsList(): List<GostSchuelerklausur>;
+    private schuelerklausurfehlendRemoveOhneUpdate;
+    /**
+     * Entfernt ein existierendes {@link GostKursklausur}-Objekt.
+     *
+     * @param klausur die {@link GostKursklausur}
+     */
+    schuelerklausurfehlendRemove(klausur: GostSchuelerklausur): void;
+    /**
+     * Entfernt alle {@link GostKursklausur}-Objekte.
+     *
+     * @param listKursklausuren Die Liste der zu entfernenden
+     *                          {@link GostKursklausur}-Objekte.
+     */
+    schuelerklausurfehlendRemoveAll(listKursklausuren: List<GostSchuelerklausur>): void;
+    private update_schuelerklausurterminmenge;
+    /**
+     * Fügt ein {@link GostSchuelerklausurtermin}-Objekt hinzu.
+     *
+     * @param schuelerklausurtermin Das {@link GostSchuelerklausurtermin}-Objekt,
+     *                              welches hinzugefügt werden soll.
+     */
+    schuelerklausurterminAdd(schuelerklausurtermin: GostSchuelerklausurtermin): void;
+    /**
+     * Fügt ein {@link GostSchuelerklausurtermin}-Objekt hinzu.
+     *
+     * @param schuelerklausur Das {@link GostSchuelerklausurtermin}-Objekt, welches
+     *                        hinzugefügt werden soll.
+     */
+    schuelerklausurAddOhneUpdate(schuelerklausur: GostSchuelerklausurtermin): void;
+    private schuelerklausurterminAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostSchuelerklausurtermin}-Objekte hinzu.
+     *
+     * @param listSchuelerklausurtermine die Menge der
+     *                                   {@link GostSchuelerklausurtermin}-Objekte,
+     *                                   welche hinzugefügt werden sollen.
+     */
+    schuelerklausurterminAddAll(listSchuelerklausurtermine: List<GostSchuelerklausurtermin>): void;
+    private static schuelerklausurterminCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link GostSchuelerklausurtermin}-Objekt. <br>
+     * Laufzeit: O(1)
+     *
+     * @param idSchuelerklausurtermin Die ID des angefragten-Objektes.
+     *
+     * @return das zur ID zugehörige {@link GostSchuelerklausurtermin}-Objekt.
+     */
+    schuelerklausurterminGetByIdOrException(idSchuelerklausurtermin: number): GostSchuelerklausurtermin;
+    /**
+     * Liefert eine Liste aller {@link GostSchuelerklausurtermin}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostSchuelerklausurtermin}-Objekte.
+     */
+    schuelerklausurterminGetMengeAsList(): List<GostSchuelerklausurtermin>;
+    /**
+     * Aktualisiert das vorhandene {@link GostSchuelerklausurtermin}-Objekt durch
+     * das neue Objekt.
+     *
+     * @param schuelerklausurtermin Das neue
+     *                              {@link GostSchuelerklausurtermin}-Objekt.
+     */
+    schuelerklausurterminPatchAttributes(schuelerklausurtermin: GostSchuelerklausurtermin): void;
+    private schuelerklausurterminPatchAttributesOhneUpdate;
+    private schuelerklausurterminRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link GostSchuelerklausurtermin}-Objekt.
+     *
+     * @param idSchuelerklausurtermin die ID des
+     *                                {@link GostSchuelerklausurtermin}-Objekts.
+     */
+    schuelerklausurterminRemoveById(idSchuelerklausurtermin: number): void;
+    /**
+     * Entfernt alle {@link GostSchuelerklausurtermin}-Objekte.
+     *
+     * @param listSchuelerklausurtermine die Liste der zu entfernenden
+     *                                   {@link GostSchuelerklausurtermin}-Objekte.
+     */
+    schuelerklausurterminRemoveAllOhneUpdate(listSchuelerklausurtermine: List<GostSchuelerklausurtermin>): void;
+    /**
+     * Entfernt alle {@link GostSchuelerklausurtermin}-Objekte.
+     *
+     * @param listSchuelerklausurtermine die Liste der zu entfernenden
+     *                                   {@link GostSchuelerklausurtermin}-Objekte.
+     */
+    schuelerklausurterminRemoveAll(listSchuelerklausurtermine: List<GostSchuelerklausurtermin>): void;
+    private update_raummenge;
+    /**
+     * Fügt ein {@link GostKlausurraum}-Objekt hinzu.
+     *
+     * @param raum Das {@link GostKlausurraum}-Objekt, welches hinzugefügt werden
+     *             soll.
+     */
+    raumAdd(raum: GostKlausurraum): void;
+    private raumAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKlausurraum}-Objekte hinzu.
+     *
+     * @param listRaum Die Menge der {@link GostKlausurraum}-Objekte, welche
+     *                 hinzugefügt werden soll.
+     */
+    raumAddAll(listRaum: List<GostKlausurraum>): void;
+    private static raumCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link GostKlausurraum}-Objekt. <br>
+     * Laufzeit: O(1)
+     *
+     * @param idRaum Die ID des angefragten-Objektes.
+     *
+     * @return das zur ID zugehörige {@link GostKlausurraum}-Objekt.
+     */
+    raumGetByIdOrException(idRaum: number): GostKlausurraum;
+    /**
+     * Liefert eine Liste aller {@link GostKlausurraum}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKlausurraum}-Objekte.
+     */
+    raumGetMengeAsList(): List<GostKlausurraum>;
+    /**
+     * Aktualisiert das vorhandene {@link GostKlausurraum}-Objekt durch das neue
+     * Objekt.
+     *
+     * @param raum Das neue {@link GostKlausurraum}-Objekt.
+     */
+    raumPatchAttributes(raum: GostKlausurraum): void;
+    private raumRemoveOhneUpdateById;
+    private raumRemoveIfExistsNoCascadeOhneUpdateById;
+    private raumRemoveAllOhneUpdate;
+    /**
+     * Entfernt ein existierendes {@link GostKlausurraum}-Objekt.
+     *
+     * @param idRaum Die ID des {@link GostKlausurraum}-Objekts.
+     */
+    raumRemoveById(idRaum: number): void;
+    /**
+     * Entfernt alle {@link StundenplanRaum}-Objekte.
+     *
+     * @param listRaum Die Liste der zu entfernenden
+     *                 {@link StundenplanRaum}-Objekte.
+     */
+    private raumRemoveAllIfExistsNoCascadeOhneUpdate;
+    /**
+     * Entfernt alle {@link StundenplanRaum}-Objekte.
+     *
+     * @param listRaum Die Liste der zu entfernenden
+     *                 {@link StundenplanRaum}-Objekte.
+     */
+    raumRemoveAll(listRaum: List<GostKlausurraum>): void;
+    private update_raumstundenmenge;
+    /**
+     * Fügt ein {@link GostKlausurraumstunde}-Objekt hinzu.
+     *
+     * @param raumstunde Das {@link GostKlausurraumstunde}-Objekt, welches
+     *                   hinzugefügt werden soll.
+     */
+    raumstundeAdd(raumstunde: GostKlausurraumstunde): void;
+    private raumstundeAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostKlausurraumstunde}-Objekte hinzu.
+     *
+     * @param listRaumstunde Die Menge der {@link GostKlausurraumstunde}-Objekte,
+     *                       welche hinzugefügt werden soll.
+     */
+    raumstundeAddAll(listRaumstunde: Collection<GostKlausurraumstunde>): void;
+    private static raumstundeCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link GostKlausurraumstunde}-Objekt. <br>
+     * Laufzeit: O(1)
+     *
+     * @param idRaumstunde Die ID des angefragten-Objektes.
+     *
+     * @return das zur ID zugehörige {@link GostKlausurraumstunde}-Objekt.
+     */
+    raumstundeGetByIdOrException(idRaumstunde: number): GostKlausurraumstunde;
+    /**
+     * Liefert eine Liste aller {@link GostKlausurraumstunde}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostKlausurraumstunde}-Objekte.
+     */
+    raumstundeGetMengeAsList(): List<GostKlausurraumstunde>;
+    /**
+     * Aktualisiert das vorhandene {@link GostKlausurraumstunde}-Objekt durch das
+     * neue Objekt.
+     *
+     * @param raumstunde Das neue {@link GostKlausurraumstunde}-Objekt.
+     */
+    raumstundePatchAttributes(raumstunde: GostKlausurraumstunde): void;
+    private raumstundeRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link GostKlausurraumstunde}-Objekt.
+     *
+     * @param idRaumstunde Die ID des {@link GostKlausurraumstunde}-Objekts.
+     */
+    raumstundeRemoveById(idRaumstunde: number): void;
+    /**
+     * Entfernt alle {@link GostKlausurraumstunde}-Objekte.
+     *
+     * @param listRaumstunde Die Liste der zu entfernenden
+     *                       {@link GostKlausurraumstunde}-Objekte.
+     */
+    raumstundeRemoveAllOhneUpdate(listRaumstunde: List<GostKlausurraumstunde>): void;
+    /**
+     * Entfernt alle {@link GostKlausurraumstunde}-Objekte.
+     *
+     * @param listRaumstunde Die Liste der zu entfernenden
+     *                       {@link GostKlausurraumstunde}-Objekte.
+     */
+    raumstundeRemoveAll(listRaumstunde: List<GostKlausurraumstunde>): void;
+    private update_schuelerklausurraumstundenmenge;
+    /**
+     * Fügt ein {@link GostSchuelerklausurterminraumstunde}-Objekt hinzu.
+     *
+     * @param schuelerklausurraumstunde Das
+     *                                  {@link GostSchuelerklausurterminraumstunde}-Objekt,
+     *                                  welches hinzugefügt werden soll.
+     */
+    schuelerklausurraumstundeAdd(schuelerklausurraumstunde: GostSchuelerklausurterminraumstunde): void;
+    private schuelerklausurraumstundeAddAllOhneUpdate;
+    /**
+     * Fügt alle {@link GostSchuelerklausurterminraumstunde}-Objekte hinzu.
+     *
+     * @param listSchuelerklausurraumstunde Die Menge der
+     *                                      {@link GostSchuelerklausurterminraumstunde}-Objekte,
+     *                                      welche hinzugefügt werden soll.
+     */
+    schuelerklausurraumstundeAddAll(listSchuelerklausurraumstunde: List<GostSchuelerklausurterminraumstunde>): void;
+    private static schuelerklausurraumstundeCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link GostSchuelerklausurterminraumstunde}-Objekt.
+     * <br>
+     * Laufzeit: O(1)
+     *
+     * @param idSchuelerklausurtermin Die ID des {@link GostSchuelerklausurtermin}-Objekts.
+     * @param idRaumstunde      Die ID des {@link GostKlausurraumstunde}-Objekts.
+     *
+     * @return das zur ID zugehörige {@link GostSchuelerklausurterminraumstunde}-Objekt.
+     */
+    schuelerklausurraumstundeGetByIdSchuelerklausurterminAndIdRaumstundeOrException(idSchuelerklausurtermin: number, idRaumstunde: number): GostSchuelerklausurterminraumstunde;
+    /**
+     * Liefert das zur ID zugehörige {@link GostSchuelerklausurterminraumstunde}-Objekt.
+     * <br>
+     * Laufzeit: O(1)
+     *
+     * @param idSchuelerklausurtermin Die ID des {@link GostSchuelerklausurtermin}-Objekts.
+     * @param idRaumstunde      Die ID des {@link GostKlausurraumstunde}-Objekts.
+     *
+     * @return das zur ID zugehörige {@link GostSchuelerklausurterminraumstunde}-Objekt.
+     */
+    schuelerklausurraumstundeGetByIdSchuelerklausurterminAndIdRaumstundeOrNull(idSchuelerklausurtermin: number, idRaumstunde: number): GostSchuelerklausurterminraumstunde | null;
+    /**
+     * Liefert eine Liste aller {@link GostSchuelerklausurterminraumstunde}-Objekte zur angegebenen Schülerklausurtermin-ID.
+     * <br>
+     * Laufzeit: O(1)
+     *
+     * @param idSchuelerklausurtermin Die ID des {@link GostSchuelerklausurtermin}-Objekts.
+     *
+     * @return das zur ID zugehörige {@link GostSchuelerklausurterminraumstunde}-Objekt.
+     */
+    schuelerklausurraumstundeGetMengeByIdSchuelerklausurtermin(idSchuelerklausurtermin: number): List<GostSchuelerklausurterminraumstunde>;
+    /**
+     * Liefert eine Liste aller {@link GostSchuelerklausurterminraumstunde}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostSchuelerklausurterminraumstunde}-Objekte.
+     */
+    schuelerklausurraumstundeGetMengeAsList(): List<GostSchuelerklausurterminraumstunde>;
+    /**
+     * Aktualisiert das vorhandene {@link GostSchuelerklausurterminraumstunde}-Objekt
+     * durch das neue Objekt.
+     *
+     * @param schuelerklausurraumstunde Das neue
+     *                                  {@link GostSchuelerklausurterminraumstunde}-Objekt.
+     */
+    schuelerklausurraumstundePatchAttributes(schuelerklausurraumstunde: GostSchuelerklausurterminraumstunde): void;
+    private schuelerklausurraumstundeRemoveOhneUpdateByIdSchuelerklausurterminAndIdRaumstunde;
+    private schuelerklausurraumstundeRemoveOhneUpdateByIdSchuelerklausurtermin;
+    private schuelerklausurraumstundenmengeRemoveOhneUpdateByIdSchuelerklausurtermin;
+    /**
+     * Entfernt ein existierendes {@link GostSchuelerklausurterminraumstunde}-Objekt.
+     *
+     * @param idSchuelerklausurtermin Die ID des {@link GostSchuelerklausurtermin}-Objekts.
+     * @param idRaumstunde      Die ID des {@link GostKlausurraumstunde}-Objekts.
+     */
+    schuelerklausurraumstundeRemoveByIdSchuelerklausurterminAndIdRaumstunde(idSchuelerklausurtermin: number, idRaumstunde: number): void;
+    /**
+     * Entfernt ein existierendes {@link GostSchuelerklausurterminraumstunde}-Objekt.
+     *
+     * @param idSchuelerklausurtermin Die ID des {@link GostSchuelerklausurtermin}-Objekts.
+     */
+    schuelerklausurraumstundeRemoveByIdSchuelerklausurtermin(idSchuelerklausurtermin: number): void;
+    /**
+     * Entfernt alle {@link GostSchuelerklausurterminraumstunde}-Objekte, deren Schülerklausur-ID in der übergebenen Liste enthalten ist.
+     *
+     * @param idsSchuelerklausurtermine die Liste der Schülerklausur-IDs.
+     */
+    private schuelerklausurraumstundeRemoveAllOhneUpdateByIdSchuelerklausurtermin;
+    /**
+     * Entfernt alle {@link GostSchuelerklausurterminraumstunde}-Objekte, deren Schülerklausur-ID in der übergebenen Liste enthalten ist.
+     *
+     * @param idsSchuelerklausurtermine die Liste der Schülerklausur-IDs.
+     */
+    schuelerklausurraumstundeRemoveAllByIdSchuelerklausurtermin(idsSchuelerklausurtermine: List<number>): void;
+    /**
+     * Entfernt alle {@link GostSchuelerklausurterminraumstunde}-Objekte.
+     *
+     * @param listSchuelerklausurRaumstunde Die Liste der zu entfernenden
+     *                                      {@link GostSchuelerklausurterminraumstunde}-Objekte.
+     */
+    schuelerklausurraumstundeRemoveAll(listSchuelerklausurRaumstunde: List<GostSchuelerklausurterminraumstunde>): void;
+    /**
+     * Entfernt alle {@link GostSchuelerklausurterminraumstunde}-Objekte.
+     *
+     * @param listSchuelerklausurRaumstunde Die Liste der zu entfernenden
+     *                                      {@link GostSchuelerklausurterminraumstunde}-Objekte.
+     */
+    schuelerklausurraumstundeRemoveAllOhneUpdate(listSchuelerklausurRaumstunde: List<GostSchuelerklausurterminraumstunde>): void;
+    /**
+     * Liefert eine Liste von {@link GostKlausurvorgabe}n zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von {@link GostKlausurvorgabe}n
+     */
+    vorgabeGetMengeByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurvorgabe>;
+    /**
+     * Gibt das {@link GostKlausurvorgabe}-Objekt zu den übergebenen Parametern zurück.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal     das Quartal
+     * @param kursartAllg die {@link GostKursart}
+     * @param idFach      die ID des Fachs
+     *
+     * @return das {@link GostKlausurvorgabe}-Objekt
+     */
+    vorgabeGetByHalbjahrAndQuartalAndKursartallgAndFachid(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, kursartAllg: GostKursart, idFach: number): GostKlausurvorgabe | null;
+    /**
+     * Liefert eine Liste von {@link GostKlausurvorgabe}n zu den übergebenen Parametern
+     * zurück.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal     die Nummer des Quartals oder 0 für alle Quartale
+     * @param kursartAllg die {@link GostKursart}
+     * @param idFach      die ID des Fachs
+     *
+     * @return die Liste der {@link GostKlausurvorgabe}-Objekte
+     */
+    vorgabeGetMengeByHalbjahrAndQuartalAndKursartallgAndFachid(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, kursartAllg: GostKursart, idFach: number): List<GostKlausurvorgabe>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurvorgabe}n zu den übergebenen Parametern
+     * zurück.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param kursartAllg die {@link GostKursart}
+     * @param idFach      die ID des Fachs
+     *
+     * @return die Liste der {@link GostKlausurvorgabe}-Objekte
+     */
+    vorgabeGetMengeByHalbjahrAndKursartallgAndFachid(abiturjahrgang: number, halbjahr: GostHalbjahr, kursartAllg: GostKursart, idFach: number): List<GostKlausurvorgabe>;
+    /**
+     * Gibt die Vorgänger-{@link GostKlausurvorgabe} zum übergebenen Parameter zurück (vorhergehendes Quartal des aktuellen Schuljahres) oder <code>null</code>, falls es keinen Vorgänger gibt.
+     *
+     * @param vorgabe das {@link GostKlausurvorgabe}-Objekt, dessen Vorgänger gesucht ist.
+     *
+     * @return die Vorgänger-{@link GostKlausurvorgabe} oder <code>null</code>, falls es keinen Vorgänger gibt.
+     */
+    vorgabeGetPrevious(vorgabe: GostKlausurvorgabe): GostKlausurvorgabe | null;
+    /**
+     * Liefert die {@link GostKursklausur} zum übergebenen {@link GostKlausurtermin} und Kursid
+     *
+     * @param termin der {@link GostKlausurtermin}, zu dem die {@link GostKursklausur} gesucht wird
+     * @param idKurs   die ID des Kurses, zu dem die {@link GostKursklausur} gesucht wird
+     *
+     * @return die {@link GostKursklausur} zum übergebenen {@link GostKlausurtermin} und Kursid
+     */
+    kursklausurGetByTerminAndKursid(termin: GostKlausurtermin, idKurs: number): GostKursklausur | null;
+    /**
+     * Liefert die {@link GostKursklausur}en des übergebenen {@link GostKlausurtermin}s, deren Kurse am übergebenen Datum,
+     * Wochentag und in der übergebenen Stunde Unterricht haben.
+     *
+     * @param termin    der {@link GostKlausurtermin}, dessen Kursklausuren gefiltert werden
+     * @param datum     das Datum, zu dem der Stundenplan gesucht wird
+     * @param wochentag der {@link Wochentag}, zu dem gefiltert wird
+     * @param stunde    die Stunde, zu der gefiltert wird
+     *
+     * @return die {@link GostKursklausur}en des Termins mit Unterricht zu den übergebenen Parametern
+     */
+    kursklausurGetMengeMitUnterrichtByTerminAndDatumAndWochentagAndStunde(termin: GostKlausurtermin, datum: string, wochentag: Wochentag, stunde: number): List<GostKursklausur>;
+    /**
+     * Liefert die Stundenplan-Zeitraster, deren Zeitbereiche durch den übergebenen Klausurtermin überlappt werden.
+     *
+     * @param termin der Klausurtermin
+     *
+     * @return die vom Klausurtermin überlappten Stundenplan-Zeitraster
+     */
+    zeitrasterGetMengeByTermin(termin: GostKlausurtermin): List<StundenplanZeitraster>;
+    /**
+     * Liefert die vom Klausurtermin überlappten Zeitraster mit den darin jeweils stattfindenden Unterrichtskursen.
+     *
+     * @param termin der Klausurtermin
+     *
+     * @return die vom Klausurtermin überlappten Zeitraster mit ihren Unterrichtskursen
+     */
+    stundenplankursGetMengeByTermin(termin: GostKlausurtermin): List<PairNN<StundenplanZeitraster, List<StundenplanKurs>>>;
+    /**
+     * Liefert die im Klausurplan bekannten Schüler eines Stundenplankurses.
+     *
+     * @param kurs der Stundenplankurs
+     *
+     * @return die Schüler des Stundenplankurses
+     */
+    schuelerGetMengeByStundenplankurs(kurs: StundenplanKurs): List<SchuelerListeEintrag>;
+    /**
+     * Liefert die Schüler eines Stundenplankurses, die während des übergebenen Zeitrasters eine aktuelle Schülerklausur schreiben.
+     *
+     * @param termin     der Klausurtermin
+     * @param zeitraster das Zeitraster des Unterrichts
+     * @param kurs       der Stundenplankurs
+     *
+     * @return die Schüler des Stundenplankurses mit Klausur während des Zeitrasters
+     */
+    schuelerGetMengeMitKlausurByTerminAndZeitrasterAndStundenplankurs(termin: GostKlausurtermin, zeitraster: StundenplanZeitraster, kurs: StundenplanKurs): List<SchuelerListeEintrag>;
+    /**
+     * Liefert die Schüler eines Stundenplankurses, die während des übergebenen Zeitrasters keine aktuelle Schülerklausur schreiben.
+     *
+     * @param termin     der Klausurtermin
+     * @param zeitraster das Zeitraster des Unterrichts
+     * @param kurs       der Stundenplankurs
+     *
+     * @return die beim Unterricht verbleibenden Schüler des Stundenplankurses
+     */
+    schuelerGetMengeVerbleibendByTerminAndZeitrasterAndStundenplankurs(termin: GostKlausurtermin, zeitraster: StundenplanZeitraster, kurs: StundenplanKurs): List<SchuelerListeEintrag>;
+    private schuelerIdsMitKlausurByTerminAndZeitraster;
+    private schuelerklausurterminAktuellGetMengeByTerminAndZeitraster;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en zum übergebenen Datum
+     *
+     * @param datum das Datum der {@link GostKlausurtermin}e im Format <code>YYYY-MM-DD</code>
+     *
+     * @return die Liste von {@link GostKlausurtermin}en zum übergebenen Datum
+     */
+    terminGetMengeByDatum(datum: string): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, die dasselbe Datum wie der als Parameter übergebene {@link GostKlausurtermin} haben.
+     *
+     * @param termin der {@link GostKlausurtermin}, an dessen Datum die {@link GostKlausurtermin}e gesucht werden.
+     * @param mitTermin wenn <code>true</code>, enthält die Rückgabe auch den {@link GostKlausurtermin} <code>termin</code>, bei <code>false</code> wird er entfernt.
+     *
+     * @return die {@link GostKlausurtermin}en, die dasselbe Datum wie der als Parameter übergebene {@link GostKlausurtermin} haben.
+     */
+    terminSelbesDatumGetMengeByTermin(termin: GostKlausurtermin, mitTermin: boolean): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von Listen von {@link GostKlausurtermin}en zum übergebenen Datum. Die inneren Listen enthalten mehrere Termine, falls sich die Termine hinsichtlich ihrer Start- und Endzeiten überschneiden.
+     *
+     * @param datum das gesuchte Datum der {@link GostKlausurtermin}e im Format <code>YYYY-MM-DD</code>
+     *
+     * @return die Liste von Listen von {@link GostKlausurtermin}en zum übergebenen Datum. Die inneren Listen enthalten mehrere Termine, falls sich die Termine hinsichtlich ihrer Start- und Endzeiten überschneiden.
+     */
+    terminGruppierteUeberschneidungenGetMengeByDatum(datum: string): List<List<GostKlausurtermin>>;
+    /**
+     * Liefert eine Liste von Listen von {@link GostKlausurtermin}en zum übergebenen Datum und Abiturjahrgang. Die inneren Listen enthalten mehrere Termine, falls sich die Termine hinsichtlich ihrer Start- und Endzeiten überschneiden.
+     *
+     * @param datum das gesuchte Datum der {@link GostKlausurtermin}e im Format <code>YYYY-MM-DD</code>
+     * @param abiturjahrgang der Abiturjahrgang, innerhalb dessen die {@link GostKlausurtermin}e gesucht werden
+     *
+     * @return die Liste von Listen von {@link GostKlausurtermin}en zum übergebenen Datum. Die inneren Listen enthalten mehrere Termine, falls sich die Termine hinsichtlich ihrer Start- und Endzeiten überschneiden.
+     */
+    terminGruppierteUeberschneidungenGetMengeByDatumAndAbijahr(datum: string, abiturjahrgang: number | null): List<List<GostKlausurtermin>>;
+    private gruppiereUeberschneidungen;
+    private checkTerminUeberschneidung;
+    /**
+     * Liefert die früheste Startzeit eines Klausurtermins anhand der zugeordneten Schüler- und Kursklausuren.
+     * Falls keine Klausur eine Startzeit besitzt, wird die Startzeit des Termins verwendet.
+     *
+     * @param termin der zu prüfende Klausurtermin
+     * @param includeNachschreiber gibt an, ob Nachschreibklausuren berücksichtigt werden
+     *
+     * @return die früheste Startzeit in Minuten oder {@code null}, falls keine Startzeit vorliegt
+     */
+    minKlausurstartzeitByTerminOrNull(termin: GostKlausurtermin, includeNachschreiber: boolean): number | null;
+    /**
+     * Liefert die späteste Endzeit der einem Klausurtermin zugeordneten Schüler- und Kursklausuren.
+     *
+     * @param termin der zu prüfende Klausurtermin
+     * @param includeNachschreiber gibt an, ob Nachschreibklausuren berücksichtigt werden
+     *
+     * @return die späteste Endzeit in Minuten oder {@code null}, falls keine berechnet werden kann
+     */
+    maxKlausurendzeitByTerminOrNull(termin: GostKlausurtermin, includeNachschreiber: boolean): number | null;
+    private hatSchuelerklausurterminByTerminAndKursklausur;
+    private kursklausurGetMengeByTerminid;
+    /**
+     * Liefert die Liste von {@link GostKursklausur}en, die zum übergebenen Termin gehören.
+     *
+     * @param termin der {@link GostKlausurtermin}, zuu dem die {@link GostKursklausur}en gesucht werden
+     *
+     * @return die Liste von {@link GostKursklausur}en, die zum übergebenen Termin gehören.
+     */
+    kursklausurGetMengeByTermin(termin: GostKlausurtermin): List<GostKursklausur>;
+    /**
+     * Liefert die Menge von {@link GostKursklausur}en, die zum übergebenen Termin gehören, die ggf. auch die {@link GostKursklausur}en der Nachschreiber an diesem Termin enthalten.
+     *
+     * @param termin der {@link GostKlausurtermin}, zuu dem die {@link GostKursklausur}en gesucht werden
+     * @param mitNachschreibern falls <code>true</code>, werden auch die {@link GostKursklausur}en der Nachschreiber an diesem Termin in der Rückgabe enthalten sein.
+     *
+     * @return die Menge von {@link GostKursklausur}en, die zum übergebenen Termin gehören, die ggf. auch die {@link GostKursklausur}en der Nachschreiber an diesem Termin enthalten.
+     */
+    kursklausurMitNachschreibernGetMengeByTermin(termin: GostKlausurtermin, mitNachschreibern: boolean): JavaSet<GostKursklausur>;
+    /**
+     * Liefert eine Liste von {@link GostKursklausur}en zu den übergebenen Parametern, für
+     * die noch kein Termin / Schiene gesetzt wurde
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr    das {@link GostHalbjahr}
+     * @param quartal     die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von GostKursklausur-Objekten
+     */
+    kursklausurOhneTerminGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKursklausur>;
+    /**
+     * Liefert eine {@link PairNN}-Liste aller aktiven Paralleljahrgänge in der Oberstufe. Die {@link PairNN}e bestehen aus dem jeweiligen Abiturjahrgang und dem {@link GostHalbjahr}.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang, zu dem die Paralleljahrgänge gesucht werden
+     * @param halbjahr    das {@link GostHalbjahr}, zu dem die Paralleljahrgänge gesucht werden
+     * @param includeSelf falls <code>true</code>, ist das {@link PairNN} aus <code>abiturjahrgang</code> und <code>halbjahr</code> in der Rückgabe inkludiert
+     *
+     * @return die {@link PairNN}-Liste aller aktiven Paralleljahrgänge in der Oberstufe. Die {@link PairNN}e bestehen aus dem jeweiligen Abiturjahrgang und dem {@link GostHalbjahr}.
+     */
+    static halbjahreParallelUndAktivGetMenge(abiturjahrgang: number, halbjahr: GostHalbjahr, includeSelf: boolean): List<PairNN<number, GostHalbjahr>>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en zu den übergebenen Parametern
+     *
+     * @param abiturjahrgang   der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param halbjahr      das {@link GostHalbjahr}, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param quartal       die Nummer des Quartals, 0 für alle Quartale
+     * @param multijahrgang wenn <code>true</code>, werden die {@link GostKlausurtermin}e der anderen aktiven Jahrgänge eingeschlossen
+     *
+     * @return die Liste von {@link GostKlausurtermin}en zu den übergebenen Parametern
+     */
+    terminGetMengeByAbijahrAndHalbjahrAndQuartalMultijahrgang(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, multijahrgang: boolean): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en zu den übergebenen Parametern
+     *
+     * @param abiturjahrgang   der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param halbjahr      das {@link GostHalbjahr}, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param quartal       die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von {@link GostKlausurtermin}en zu den übergebenen Parametern
+     */
+    terminGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en zu den übergebenen Parametern
+     *
+     * @param jahr           das Kalenderwochenjahr, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param kw             die Kalenderwoche, zu der die {@link GostKlausurtermin}e gesucht werden
+     * @param abiturjahrgang der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param multijahrgang  wenn <code>true</code>, werden die {@link GostKlausurtermin}e aller Abiturjahrgänge in der Kalenderwoche zurückgegeben
+     *
+     * @return die Liste von {@link GostKlausurtermin}en zu den übergebenen Parametern
+     */
+    terminGetMengeByJahrAndKwAndAbijahrMultijahrgang(jahr: number, kw: number, abiturjahrgang: number, multijahrgang: boolean): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en zu den übergebenen Parametern
+     *
+     * @param jahr           das Kalenderwochenjahr, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param kw             die Kalenderwoche, zu der die {@link GostKlausurtermin}e gesucht werden
+     * @param abiturjahrgang der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     *
+     * @return die Liste von {@link GostKlausurtermin}en zu den übergebenen Parametern
+     */
+    terminGetMengeByJahrAndKwAndAbijahr(jahr: number, kw: number, abiturjahrgang: number): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, die für Nachschreiber zugelassen sind, zu den übergebenen Parametern
+     *
+     * @param abiturjahrgang   der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param halbjahr      das {@link GostHalbjahr}, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param quartal       die Nummer des Quartals, 0 für alle Quartale
+     * @param multijahrgang wenn <code>true</code>, werden die {@link GostKlausurtermin}e der anderen aktiven Jahrgänge eingeschlossen
+     *
+     * @return die Liste von {@link GostKlausurtermin}en, die für Nachschreiber zugelassen, zu den übergebenen Parametern
+     */
+    terminNTGetMengeByAbijahrAndHalbjahrAndQuartalMultijahrgang(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, multijahrgang: boolean): List<GostKlausurtermin>;
+    /**
+     * Prüft, ob in einem Nachschreibtermin {@link GostSchuelerklausurtermin}e anderer
+     * Jahrgangsstufen enthalten sind
+     *
+     * @param abiturjahrgang   der Abitur-Jahrgang, dessen Nachschreibtermine geprüft werden
+     * @param halbjahr      das {@link GostHalbjahr}, dessen Nachschreibtermine geprüft werden
+     * @param quartal       die Nummer des Quartals, 0 für alle Quartale
+     * @param multijahrgang wenn <code>true</code>, werden die {@link GostKlausurtermin}e der anderen aktiven Jahrgänge eingeschlossen
+     *
+     * @return <code>true</code>, falls in einem Nachschreibtermin {@link GostSchuelerklausurtermin}e anderer
+     * Jahrgangsstufen enthalten sind
+     */
+    terminNtMengeEnthaeltFremdeJgstByAbijahrAndHalbjahrAndQuartalMultijahrgang(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, multijahrgang: boolean): boolean;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, die als Haupttermin angelegt wurden zu den übergebenen Parametern
+     *
+     * @param abiturjahrgang   der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param halbjahr      das {@link GostHalbjahr}, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param quartal       die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von {@link GostKlausurtermin}en, die als Haupttermin angelegt wurden zu den übergebenen Parametern
+     */
+    terminHtGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, denen bereits ein Datum zugewiesen wurde.
+     *
+     * @param abiturjahrgang   der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param halbjahr      das {@link GostHalbjahr}, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param quartal       die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von {@link GostKlausurtermin}en, denen bereits ein Datum zugewiesen wurde.
+     */
+    terminMitDatumGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, denen bereits ein Datum zugewiesen wurde.
+     *
+     * @return die Liste von {@link GostKlausurtermin}en, denen bereits ein Datum zugewiesen wurde.
+     */
+    terminMitDatumGetMenge(): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, denen noch kein Datum zugewiesen wurde.
+     *
+     * @return die Liste von {@link GostKlausurtermin}en, denen noch kein Datum zugewiesen wurde.
+     */
+    terminOhneDatumGetMenge(): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, denen noch kein Datum zugewiesen wurde.
+     *
+     * @param abiturjahrgang   der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param halbjahr      das {@link GostHalbjahr}, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param quartal       die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von {@link GostKlausurtermin}en, denen noch kein Datum zugewiesen wurde.
+     */
+    terminOhneDatumGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, die als Haupttermin angelegt wurden und denen bereits ein Datum zugewiesen wurde.
+     *
+     * @param abiturjahrgang   der Abitur-Jahrgang, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param halbjahr      das {@link GostHalbjahr}, zu dem die {@link GostKlausurtermin}e gesucht werden
+     * @param quartal       die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von {@link GostKlausurtermin}en, die als Haupttermin angelegt wurden und denen bereits ein Datum zugewiesen wurde.
+     */
+    terminHtMitDatumGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     * Gibt das allen Kursklausuren gemeinsame Quartal innerhalb des übergebenen {@link GostKlausurtermin}s zurück. Falls es verschiedene Quartale sind, wird <code>-1</code> zurückgegeben.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     *
+     * @return das allen Kursklausuren gemeinsame Quartal innerhalb des übergebenen {@link GostKlausurtermin}s, sonst <code>-1</code>.
+     */
+    quartalGetByTermin(termin: GostKlausurtermin): number;
+    /**
+     * Liefert die minimale Startzeit des {@link GostKlausurtermin}s in Minuten und berücksichtigt dabei auf Wunsch auch Nachschreibklausuren an dem Termin
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren an dem Termin berücksichtigt
+     *
+     * @return die minimale Startzeit des {@link GostKlausurtermin}s in Minuten ggf. unter Berücksichtigung der Nachschreibklausuren an dem Termin
+     */
+    minKlausurstartzeitByTermin(termin: GostKlausurtermin, includeNachschreiber: boolean): number;
+    /**
+     * Liefert die minimale Startzeit des {@link GostKlausurraum}s in Minuten und berücksichtigt dabei auf Wunsch auch Nachschreibklausuren an dem Termin
+     *
+     * @param raum der zu prüfende {@link GostKlausurraum}
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren an dem Termin berücksichtigt
+     *
+     * @return die minimale Startzeit des {@link GostKlausurraum}s in Minuten ggf. unter Berücksichtigung der Nachschreibklausuren an dem Termin
+     */
+    minKlausurstartzeitByRaum(raum: GostKlausurraum, includeNachschreiber: boolean): number;
+    /**
+     * Liefert die minimale Startzeit der {@link GostSchuelerklausurtermin}e in Minuten im Kontext des übergebenen {@link GostKlausurraum}s.
+     * Der Raumkontext wird benötigt, wenn Kursklausuren in Räumen eines anderen, z.B. jahrgangsübergreifenden, Termins geschrieben werden.
+     *
+     * @param raum der {@link GostKlausurraum}, dessen Terminkontext verwendet wird
+     * @param skts die zu prüfenden {@link GostSchuelerklausurtermin}e
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren in der Menge berücksichtigt
+     *
+     * @return die minimale Startzeit der {@link GostSchuelerklausurtermin}e im Kontext des {@link GostKlausurraum}s
+     */
+    minKlausurstartzeitByKlausurraumAndSchuelerklausurterminMenge(raum: GostKlausurraum, skts: List<GostSchuelerklausurtermin>, includeNachschreiber: boolean): number;
+    /**
+     * Liefert die minimale Startzeit der {@link GostSchuelerklausurtermin}e in Minuten im jeweiligen Terminkontext des Schülerklausurtermins.
+     * Für die Ermittlung von Raumstunden muss die Methode mit Raumkontext verwendet werden.
+     *
+     * @param skts die zu prüfenden {@link GostSchuelerklausurtermin}e
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren in der Menge berücksichtigt
+     *
+     * @return die minimale Startzeit der {@link GostSchuelerklausurtermin}e in Minuten im jeweiligen Terminkontext
+     */
+    private minKlausurstartzeitBySchuelerklausurterminMenge;
+    private minKlausurstartzeitBySchuelerklausurterminMengeOrNull;
+    private minKlausurstartzeitBySchuelerklausurterminMengeIntern;
+    private minKlausurstartzeitByKlausurraumAndSchuelerklausurterminMengeIntern;
+    /**
+     * Liefert die maximale Endzeit des {@link GostKlausurraum}s in Minuten und berücksichtigt dabei auf Wunsch auch Nachschreibklausuren an dem Termin
+     *
+     * @param raum der zu prüfende {@link GostKlausurraum}
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren an dem Termin berücksichtigt
+     *
+     * @return die maximale Endzeit des {@link GostKlausurraum}s in Minuten ggf. unter Berücksichtigung der Nachschreibklausuren an dem Termin
+     */
+    maxKlausurendzeitByRaum(raum: GostKlausurraum, includeNachschreiber: boolean): number;
+    /**
+     * Liefert die maximale Endzeit der {@link GostSchuelerklausurtermin}e in Minuten im Kontext des übergebenen {@link GostKlausurraum}s.
+     * Der Raumkontext wird benötigt, wenn Kursklausuren in Räumen eines anderen, z.B. jahrgangsübergreifenden, Termins geschrieben werden.
+     *
+     * @param raum der {@link GostKlausurraum}, dessen Terminkontext verwendet wird
+     * @param skts die zu prüfenden {@link GostSchuelerklausurtermin}e
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren in der Menge berücksichtigt
+     *
+     * @return die maximale Endzeit der {@link GostSchuelerklausurtermin}e im Kontext des {@link GostKlausurraum}s
+     */
+    maxKlausurendzeitByKlausurraumAndSchuelerklausurterminMenge(raum: GostKlausurraum, skts: List<GostSchuelerklausurtermin>, includeNachschreiber: boolean): number;
+    /**
+     * Liefert die maximale Endzeit des {@link GostKlausurtermin}s in Minuten anhand der zugeordneten Schüler- und Kursklausuren
+     * und berücksichtigt dabei auf Wunsch auch Nachschreibklausuren an dem Termin.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren an dem Termin berücksichtigt
+     *
+     * @return die maximale Endzeit des {@link GostKlausurtermin}s in Minuten ggf. unter Berücksichtigung der Nachschreibklausuren an dem Termin
+     */
+    maxKlausurendzeitByTermin(termin: GostKlausurtermin, includeNachschreiber: boolean): number;
+    /**
+     * Liefert die maximale Endzeit der {@link GostSchuelerklausurtermin}e in Minuten im jeweiligen Terminkontext des Schülerklausurtermins.
+     * Für die Ermittlung von Raumstunden muss die Methode mit Raumkontext verwendet werden.
+     *
+     * @param skts die zu prüfenden {@link GostSchuelerklausurtermin}e
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren in der Menge berücksichtigt
+     *
+     * @return die maximale Endzeit der {@link GostSchuelerklausurtermin}e in Minuten im jeweiligen Terminkontext
+     */
+    private maxKlausurendzeitBySchuelerklausurterminMenge;
+    private maxKlausurendzeitBySchuelerklausurterminMengeOrNull;
+    private maxKlausurendzeitBySchuelerklausurterminMengeIntern;
+    private maxKlausurendzeitByKlausurraumAndSchuelerklausurterminMengeIntern;
+    /**
+     * Liefert die minimale Klausurdauer der Kurs- und Schülerklausuren eines {@link GostKlausurtermin}s in Minuten.
+     * Schüler-Nachschreibklausuren werden auf Wunsch berücksichtigt.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren an dem Termin berücksichtigt
+     *
+     * @return die minimale Klausurdauer des {@link GostKlausurtermin}s in Minuten ggf. unter Berücksichtigung der Nachschreibklausuren an dem Termin
+     */
+    minKlausurdauerGetByTermin(termin: GostKlausurtermin, includeNachschreiber: boolean): number;
+    /**
+     * Liefert die maximale Klausurdauer der Kurs- und Schülerklausuren eines {@link GostKlausurtermin}s in Minuten.
+     * Schüler-Nachschreibklausuren werden auf Wunsch berücksichtigt.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param includeNachschreiber wenn <code>true</code> werden auch Nachschreibklausuren an dem Termin berücksichtigt
+     *
+     * @return die maximale Klausurdauer des {@link GostKlausurtermin}s in Minuten ggf. unter Berücksichtigung der Nachschreibklausuren an dem Termin
+     */
+    maxKlausurdauerGetByTermin(termin: GostKlausurtermin, includeNachschreiber: boolean): number;
+    /**
+     * Liefert die Konflikt-Paare, wenn {@link GostSchuelerklausurtermin}e aus der Menge <code>menge2</code> in die
+     * Menge <code>menge1</code> hinzugefügt werden. Falls ein {@link GostSchuelerklausurtermin} aus
+     * <code>menge1</code> bereits in <code>menge2</code> enthalten ist, wird dies nicht als Konflikt
+     * bewertet.
+     *
+     * @param menge1 die Liste der Ziel-{@link GostSchuelerklausurtermin}e, in die die Integration geprüft werden soll
+     * @param menge2 die Liste der Quell-{@link GostSchuelerklausurtermin}e, aus der die Integration in <code>menge1</code> geprüft werden soll
+     *
+     * @return die Liste der Konflikt-Paare
+     */
+    private konfliktPaarSchuelerklausurtermineGetMenge;
+    private hatKonfliktBySchuelerklausurterminen;
+    /**
+     * Berechnet die Konflikt-Menge, wenn der übergebene {@link GostSchuelerklausurtermin} in den übergebenen {@link GostKlausurtermin} hinzugefügt wird. Falls der übergebene {@link GostSchuelerklausurtermin} bereits im {@link GostKlausurtermin} enthalten ist, wird dies nicht als Konflikt
+     * bewertet.
+     *
+     * @param termin der {@link GostKlausurtermin}, in den <code>skt</code> hinzugefügt werden soll
+     * @param skt der {@link GostSchuelerklausurtermin}, der in <code>termin</code> hinzugefügt werden soll
+     *
+     * @return die Liste von {@link PairNN}en aus den beiden am Konflikt beteiligten {@link GostSchuelerklausurtermin}en
+     */
+    konfliktPaarGetMengeTerminAndSchuelerklausurtermin(termin: GostKlausurtermin, skt: GostSchuelerklausurtermin): List<PairNN<GostSchuelerklausurtermin, GostSchuelerklausurtermin>>;
+    /**
+     * Berechnet die Konflikt-Menge, wenn die übergebenen {@link GostSchuelerklausurtermin}e in den übergebenen
+     * {@link GostKlausurtermin} hinzugefügt werden. Konflikte gegen bereits enthaltene identische Schülerklausurtermine
+     * werden nicht bewertet.
+     *
+     * @param termin der {@link GostKlausurtermin}, in den <code>skts</code> hinzugefügt werden sollen
+     * @param skts die {@link GostSchuelerklausurtermin}e, die in <code>termin</code> hinzugefügt werden sollen
+     *
+     * @return die Liste von {@link PairNN}en aus den beiden am Konflikt beteiligten {@link GostSchuelerklausurtermin}en
+     */
+    konfliktPaarGetMengeTerminAndSchuelerklausurtermine(termin: GostKlausurtermin, skts: List<GostSchuelerklausurtermin>): List<PairNN<GostSchuelerklausurtermin, GostSchuelerklausurtermin>>;
+    /**
+     * Prüft, ob der zu einem {@link GostSchuelerklausurtermin} gehörige Schüler in einer {@link GostKursklausur} enthalten ist.
+     *
+     * @param schuelerklausurtermin der zu prüfende {@link GostSchuelerklausurtermin}
+     * @param kursklausur     die zu prüfende {@link GostKursklausur}
+     *
+     * @return <code>true</code>, falls der zum {@link GostSchuelerklausurtermin} gehörige Schüler in der {@link GostKursklausur} enthalten ist
+     */
+    konfliktZuKursklausurBySchuelerklausur(schuelerklausurtermin: GostSchuelerklausurtermin, kursklausur: GostKursklausur): boolean;
+    /**
+     * Prüft, ob der übergebene {@link GostSchuelerklausurtermin} im übergebenen {@link GostKlausurtermin} mit einem anderen
+     * aktuellen {@link GostSchuelerklausurtermin} desselben Schülers kollidiert.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param schuelerklausurtermin der zu prüfende {@link GostSchuelerklausurtermin}
+     *
+     * @return <code>true</code>, falls im Termin ein anderer aktueller Schülerklausurtermin desselben Schülers vorhanden ist
+     */
+    hatKonfliktByTerminAndSchuelerklausurtermin(termin: GostKlausurtermin, schuelerklausurtermin: GostSchuelerklausurtermin): boolean;
+    /**
+     * Prüft, ob die übergebene {@link GostKursklausur} fachlich in den übergebenen {@link GostKlausurtermin} passt.
+     * Eine Kursklausur passt, wenn der Termin für alle Quartale gilt oder dem Quartal der Klausurvorgabe entspricht.
+     *
+     * @param termin      der zu prüfende {@link GostKlausurtermin}
+     * @param kursklausur die zu prüfende {@link GostKursklausur}
+     *
+     * @return <code>true</code>, wenn die Kursklausur in den Termin passt
+     */
+    kursklausurPasstInTermin(termin: GostKlausurtermin, kursklausur: GostKursklausur): boolean;
+    /**
+     * Prüft, ob der übergebene {@link GostSchuelerklausurtermin} fachlich in den übergebenen Nachschreibtermin passt.
+     * Der Schülerklausurtermin passt, wenn der Termin für alle Quartale gilt oder dem Quartal der Klausurvorgabe entspricht
+     * und für den Schüler im Zieltermin noch kein Schülerklausurtermin existiert.
+     *
+     * @param termin                  der zu prüfende {@link GostKlausurtermin}
+     * @param schuelerklausurtermin  der zu prüfende {@link GostSchuelerklausurtermin}
+     *
+     * @return <code>true</code>, wenn der Schülerklausurtermin in den Nachschreibtermin passt
+     */
+    schuelerklausurterminPasstInNachschreibtermin(termin: GostKlausurtermin, schuelerklausurtermin: GostSchuelerklausurtermin): boolean;
+    /**
+     * Prüft, ob die übergebenen {@link GostSchuelerklausurtermin}e fachlich gemeinsam in den übergebenen Nachschreibtermin passen.
+     * Die Schülerklausurtermine passen, wenn der Termin für Nachschreiber zugelassen ist, für alle Quartale gilt oder dem Quartal der
+     * jeweiligen Vorgabe entspricht und für keinen Schüler im Zieltermin oder in der übergebenen Menge ein weiterer Schülerklausurtermin
+     * existiert.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param schuelerklausurtermine die zu prüfenden {@link GostSchuelerklausurtermin}e
+     *
+     * @return <code>true</code>, wenn die Schülerklausurtermine gemeinsam in den Nachschreibtermin passen
+     */
+    schuelerklausurterminePassenInNachschreibtermin(termin: GostKlausurtermin, schuelerklausurtermine: List<GostSchuelerklausurtermin>): boolean;
+    /**
+     * Liefert eine Liste mit {@link GostKursklausur}en und den zugehörigen Schülern, die bereits existierende Konflikte im
+     * übergebenen {@link GostKlausurtermin} enthält. Bei Konflikten zwischen Nachschreibern werden deren zugehörige
+     * Kursklausuren aufgeführt.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     *
+     * @return die Liste mit {@link GostKursklausur}en und den zugehörigen Schülern, die bereits existierende Konflikte im
+     * übergebenen {@link GostKlausurtermin} enthält
+     */
+    konflikteKursklausurSchuelerByTermin(termin: GostKlausurtermin): List<PairNN<GostKursklausur, List<SchuelerListeEintrag>>>;
+    /**
+     * Liefert die Anzahl der bereits existierenden Schüler-Konflikte innerhalb des übergebenen {@link GostKlausurtermin}s.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     *
+     * @return die Anzahl der bereits existierenden Schüler-Konflikte innerhalb des übergebenen {@link GostKlausurtermin}s.
+     */
+    konflikteAnzahlGetByTermin(termin: GostKlausurtermin): number;
+    private konflikteMapByTermin;
+    private konflikteMapByKonfliktpaaren;
+    /**
+     * Liefert eine Liste mit {@link GostKursklausur} und den zugehörigen Schülern, die nur die neuen Konflikte liefert,
+     * die die übergebe {@link GostKursklausur} beim Hinzufügen im übergebenen {@link GostKlausurtermin} verursacht.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param kursklausur die zu prüfende {@link GostKursklausur}
+     *
+     * @return die Liste mit {@link GostKursklausur} und den zugehörigen Schülern, die nur die neuen Konflikte liefert,
+     * die die Übergebe {@link GostKursklausur} beim Hinzufügen im übergebenen {@link GostKlausurtermin} verursacht.
+     */
+    konflikteNeuKursklausurSchuelerByTerminAndKursklausur(termin: GostKlausurtermin, kursklausur: GostKursklausur): List<PairNN<GostKursklausur, List<SchuelerListeEintrag>>>;
+    /**
+     * Liefert die Anzahl der neuen Schüler-Konflikte, die die übergebe {@link GostKursklausur} beim Hinzufügen im übergebenen {@link GostKlausurtermin}
+     * verursacht.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param kursklausur die zu prüfende {@link GostKursklausur}
+     *
+     * @return die Anzahl der neuen Schüler-Konflikte, die die übergebe {@link GostKursklausur} beim Hinzufügen im übergebenen {@link GostKlausurtermin}
+     * verursacht.
+     */
+    konflikteAnzahlZuTerminGetByTerminAndKursklausur(termin: GostKlausurtermin, kursklausur: GostKursklausur): number;
+    private aktuelleHauptversucheByKursklausur;
+    private konflikteNeuMapByTerminAndKursklausur;
+    /**
+     * Liefert alle Konflikte des Zieltermins nach dem angenommenen Hinzufügen einer Kursklausur.
+     *
+     * @param kursklausur die hinzuzufügende Kursklausur
+     * @param termin der Zieltermin
+     * @return die betroffenen Kursklausuren mit den jeweils betroffenen Schülern
+     */
+    konflikteNachZuweisungByKursklausurZuTermin(kursklausur: GostKursklausur, termin: GostKlausurtermin): List<PairNN<GostKursklausur, List<SchuelerListeEintrag>>>;
+    /**
+     * Zählt die unterschiedlichen betroffenen Schüler am Zieltermin nach der angenommenen Kursklausur-Zuweisung.
+     *
+     * @param kursklausur die hinzuzufügende Kursklausur
+     * @param termin der Zieltermin
+     * @return die Anzahl der betroffenen Schüler
+     */
+    konflikteAnzahlNachZuweisungByKursklausurZuTermin(kursklausur: GostKursklausur, termin: GostKlausurtermin): number;
+    private konflikteNachZuweisungMapByKursklausurZuTermin;
+    private konflikteZuEigenemTerminMapByKursklausur;
+    /**
+     * Liefert die Anzahl Schüler-Konfilte, die die übergebe {@link GostKursklausur} im zugewiesenen {@link GostKlausurtermin} verursacht.
+     *
+     * @param klausur die zu prüfende {@link GostKursklausur}
+     *
+     * @return die Anzahl Schüler-Konfilte, die die übergebe {@link GostKursklausur} im zugewiesenen {@link GostKlausurtermin} verursacht.
+     */
+    konflikteAnzahlZuEigenemTerminGetByKursklausur(klausur: GostKursklausur): number;
+    private berechneKonflikte;
+    private addNachschreiberKonflikteByKursklausur;
+    private toKursklausurSchuelerKonflikte;
+    private berechneKlausurKonflikte;
+    private static berechneIdKonflikte;
+    private static countKonflikte;
+    /**
+     * Liefert für einen Schwellwert und einen {@link GostKlausurtermin} eine Liste mit Schülern und zugehörigen {@link GostSchuelerklausurtermin}en für Schüler, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert, und die betreffenden {@link GostSchuelerklausurtermin}e.
+     *
+     * @param termin    der {@link GostKlausurtermin}, dessen Kalenderwoche geprüft wird
+     * @param threshold der Schwellwert (z. B. 3), der mindestens erreicht sein muss, damit die Schüler-IDs in die Rückgabe-Map aufgenommen werden
+     *
+     * @return die Liste mit Schülern und zugehörigen {@link GostSchuelerklausurtermin}en für Schüler, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert und die betreffenden {@link GostSchuelerklausurtermin}e.
+     */
+    klausurenProSchueleridExceedingKWThresholdByTerminAndThreshold(termin: GostKlausurtermin, threshold: number): List<PairNN<SchuelerListeEintrag, List<GostSchuelerklausurtermin>>>;
+    /**
+     * Liefert für einen Schwellwert, einen {@link GostKlausurtermin} und eine {@link GostKursklausur} eine Liste mit Schülern und zugehörigen {@link GostSchuelerklausurtermin}en für Schüler, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert, und die betreffenden {@link GostSchuelerklausurtermin}e, wenn die übergebene {@link GostKursklausur} in den übergebenen {@link GostKlausurtermin} integriert würde.
+     *
+     * @param termin    der {@link GostKlausurtermin}, dessen Kalenderwoche geprüft wird
+     * @param klausur   die {@link GostKursklausur}, deren Integration in den {@link GostKlausurtermin} <code>termin</code> angenommen wird
+     * @param threshold der Schwellwert (z. B. 3), der mindestens erreicht sein muss, damit die
+     *                  Schüler-IDs in die Rückgabe-Map aufgenommen werden
+     *
+     * @return die Liste mit Schülern und zugehörigen {@link GostSchuelerklausurtermin}en für Schüler, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert, und die betreffenden {@link GostSchuelerklausurtermin}e, wenn die übergebene {@link GostKursklausur} in den übergebenen {@link GostKlausurtermin} integriert würde.
+     */
+    klausurenProSchueleridExceedingKWThresholdByTerminAndKursklausurAndThreshold(termin: GostKlausurtermin, klausur: GostKursklausur, threshold: number): List<PairNN<SchuelerListeEintrag, List<GostSchuelerklausurtermin>>>;
+    /**
+     * Liefert für einen Schwellwert und ein Datum eine Liste mit Schülern und zugehörigen {@link GostSchuelerklausurtermin}en für Schüler, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert, und die betreffenden {@link GostSchuelerklausurtermin}e, wenn der übergebene {@link GostKlausurtermin} in die Kalenderwoche zusätzlich geplant würde.
+     *
+     * @param termin        der Klausurtermin, der zusätzlich in die durch <code>datum</code> angegebene Kalenderwoche geplant werden soll
+     * @param datum         das Datum, dessen Kalenderwoche auf die Klausuranzahl geprüft wird
+     * @param threshold     der Schwellwert (z. B. 3), der mindestens erreicht sein muss, damit die
+     *                  Schüler-IDs in die Rückgabe-Map aufgenommen werden
+     * @param thresholdOnly wenn <code>true</code> wird die Schüler-ID nur bei exaktem Erreichen des <code>threshold</code> in die Rückgabe-Map aufgenommen. Größere Werte werden nicht berücksichtigt.
+     *
+     * @return die Liste mit Schülern und zugehörigen {@link GostSchuelerklausurtermin}en für Schüler, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert, und die betreffenden {@link GostSchuelerklausurtermin}e, wenn der übergebene {@link GostKlausurtermin} in die Kalenderwoche zusätzlich geplant würde.
+     */
+    klausurenProSchueleridExceedingKWThresholdByTerminAndDatumAndThreshold(termin: GostKlausurtermin, datum: string, threshold: number, thresholdOnly: boolean): List<PairNN<SchuelerListeEintrag, List<GostSchuelerklausurtermin>>>;
+    private klausurenProSchueleridExceedingKWThresholdByJahrAndKwAndAbijahrAndAddmengeAndThreshold;
+    /**
+     * Liefert für einen Schwellwert, ein Kalenderwochenjahr, eine Kalenderwoche und ein Abiturjahr eine Liste mit Schülern und zugehörigen {@link GostSchuelerklausurtermin}en für Schüler, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert, und die betreffenden {@link GostSchuelerklausurtermin}e.
+     *
+     * @param jahr          das Kalenderwochenjahr, für das die Klausuranzahl geprüft wird
+     * @param kw            die Kalenderwoche, für die die Klausuranzahl geprüft wird
+     * @param abiturjahrgang       das Abiturjahr der gesuchten Konflikt-Schüler
+     * @param threshold     der Schwellwert (z. B. 3), der mindestens erreicht sein muss, damit die
+     *                  Schüler-IDs in die Rückgabe-Map aufgenommen werden
+     * @param thresholdOnly wenn <code>true</code> wird die Schüler-ID nur bei exaktem Erreichen des <code>threshold</code> in die Rückgabe-Map aufgenommen. Größere Werte werden nicht berücksichtigt.
+     *
+     * @return die Liste mit Schülern und zugehörigen {@link GostSchuelerklausurtermin}en für Schüler, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert und die betreffenden {@link GostSchuelerklausurtermin}e.
+     */
+    klausurenProSchueleridExceedingKWThresholdByJahrAndKwAndAbijahrAndThreshold(jahr: number, kw: number, abiturjahrgang: number, threshold: number, thresholdOnly: boolean): List<PairNN<SchuelerListeEintrag, List<GostSchuelerklausurtermin>>>;
+    /**
+     * Liefert für einen Schwellwert, eine Kalenderwoche und ein Abiturjahr eine Map Schüler-ID → {@link GostSchuelerklausurtermin}menge, die Schüler-IDs von Schülern enthalten, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert, und die betreffenden {@link GostSchuelerklausurtermin}e.
+     *
+     * @param abiturjahrgang       das Abiturjahr der gesuchten Konflikt-Schüler
+     * @param halbjahr das GostHalbjahr
+     * @param quartal das Quartal
+     * @param threshold     der Schwellwert (z. B. 3), der mindestens erreicht sein muss, damit die
+     *                  Schüler-IDs in die Rückgabe-Map aufgenommen werden
+     * @param thresholdMinus der Schwellwert (z. B. 4), dessen Menge von der Threshold-Menge abgezogen wird, damit Warnungen nicht die Fehler enthalten, bei -1 wird nichts abgezogen
+     *
+     * @return die Map Schüler-ID → {@link GostSchuelerklausurtermin}menge, die Schüler-IDs von Schülern enthalten, die in der den Termin
+     * enthaltenen Kalenderwoche mehr (>=) Klausuren schreiben, als der Schwellwert definiert und die betreffenden {@link GostSchuelerklausurtermin}e.
+     */
+    klausurenProSchueleridExceedingKWThresholdByAbijahrAndHalbjahrAndThreshold(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, threshold: number, thresholdMinus: number): List<PairNN<PairNN<number, SchuelerListeEintrag>, List<GostSchuelerklausurtermin>>>;
+    /**
+     * Liefert für eine Liste von {@link GostSchuelerklausur}en die zugehörigen
+     * Schüler-IDs als Liste.
+     *
+     * @param sks die Liste von {@link GostSchuelerklausur}en
+     *
+     * @return die Liste der Schüler-IDs
+     */
+    private getSchuelerIDsFromSchuelerklausurterminen;
+    /**
+     * Liefert für eine Liste von {@link GostSchuelerklausur}en die zugehörigen
+     * Schüler-IDs als Liste.
+     *
+     * @param sks die Liste von {@link GostSchuelerklausur}en
+     *
+     * @return die Liste der Schüler-IDs
+     */
+    getSchuelerIDsFromSchuelerklausuren(sks: List<GostSchuelerklausur>): List<number>;
+    /**
+     * Liefert für eine {@link GostKursklausur} die zugehörigen Schüler-IDs als Liste.
+     *
+     * @param kk die {@link GostKursklausur}, zu der die Schüler-IDs gesucht werden
+     *
+     * @return die Liste der Schüler-IDs
+     */
+    private getSchuelerIDsAktivFromKursklausur;
+    /**
+     * Liefert den {@link GostKlausurtermin} zu einer {@link GostKursklausur}, sonst <code>null</code>, wenn noch kein Termin bestimmt wurde.
+     *
+     * @param klausur die {@link GostKursklausur}, zu der der Termin gesucht wird.
+     *
+     * @return den {@link GostKlausurtermin} oder <code>null</code>
+     */
+    terminOrNullByKursklausur(klausur: GostKursklausur): GostKlausurtermin | null;
+    /**
+     * Liefert den {@link GostKlausurtermin} zu einer {@link GostSchuelerklausur}, sonst <code>null</code>, wenn noch kein Termin bestimmt wurde.
+     *
+     * @param sk die {@link GostSchuelerklausur}, zu der der Termin gesucht wird.
+     *
+     * @return den {@link GostKlausurtermin} oder <code>null</code>
+     */
+    terminOrNullBySchuelerklausur(sk: GostSchuelerklausur): GostKlausurtermin | null;
+    /**
+     * Liefert den {@link GostKlausurtermin} zu einer {@link GostKursklausur}. Wenn noch kein Termin bestimmt ist, wird eine <code>DeveloperNotificationException</code> geworfen.
+     *
+     * @param klausur die {@link GostKursklausur}, zu der der Termin gesucht wird.
+     *
+     * @return den {@link GostKlausurtermin}
+     */
+    terminOrExceptionByKursklausur(klausur: GostKursklausur): GostKlausurtermin;
+    /**
+     * Liefert den {@link GostKlausurtermin} zu einem {@link GostSchuelerklausurtermin} oder <code>null</code>, wenn noch kein Termin bestimmt wurde.
+     *
+     * @param termin der {@link GostSchuelerklausurtermin}, zu dem der Termin gesucht wird.
+     *
+     * @return den {@link GostKlausurtermin}
+     */
+    terminOrNullBySchuelerklausurtermin(termin: GostSchuelerklausurtermin): GostKlausurtermin | null;
+    /**
+     * Liefert den {@link GostKlausurtermin} zu einem {@link GostSchuelerklausurtermin}. Wenn noch kein Termin bestimmt ist, wird eine <code>DeveloperNotificationException</code> geworfen.
+     *
+     * @param termin der {@link GostSchuelerklausurtermin}, zu dem der Termin gesucht wird.
+     *
+     * @return den {@link GostKlausurtermin}
+     */
+    terminOrExceptionBySchuelerklausurtermin(termin: GostSchuelerklausurtermin): GostKlausurtermin;
+    private datumSchuelerklausurterminOrNull;
+    /**
+     * Liefert den {@link GostKlausurtermin} zu einer {@link GostSchuelerklausur} oder <code>null</code>, wenn noch kein Termin bestimmt wurde.
+     *
+     * @param sk die {@link GostSchuelerklausur}, zu der der Termin gesucht wird.
+     *
+     * @return den {@link GostKlausurtermin}
+     */
+    terminKursklausurBySchuelerklausur(sk: GostSchuelerklausur): GostKlausurtermin | null;
+    /**
+     * Liefert die {@link GostKlausurvorgabe} zu einer {@link GostKursklausur}.
+     *
+     * @param klausur die {@link GostKursklausur}, zu der die Vorgabe gesucht wird.
+     *
+     * @return die {@link GostKlausurvorgabe}
+     */
+    vorgabeByKursklausur(klausur: GostKursklausur): GostKlausurvorgabe;
+    /**
+     * Liefert die {@link GostKlausurvorgabe} zu einer {@link GostSchuelerklausur}.
+     *
+     * @param klausur die {@link GostSchuelerklausur}, zu der die Vorgabe gesucht wird.
+     *
+     * @return die {@link GostKlausurvorgabe}
+     */
+    vorgabeBySchuelerklausur(klausur: GostSchuelerklausur): GostKlausurvorgabe;
+    /**
+     * Liefert die {@link GostKlausurvorgabe} zu einem {@link GostSchuelerklausurtermin}.
+     *
+     * @param klausur der {@link GostSchuelerklausurtermin}, zu dem die Vorgabe gesucht wird.
+     *
+     * @return die {@link GostKlausurvorgabe}
+     */
+    vorgabeBySchuelerklausurtermin(klausur: GostSchuelerklausurtermin): GostKlausurvorgabe;
+    /**
+     * Liefert die {@link GostSchuelerklausur} zu einem {@link GostSchuelerklausurtermin}.
+     *
+     * @param klausur der {@link GostSchuelerklausurtermin}, zu der die {@link GostSchuelerklausur} gesucht wird.
+     *
+     * @return die {@link GostSchuelerklausur}
+     */
+    schuelerklausurBySchuelerklausurtermin(klausur: GostSchuelerklausurtermin): GostSchuelerklausur;
+    /**
+     * Liefert die {@link GostKursklausur} zu einer {@link GostSchuelerklausur}.
+     *
+     * @param klausur die {@link GostSchuelerklausur}, zu der die {@link GostKursklausur} gesucht wird.
+     *
+     * @return die {@link GostKursklausur}
+     */
+    kursklausurBySchuelerklausur(klausur: GostSchuelerklausur): GostKursklausur;
+    /**
+     * Liefert die {@link GostKursklausur} zu einer {@link GostKlausurvorgabe} und einer Kurs-ID.
+     *
+     * @param vorgabe die {@link GostKlausurvorgabe}, zu der die {@link GostKursklausur} gesucht wird.
+     * @param idKurs die ID des Kurses der {@link GostKursklausur}.
+     *
+     * @return die {@link GostKursklausur}
+     */
+    kursklausurByVorgabeAndKursid(vorgabe: GostKlausurvorgabe, idKurs: number): GostKursklausur | null;
+    /**
+     * Liefert die {@link GostKursklausur} zu einem {@link GostSchuelerklausurtermin}.
+     *
+     * @param termin der {@link GostSchuelerklausurtermin}, zu der die {@link GostKursklausur} gesucht wird.
+     *
+     * @return die {@link GostKursklausur}
+     */
+    kursklausurBySchuelerklausurtermin(termin: GostSchuelerklausurtermin): GostKursklausur;
+    /**
+     * Liefert zurück, ob die übergebene {@link GostKlausurvorgabe} von einer {@link GostKursklausur}
+     * verwendet wird.
+     *
+     * @param vorgabe die {@link GostKlausurvorgabe}, die auf Verwendung geprüft werden soll.
+     *
+     * @return <code>true</code>, falls die {@link GostKlausurvorgabe} verwendet wird, sonst <code>false</code>
+     */
+    istVorgabeVerwendetByKursklausur(vorgabe: GostKlausurvorgabe): boolean;
+    /**
+     * Liefert die Vorgänger-{@link GostKursklausur} aus dem letzten Quartal, wenn eine solche existiert, sonst <code>null</code>.
+     *
+     * @param klausur die {@link GostKursklausur}, deren Vorgänger gesucht wird
+     *
+     * @return die {@link GostKursklausur} oder <code>null</code>
+     */
+    kursklausurVorterminByKursklausur(klausur: GostKursklausur): GostKursklausur | null;
+    /**
+     * Gibt die Startzeit des übergebenen {@link GostSchuelerklausurtermin}s aus. Falls keine individuelle Zeit
+     * gesetzt ist, wird bei einem regulären Schülerklausurtermin die Zeit der {@link GostKursklausur}, bei einem
+     * Nachschreibertermin die Zeit des zugeordneten {@link GostKlausurtermin}s zurückgegeben. Sollte keine
+     * Startzeit definiert sein, wird <code>null</code> zurückgegeben.
+     *
+     * @param skt der {@link GostSchuelerklausurtermin}, dessen Startzeit gesucht wird.
+     *
+     * @return die Startzeit des {@link GostSchuelerklausurtermin}s oder <code>null</code>
+     */
+    startzeitBySchuelerklausurterminOrNull(skt: GostSchuelerklausurtermin): number | null;
+    /**
+     * Gibt die Startzeit des übergebenen {@link GostSchuelerklausurtermin}s aus. Falls keine individuelle Zeit
+     * gesetzt ist, wird die Zeit der {@link GostKursklausur} zurückgegeben, sonst die des {@link GostKlausurtermin}s. Sollte kein {@link GostKlausurtermin} gesetzt
+     * sein oder der {@link GostKlausurtermin} keine Startzeit definiert haben, wird eine <code>DeveloperNotificationException</code> geworfen.
+     * zurückgegeben.
+     *
+     * @param skt der {@link GostSchuelerklausurtermin}, dessen Startzeit gesucht wird.
+     *
+     * @return die Startzeit des {@link GostSchuelerklausurtermin}s
+     */
+    startzeitBySchuelerklausurterminOrException(skt: GostSchuelerklausurtermin): number;
+    /**
+     * Gibt die Startzeit des übergebenen {@link GostSchuelerklausurtermin}s im Kontext des übergebenen {@link GostKlausurraum}s zurück.
+     * Dieser Zugriff wird für Raumstunden benötigt, wenn Schülerklausuren in Räumen eines anderen Termins geschrieben werden.
+     *
+     * @param raum der {@link GostKlausurraum}, dessen Terminkontext verwendet wird
+     * @param skt  der {@link GostSchuelerklausurtermin}, dessen Startzeit gesucht wird
+     *
+     * @return die Startzeit des {@link GostSchuelerklausurtermin}s im Kontext des {@link GostKlausurraum}s oder <code>null</code>
+     */
+    startzeitByKlausurraumAndSchuelerklausurterminOrNull(raum: GostKlausurraum, skt: GostSchuelerklausurtermin): number | null;
+    /**
+     * Gibt die Startzeit des übergebenen {@link GostSchuelerklausurtermin}s im Kontext des übergebenen {@link GostKlausurraum}s zurück.
+     * Falls keine Startzeit ermittelt werden kann, wird eine {@link DeveloperNotificationException} geworfen.
+     *
+     * @param raum der {@link GostKlausurraum}, dessen Terminkontext verwendet wird
+     * @param skt  der {@link GostSchuelerklausurtermin}, dessen Startzeit gesucht wird
+     *
+     * @return die Startzeit des {@link GostSchuelerklausurtermin}s im Kontext des {@link GostKlausurraum}s
+     */
+    startzeitByKlausurraumAndSchuelerklausurterminOrException(raum: GostKlausurraum, skt: GostSchuelerklausurtermin): number;
+    private startzeitBySchuelerklausurterminIntern;
+    /**
+     * Gibt die Startzeit der übergebenen {@link GostKursklausur} aus. Falls keine individuelle Zeit
+     * gesetzt ist, wird die Zeit des {@link GostKlausurtermin}s zurückgegeben. Sollte kein {@link GostKlausurtermin} gesetzt
+     * sein oder der {@link GostKlausurtermin} keine Startzeit definiert haben, wird <code>null</code>
+     * zurückgegeben.
+     *
+     * @param klausur die {@link GostKursklausur}, deren Startzeit gesucht wird.
+     *
+     * @return die Startzeit der {@link GostKursklausur} oder <code>null</code>
+     */
+    startzeitByKursklausurOrNull(klausur: GostKursklausur): number | null;
+    /**
+     * Gibt die Startzeit der übergebenen {@link GostKursklausur} im Kontext des übergebenen {@link GostKlausurraum}s zurück.
+     * Falls eine individuelle Startzeit gesetzt ist, wird diese verwendet. Ist die {@link GostKursklausur} dem Termin des Raums
+     * zugeordnet, wird die effektive Startzeit der Kursklausur zurückgegeben. Andernfalls wird die Startzeit des Termins des
+     * Raums zurückgegeben.
+     *
+     * @param raum    der {@link GostKlausurraum}, dessen Terminkontext verwendet wird
+     * @param klausur die {@link GostKursklausur}, deren Startzeit gesucht wird
+     *
+     * @return die Startzeit der {@link GostKursklausur} im Kontext des {@link GostKlausurraum}s oder <code>null</code>
+     */
+    startzeitByKlausurraumAndKursklausurOrNull(raum: GostKlausurraum, klausur: GostKursklausur): number | null;
+    /**
+     * Gibt die Startzeit der übergebenen {@link GostKursklausur} im Kontext des übergebenen {@link GostKlausurraum}s zurück.
+     * Falls keine Startzeit ermittelt werden kann, wird eine {@link DeveloperNotificationException} geworfen.
+     *
+     * @param raum    der {@link GostKlausurraum}, dessen Terminkontext verwendet wird
+     * @param klausur die {@link GostKursklausur}, deren Startzeit gesucht wird
+     *
+     * @return die Startzeit der {@link GostKursklausur} im Kontext des {@link GostKlausurraum}s
+     */
+    startzeitByKlausurraumAndKursklausurOrException(raum: GostKlausurraum, klausur: GostKursklausur): number;
+    /**
+     * Gibt die Startzeit der übergebenen {@link GostKursklausur} aus. Falls keine individuelle Zeit
+     * gesetzt ist, wird die Zeit des {@link GostKlausurtermin}s zurückgegeben. Sollte kein {@link GostKlausurtermin} gesetzt
+     * sein oder der {@link GostKlausurtermin} keine Startzeit definiert haben, wird eine <code>DeveloperNotificationException</code> geworfen.
+     *
+     * @param klausur die {@link GostKursklausur}, deren Startzeit gesucht wird.
+     *
+     * @return die Startzeit der {@link GostKursklausur}
+     */
+    startzeitByKursklausurOrException(klausur: GostKursklausur): number;
+    /**
+     * Prüft, ob die übergebene {@link GostKursklausur} eine vom Terminkontext des übergebenen {@link GostKlausurraum}s abweichende Startzeit hat.
+     *
+     * @param raum    der {@link GostKlausurraum}, dessen Terminkontext verwendet wird
+     * @param klausur die {@link GostKursklausur}, deren Startzeit geprüft wird
+     *
+     * @return <code>true</code>, wenn die {@link GostKursklausur} eine vom Raumtermin abweichende Startzeit aufweist.
+     */
+    hatAbweichendeStartzeitByRaumAndKursklausur(raum: GostKlausurraum, klausur: GostKursklausur): boolean;
+    /**
+     * Gibt die Liste von {@link GostSchuelerklausurtermin}en zu einer {@link GostSchuelerklausur} zurück.
+     *
+     * @param sk die {@link GostSchuelerklausur}, zu der die {@link GostSchuelerklausurtermin}e gesucht werden.
+     *
+     * @return die Liste von {@link GostSchuelerklausurtermin}en
+     */
+    schuelerklausurterminGetMengeBySchuelerklausur(sk: GostSchuelerklausur): List<GostSchuelerklausurtermin>;
+    /**
+     * Gibt die Liste von {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} zurück.
+     *
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return die Liste von {@link GostSchuelerklausurtermin}en
+     */
+    schuelerklausurterminGetMengeByTermin(termin: GostKlausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Gibt die Liste von {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} zurück. Ggf. werden Fremdtermine am selben Datum aus anderen Jahrgangsstufen inkludiert.
+     *
+     * @param termin der {@link GostKlausurtermin}
+     * @param fremdTermine wenn <code>true</code>, werden Fremdtermine am selben Datum wie <code>termin</code> aus anderen Jahrgangsstufen inkludiert.
+     *
+     * @return die Liste von {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} zurück. Ggf. sind Fremdtermine am selben Datum aus anderen Jahrgangsstufen inkludiert.
+     */
+    schuelerklausurterminaktuellGetMengeByTerminIncludingFremdtermine(termin: GostKlausurtermin, fremdTermine: boolean): List<GostSchuelerklausurtermin>;
+    /**
+     * Gibt die Liste von {@link GostSchuelerklausurtermin}en zu einer Menge von {@link GostKlausurtermin}en zurück.
+     *
+     * @param termine die Liste der {@link GostKlausurtermin}e
+     *
+     * @return die Liste von zugehörigen {@link GostSchuelerklausurtermin}en
+     */
+    schuelerklausurterminGetMengeByTerminmenge(termine: List<GostKlausurtermin>): List<GostSchuelerklausurtermin>;
+    /**
+     * Gibt die Liste von {@link GostSchuelerklausurtermin}en zu einer Menge von {@link GostKlausurtermin}en zurück.
+     *
+     * @param termine die Liste der {@link GostKlausurtermin}e
+     *
+     * @return die Liste von zugehörigen {@link GostSchuelerklausurtermin}en
+     */
+    schuelerklausurterminaktuellGetMengeByTerminmenge(termine: List<GostKlausurtermin>): List<GostSchuelerklausurtermin>;
+    /**
+     * Gibt die Liste der aktuellen (ohne abwesend gemeldete) {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} und einer
+     * {@link GostKursklausur} zurück.
+     *
+     * @param termin      der {@link GostKlausurtermin}
+     * @param kursklausur die {@link GostKursklausur}
+     *
+     * @return die Liste der aktuellen (ohne abwesend gemeldete) {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} und einer
+     * {@link GostKursklausur} zurück.
+     */
+    schuelerklausurterminAktuellGetMengeByTerminAndKursklausur(termin: GostKlausurtermin, kursklausur: GostKursklausur): List<GostSchuelerklausurtermin>;
+    /**
+     * Gibt die Liste der aktuellen (ohne abwesend gemeldete) {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} und einer
+     * {@link GostKursklausur} zurück. Ggf. werden auch die jahrgangsübergreifenden datumsgleichen {@link GostKlausurtermin}e berücksichtigt.
+     *
+     * @param termin      der {@link GostKlausurtermin}
+     * @param kursklausur die {@link GostKursklausur}
+     * @param multijahrgang wenn <code>true</code>, werden auch jahrgangsübergreifende datumsgleiche {@link GostKlausurtermin}e berücksichtigt.
+     *
+     * @return die Liste der aktuellen (ohne abwesend gemeldete) {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} und einer
+     * {@link GostKursklausur} zurück.
+     */
+    schuelerklausurterminAktuellGetMengeByTerminAndKursklausurMultijahrgang(termin: GostKlausurtermin, kursklausur: GostKursklausur, multijahrgang: boolean): List<GostSchuelerklausurtermin>;
+    /**
+     * Gibt die Liste der aktuellen (ohne abwesend gemeldete) {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} zurück.
+     *
+     * @param termin      der {@link GostKlausurtermin}
+     *
+     * @return die Liste der aktuellen (ohne abwesend gemeldete) {@link GostSchuelerklausurtermin}en zu einem {@link GostKlausurtermin} zurück.
+     */
+    schuelerklausurterminAktuellGetMengeByTermin(termin: GostKlausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Gibt die Liste von {@link GostSchuelerklausur}en zu einem Klausurtermin zurück.
+     *
+     * @param termin der {@link GostKlausurtermin}, zu dem die {@link GostSchuelerklausur}en gesucht werden
+     *
+     * @return die Liste von {@link GostSchuelerklausur}en zu einem Klausurtermin
+     */
+    schuelerklausurGetMengeByTermin(termin: GostKlausurtermin): List<GostSchuelerklausur>;
+    /**
+     * Prüft, ob der übergebene {@link GostSchuelerklausurtermin} der aktuellste Termin der zugehörigen {@link GostSchuelerklausur} ist.
+     *
+     * @param skt der {@link GostSchuelerklausurtermin}, der auf Aktualität geprüft werden soll
+     *
+     * @return <code>true</code>, wenn es sich um den aktuellsten {@link GostSchuelerklausurtermin} handelt, sonst <code>false</code>
+     */
+    istSchuelerklausurterminAktuell(skt: GostSchuelerklausurtermin): boolean;
+    /**
+     * Gibt an, ob die übergebene {@link GostSchuelerklausur} aktiv ist, d.h. der Schüler mitschreibt.
+     *
+     * @param sk die zu prüfende {@link GostSchuelerklausur}
+     *
+     * @return true, falls der Schüler bei der Klausur mitschreibt
+     */
+    istSchuelerklausurAktiv(sk: GostSchuelerklausur): boolean;
+    /**
+     * Liefert den aktuellen {@link GostSchuelerklausurtermin} zu einer übergebenen
+     * {@link GostSchuelerklausur}
+     *
+     * @param schuelerklausur die {@link GostSchuelerklausur}, deren aktueller
+     *                          {@link GostSchuelerklausurtermin} gesucht wird
+     *
+     * @return den aktuellen {@link GostSchuelerklausurtermin} zur übergebenen {@link GostSchuelerklausur}
+     */
+    schuelerklausurterminAktuellBySchuelerklausur(schuelerklausur: GostSchuelerklausur): GostSchuelerklausurtermin;
+    private schuelerklausurterminAktuellByKursklausur;
+    /**
+     * Liefert eine Liste von aktuellen
+     * Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen Abijahrgang, {@link GostHalbjahr} und Quartal denen ein {@link GostKlausurtermin} zugewiesen wurde.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr    das {@link GostHalbjahr}
+     * @param quartal     die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von aktuellen Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen Abijahrgang, {@link GostHalbjahr} und Quartal
+     * denen ein {@link GostKlausurtermin} zugewiesen wurde.
+     */
+    schuelerklausurterminNtAktuellMitTerminGetMengeByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert eine Liste von aktuellen
+     * Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen Abijahrgang, {@link GostHalbjahr} und Quartal.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr    das {@link GostHalbjahr}
+     * @param quartal     die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von aktuellen Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen Abijahrgang, {@link GostHalbjahr} und Quartal.
+     */
+    schuelerklausurterminNtAktuellGetMengeByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert eine Liste von aktuellen
+     * Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen Abijahrgang, {@link GostHalbjahr} und Quartal denen ein {@link GostKlausurtermin} inklusive Datum zugewiesen wurde.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr    das {@link GostHalbjahr}
+     * @param quartal     die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von aktuellen Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen Abijahrgang, {@link GostHalbjahr} und Quartal
+     * denen ein {@link GostKlausurtermin} inklusive Datum zugewiesen wurde.
+     */
+    schuelerklausurterminNtAktuellMitTerminUndDatumGetMengeByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert eine Liste von aktuellen
+     * Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen Abijahrgang, {@link GostHalbjahr} und Quartal denen noch kein {@link GostKlausurtermin} zugewiesen wurde.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr    das {@link GostHalbjahr}
+     * @param quartal     die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von aktuellen Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen Abijahrgang, {@link GostHalbjahr} und Quartal
+     * denen noch kein {@link GostKlausurtermin} zugewiesen wurde.
+     */
+    schuelerklausurterminNtAktuellOhneTerminGetMengeByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert eine Liste von Haupttermin-{@link GostSchuelerklausurtermin}en zum übergebenen {@link GostKlausurtermin}
+     *
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return die Liste von Haupttermin-{@link GostSchuelerklausurtermin}en zum übergebenen {@link GostKlausurtermin}
+     */
+    schuelerklausurterminAktuellHtGetMengeByTermin(termin: GostKlausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert eine Liste von Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen {@link GostKlausurtermin}
+     *
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return die Liste von Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen {@link GostKlausurtermin}
+     */
+    schuelerklausurterminNtGetMengeByTermin(termin: GostKlausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert eine Liste von aktuellen Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen {@link GostKlausurtermin}
+     *
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return die Liste von aktuellen Nachschreib-{@link GostSchuelerklausurtermin}en zum übergebenen {@link GostKlausurtermin}
+     */
+    schuelerklausurterminAktuellNtGetMengeByTermin(termin: GostKlausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert den {@link GostSchuelerklausurtermin}, sofern vorhanden, zu einem {@link GostKlausurtermin} und einer Schüler-ID.
+     *
+     * @param termin   der {@link GostKlausurtermin}
+     * @param idSchueler die ID des Schülers
+     *
+     * @return das {@link GostSchuelerklausurtermin} zu einem {@link GostKlausurtermin} und einer Schüler-ID, sonst <code>null</code>.
+     */
+    schuelerklausurterminByTerminAndSchuelerid(termin: GostKlausurtermin, idSchueler: number): GostSchuelerklausurtermin | null;
+    /**
+     * Liefert die {@link GostSchuelerklausur}en zur übergebenen {@link GostKursklausur}
+     *
+     * @param kursklausur die {@link GostKursklausur}
+     *
+     * @return die {@link GostSchuelerklausur}en zur übergebenen {@link GostKursklausur}
+     */
+    schuelerklausurGetMengeByKursklausur(kursklausur: GostKursklausur): List<GostSchuelerklausur>;
+    /**
+     * Liefert die {@link GostSchuelerklausur} zur übergebenen {@link GostKursklausur} und zur Schüler-ID
+     *
+     * @param kursklausur die {@link GostKursklausur}
+     * @param idSchueler die ID des Schülers
+     *
+     * @return die {@link GostSchuelerklausur} zur übergebenen {@link GostKursklausur} und zur Schüler-ID
+     */
+    schuelerklausurByKursklausurAndSchuelerid(kursklausur: GostKursklausur, idSchueler: number): GostSchuelerklausur | null;
+    /**
+     * Liefert den {@link LehrerListeEintrag} zur übergebenen {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return den {@link LehrerListeEintrag} zur übergebenen {@link GostKursklausur} oder <code>null</code> falls kein Lehrer zugeordnet ist.
+     */
+    kursLehrerByKursklausur(k: GostKursklausur): LehrerListeEintrag | null;
+    /**
+     * Liefert das Lehrerkürzel zur übergebenen {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return das Lehrerkürzel zur übergebenen {@link GostKursklausur} oder <code>null</code> falls kein Lehrer zugeordnet ist.
+     */
+    kursLehrerKuerzelByKursklausur(k: GostKursklausur): string | null;
+    /**
+     * Liefert die {@link KursDaten} zur übergebenen {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return die {@link KursDaten} zur übergebenen {@link GostKursklausur}.
+     */
+    kursdatenByKursklausur(k: GostKursklausur): KursDaten;
+    /**
+     * Liefert das {@link GostFach} zur übergebenen {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return das {@link GostFach} zur übergebenen {@link GostKursklausur}.
+     */
+    fachByKursklausur(k: GostKursklausur): GostFach;
+    /**
+     * Liefert das {@link GostFach} zur übergebenen {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return das {@link GostFach} zur übergebenen {@link GostKursklausur}.
+     */
+    fachOrNullByKursklausur(k: GostKursklausur): GostFach | null;
+    /**
+     * Liefert das {@link GostFach} zur übergebenen {@link GostKlausurvorgabe}.
+     *
+     * @param v die {@link GostKlausurvorgabe}
+     *
+     * @return das {@link GostFach} zur übergebenen {@link GostKlausurvorgabe}.
+     */
+    fachByVorgabe(v: GostKlausurvorgabe): GostFach;
+    /**
+     * Liefert das {@link GostFach} zur übergebenen {@link GostKlausurvorgabe}.
+     *
+     * @param v die {@link GostKlausurvorgabe}
+     *
+     * @return das {@link GostFach} zur übergebenen {@link GostKlausurvorgabe}.
+     */
+    fachOrNullByVorgabe(v: GostKlausurvorgabe): GostFach | null;
+    /**
+     * Liefert die Liste der Kursschienen des Kurses einer {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return die Liste der Kursschienen des Kurses einer {@link GostKursklausur}.
+     */
+    kursSchieneByKursklausur(k: GostKursklausur): List<number>;
+    /**
+     * Liefert die Kurzbezeichnung des Kurses zu einer übergebenen {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return die Kurzbezeichnung des Kurses zu einer übergebenen {@link GostKursklausur}.
+     */
+    kursKurzbezeichnungByKursklausur(k: GostKursklausur): string;
+    /**
+     * Liefert die {@link KursDaten} zur übergebenen {@link GostSchuelerklausur}.
+     *
+     * @param k die {@link GostSchuelerklausur}
+     *
+     * @return die {@link KursDaten} zur übergebenen {@link GostSchuelerklausur}.
+     */
+    kursdatenBySchuelerklausur(k: GostSchuelerklausur): KursDaten;
+    /**
+     * Liefert die {@link KursDaten} zum übergebenen {@link GostSchuelerklausurtermin}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return die {@link KursDaten} zum übergebenen {@link GostSchuelerklausurtermin}.
+     */
+    kursdatenBySchuelerklausurtermin(k: GostSchuelerklausurtermin): KursDaten;
+    /**
+     * Liefert die Anzahl aller Schüler im Kurs zu einer übergebenen {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}.
+     *
+     * @return die Anzahl aller Schüler im Kurs zu einer übergebenen {@link GostKursklausur}.
+     */
+    kursAnzahlSchuelerGesamtByKursklausur(k: GostKursklausur): number;
+    /**
+     * Liefert die Anzahl der Klausurscheiber im Kurs zu einer übergebenen
+     * {@link GostKursklausur}.
+     *
+     * @param k die {@link GostKursklausur}
+     *
+     * @return die Anzahl der Klausurscheiber im Kurs zu einer übergebenen
+     * {@link GostKursklausur}.
+     */
+    kursAnzahlKlausurschreiberByKursklausur(k: GostKursklausur): number;
+    /**
+     * Gibt die HTML-Farbe des zulässigen Faches zur übergebenen {@link GostKursklausur} als Aufruf der rgba-Funktion
+     * mit der Transparenz 1.0 zurück.
+     *
+     * @param k           die {@link GostKursklausur}
+     *
+     * @return die RGBA-HTML-Farbdefinition als String
+     */
+    fachHTMLFarbeRgbaByKursklausur(k: GostKursklausur): string;
+    /**
+     * Liefert den Vorgänger-{@link GostSchuelerklausurtermin}, sofern vorhanden, zu einem {@link GostSchuelerklausurtermin}, also den
+     * versäumten Schülerklausurtermin.
+     *
+     * @param skt der {@link GostSchuelerklausurtermin}, dessen Vorgänger gesucht wird
+     *
+     * @return den Vorgänger-{@link GostSchuelerklausurtermin} oder <code>null</code>
+     */
+    schuelerklausurterminVorgaengerBySchuelerklausurtermin(skt: GostSchuelerklausurtermin): GostSchuelerklausurtermin | null;
+    /**
+     * Prüft, ob eine {@link GostKursklausur} externe Klausurschreiber enthält.
+     *
+     * @param k die zu prüfende {@link GostKursklausur}
+     *
+     * @return <code>true</code>, falls externe Schüler in der {@link GostKursklausur} enthalten sind, sonst <code>false</code>
+     */
+    kursklausurMitExternenS(k: GostKursklausur): boolean;
+    /**
+     * Prüft, ob einem {@link GostKlausurtermin} Schüler anderer Jahrgangsstufen zugeordnet sind
+     *
+     * @param t der zu prüfende {@link GostKlausurtermin}
+     *
+     * @return <code>true</code>, falls Schüler anderer Jahrgangsstufen zugeordnet sind
+     */
+    terminMitAnderenJgst(t: GostKlausurtermin): boolean;
+    /**
+     * Gibt das Datum des Vorgängertermins zum übergebenen {@link GostSchuelerklausurtermin}
+     * zurück. Falls kein Vorgängertermin existiert, wird eine <code>DeveloperNotificationException</code> geworfen. Falls noch kein Termin oder kein Datum zugewiesen ist, wird <code>null</code> zurückgegeben.
+     *
+     * @param sk der {@link GostSchuelerklausurtermin}, dessen Vorgänger-Datum gesucht wird.
+     *
+     * @return das Datum des Vorgängertermins zum übergebenen {@link GostSchuelerklausurtermin}
+     */
+    datumSchuelerklausurHT(sk: GostSchuelerklausur): string | null;
+    /**
+     * Gibt das Datum des Vorgängertermins zum übergebenen {@link GostSchuelerklausurtermin}
+     * zurück. Falls kein Vorgängertermin existiert, wird eine <code>DeveloperNotificationException</code> geworfen. Falls noch kein Termin oder kein Datum zugewiesen ist, wird <code>null</code> zurückgegeben.
+     *
+     * @param skt der {@link GostSchuelerklausurtermin}, dessen Vorgänger-Datum gesucht wird.
+     *
+     * @return das Datum des Vorgängertermins zum übergebenen {@link GostSchuelerklausurtermin}
+     */
+    datumSchuelerklausurVorgaenger(skt: GostSchuelerklausurtermin): string | null;
+    /**
+     * Prüft, ob ein Schüler an einem {@link GostKlausurtermin} gesetzt ist.
+     *
+     * @param idSchueler die ID des zu prüfenden Schülers
+     * @param termin   der {@link GostKlausurtermin}
+     *
+     * @return <code>true</code>, wenn der Schüler an dem {@link GostKlausurtermin} eine Klausur schreibt, sonst
+     *         <code>false</code>
+     */
+    schuelerSchreibtKlausurtermin(idSchueler: number, termin: GostKlausurtermin): boolean;
+    /**
+     * Liefert zu einer {@link GostKursklausur} die {@link GostSchuelerklausurtermin}e der Schüler, die den
+     * Kurs schriftlich belegt haben
+     *
+     * @param kursklausur die {@link GostKursklausur}
+     *
+     * @return die {@link GostSchuelerklausurtermin}e der Schüler, die den
+     * Kurs schriftlich belegt haben
+     */
+    schuelerklausurterminGetMengeByKursklausur(kursklausur: GostKursklausur): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert zu einer {@link GostSchuelerklausur} den zugehörigen {@link SchuelerListeEintrag}
+     *
+     * @param sk die {@link GostSchuelerklausur}
+     *
+     * @return der zugehörige {@link SchuelerListeEintrag}
+     */
+    schuelerGetBySchuelerklausur(sk: GostSchuelerklausur): SchuelerListeEintrag;
+    /**
+     * Liefert zu einem {@link GostSchuelerklausurtermin} den zugehörigen {@link SchuelerListeEintrag}
+     *
+     * @param skt der {@link GostSchuelerklausurtermin}
+     *
+     * @return der zugehörige {@link SchuelerListeEintrag}
+     */
+    schuelerGetBySchuelerklausurtermin(skt: GostSchuelerklausurtermin): SchuelerListeEintrag;
+    /**
+     * Liefert die {@link GostKlausurraumstunde} zum übergebenen {@link GostKlausurraum} und {@link StundenplanZeitraster} zurück.
+     *
+     * @param raum       der {@link GostKlausurraum}
+     * @param zeitraster das {@link StundenplanZeitraster}
+     *
+     * @return die {@link GostKlausurraumstunde} zum übergebenen {@link GostKlausurraum} und {@link StundenplanZeitraster} zurück.
+     */
+    raumstundeGetByRaumAndZeitrasterOrNull(raum: GostKlausurraum, zeitraster: StundenplanZeitraster): GostKlausurraumstunde | null;
+    /**
+     * Liefert die {@link GostKlausurraumstunde} zum übergebenen {@link GostKlausurraum} und {@link StundenplanZeitraster} zurück.
+     *
+     * @param raum       der {@link GostKlausurraum}
+     * @param zeitraster das {@link StundenplanZeitraster}
+     *
+     * @return die {@link GostKlausurraumstunde} zum übergebenen {@link GostKlausurraum} und {@link StundenplanZeitraster} zurück.
+     */
+    raumstundeGetByRaumAndZeitrasterOrException(raum: GostKlausurraum, zeitraster: StundenplanZeitraster): GostKlausurraumstunde;
+    /**
+     * Liefert die {@link GostKlausurraumstunde}en des Raums als neue, nach auflösbarem Zeitraster sortierte Liste zurück.
+     * Raumstunden ohne auflösbares Zeitraster stehen am Ende.
+     *
+     * @param raum der {@link GostKlausurraum}
+     *
+     * @return die sortierten {@link GostKlausurraumstunde}en zum übergebenen {@link GostKlausurraum}
+     */
+    raumstundeGetMengeByRaum(raum: GostKlausurraum): List<GostKlausurraumstunde>;
+    private setzeRaumZuSchuelerklausurenOhneUpdate;
+    /**
+     * Aktualisiert die internen Strukturen anhand der übergebenen {@link GostKlausurenPatchResponseData}. Diese Methode
+     * sollte nur nach einem API-Call aufgerufen werden, in dem das {@link GostKlausurenPatchResponseData}-Objekt erzeugt wurde.
+     *
+     * @param patchResponseData die {@link GostKlausurenPatchResponseData}
+     */
+    setzeRaumZuSchuelerklausuren(patchResponseData: GostKlausurenPatchResponseData): void;
+    /**
+     * Liefert die Menge aller {@link GostKursklausur}en zurück, die in einem {@link GostKlausurraum} geschrieben werden, auch wenn die {@link GostKursklausur} nur nachgeschrieben wird.
+     *
+     * @param raum  der {@link GostKlausurraum}
+     * @param includeNachschreiber <code>true</code>, wenn auch Nachschreiber berücksichtigt werden sollen
+     *
+     * @return die Menge aller {@link GostKursklausur}en zurück, die in einem {@link GostKlausurraum} geschrieben werden, auch wenn die {@link GostKursklausur} nur nachgeschrieben wird.
+     */
+    kursklausurGetMengeByRaum(raum: GostKlausurraum, includeNachschreiber: boolean): JavaSet<GostKursklausur>;
+    /**
+     * Liefert die Menge aller {@link GostKursklausur}en zurück, die in einem {@link GostKlausurraum} geschrieben werden, wenn es sich um Nachschreibklausuren handelt.
+     *
+     * @param raum  der {@link GostKlausurraum}
+     *
+     * @return die Menge aller {@link GostKursklausur}en zurück, die in einem {@link GostKlausurraum} geschrieben werden, wenn es sich um Nachschreibklausuren handelt.
+     */
+    nachschreiberGetMengeByRaum(raum: GostKlausurraum): JavaSet<GostKursklausur>;
+    /**
+     * Liefert die Menge aller {@link GostSchuelerklausurtermin}e zurück, die in einem {@link GostKlausurraum} geschrieben werden und zu einer {@link GostKursklausur} gehören.
+     *
+     * @param raum der {@link GostKlausurraum}
+     * @param kursklausur die {@link GostKursklausur}
+     *
+     * @return die Liste der GostKursklausuren
+     */
+    schuelerklausurterminGetMengeByRaumAndKursklausur(raum: GostKlausurraum, kursklausur: GostKursklausur): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert die Menge aller aktueller {@link GostSchuelerklausurtermin}e zurück, die in einem {@link GostKlausurraum} geschrieben werden.
+     *
+     * @param raum  der {@link GostKlausurraum}
+     *
+     * @return die Menge aller aktueller {@link GostSchuelerklausurtermin}e zurück, die in einem {@link GostKlausurraum} geschrieben werden.
+     */
+    schuelerklausurterminGetMengeByRaum(raum: GostKlausurraum): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert die Menge aller aktueller {@link GostSchuelerklausurtermin}e zurück, die in einem {@link GostKlausurraum} geschrieben werden.
+     *
+     * @param idRaum die ID des {@link GostKlausurraum}s
+     *
+     * @return die Menge aller aktueller {@link GostSchuelerklausurtermin}e zurück, die in einem {@link GostKlausurraum} geschrieben werden.
+     */
+    schuelerklausurterminGetMengeByRaumid(idRaum: number): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert die Menge aller aktueller {@link GostSchuelerklausur}e zurück, die in einem {@link GostKlausurraum} geschrieben werden.
+     *
+     * @param raum  der {@link GostKlausurraum}
+     *
+     * @return die Menge aller aktueller {@link GostSchuelerklausur}e zurück, die in einem {@link GostKlausurraum} geschrieben werden.
+     */
+    schuelerklausurGetMengeByRaum(raum: GostKlausurraum): List<GostSchuelerklausur>;
+    /**
+     * Liefert die Menge aller {@link GostSchuelerklausurtermin}e zu einem {@link GostKlausurtermin} zurück, die noch keinem {@link GostKlausurraum} zugewiesen sind.
+     *
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return die Menge aller {@link GostSchuelerklausurtermin}e zu einem {@link GostKlausurtermin}, die noch keinem {@link GostKlausurraum} zugewiesen sind.
+     */
+    schuelerklausurOhneRaumGetMengeByTermin(termin: GostKlausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert die {@link GostSchuelerklausurtermin}e eines {@link GostKlausurtermin}s, die bei einer Raumzuweisung des ganzen Termins einem Raum
+     * zugeordnet werden.
+     * <br>
+     * Anwendungsfall ist das Ziehen eines ganzen Klausurtermins in der Raum- und Zeitplanung auf einen Raum. Es werden nur die bisher raumlosen
+     * Schülerklausurtermine des Termins ermittelt. Änderungen an Raumzuweisungen werden nicht durchgeführt.
+     *
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return die {@link GostSchuelerklausurtermin}e für die Raumzuweisung
+     */
+    schuelerklausurterminFuerRaumzuweisungGetMengeByTermin(termin: GostKlausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert die {@link GostSchuelerklausurtermin}e einer {@link GostKursklausur} in einem {@link GostKlausurtermin}, die bei einer
+     * Raumzuweisung der Kursklausur einem Raum zugeordnet werden. Dabei werden auch jahrgangsübergreifende datumsgleiche Termine berücksichtigt.
+     * <br>
+     * Anwendungsfall ist das Ziehen einer Kursklausur aus der Raum- und Zeitplanung auf einen Raum. Es werden die betroffenen
+     * Schülerklausurtermine ermittelt. Änderungen an Raumzuweisungen werden nicht durchgeführt.
+     *
+     * @param termin      der {@link GostKlausurtermin}
+     * @param kursklausur die {@link GostKursklausur}
+     *
+     * @return die {@link GostSchuelerklausurtermin}e für die Raumzuweisung
+     */
+    schuelerklausurterminFuerRaumzuweisungGetMengeByTerminAndKursklausur(termin: GostKlausurtermin, kursklausur: GostKursklausur): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert den übergebenen {@link GostSchuelerklausurtermin} für eine Raumzuweisung.
+     * <br>
+     * Anwendungsfall ist das Ziehen eines einzelnen Schülerklausurtermins in der Raum- und Zeitplanung auf einen Raum. Änderungen an
+     * Raumzuweisungen werden nicht durchgeführt.
+     *
+     * @param schuelerklausurtermin der {@link GostSchuelerklausurtermin}
+     *
+     * @return der {@link GostSchuelerklausurtermin} für die Raumzuweisung
+     */
+    schuelerklausurterminFuerRaumzuweisungGetMengeBySchuelerklausurtermin(schuelerklausurtermin: GostSchuelerklausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert die {@link GostSchuelerklausurtermin}e einer {@link GostKursklausur} in einem {@link GostKlausurtermin}, deren Raumzuweisung
+     * aufgehoben wird.
+     * <br>
+     * Anwendungsfall ist das Zurücklegen einer Kursklausur aus einem Raum in die Planungsliste der Raum- und Zeitplanung. Es werden die betroffenen
+     * Schülerklausurtermine ermittelt. Änderungen an Raumzuweisungen werden nicht durchgeführt.
+     *
+     * @param termin      der {@link GostKlausurtermin}
+     * @param kursklausur die {@link GostKursklausur}
+     *
+     * @return die {@link GostSchuelerklausurtermin}e für das Aufheben der Raumzuweisung
+     */
+    schuelerklausurterminFuerRaumzuweisungAufhebenGetMengeByTerminAndKursklausur(termin: GostKlausurtermin, kursklausur: GostKursklausur): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert den übergebenen {@link GostSchuelerklausurtermin} für das Aufheben einer Raumzuweisung.
+     * <br>
+     * Anwendungsfall ist das Zurücklegen eines einzelnen Schülerklausurtermins aus einem Raum in die Planungsliste der Raum- und Zeitplanung.
+     * Änderungen an Raumzuweisungen werden nicht durchgeführt.
+     *
+     * @param schuelerklausurtermin der {@link GostSchuelerklausurtermin}
+     *
+     * @return der {@link GostSchuelerklausurtermin} für das Aufheben der Raumzuweisung
+     */
+    schuelerklausurterminFuerRaumzuweisungAufhebenGetMengeBySchuelerklausurtermin(schuelerklausurtermin: GostSchuelerklausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert die Menge aller {@link GostSchuelerklausurtermin}e zu einem {@link GostKlausurraum} und {@link GostKlausurtermin} zurück.
+     *
+     * @param raum der {@link GostKlausurraum}
+     * @param termin der {@link GostKlausurtermin}
+     *
+     * @return die Menge aller {@link GostSchuelerklausurtermin}e zu einem {@link GostKlausurraum} und {@link GostKlausurtermin} zurück.
+     */
+    schuelerklausurterminGetMengeByRaumAndTermin(raum: GostKlausurraum, termin: GostKlausurtermin): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert eine Liste von {@link StundenplanRaum}en, die nicht für den übergebenen Klausurtermin verplant sind.
+     *
+     * @param termin der {@link GostKlausurtermin}
+     * @param multijahrgang ob die Liste für einen Termin oder für alle Termine des gleichen Datums gelten soll
+     *
+     * @return die Liste von {@link StundenplanRaum}en, die nicht für den übergebenen Klausurtermin verplant sind.
+     */
+    stundenplanraumVerfuegbarGetMengeByTermin(termin: GostKlausurtermin, multijahrgang: boolean): List<StundenplanRaum>;
+    /**
+     * Liefert den {@link GostKlausurraum}, zu den übergebenen Parametern oder null
+     *
+     * @param termin der {@link GostKlausurtermin}
+     * @param stundenplanRaum der {@link StundenplanRaum}
+     *
+     * @return den {@link GostKlausurraum}, zu den übergebenen Parametern oder null
+     */
+    raumGetByTerminUndStundenplanraum(termin: GostKlausurtermin, stundenplanRaum: StundenplanRaum): GostKlausurraum | null;
+    /**
+     * Prüft, ob alle zu einer {@link GostKursklausur} gehörenden {@link GostSchuelerklausurtermin}e an einem bestimmten {@link GostKlausurtermin} einem {@link GostKlausurraum}
+     * zugeordnet sind. Wird kein {@link GostKlausurtermin} übergeben, wird der Haupttermin der {@link GostKursklausur} geprüft.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}. Wird kein <code>null</code> übergeben, wird der Haupttermin der {@link GostKursklausur} geprüft.
+     * @param kk die zu prüfende {@link GostKursklausur}
+     *
+     * @return <code>true</code>, wenn alle {@link GostSchuelerklausurtermin}e verplant sind, sonst <code>false</code>.
+     */
+    isKursklausurAlleSchuelerklausurenVerplant(kk: GostKursklausur, termin: GostKlausurtermin | null): boolean;
+    /**
+     * Prüft, ob alle zu einer {@link GostKlausurtermin} gehörenden {@link GostSchuelerklausurtermin}e einem {@link GostKlausurraum}
+     * zugeordnet sind.
+     *
+     * @param t der zu prüfende {@link GostKlausurtermin}
+     *
+     * @return <code>true</code>, wenn alle {@link GostSchuelerklausurtermin}e verplant sind, sonst <code>false</code>.
+     */
+    isTerminAlleSchuelerklausurenVerplant(t: GostKlausurtermin): boolean;
+    /**
+     * Prüft, ob eine {@link GostKursklausur} im übergebenen {@link GostKlausurraum} enthalten ist.
+     *
+     * @param raum der {@link GostKlausurraum}, in dem die {@link GostKursklausur} geprüft wird
+     * @param kursklausur die zu prüfende {@link GostKursklausur}
+     *
+     * @return <code>true</code>, wenn die {@link GostKursklausur} im übergebenen {@link GostKlausurraum} enthalten ist, sonst <code>false</code>.
+     */
+    containsKlausurraumKursklausur(raum: GostKlausurraum, kursklausur: GostKursklausur): boolean;
+    /**
+     * Liefert die gemeinsame Klausurdauer aller {@link GostKursklausur}en, die im übergebenen {@link GostKlausurraum} geschrieben werden.
+     * Falls die Dauern sich unterscheiden, wird <code>null</code> zurückgegeben.
+     *
+     * @param raum der {@link GostKlausurraum}, dessen Klausurdauern überprüft werden.
+     *
+     * @return die gemeinsame Klausurdauer aller {@link GostKursklausur}en oder <code>null</code>, falls keine solche existiert.
+     */
+    getGemeinsameKursklausurdauerByKlausurraum(raum: GostKlausurraum): number | null;
+    /**
+     * Liefert die gemeinsame Klausurstartzeit aller {@link GostKursklausur}en, die im übergebenen {@link GostKlausurraum} geschrieben werden.
+     * Falls die Startzeiten sich unterscheiden, wird <code>null</code> zurückgegeben.
+     *
+     * @param raum der {@link GostKlausurraum}, dessen Startzeiten überprüft werden.
+     *
+     * @return die gemeinsame Klausurstartzeit aller {@link GostKursklausur}en oder <code>null</code>, falls keine solche existiert.
+     */
+    getGemeinsamerKursklausurstartByKlausurraum(raum: GostKlausurraum): number | null;
+    /**
+     * Liefert <code>true</code> zurück, falls {@link GostSchuelerklausurtermin}e des übergebenen {@link GostKlausurtermin}s in {@link GostKlausurraum}en von {@link GostKlausurtermin}en anderer Jahrgangsstufen zugeordnet sind, sonst <code>false</code>.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     *
+     * @return <code>true</code> zurück, falls {@link GostSchuelerklausurtermin}e des übergebenen {@link GostKlausurtermin}s in {@link GostKlausurraum}en von {@link GostKlausurtermin}en anderer Jahrgangsstufen zugeordnet sind, sonst <code>false</code>.
+     */
+    isKlausurenInFremdraeumenByTermin(termin: GostKlausurtermin): boolean;
+    /**
+     * Liefert <code>true</code> zurück, falls {@link GostSchuelerklausurtermin}e des übergebenen {@link GostKlausurraum}s in zu {@link GostKlausurtermin}en anderer Jahrgangsstufen gehören, sonst <code>false</code>.
+     *
+     * @param raum der zu prüfende {@link GostKlausurraum}
+     *
+     * @return <code>true</code> zurück, falls {@link GostSchuelerklausurtermin}e des übergebenen {@link GostKlausurraum}s in zu {@link GostKlausurtermin}en anderer Jahrgangsstufen gehören, sonst <code>false</code>.
+     */
+    raumEnthaeltTerminfremdeKlausuren(raum: GostKlausurraum): boolean;
+    /**
+     * Liefert die Liste von {@link GostSchuelerklausurtermin}en aus dem übergebenen {@link GostKlausurraum}, die einem raumfremden Klausurtermin zugeordnet sind.
+     *
+     * @param raum der zu prüfende {@link GostKlausurraum}
+     *
+     * @return die Liste von {@link GostSchuelerklausurtermin}en aus dem übergebenen {@link GostKlausurraum}, die einem raumfremden Klausurtermin zugeordnet sind.
+     */
+    schuelerklausurterminFremdterminGetMengeByRaum(raum: GostKlausurraum): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert die Liste von {@link GostSchuelerklausurtermin}en aus dem übergebenen {@link GostKlausurraum}, die dem Raumtermin zugeordnet sind.
+     *
+     * @param raum der zu prüfende {@link GostKlausurraum}
+     *
+     * @return die Liste von {@link GostSchuelerklausurtermin}en aus dem übergebenen {@link GostKlausurraum}, die dem Raumtermin zugeordnet sind.
+     */
+    schuelerklausurterminRaumterminGetMengeByRaum(raum: GostKlausurraum): List<GostSchuelerklausurtermin>;
+    /**
+     * Liefert den zu einem {@link GostSchuelerklausurtermin} den zugehörigen {@link GostKlausurraum}, falls ein solcher schon zugeordnet ist.
+     *
+     * @param skt der {@link GostSchuelerklausurtermin}, zu dem der {@link GostKlausurraum} gesucht wird.
+     *
+     * @return den {@link GostKlausurraum}, falls einer zugewiesen ist, sonst <code>null</code>.
+     */
+    raumGetBySchuelerklausurtermin(skt: GostSchuelerklausurtermin): GostKlausurraum | null;
+    /**
+     * Liefert den zu einem {@link GostSchuelerklausurtermin} zugehörigen {@link StundenplanRaum} zurück.
+     *
+     * @param skt der {@link GostSchuelerklausurtermin}, zu dem der {@link StundenplanRaum} gesucht wird.
+     *
+     * @return den {@link StundenplanRaum}, falls einer zugewiesen ist, sonst <code>null</code>
+     */
+    stundenplanraumGetBySchuelerklausurtermin(skt: GostSchuelerklausurtermin): StundenplanRaum | null;
+    /**
+     * Liefert die Menge von {@link GostKlausurtermin}en aus anderen Jahrgangsstufen, die am selben Datum wie der übergebene {@link GostKlausurtermin} terminiert sind. Der als Parameter übergebene {@link GostKlausurtermin} <code>termin</code> ist in der Rückgabemenge nicht enthalten.
+     *
+     * @param termin der {@link GostKlausurtermin}, an dessen Datum jahrgangsfremde {@link GostKlausurtermin}e gesucht werden. Dieser {@link GostKlausurtermin} ist in der Rückgabeliste nicht enthalten.
+     *
+     * @return die Menge von {@link GostKlausurtermin}en aus anderen Jahrgangsstufen, die am selben Datum wie der übergebene {@link GostKlausurtermin} terminiert sind.
+     */
+    getFremdTermineByTermin(termin: GostKlausurtermin): List<GostKlausurtermin>;
+    /**
+     * Prüft, ggf. jahrgangsübergreifend, ob {@link GostSchuelerklausurtermin}e des als Parameter übergebenen {@link GostKlausurtermin}s bereits {@link GostKlausurraum}en zugeordnet sind.
+     *
+     * @param termin der {@link GostKlausurtermin}, dessen {@link GostSchuelerklausurtermin}e geprüft werden
+     * @param fremdTermine wenn <code>true</code>, werden auch {@link GostSchuelerklausurtermin}e anderer Jahrgänge am selben Datum berücksichtigt.
+     *
+     * @return <code>true</code>, falls {@link GostSchuelerklausurtermin}e des als Parameter übergebenen {@link GostKlausurtermin}s bereits {@link GostKlausurraum}en zugeordnet sind.
+     */
+    isSchuelerklausurenInRaumByTermin(termin: GostKlausurtermin, fremdTermine: boolean): boolean;
+    /**
+     * Liefert die Menge der {@link GostKlausurraum}e zum als Parameter übergebenen {@link GostKlausurtermin}.
+     *
+     * @param termin der {@link GostKlausurtermin}, zu dem die {@link GostKlausurraum}e gesucht werden
+     *
+     * @return die Menge der {@link GostKlausurraum}e zum als Parameter übergebenen {@link GostKlausurtermin}.
+     */
+    raumGetMengeByTermin(termin: GostKlausurtermin): List<GostKlausurraum>;
+    /**
+     * Liefert die Menge der {@link GostKlausurraum}e zu den als Parameter übergebenen {@link GostKlausurtermin} und {@link GostKursklausur}.
+     *
+     * @param termin der {@link GostKlausurtermin}, zu dem die {@link GostKlausurraum}e gesucht werden
+     * @param klausur die {@link GostKursklausur}, zu der die {@link GostKlausurraum}e gesucht werden
+     *
+     * @return die Menge der {@link GostKlausurraum}e zu den als Parameter übergebenen {@link GostKlausurtermin} und {@link GostKursklausur}.
+     */
+    raumGetMengeByTerminAndKursklausur(termin: GostKlausurtermin, klausur: GostKursklausur): List<GostKlausurraum>;
+    /**
+     * Liefert die Menge der {@link GostKlausurraum}e, ggf. jahrgangsübergreifend, zum als Parameter übergebenen {@link GostKlausurtermin}.
+     *
+     * @param termin der {@link GostKlausurtermin}, zu dem die {@link GostKlausurraum}e gesucht werden
+     * @param fremdTermine wenn <code>true</code> werden auch die {@link GostKlausurraum}e von datumsgleichen {@link GostKlausurtermin}en anderer Jahrgangsstufen zurückgegeben
+     *
+     * @return die Menge der {@link GostKlausurraum}e, ggf. jahrgangsübergreifend, zum als Parameter übergebenen {@link GostKlausurtermin}.
+     */
+    raumGetMengeByTerminIncludingFremdtermine(termin: GostKlausurtermin, fremdTermine: boolean): List<GostKlausurraum>;
+    /**
+     * Liefert die Menge der {@link GostKlausurraum}e zur als Parameter übergebenen {@link GostKlausurtermin}menge.
+     *
+     * @param termine die Menge der {@link GostKlausurtermin}e, zu denen die {@link GostKlausurraum}e gesucht werden
+     *
+     * @return die Menge der {@link GostKlausurraum}e zur als Parameter übergebenen {@link GostKlausurtermin}menge.
+     */
+    raumGetMengeByTerminmenge(termine: List<GostKlausurtermin>): List<GostKlausurraum>;
+    /**
+     * Liefert die Summe der Plätze in allen {@link GostKlausurraum}en eines {@link GostKlausurtermin}s, ggf. jahrgangsübergreifend.
+     *
+     * @param termin der {@link GostKlausurtermin}, zu dem die Summe der Plätze gesucht wird
+     * @param fremdTermine wenn <code>true</code> werden auch die Plätze in {@link GostKlausurraum}en von datumsgleichen {@link GostKlausurtermin}en anderer Jahrgangsstufen addiert
+     *
+     * @return die Summe der Plätze in allen {@link GostKlausurraum}en eines {@link GostKlausurtermin}s, ggf. jahrgangsübergreifend.
+     */
+    anzahlPlaetzeAlleRaeumeByTermin(termin: GostKlausurtermin, fremdTermine: boolean): number;
+    /**
+     * Liefert die Anzahl der benötigten Plätze für alle Schüler eines {@link GostKlausurtermin}s, ggf. jahrgangsübergreifend.
+     *
+     * @param termin der {@link GostKlausurtermin}, zu dem die Anzahl der benötigten Plätze gesucht wird
+     * @param fremdTermine wenn <code>true</code> werden auch die benötigten Plätze von datumsgleichen {@link GostKlausurtermin}en anderer Jahrgangsstufen addiert
+     *
+     * @return die Anzahl der benötigten Plätze für alle Schüler eines {@link GostKlausurtermin}s, ggf. jahrgangsübergreifend.
+     */
+    anzahlBenoetigtePlaetzeAlleKlausurenByTermin(termin: GostKlausurtermin, fremdTermine: boolean): number;
+    /**
+     * Prüft, die Platzkapazität aller {@link GostKlausurraum}e des übergebenen {@link GostKlausurtermin}s für die benötigte Platzmenge an {@link GostSchuelerklausurtermin}en ausreichend ist.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param fremdTermine wenn <code>true</code> werden auch die vorhandenen und benötigten Plätze von datumsgleichen {@link GostKlausurtermin}en anderer Jahrgangsstufen geprüft
+     *
+     * @return <code>true</code>, die Platzkapazität aller {@link GostKlausurraum}e des übergebenen {@link GostKlausurtermin}s für die benötigte Platzmenge an {@link GostSchuelerklausurtermin}en ausreichend ist.
+     */
+    isPlatzkapazitaetAusreichendByTermin(termin: GostKlausurtermin, fremdTermine: boolean): boolean;
+    /**
+     * Erzeugt aus einer Liste von {@link GostSchuelerklausurtermin}en eine um z. B. für Blockungs-Algorithmen relevante Informationen angereicherte Liste von {@link GostSchuelerklausurterminRich}-Objekten.
+     *
+     * @param termine die Liste der {@link GostSchuelerklausurtermin}e.
+     *
+     * @return die Liste von angereicherten {@link GostSchuelerklausurterminRich}-Objekten
+     */
+    enrichSchuelerklausurtermine(termine: List<GostSchuelerklausurtermin>): List<GostSchuelerklausurterminRich>;
+    /**
+     * Erzeugt aus einer Liste von {@link GostKlausurraum}en eine um z. B. für Blockungs-Algorithmen relevante Informationen angereicherte Liste von {@link GostKlausurraumRich}-Objekten.
+     *
+     * @param raeume die Liste der {@link GostKlausurraum}e.
+     *
+     * @return die Liste von angereicherten {@link GostKlausurraumRich}-Objekten
+     */
+    enrichKlausurraeume(raeume: List<GostKlausurraum>): List<GostKlausurraumRich>;
+    /**
+     * Liefert den {@link StundenplanRaum} zu einem übergebenen {@link GostKlausurraum}. Falls kein {@link StundenplanRaum} zugeordnet ist, wird eine <code>DeveloperNotificationException</code> geworfen.
+     *
+     * @param raum der {@link GostKlausurraum}
+     *
+     * @return der zugehörige {@link StundenplanRaum}
+     */
+    stundenplanraumGetByKlausurraum(raum: GostKlausurraum): StundenplanRaum;
+    /**
+     * Liefert den {@link StundenplanRaum} zu einem übergebenen {@link GostKlausurraum} oder <code>null</code>, falls kein zugehöriger Raum vorhanden ist.
+     *
+     * @param raum der {@link GostKlausurraum}
+     *
+     * @return der zugehörige {@link StundenplanRaum} oder <code>null</code>
+     */
+    stundenplanraumGetByKlausurraumOrNull(raum: GostKlausurraum): StundenplanRaum | null;
+    /**
+     * Prüft, ob allen zum übergebenen {@link GostKlausurtermin} gehörigen {@link GostKlausurraum}en ein {@link StundenplanRaum} zugewiesen ist.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param fremdTermine wenn <code>true</code> werden auch die {@link GostKlausurraum}e von datumsgleichen {@link GostKlausurtermin}en anderer Jahrgangsstufen geprüft
+     * @param nurVerwendet prüft nur Räume, in denen Schülerklausuren geplant wurden.
+     *
+     * @return <code>true</code>, falls allen zum übergebenen {@link GostKlausurtermin} gehörigen {@link GostKlausurraum}en ein {@link StundenplanRaum} zugewiesen ist.
+     */
+    alleRaeumeHabenStundenplanRaumByTermin(termin: GostKlausurtermin, fremdTermine: boolean, nurVerwendet: boolean): boolean;
+    /**
+     * Prüft, ob alle zum übergebenen {@link GostKlausurtermin} gehörigen {@link GostKlausurraum}e ausreichend Platzkapazität haben.
+     *
+     * @param termin der zu prüfende {@link GostKlausurtermin}
+     * @param fremdTermine wenn <code>true</code> werden auch die {@link GostKlausurraum}e von datumsgleichen {@link GostKlausurtermin}en anderer Jahrgangsstufen geprüft
+     *
+     * @return <code>true</code>, falls alle zum übergebenen {@link GostKlausurtermin} gehörigen {@link GostKlausurraum}e ausreichend Platzkapazität haben.
+     */
+    alleRaeumeHabenAusreichendKapazitaetByTermin(termin: GostKlausurtermin, fremdTermine: boolean): boolean;
+    /**
+     * Prüft, ob der übergebene {@link GostKlausurraum} ausreichend Platzkapazität hat.
+     *
+     * @param raum der zu prüfende {@link GostKlausurraum}
+     *
+     * @return <code>true</code>, falls der übergebene {@link GostKlausurraum} ausreichend Platzkapazität hat.
+     */
+    raumHatAusreichendKapazitaetByRaum(raum: GostKlausurraum): boolean;
+    /**
+     * Prüft, ob die {@link GostKursklausur} schon eine Raumzuweisung an einem {@link GostKlausurtermin} hat.
+     *
+     * @param klausur die zu prüfende {@link GostKursklausur}
+     *
+     * @return <code>true</code>, falls die {@link GostKursklausur} schon eine Raumzuweisung an einem {@link GostKlausurtermin} hat.
+     */
+    hatRaumzuteilungByKursklausur(klausur: GostKursklausur): boolean;
+    /**
+     * Liefert die Menge von {@link GostSchuelerklausur}en zum übergebenen Abiturjahrgang, die zu keinem Schüler im Jahrgang gehören.
+     *
+     * @param abijahrgang der Abiturjahrgang
+     *
+     * @return die Menge von {@link GostSchuelerklausur}en zum übergebenen Abiturjahrgang, die zu keinem Schüler im Jahrgang gehören.
+     */
+    schuelerklausurOhneSchuelerGetMengeByJahrgang(abijahrgang: number): List<GostSchuelerklausur>;
+    private ignoreVorgabeMatches;
+    private vorgabeIsIgnored;
+    /**
+     * Liefert eine Liste von fehlenden {@link GostKlausurvorgabe}n zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     * @param ignoreVorgaben eine Liste von {@link GostKlausurvorgabe}n, die ignoriert werden sollen
+     *
+     * @return die Liste von fehlenden {@link GostKlausurvorgabe}n
+     */
+    vorgabefehlendGetMengeByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, ignoreVorgaben: List<GostKlausurvorgabe> | null): List<GostKlausurvorgabe>;
+    /**
+     * Gibt das fehlende {@link GostKlausurvorgabe}-Objekt zu den übergebenen Parametern zurück.
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal     das Quartal
+     * @param kursartAllg die {@link GostKursart}
+     * @param idFach      die ID des Fachs
+     *
+     * @return das fehlende {@link GostKlausurvorgabe}-Objekt
+     */
+    vorgabefehlendGetByHalbjahrAndQuartalAndKursartallgAndFachid(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, kursartAllg: GostKursart, idFach: number): GostKlausurvorgabe | null;
+    /**
+     * Liefert eine Liste von fehlenden {@link GostKursklausur}en zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von fehlenden {@link GostKursklausur}en
+     */
+    kursklausurfehlendGetMengeByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKursklausur>;
+    /**
+     * Liefert eine Liste von fehlenden {@link GostKursklausur}en zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return die Liste von fehlenden {@link GostKursklausur}en
+     */
+    schuelerklausurfehlendGetMengeByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostSchuelerklausur>;
+    /**
+     * Liefert die Anzahl möglicher Probleme in der aktuellen Klausurplanung zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     * @param kwErrorLimit das Errorlimit für die Anzahl der Klausuren pro Schüler und Woche
+     * @param ignoreVorgaben eine Liste von {@link GostKlausurvorgabe}n, die bei der Zählung ignoriert werden sollen
+     *
+     * @return die Anzahl möglicher Probleme in der aktuellen Klausurplanung zum übergebenen {@link GostHalbjahr} und Quartal
+     */
+    planungsfehlerGetAnzahlByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, kwErrorLimit: number, ignoreVorgaben: List<GostKlausurvorgabe> | null): number;
+    /**
+     * Liefert die Anzahl möglicher Probleme in der aktuellen Klausurplanung zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     * @param kwWarnLimit die Anzahl der Klausuren pro Schüler und Woche, ab der eine Warnung ausgegeben wird
+     * @param kwErrorLimit die Anzahl der Klausuren pro Schüler und Woche, ab der ein Fehler ausgegeben wird
+     *
+     * @return die Anzahl möglicher Probleme in der aktuellen Klausurplanung zum übergebenen {@link GostHalbjahr} und Quartal
+     */
+    planungshinweiseGetAnzahlByHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number, kwWarnLimit: number, kwErrorLimit: number): number;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, die Schülerkonflikte beinhalten zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return eine Liste von {@link GostKlausurtermin}en, die Schülerkonflikte beinhalten zum übergebenen {@link GostHalbjahr} und Quartal
+     */
+    terminMitKonfliktGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von datierten {@link GostKlausurtermin}en, die keinen validen Stundenplan haben zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return eine Liste von datierten {@link GostKlausurtermin}en, die keinen validen Stundenplan haben zum übergebenen {@link GostHalbjahr} und Quartal
+     */
+    terminOhneStundenplanGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, bei denen die Raumzuweisung noch unvollständig ist zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return eine Liste von {@link GostKlausurtermin}en, bei denen die Raumzuweisung noch unvollständig ist zum übergebenen {@link GostHalbjahr} und Quartal
+     */
+    terminUnvollstaendigeRaumzuweisungGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     * Liefert eine Liste von {@link GostKlausurtermin}en, bei denen die Platzkapazität nicht ausreichend ist zum übergebenen {@link GostHalbjahr} und Quartal
+     *
+     * @param abiturjahrgang der Abitur-Jahrgang
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param quartal die Nummer des Quartals, 0 für alle Quartale
+     *
+     * @return eine Liste von {@link GostKlausurtermin}en, bei denen die Platzkapazität nicht ausreichend ist zum übergebenen {@link GostHalbjahr} und Quartal
+     */
+    terminUnzureichendePlatzkapazitaetGetMengeByAbijahrAndHalbjahrAndQuartal(abiturjahrgang: number, halbjahr: GostHalbjahr, quartal: number): List<GostKlausurtermin>;
+    /**
+     *	Fasst zwei Update-Methoden zusammen, um Laufzeit bei update_all() zu sparen.
+     *  @param kursklausur die {@link GostKursklausur}, zu der die Attribute aktualisiert werden sollen
+     * 	@param raumData die Raumdaten, die aktualisiert werden sollen
+     */
+    kursklausurPatchAttributesAndSetzeRaumZuSchuelerklausuren(kursklausur: GostKursklausur, raumData: GostKlausurenPatchResponseData): void;
+    /**
+     *	Fasst zwei Update-Methoden zusammen, um Laufzeit bei update_all() zu sparen.
+     *  @param termin der {@link GostKlausurtermin}, zu dem die Attribute aktualisiert werden sollen
+     * 	@param raumData die Raumdaten, die aktualisiert werden sollen
+     */
+    terminPatchAttributesAndSetzeRaumZuSchuelerklausuren(termin: GostKlausurtermin, raumData: GostKlausurenPatchResponseData): void;
+    /**
+     *	Fasst zwei Update-Methoden zusammen, um Laufzeit bei update_all() zu sparen.
+     *  @param schuelerklausurtermin der {@link GostSchuelerklausurtermin}, zu dem die Attribute aktualisiert werden sollen
+     * 	@param raumData die Raumdaten, die aktualisiert werden sollen
+     */
+    schuelerklausurterminPatchAttributesAndSetzeRaumZuSchuelerklausuren(schuelerklausurtermin: GostSchuelerklausurtermin, raumData: GostKlausurenPatchResponseData): void;
+    /**
+     * Liefert eine Liste von {@link GostSchuelerklausurterminraumstunde}n, die zu den übergebenen {@link GostKlausurraumstunde}n gehören.
+     * @param raumStunden die Liste von {@link GostKlausurraumstunde}n, zu denen die {@link GostSchuelerklausurterminraumstunde}n geliefert werden sollen
+     * @return die Liste von {@link GostSchuelerklausurterminraumstunde}n, die zu den übergebenen {@link GostKlausurraumstunde}n gehören
+     */
+    schuelerklausurraumstundeGetMengeByKlausurraumstundenmenge(raumStunden: List<GostKlausurraumstunde>): List<GostSchuelerklausurterminraumstunde>;
+    /**
+     * Liefert die auflösbaren Stundenplanzeitraster eines Klausurraums nach Wochentag und Unterrichtsstunde sortiert.
+     * @param raum der Klausurraum
+     * @return die Stundenplanzeitraster-Menge zu einem Klausurraum
+     */
+    zeitrasterGetMengeByRaum(raum: GostKlausurraum): List<StundenplanZeitraster>;
+    /**
+     * Liefert eine Liste aller {@link GostSchuelerklausur}-Objekte. <br>
+     * Laufzeit: O(1)
+     *
+     * @return eine Liste aller {@link GostSchuelerklausur}-Objekte.
+     */
+    schuelerklausurGetMengeAsListSortedByDatumHT(): List<GostSchuelerklausur>;
+    /**
+     * Berechnet die Klausurdauer laut APO-GOSt basierend auf der übergebenen Vorgabe.
+     *
+     * @param vorgabe  die {@link GostKlausurvorgabe}, die die notwendigen Informationen wie
+     *                 Halbjahr, Kursart und Abiturjahrgang für die Berechnung liefert.
+     * @return die berechnete Klausurdauer in Minuten als {@code int}.
+     */
+    berechneGostKlausurdauerByVorgabe(vorgabe: GostKlausurvorgabe): number;
+    /**
+     * Berechnet die Klausurdauer gemäß Halbjahr, Kursart, Fach und Abiturjahrgang.
+     * Die Klausurdauer richtet sich nach den APO-GOSt-Vorgaben, abhängig vom Halbjahr und
+     * dem Abiturjahrgang (alte oder neue Verordnung).
+     *
+     * @param halbjahr das {@link GostHalbjahr}
+     * @param kursart die {@link GostKursart}
+     * @param fach das {@link GostFach}
+     * @param abiturjahrgang der Abiturjahrgang
+     * @return die berechnete Klausurdauer in Minuten
+     */
+    static berechneGostKlausurdauerByHalbjahrAndKursartAndFach(halbjahr: GostHalbjahr, kursart: GostKursart, fach: GostFach, abiturjahrgang: number): number;
+    private static berechneAbiturKlausurdauer;
+    transpilerCanonicalName(): string;
+    isTranspiledInstanceOf(name: string): boolean;
+    static readonly class: Class<GostKlausurplanManager>;
+}
+export declare function cast_de_svws_nrw_core_utils_gost_klausuren_GostKlausurplanManager(obj: unknown): GostKlausurplanManager;
+//# sourceMappingURL=GostKlausurplanManager.d.ts.map