@hmt/svws-core 1.5.2 → 1.5.4

package/dist/core/abschluss/gost/AbiturdatenManager.d.ts

@@ -0,0 +1,1301 @@
+import { JavaObject } from '../../../java/lang/JavaObject';
+import { GostLaufbahnplanungGKLKlausurvorgabe } from '../../../core/utils/gost/GostLaufbahnplanungGKLKlausurvorgabe';
+import { GostFaecherManager } from '../../../core/utils/gost/GostFaecherManager';
+import { GostBelegpruefungErgebnis } from '../../../core/abschluss/gost/GostBelegpruefungErgebnis';
+import { GostKursart } from '../../../core/types/gost/GostKursart';
+import { Sprachendaten } from '../../../asd/data/schueler/Sprachendaten';
+import { GostFachbereich } from '../../../core/types/gost/GostFachbereich';
+import type { List } from '../../../java/util/List';
+import { Fach } from '../../../asd/types/fach/Fach';
+import { GostAbiturFach } from '../../../core/types/gost/GostAbiturFach';
+import { GostJahrgangFachkombination } from '../../../core/data/gost/GostJahrgangFachkombination';
+import { AbiturKursMarkierung } from '../../../core/data/gost/AbiturKursMarkierung';
+import { Class } from '../../../java/lang/Class';
+import type { JavaMap } from '../../../java/util/JavaMap';
+import { GostBelegpruefungsArt } from '../../../core/abschluss/gost/GostBelegpruefungsArt';
+import { AbiturFachbelegungHalbjahr } from '../../../core/data/gost/AbiturFachbelegungHalbjahr';
+import { GostSchuelerFachwahl } from '../../../core/data/gost/GostSchuelerFachwahl';
+import { GostJahrgangsdaten } from '../../../core/data/gost/GostJahrgangsdaten';
+import { GostAbiturMarkierungspruefungErgebnis } from '../../../core/abschluss/gost/GostAbiturMarkierungspruefungErgebnis';
+import { GostHalbjahr } from '../../../core/types/gost/GostHalbjahr';
+import { GostSchriftlichkeit } from '../../../core/types/gost/GostSchriftlichkeit';
+import { GostFach } from '../../../core/data/gost/GostFach';
+import { AbiturFachbelegung } from '../../../core/data/gost/AbiturFachbelegung';
+import { GostBelegpruefung } from '../../../core/abschluss/gost/GostBelegpruefung';
+import { Abiturdaten } from '../../../core/data/gost/Abiturdaten';
+import { AbiturBelegungsart } from '../../../core/types/gost/AbiturBelegungsart';
+import { Abi30BelegpruefungEinbringung } from '../../../core/abschluss/gost/belegpruefung/abi2030/Abi30BelegpruefungEinbringung';
+import { GostAbiturMarkierungsalgorithmusErgebnis } from '../../../core/abschluss/gost/GostAbiturMarkierungsalgorithmusErgebnis';
+import { GostSchuelerGKLWahl } from '../../../core/data/gost/GostSchuelerGKLWahl';
+export declare class AbiturdatenManager extends JavaObject {
+    /**
+     * Das Abiturdaten-Objekt, welches mithilfe dieses Managers bearbeitet wird
+     */
+    private readonly abidaten;
+    /**
+     * Die Informationen zu den Jahrgangsdaten, sofern welche vorhanden sind - ansonsten null
+     */
+    private readonly _jahrgangsdaten;
+    /**
+     * Der Manager für die Fächer und Fachkombinationen der gymnasialen Oberstufe für diesen Abiturjahrgang
+     */
+    private readonly faecherManager;
+    /**
+     * Die Art der durchzuführenden Belegprüfung
+     */
+    private readonly pruefungsArt;
+    /**
+     * Eine HashMap, welche den schnellen Zugriff auf eine Fachbelegung anhand der Fach-ID ermöglicht
+     */
+    private readonly mapFachbelegungByFachID;
+    /**
+     * Eine HashMap, welche den schnellen Zugriff auf die Fachbelegungen für ein Fach-Kürzel ermöglicht (können mehrere sein - Beispiel billingual mit Wechsel
+     */
+    private readonly mapFachbelegungenByFachKuerzel;
+    /**
+     * Eine HashMap für den schnellen Zugriff auf die Fachbelegungen, welche in dem Halbjahr eine gültige Belegung haben
+     */
+    private readonly mapFachbelegungenByGostHalbjahr;
+    /**
+     * Eine HashMap2D für den schnellen Zugriff auf die Halbjahresbelegungen anhand der Fach-UD und der ID des GostHalbjahres
+     */
+    private readonly mapFachbelegungHalbjahrByFachIDAndHalbjahrID;
+    /**
+     * Eine HashMap, welche den schnellen Zugriff auf die Fachbelegungen über den Fachbereich ermöglicht
+     */
+    private readonly mapFachbereiche;
+    /**
+     * Eine HashMap, welche den schnellen Zugriff auf die Prüfungsordnungs-relevanten Fachbelegungen über den Fachbereich ermöglicht
+     */
+    private readonly mapFachbereicheRelevant;
+    /**
+     * Die Prüfungsergebnisse der einzelnen Teilprüfungen der Belegprüfung
+     */
+    private belegpruefungen;
+    /**
+     * Die zuletzt durchgeführte Belegprüfung bezüglich der Kurszahlen und der Wochenstunden
+     */
+    private belegpruefungKurszahlenUndWochenstunden;
+    /**
+     * Die zuletzt durchgeführte Belegprüfung bezüglich der Kurszahlen und der Wochenstunden
+     */
+    private abi30BelegpruefungKurszahlenUndWochenstunden;
+    /**
+     * Die zuletzt durchgeführte Belegprüfung bezüglich der Einbringungsverpflichtungen
+     */
+    private abi30BelegpruefungEinbringung;
+    /**
+     * Die Menge der Belegprüfungsfehler, die bei den durchgeführten Belegprüfungen aufgetreten sind.
+     */
+    private belegpruefungsfehler;
+    /**
+     * Gibt an, ob die Belegprüfung insgesamt erfolgreich war oder nicht.
+     */
+    private belegpruefungErfolgreich;
+    /**
+     * Das Ergebnis des Markierungsalgorithmus
+     */
+    private markierungsErgebnis;
+    /**
+     * Das Ergebnis des Markierprüfungsalgorithmus
+     */
+    private markierpruefungsergebnis;
+    /**
+     * Erstellt ein neues Manager-Objekt, welches mit den übergebenen Abiturdaten verknüpft wird.
+     *
+     * @param abidaten       die Abiturdaten
+     * @param gostJahrgang   die Informationen zu dem Abiturjahrgang
+     * @param faecherManager der Manager für die Fächer und Fachkombinationen der Gymnasialen Oberstufe
+     * @param pruefungsArt   die Art der Belegpruefung (z.B. EF1 oder GESAMT)
+     */
+    constructor(abidaten: Abiturdaten, gostJahrgang: GostJahrgangsdaten | null, faecherManager: GostFaecherManager, pruefungsArt: GostBelegpruefungsArt);
+    /**
+     * Initialisiert die Belegprüfung der Art pruefungs_art für einen Schüler durch, dessen Abiturdaten mit dem angegebenen
+     * Manager verwaltet werden.
+     *
+     * @param pruefungsArt    die Art der Prüfung, die durchgeführt wird
+     *
+     * @return eine Liste mit den durchgefuehrten Belegpruefungen
+     */
+    private getPruefungenDefault;
+    /**
+     * Einbinden von experimentellem Code:
+     * Initialisiert die Belegprüfung der Art pruefungs_art für einen Schüler durch, dessen Abiturdaten mit dem angegebenen
+     * Manager verwaltet werden.
+     *
+     * @param pruefungsArt    die Art der Prüfung, die durchgeführt wird
+     *
+     * @return eine Liste mit den durchgefuehrten Belegpruefungen
+     */
+    private getPruefungenAbi2030;
+    /**
+     * Führt die Belegprüfung der Art pruefungs_art für einen Schüler durch, dessen Abiturdaten mit dem angegebenen
+     * Manager verwaltet werden.
+     *
+     * @param pruefungsArt    die Art der Prüfung, die durchgeführt wird
+     *
+     * @return eine Liste mit den durchgefuehrten Belegpruefungen
+     */
+    getPruefungen(pruefungsArt: GostBelegpruefungsArt): List<GostBelegpruefung>;
+    /**
+     * Initialisiert bzw. reinitialisert die Datenstrukturen, die für den schnellen Zugriff auf die Daten
+     * eingerichtet werden.
+     */
+    init(): void;
+    /**
+     * Führt eine Belegprüfung der GKL-Wahlen durch
+     *
+     * @param gklWahlen            die GKL-Wahlen des Schülers
+     * @param mapKlausurvorgaben   die Klausurvorgaben mit den Informationen zu den möglichen GKL-Wahlen in der Abiturjahrgang
+     */
+    pruefeGKL(gklWahlen: GostSchuelerGKLWahl, mapKlausurvorgaben: JavaMap<number, GostLaufbahnplanungGKLKlausurvorgabe>): void;
+    /**
+     * Prüft ob, bei dem übergeben Abiturjahr der Code für das Abitur ab 2030 eingesetzt werden soll.
+     *
+     * @param abiturjahr   das Abiturjahr
+     *
+     * @return true, wenn der Abi2030-Code genutzt werden soll, und ansonsten false
+     */
+    static istAbitur2030(abiturjahr: number): boolean;
+    /**
+     * Gibt zurück, ob die Abiturprüfung nach der APO Gost mit dem ersten Abiturjahrgang 2030 geprüft wird.
+     *
+     * @return true, wenn die Abiturprüfung nach der APO Gost mit dem ersten Abiturjahrgang 2030 verwendet wird, und ansonsten false
+     */
+    istAbi2030(): boolean;
+    /**
+     * Initialisiert bzw. reinitialisiert die Map für den schnellen Zugriff auf Fachbelegungen
+     * anhand des Fachbereichs, der Fach-ID oder des Halbjahres.
+     */
+    private initMaps;
+    /**
+     * Fasst die bilingualen und nicht biligualen Fachbelegungen unter dem Fach der
+     * letzten Halbjahresbelegung zusammen und initialisiert den Manager danach neu.
+     *
+     * @return true, wenn das Kombinieren erfolgreich durchgeführt wurde, und ansonsten false
+     */
+    kombiniereFachbelegungenEinesFaches(): boolean;
+    /**
+     * Gibt die von diesem Manager verwalteten Abiturdaten zurück.
+     *
+     * @return die Abiturdaten des Managers
+     */
+    daten(): Abiturdaten;
+    /**
+     * Gibt den zugehörigen Fächer-Manager zurück.
+     *
+     * @return der Fächer-Manager
+     */
+    faecher(): GostFaecherManager;
+    /**
+     * Gibt die Jahrgangsdaten für den Abiturjahrgang zurück.
+     *
+     * @return die Jahrgangsdaten
+     *
+     * @throws DeveloperNotificationException falls keine Jahrgangsdaten vorliegen
+     */
+    jahrgangsdaten(): GostJahrgangsdaten;
+    /**
+     * gibt die gewählte Prüfungsart zurück
+     *
+     * @return entweder Gesamtprüfung oder EF1-Prüfung
+     */
+    getPruefungsArt(): GostBelegpruefungsArt;
+    /**
+     * Gibt zurück, ob das angegebene Halbjahr bereits bewertet ist oder nicht.
+     *
+     * @param halbjahr   das Halbjahr
+     *
+     * @return true, falls es bereits bewertet ist
+     */
+    istBewertet(halbjahr: GostHalbjahr): boolean;
+    /**
+     * Gibt zurück, ob alle Halbjahr der Qualifikationsphase bewertet sind oder nicht.
+     *
+     * @return true, falls alle Halbjahre bewertet sind, und ansonsten false
+     */
+    istBewertetQualifikationsPhase(): boolean;
+    /**
+     * Liefert die in den Abiturdaten enthaltenen Sprachendaten.
+     *
+     * @return Die Sprachendaten (siehe {@link Sprachendaten})
+     */
+    getSprachendaten(): Sprachendaten;
+    /**
+     * Liefert das Abiturjahr
+     *
+     * @return das Abiturjahr
+     */
+    getAbiturjahr(): number;
+    /**
+     * Liefert das Schuljahr, in dem das Abitur gemacht wird
+     *
+     * @return das Schuljahr
+     */
+    getSchuljahr(): number;
+    /**
+     * Gibt zurück, ob es sich bei der Halbjahresbelegung um eine Belegung handelt, welche mit
+     * null Punkten abgeschlossen wurde und welche daher als nicht belegter Kurs zu werten ist.
+     *
+     * @param halbjahresbelegung   die Halbjahresbelegung eines Kurses
+     *
+     * @return true, fall es sich um einen Null-Punkte-Kurs in der Qualifikationsphase handelt.
+     */
+    static istNullPunkteBelegungInQPhase(halbjahresbelegung: AbiturFachbelegungHalbjahr): boolean;
+    private static getSchuelerFachwahlFromBelegung;
+    /**
+     * Bestimmt die Schüler-Fachwahl für das Fach mit der übergebenen ID
+     *
+     * @param fachID   die ID des Faches
+     *
+     * @return die Schüler-Fachwahl
+     */
+    getSchuelerFachwahl(fachID: number): GostSchuelerFachwahl;
+    /**
+     * Bestimmt die Schüler-Fachwahlen aller belegten Fächer.
+     *
+     * @return die Map mit den Schüler-Fachwahlen
+     */
+    getSchuelerFachwahlen(): JavaMap<number, GostSchuelerFachwahl>;
+    /**
+     * Liefert das Fach der gymnasialen Oberstufe für die angegeben Abiturfachbelegung.
+     *
+     * @param belegung   die Fachbelegung (siehe {@link AbiturFachbelegung})
+     *
+     * @return das Fach der gymnasialen Oberstufe (siehe {@link GostFach})
+     */
+    getFach(belegung: AbiturFachbelegung | null): GostFach | null;
+    /**
+     * Prüft, ob die Fachbelegung in einem der übergebenen Fachbereiche liegt.
+     *
+     * @param belegung   die Belegung
+     * @param bereiche   die Fachbereiche
+     *
+     * @return true, wenn die Fachbelegung in einem der Bereiche liegt und ansonsten false
+     */
+    hatFachbereich(belegung: AbiturFachbelegung | null, ...bereiche: Array<GostFachbereich>): boolean;
+    /**
+     * Prüft, ob eine Belegung der Abiturfächer in einem der übergebenen Fachbereiche liegt.
+     *
+     * @param bereiche   die Fachbereiche
+     *
+     * @return true, wenn eine der Fachbelegungen in einem der Fachbereiche liegt und ansonsten false
+     */
+    hatFachbereichInAbiturfaechern(...bereiche: Array<GostFachbereich>): boolean;
+    /**
+     * Prüft, ob eine Belegung der Leistungskurse in einem der übergebenen Fachbereiche liegt.
+     *
+     * @param bereiche   die Fachbereiche
+     *
+     * @return true, wenn eine Belegung der Leistungskurse in einem der Fachbereiche liegt und ansonsten false
+     */
+    hatFachbereichInLKAbiturfaechern(...bereiche: Array<GostFachbereich>): boolean;
+    /**
+     * Prüft, ob eine Belegung der Abitur-Grundkurse in einem der übergebenen Fachbereiche liegt.
+     *
+     * @param bereiche   die Fachbereiche
+     *
+     * @return true, wenn eine Belegung der Abitur-Grundkurse in einem der Fachbereiche liegt und ansonsten false
+     */
+    hatFachbereichInGKAbiturfaechern(...bereiche: Array<GostFachbereich>): boolean;
+    /**
+     * Prüft, ob in den Abiturdaten mindestens eine Fachbelegung existiert oder nicht.
+     * Wichtig: Bei dieser Methode wird auch eine 0-Punkte-Belegung als Fachbelegung gezählt!
+     *
+     * @return true, wenn mindestens eine Fachbelegung existiert, und ansonsten false
+     */
+    existsFachbelegung(): boolean;
+    /**
+     * Prüft, ob das Fach in allen angegebenen Halbjahren belegt wurde.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegung      die zu prüfende Fachbelegung
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls das Fach in den Halbjahren belegt wurde, sonst false
+     */
+    pruefeBelegung(fachbelegung: AbiturFachbelegung | null, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Bestimmt die Anzahl der Fachbelegungen, die dem Fach zugeordnet sind.
+     * Wird keine gültige Fachbelegung übergeben, so wird 0 zurückgegeben.
+     *
+     * @param fachbelegung   die Fachbelegung
+     *
+     * @return die Anzahl der Belegungen des Faches
+     */
+    zaehleBelegung(fachbelegung: AbiturFachbelegung | null): number;
+    /**
+     * Zählt die Anzahl der Halbjahresbelegungen für die angegebene Fachbelegung in den angegeben Halbjahren.
+     * Ist die Fachbelegung null, so wird 0 zurückgegeben. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so wird ebenfalls 0 zurückgegeben.
+     *
+     * @param fachbelegung   die Fachbelegung
+     * @param halbjahre      die Halbjahre
+     *
+     * @return die Anzahl der Belegungen in den Halbjahren
+     */
+    zaehleHalbjahresbelegungen(fachbelegung: AbiturFachbelegung | null, ...halbjahre: Array<GostHalbjahr>): number;
+    /**
+     * Zählt die Anzahl der Belegungen für die angegebenen Fachbelegungen in den angegeben Halbjahren.
+     * Ist die Fachbelegung null, so wird 0 zurückgegeben. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so wird ebenfalls 0 zurückgegeben.
+     *
+     * @param fachbelegungen      die Fachbelegungen
+     * @param halbjahre           die Halbjahre
+     *
+     * @return die Anzahl der Belegungen in den Halbjahren und den Fächern
+     */
+    zaehleBelegungInHalbjahren(fachbelegungen: List<AbiturFachbelegung> | null, ...halbjahre: Array<GostHalbjahr>): number;
+    /**
+     * Zählt die Anzahl der Belegungen für die angegebenen Fachbelegungen in den angegeben Halbjahren.
+     * Ist die Fachbelegung null, so wird 0 zurückgegeben. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so wird ebenfalls 0 zurückgegeben. Eintragungen mit AT werden dabei ignoriert.
+     *
+     * @param fachbelegungen      die Fachbelegungen
+     * @param halbjahre           die Halbjahre
+     *
+     * @return die Anzahl der Belegungen in den Halbjahren und den Fächern
+     */
+    zaehleBelegungInHalbjahrenOhneAT(fachbelegungen: List<AbiturFachbelegung> | null, ...halbjahre: Array<GostHalbjahr>): number;
+    /**
+     * Zählt die Anzahl der 0-Punkte-Belegungen aller Fachbelegungen in der Qualifikationsphase.
+     *
+     * @return die Anzahl der 0-Punkte-Belegungen aller Fachbelegungen in der Qualifikationsphase
+     */
+    zaehleNullPunkteBelegungenInQPhase(): number;
+    /**
+     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren der angegebenen Kursart entspricht.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegung      die zu prüfende Fachnbelegung
+     * @param kursart           die zu prüfende Kursart
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungMitKursart(fachbelegung: AbiturFachbelegung | null, kursart: GostKursart, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob eine Fachbelegung existiert, welche in den angegebenen Halbjahren der angegebenen Kursart
+     * entspricht.
+     * Ist keine Fachbelegung angegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen
+     * Fachbelegung kein Halbjahr angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param kursart           die zu prüfende Kursart
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungExistiertMitKursart(fachbelegungen: List<AbiturFachbelegung> | null, kursart: GostKursart, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren mindestens einmal die angegebenen Kursart hat.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung nicht erfolgreich, da kein Halbjahr geprüft werden muss und somit die Kursart nicht
+     * einmal existiert.
+     *
+     * @param fachbelegung      die zu prüfende Fachnbelegung
+     * @param kursart           die zu prüfende Kursart
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die Kursart mindestens einmal in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungHatMindestensEinmalKursart(fachbelegung: AbiturFachbelegung | null, kursart: GostKursart, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung des Faches in dem angegebenen Halbjahr der angegebenen Schriftlichkeit entspricht.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl.
+     *
+     * @param fachbelegung      die zu prüfende Fachnbelegung
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahr          das zu prüfende Halbjahr
+     *
+     * @return true, falls die Schriftlichkeit in dem Halbjahr gegeben ist, sonst false
+     */
+    pruefeBelegungMitSchriftlichkeitEinzeln(fachbelegung: AbiturFachbelegung | null, schriftlichkeit: GostSchriftlichkeit, halbjahr: GostHalbjahr): boolean;
+    /**
+     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegung      die zu prüfende Fachnbelegung
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungMitSchriftlichkeit(fachbelegung: AbiturFachbelegung | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob eine Belegung des Faches in den angegebenen Halbjahren nicht der angegebenen Schriftlichkeit entspricht.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegung      die zu prüfende Fachnbelegung
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die Schriftlichkeit in den Halbjahren nicht gegeben ist, sonst false
+     */
+    pruefeBelegungErfuelltNicht(fachbelegung: AbiturFachbelegung | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob eine Belegung des Faches in den angegebenen Halbjahren nicht der angegebenen Schriftlichkeit entspricht,
+     * sofern es in dem Halbjahr überhaupt belegt wurde..
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegung      die zu prüfende Fachnbelegung
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die Schriftlichkeit in den Halbjahren nicht gegeben ist, sonst false
+     */
+    pruefeBelegungErfuelltNichtFallsBelegt(fachbelegung: AbiturFachbelegung | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren mindestens einmal die angegebene Schritflichkeit hat.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung nicht erfolgreich, da kein Halbjahr geprüft werden muss und somit die Schriftlichkeit nicht
+     * einmal existiert.
+     *
+     * @param fachbelegung      die zu prüfende Fachbelegung
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die angegebene Schriftlichkeit mindestens einmal in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungHatMindestensEinmalSchriftlichkeit(fachbelegung: AbiturFachbelegung | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob eine Fachbelegung existiert, welche in den angegebenen Halbjahren mindestens einmal die angegebene
+     * Schritflichkeit hat.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung nicht erfolgreich, da kein Halbjahr geprüft werden muss und somit die Schriftlichkeit nicht
+     * einmal existiert.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachbelegungen
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die angegebene Schriftlichkeit bei einer Fachbelegung mindestens einmal in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungExistiertHatMindestensEinmalSchriftlichkeit(fachbelegungen: List<AbiturFachbelegung> | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer mit den angegebenen Halbjahren existiert.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
+     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist z.B. bei bilingualen
+     * Fächern nötig oder bei der Unterscheidung von Sport-Profilen.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls eine Fachbelegung mit den Halbjahren existiert, sonst false
+     */
+    pruefeBelegungExistiert(fachbelegungen: List<AbiturFachbelegung> | null, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer mit den angegebenen Halbjahren existiert und bei diesen Halbjahren keine Note "AT"
+     * eingetragen ist..
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
+     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist z.B. bei bilingualen
+     * Fächern nötig oder bei der Unterscheidung von Sport-Profilen.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls eine Fachbelegung mit den Halbjahren existiert, welche keinen Noteneintrag "AT" hat, sonst false
+     */
+    pruefeBelegungExistiertOhneAT(fachbelegungen: List<AbiturFachbelegung> | null, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer mit dem angegebenen Halbjahr existiert.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl.
+     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
+     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist z.B. bei bilingualen
+     * Fächern nötig oder bei der Unterscheidung von Sport-Profilen.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param halbjahr          das zu prüfende Halbjahr
+     *
+     * @return true, falls eine Fachbelegung mit dem Halbjahr existiert, sonst false
+     */
+    pruefeBelegungExistiertEinzeln(fachbelegungen: List<AbiturFachbelegung> | null, halbjahr: GostHalbjahr): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer mit dem angegebenen Halbjahr existiert und diese keine Belegung
+     * mit Sport-Attest ist.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl.
+     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
+     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist z.B. bei bilingualen
+     * Fächern nötig oder bei der Unterscheidung von Sport-Profilen.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param halbjahr          das zu prüfende Halbjahr
+     *
+     * @return true, falls eine Fachbelegung mit dem Halbjahr existiert, sonst false
+     */
+    pruefeBelegungExistiertEinzelnOhneAT(fachbelegungen: List<AbiturFachbelegung> | null, halbjahr: GostHalbjahr): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer mit einer durchgängigen Belegung existiert,
+     * die zumindest in der Q1 und der Q2.1 schriftlich ist.
+     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
+     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist bei bilingualen
+     * Fächern nötig.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     *
+     * @return true, falls eine durchgehend schriftliche Fachbelegung existiert, sonst false
+     */
+    pruefeBelegungExistiertDurchgehendSchriftlich(fachbelegungen: List<AbiturFachbelegung> | null): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer in dem angegebenen Halbjahr der angegebenen Schriftlichkeit entspricht.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahr          das zu prüfende Halbjahr
+     *
+     * @return true, falls bei einer Fachbelegung die Schriftlichkeit in dem Halbjahr gegeben ist, sonst false
+     */
+    pruefeBelegungExistiertMitSchriftlichkeitEinzeln(fachbelegungen: List<AbiturFachbelegung> | null, schriftlichkeit: GostSchriftlichkeit, halbjahr: GostHalbjahr): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls bei einer Fachbelegung die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungExistiertMitSchriftlichkeit(fachbelegungen: List<AbiturFachbelegung> | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren mindestens einmal die angegebene Kursart
+     * hat. Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param kursart           die zu prüfende Kursart
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die Kursart bei einer Fachbelegung mindestens einmal in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungExistiertHatMindestensEinmalKursart(fachbelegungen: List<AbiturFachbelegung> | null, kursart: GostKursart, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren existiert,
+     * bei welchem in mind. einem der Halbjahren die angebene Schriftlichkeit nicht gegeben ist.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true oder false (siehe oben)
+     */
+    pruefeBelegungExistiertErfuelltNicht(fachbelegungen: List<AbiturFachbelegung> | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren existiert,
+     * bei welchem in mind. einem der Halbjahren die angebene Schriftlichkeit nicht gegeben ist, sofern
+     * das Fach überhaupt belegt wurde.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachnbelegungen
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true oder false (siehe oben)
+     */
+    pruefeBelegungExistiertErfuelltNichtFallsBelegt(fachbelegungen: List<AbiturFachbelegung> | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung des Faches in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht
+     * und das Fach durchgehend belegbar ist.
+     * Ist die Fachbelegung null, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegung      die zu prüfende Fachnbelegung
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungDurchgehendBelegbar(fachbelegung: AbiturFachbelegung | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht
+     * und das Fach durchgängig belegbar ist.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachbelegungen
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls bei einer Fachbelegung die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungDurchgehendBelegbarExistiert(fachbelegungen: List<AbiturFachbelegung> | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Belegung eines der angegebenen Fächer in den angegebenen Halbjahren der angegebenen Schriftlichkeit entspricht
+     * und das Fach durchgängig belegt ist.
+     * Ist keine Fachbelegung gegeben, so schlägt die Prüfung fehl. Wird bei einer gültigen Fachbelegung kein Halbjahr
+     * angegeben, so ist die Prüfung erfolgreich sofern das Fach durchgängig belegt wurde, da kein Halbjahr auf die
+     * Schriftlichkeit geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu prüfenden Fachbelegungen
+     * @param schriftlichkeit   die zu prüfende Schriftlichkeit
+     * @param halbjahre         die zu prüfenden Halbjahre
+     *
+     * @return true, falls bei eine Fachbelegung durchgängig belegt wurde und die Schriftlichkeit in den Halbjahren gegeben ist, sonst false
+     */
+    pruefeBelegungDurchgehendBelegtExistiert(fachbelegungen: List<AbiturFachbelegung> | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Prüft, ob die Fachbelegung in mindestens einem der Halbjahre die angegebene Kursart aufweist.
+     * Existiert die Fachbelegung nicht (null), so kommt die Kursart auch nicht vor.
+     *
+     * @param fachbelegung   die Fachbelegung
+     * @param kursart        die Kursart
+     *
+     * @return true, falls mindestens einmal die Kursart belegt wurde, sonst false
+     */
+    pruefeAufKursart(fachbelegung: AbiturFachbelegung | null, kursart: GostKursart): boolean;
+    /**
+     * Filtert die Fachbelegungen und gibt nur die Fachbelegungen zurück, bei denen die
+     * Kursart existiert.
+     * Wird keine Fachbelegung übergeben (null oder leere Liste), so kommt auch keine
+     * Belegung mit der Kursart vor.
+     *
+     * @param fachbelegungen   die Fachbelegungen
+     * @param kursart          die Kursart
+     *
+     * @return eine Liste mit den Fachbelegungen, welche die kursart haben
+     */
+    filterBelegungKursartExistiert(fachbelegungen: List<AbiturFachbelegung> | null, kursart: GostKursart): List<AbiturFachbelegung>;
+    /**
+     * Prüft, ob die Fachbelegung eine durchgängige Belegung hat. Zusatzkurse können nicht für eine
+     * durchgängige Belegung zählen.
+     *
+     * @param fachbelegung   die zu prüfende Fachbelegung
+     *
+     * @return true, wenn die Belegung durchgängig ist.
+     */
+    pruefeDurchgaengigkeit(fachbelegung: AbiturFachbelegung | null): boolean;
+    /**
+     * Zählt die Fachbelegungen, welche eine durchgängige Belegung aufweisen. Zusatzkurse zählen
+     * nicht für eine durchgängige Belegung.
+     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
+     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist bei bilingualen
+     * Fächern nötig.
+     *
+     * @param fachbelegungen   die zu überprüfenden Fachbelegungen
+     *
+     * @return die Anzahl der durchgängigen Belegungen
+     */
+    zaehleDurchgaengigeBelegungen(fachbelegungen: List<AbiturFachbelegung> | null): number;
+    /**
+     * Prüft, ob die Fachbelegung eine durchgängige Belegung hat und prüft die Schriftlichkeit
+     * in der Qualifikationsphase. Ein Fach in der Qualifikationsphase gilt als Schriftlich belegt,
+     * sofern die ersten 3 Halbjahre der Qualifikationsphase schriftlich belegt wurden.
+     * - Zusatzkurse können nicht für eine durchgängige Belegung zählen.
+     *
+     * @param fachbelegung   die zu prüfende die zu überprüfenden Fachbelegung
+     *
+     * @return true, wenn die Belegung durchgängig ist und die Schriftlichkeit den Anforderungen genügt.
+     */
+    pruefeDurchgaengigkeitSchriftlich(fachbelegung: AbiturFachbelegung | null): boolean;
+    /**
+     * Prüft, ob unter den angegebenen Fachbelegungen ein Fach als Abiturfach von einem der angegebenen Arten
+     * gewählt wurde. Wird keine Art angebeben, so wird jede Fachbelegung akzeptiert und true zurückgegeben.
+     *
+     * @param fachbelegungen   die Fachbelegungen
+     * @param arten            die Arten der Abiturfächer
+     *
+     * @return true, falls unter den Fachbelegungen mindestens ein Fach als Abiturfach von einem der
+     *         angegebenen Arten gewählt wurde und false sonst
+     */
+    pruefeExistiertAbiFach(fachbelegungen: List<AbiturFachbelegung> | null, ...arten: Array<GostAbiturFach>): boolean;
+    /**
+     * Prüft, ob ein Abiturfach der übergebenen Art (1-4) existiert oder nicht.
+     *
+     * @param art   die Art des Abiturfaches (siehe {@link GostAbiturFach}
+     *
+     * @return true, falls die Art des Abiturfaches belegt wurde und ansonsten false
+     */
+    hatAbiFach(art: GostAbiturFach): boolean;
+    /**
+     * Prüft anhand des Statistik-Kürzels, ob in dem angegebenen Halbjahr eine doppelte Fachbelegung
+     * vorliegt oder nicht. Bei den Fremdsprachen werden nur unterschiedliche Fremdsprachen in einem Halbjahr
+     * akzeptiert und es dürfen mehrere Vertiefungsfächer (VX) in einem Halbjahr vorkommen. Fächer, die
+     * als nicht Prüfungsordnungs-relevant markiert sind werden ignoriert
+     *
+     * @param halbjahr   das zu prüfende Halbjahr
+     *
+     * @return true, falls eine doppelte Belegung vorliegt, sonst false
+     */
+    hatDoppelteFachbelegungInHalbjahr(halbjahr: GostHalbjahr): boolean;
+    /**
+     * Prüft anhand des Statistik-Kürzels, ob in einem der angegebenen Halbjahre eine doppelte Fachbelegung
+     * vorliegt oder nicht. Bei den Fremdsprachen werden nur unterschiedliche Fremdsprachen in einem Halbjahr
+     * akzeptiert und es dürfen mehrere Vertiefungsfächer (VX) in einem Halbjahr vorkommen.
+     *
+     * @param halbjahre   die zu prüfenden Halbjahre
+     *
+     * @return true, falls eine doppelte Belegung vorliegt, sonst false
+     */
+    hatDoppelteFachbelegung(...halbjahre: Array<GostHalbjahr>): boolean;
+    /**
+     * Gibt zurück, ob der Projektkurs als besondere Lernleistung verwendet wird.
+     *
+     * @return true, falls der Projektkurs als besondere Lernleistung verwendet wird
+     */
+    istProjektKursBesondereLernleistung(): boolean;
+    /**
+     * Bestimmt die Fachbelegung des Faches mit der angegebenen ID
+     *
+     * @param fachID   die ID des Faches
+     *
+     * @return die Fachbelegung oder null, falls keine vorhanden ist
+     */
+    getFachbelegungByID(fachID: number | null): AbiturFachbelegung | null;
+    /**
+     * Bestimmt die erste Fachbelegung mit dem angegebenen Statistik-Kürzel
+     *
+     * @param kuerzel          das Kürzel des Faches, kann null sein (dann wird auch null zurückgegeben)
+     *
+     * @return die Fachbelegung oder null, falls keine vorhanden ist
+     */
+    getFachbelegungByKuerzel(kuerzel: string | null): AbiturFachbelegung | null;
+    /**
+     * Liefert alle Fachbelegungen der Abiturdaten, welche den angegebenen Fachbereichen zuzuordnen sind.
+     * Wird kein Fachbereich angegeben, so werden alle Fachbelegungen der Abiturdaten zurückgegeben.
+     *
+     * @param fachbereiche   die Fachbereiche
+     *
+     * @return eine Liste der Fachbelegungen aus den Fachbereichen
+     */
+    getFachbelegungen(...fachbereiche: Array<GostFachbereich>): List<AbiturFachbelegung>;
+    /**
+     * Liefert alle Prüfungsordnungs-relevanten Fachbelegungen der Abiturdaten, welche den angegebenen Fachbereichen
+     * zuzuordnen sind.
+     * Wird kein Fachbereich angegeben, so werden alle Fachbelegungen der Abiturdaten zurückgegeben.
+     *
+     * @param fachbereiche   die Fachbereiche
+     *
+     * @return eine Liste der Fachbelegungen aus den Fachbereichen
+     */
+    getRelevanteFachbelegungen(...fachbereiche: Array<GostFachbereich>): List<AbiturFachbelegung>;
+    /**
+     * Liefert alle Prüfungsordnungs-relevanten Fachbelegungen der Abiturdaten, welche den angegebenen
+     * Statistik-Fächern zuzuordnen sind.
+     * Wird kein Fach angegeben, so werden alle Fachbelegungen der Abiturdaten zurückgegeben.
+     *
+     * @param faecher   die Statistik-Fächer
+     *
+     * @return die Liste der Fachbelegungen
+     */
+    getRelevanteFachbelegungenByFach(...faecher: Array<Fach>): List<AbiturFachbelegung>;
+    /**
+     * Liefert alle Fachbelegungen, die bilingual unterrichtet wurden.
+     *
+     * @return eine Liste der Fachbelegungen
+     */
+    getFachbelegungenBilingual(): List<AbiturFachbelegung>;
+    /**
+     * Prüft, ob es sich bei der übergebenen Fachbelegung um eine bilinguale Belegung handelt oder nicht.
+     *
+     * @param fachbelegung   die Fachbelegung
+     *
+     * @return true, wenn es sich bei der Fachbelegung um die Belegung eines bilingualen Sachfaches handelt.
+     */
+    istFachbelegungBilingualesSachfach(fachbelegung: AbiturFachbelegung | null): boolean;
+    /**
+     * Filtert die Fachbelegungen auf neu einsetzende Fremdsprachen.
+     *
+     * @param fachbelegungen   die zu filternden Fachbelegungen
+     *
+     * @return die gefilterten Fachbelegungen
+     */
+    filterFremdspracheNeuEinsetzend(fachbelegungen: List<AbiturFachbelegung> | null): List<AbiturFachbelegung>;
+    /**
+     * Filtert die Fachbelegungen auf fortgeführte Fremdsprachen.
+     *
+     * @param fachbelegungen   die zu filternden Fachbelegungen
+     *
+     * @return die gefilterten Fachbelegungen
+     */
+    filterFremdspracheFortgefuehrt(fachbelegungen: List<AbiturFachbelegung> | null): List<AbiturFachbelegung>;
+    /**
+     * Filtert die Fachbelegungen danach, ob sie durchgehend belegbar sind
+     *
+     * @param fachbelegungen   die zu filternden Fachbelegungen
+     *
+     * @return die gefilterten Fachbelegungen
+     */
+    filterDurchgehendBelegbar(fachbelegungen: List<AbiturFachbelegung> | null): List<AbiturFachbelegung>;
+    /**
+     * Filtert die Fachbelegungen. Es werden nur Fachbelegungen behalten, die in den angegebenen Halbjahren eine Belegung aufweisen.
+     * Wird kein Halbjahr angegeben, so wird nichts gefiltert, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu filternden Fachbelegungen
+     * @param halbjahre         die Halbjahre, die belegt sein müssen
+     *
+     * @return die gefilterten Fachbelegungen
+     */
+    filterBelegungen(fachbelegungen: List<AbiturFachbelegung> | null, ...halbjahre: Array<GostHalbjahr>): List<AbiturFachbelegung>;
+    /**
+     * Bestimmt die Menge der unterschiedlichen Statistik-Fächer in der angegebenen Fachbelegungen.
+     *
+     * @param fachbelegungen   die Fachbelegungen
+     *
+     * @return die Menge der Statistik-Fächer
+     */
+    private getMengeStatistikFaecher;
+    /**
+     * Diese Methode zählt die Anzahl der angegebenen Fachbelegungen, welche in allen
+     * Halbjahren belegt sind. Dabei werden Fachbelegungen, welche dem gleichem Statistik-Fach
+     * zuzuordnen sind zusammengefasst. Dies ist bei der Abwahl von bilingualen Sachfächern
+     * relevant.
+     *
+     * @param fachbelegungen   die zu zählenden Fachbelegungen
+     *
+     * @return die Anzahl der Fachbelegungen
+     */
+    zaehleBelegungenDurchgaengig(fachbelegungen: List<AbiturFachbelegung> | null): number;
+    private istBelegungDurchgaengigSchriftlichInQPhase;
+    /**
+     * Diese Methode zählt die Anzahl der angegebenen Fachbelegungen, welche in allen
+     * Halbjahren belegt sind. Dabei werden Fachbelegungen, welche dem gleichem Statistik-Fach
+     * zuzuordnen sind zusammengefasst. Dies ist bei der Abwahl von bilingualen Sachfächern
+     * relevant.
+     *
+     * @param fachbelegungen   die zu zählenden Fachbelegungen
+     *
+     * @return die Anzahl der Fachbelegungen
+     */
+    zaehleBelegungenDurchgaengigSchriftlichInQPhase(fachbelegungen: List<AbiturFachbelegung> | null): number;
+    /**
+     * Filtert die Fachbelegungen. Es werden nur Belegungen behalten, die in den angegebenen Halbjahren die geforderte Schriftlichkeit aufweisen.
+     * Wird kein Halbjahr angegeben, so wird nichts gefiltert, da kein Halbjahr geprüft werden muss.
+     *
+     * @param fachbelegungen    die zu filternden Fachbelegungen
+     * @param schriftlichkeit   die geforderte Schriftlichkeit
+     * @param halbjahre         die Halbjahre, die belegt sein müssen
+     *
+     * @return die gefilterten Fachbelegungen
+     */
+    filterBelegungenMitSchriftlichkeit(fachbelegungen: List<AbiturFachbelegung> | null, schriftlichkeit: GostSchriftlichkeit, ...halbjahre: Array<GostHalbjahr>): List<AbiturFachbelegung>;
+    /**
+     * Liefert die erste Fachbelegung für den Fachbereich - sofern eine existiert
+     *
+     * @param fachbereich   der Fachbereich
+     *
+     * @return die Fachbelegung oder null
+     */
+    getFachbelegung(fachbereich: GostFachbereich): AbiturFachbelegung | null;
+    /**
+     * Liefert die erste Prüfungsordnungs-relevante Fachbelegung für den Fachbereich - sofern eine existiert
+     *
+     * @param fachbereich   der Fachbereich
+     *
+     * @return die Fachbelegung oder null
+     */
+    getRelevanteFachbelegung(fachbereich: GostFachbereich): AbiturFachbelegung | null;
+    /**
+     * Liefert alle Fachbelegungen mit dem angegebenen Statistk-Kürzel des Faches
+     *
+     * @param kuerzel   das Kürzel des Faches
+     *
+     * @return eine Liste mit den Fachbelegungen
+     */
+    getFachbelegungByFachkuerzel(kuerzel: string | null): List<AbiturFachbelegung>;
+    /**
+     * Prüft, ob der Kurs in dem angegebenen Halbjahr mit der angegebenen Schriftlichkeit belegt ist
+     * und gibt ggf. die Belegung zurück.
+     *
+     * @param fachbelegung   die Abiturfachbelegung aus welcher die Belegungsinformationen für das Halbjahr entnommen wird
+     * @param halbjahr       das Halbjahr, in welchem die Belegung gesucht wird.
+     * @param schriftlich    gibt an, ob das Fach schriftlich oder mündlich belegt sein muss
+     *
+     * @return die Belegungsinformationen zu dem Fach
+     */
+    getBelegungHalbjahr(fachbelegung: AbiturFachbelegung, halbjahr: GostHalbjahr, schriftlich: GostSchriftlichkeit): AbiturFachbelegungHalbjahr | null;
+    /**
+     * Liefert die erste Sprachbelegung - sofern eine existiert
+     *
+     * @param sprache   das einstellige Kürzel der Sprache
+     *
+     * @return die Fachbelegung für die Sprache
+     */
+    getSprachbelegung(sprache: string | null): AbiturFachbelegung | null;
+    /**
+     * Prüft, ob das Fach mit der übergebenen ID als Abiturfach möglich ist und mit welcher Kursart
+     * dieses Fach aufgrund der Belegungen im Abitur gewählt werden kann.
+     *
+     * @param id   die ID des Fachs
+     *
+     * @return die mögliche Kursart des Faches im Abitur oder null, falls das Fach nicht als Abiturfach
+     *         ausgewählt werden kann.
+     */
+    getMoeglicheKursartAlsAbiturfach(id: number): GostKursart | null;
+    /**
+     * Experimenteller Code:
+     *
+     * Prüft, ob das Fach mit der übergebenen ID als Abiturfach möglich ist und mit welcher Kursart
+     * dieses Fach aufgrund der Belegungen im Abitur gewählt werden kann.
+     *
+     * @param id   die ID des Fachs
+     *
+     * @return die mögliche Kursart des Faches im Abitur oder null, falls das Fach nicht als Abiturfach
+     *         ausgewählt werden kann.
+     */
+    private _getAbi30MoeglicheKursartAlsAbiturfach;
+    /**
+     * Liefert für die übergebene Fachbelegung die Halbjahre, in denen das Fach mit einer der angebenen
+     * Kursarten belegt wurde. Ist keine Kursart angegeben, so werden die Halbjahre aller Belegungen
+     * zurückgegeben. Ist keine Fachbelegung angegeben, so wird eine leere Liste zurückgegeben.
+     *
+     * @param fachbelegung   die Fachbelegung
+     * @param kursarten      die Kursarten
+     *
+     * @return eine Liste der Halbjahre in den das Fach mit einer der Kursarten belegt wurde
+     */
+    getHalbjahreKursart(fachbelegung: AbiturFachbelegung | null, ...kursarten: Array<GostKursart>): List<GostHalbjahr>;
+    /**
+     * Gibt die Sprache des bilingualen Bildungsgang zurück oder null, falls keiner gewählt wurde.
+     *
+     * @return die Sprache des bilingualen Bildungsgang oder null
+     */
+    getBiligualenBildungsgang(): string | null;
+    /**
+     * Prüft bei der Sprachenfolge, ob eine laut Sprachenfolge fortgeführte
+     * Fremdsprache fehlerhafterweise als neu einsetzende Fremdsprache belegt wurde.
+     * Übergebene Fachbelegungen, die keine Fremdsprachen sind werden ignoriert.
+     *
+     * @param fremdsprachen   die zu prüfenden Fachbelegungen
+     *
+     * @return true, falls eine fortgeführte Fremdsprache bei den übergebenen
+     *         Fachbelegungen existiert, ansonsten false
+     */
+    hatFortgefuehrteFremdspracheInSprachendaten(fremdsprachen: List<AbiturFachbelegung> | null): boolean;
+    /**
+     * Prüft bei der Sprachenfolge, ob für eine laut Sprachenfolge neu einsetzende
+     * Fremdsprache fehlerhafterweise ein Kurs in einer fortgeführten Fremdsprache belegt wurde.
+     * Übergebene Fachbelegungen, die keine Fremdsprachen sind werden ignoriert.
+     *
+     * @param fremdsprachen   die zu prüfenden Fachbelegungen
+     *
+     * @return true, falls eine neu einsetzende Fremdsprache bei den übergebenen
+     *         Fachbelegungen existiert, ansonsten false
+     */
+    hatNeuEinsetzendeFremdspracheInSprachendaten(fremdsprachen: List<AbiturFachbelegung> | null): boolean;
+    /**
+     * Prüft, ob die Belegung seit der EF1 vorhanden ist. Hierbei werden
+     * Zusatz-, Vertiefungs- und Projektkurse auch als später einsetzend akzeptiert.
+     * Dies gilt auch für Literatur, instrumental- und vokal-praktische Kurse sowie
+     * für Religion und Philosophie.
+     *
+     * @param fachbelegung   die Abiturfachbelegungen, die geprüft werden
+     *
+     * @return true, falls das Fach seit EF1 durchgängig belegt wurde oder eine der Ausnahmen zutrifft, sonst false
+     */
+    istBelegtSeitEF(fachbelegung: AbiturFachbelegung): boolean;
+    /**
+     * Gibt zurück, ob ein Zusatzkurs in Geschichte in diesem Jahrgang angeboten
+     * wird oder nicht.
+     *
+     * @return true, wenn einer angeboten wird und ansonsten false
+     */
+    istErlaubtZusatzkursGE(): boolean;
+    /**
+     * Gibt das erste Halbjahr für Zusatzkurse in Geschichte
+     * in diesem Jahrgang zurück.
+     *
+     * @return das erste Halbjahr für Zusatzkurse in Geschichte
+     */
+    getBeginnZusatzkursGE(): GostHalbjahr;
+    /**
+     * Gibt zurück, ob ein Zusatzkurs in Sozialwissenschaften in diesem Jahrgang
+     * angeboten wird oder nicht.
+     *
+     * @return true, wenn einer angeboten wird und ansonsten false
+     */
+    istErlaubtZusatzkursSW(): boolean;
+    /**
+     * Gibt das erste Halbjahr für Zusatzkurse in Sozialwissenschaften
+     * in diesem Jahrgang zurück.
+     *
+     * @return das erste Halbjahr für Zusatzkurse in Sozialwissenschaften
+     */
+    getBeginnZusatzkursSW(): GostHalbjahr;
+    /**
+     * Gibt alle Fachkombination zurück, welche in der EF.1 gültig sind.
+     *
+     * @return die Liste mit den Fachkombinationen
+     */
+    getFachkombinationenEF1(): List<GostJahrgangFachkombination>;
+    /**
+     * Gibt alle Fachkombination zurück.
+     *
+     * @return die Liste mit den Fachkombinationen
+     */
+    getFachkombinationenGesamt(): List<GostJahrgangFachkombination>;
+    /**
+     * Gibt das Ergebnis der Belegprüfung zurück. Dieses enthält eine Liste der Fehler, die bei der Belegprüfung
+     * festgestellt wurden und ob diese erfolgreich gewesen ist oder nicht.
+     *
+     * @return das Ergebnis der Belegprüfung
+     */
+    getBelegpruefungErgebnis(): GostBelegpruefungErgebnis;
+    /**
+     * Gibt das Belegprüfungs-Objekt für die KurszahlenUndWochenstunden zurück, welches für
+     * die Belegprüfung genutzt wurde und die Statistiken dazu erstellt hat.
+     *
+     * @return das Belegprüfungs-Objekt für die KurszahlenUndWochenstunden
+     */
+    private getKurszahlenUndWochenstunden;
+    /**
+     * Gibt das Belegprüfungs-Objekt für die KurszahlenUndWochenstunden zurück, welches für
+     * die Belegprüfung genutzt wurde und die Statistiken dazu erstellt hat.
+     *
+     * @return das Belegprüfungs-Objekt für die KurszahlenUndWochenstunden
+     */
+    private getAbi30KurszahlenUndWochenstunden;
+    /**
+     * Gibt die Belegprüfung zu den Einbringungsverpflichtungen zurück.
+     *
+     * @return die Belegprüfung zu den Einbringungsverpflichtungen
+     */
+    getBelegpruefungEinbringungsverpflichtungen(): Abi30BelegpruefungEinbringung;
+    /**
+     * Berechnet die Wochenstunden, welche von dem Schüler in den einzelnen
+     * Halbjahren der gymnasialen Oberstufe für das Abitur relevant belegt wurden.
+     *
+     * @return ein Array mit den Wochenstunden für die sechs Halbjahre
+     */
+    getWochenstunden(): Array<number>;
+    /**
+     * Gibt die Anzahl der Wochenstunden für die Einführungsphase zurück.
+     *
+     * @return die Anzahl der Wochenstunden
+     */
+    getWochenstundenEinfuehrungsphase(): number;
+    /**
+     * Gibt die Anzahl der Wochenstunden für die Qualifikationsphase zurück.
+     *
+     * @return die Anzahl der Wochenstunden
+     */
+    getWochenstundenQualifikationsphase(): number;
+    /**
+     * Berechnet die Anzahl der anrechenbaren Kurse, welche von dem Schüler in den einzelnen
+     * Halbjahren der gymnasialen Oberstufe für das Abitur belegt wurden.
+     *
+     * @return ein Array mit den anrechenbaren Kursen für die sechs Halbjahre
+     */
+    getAnrechenbareKurse(): Array<number>;
+    /**
+     * Gibt die Anzahl der anrechenbaren Kurse für den Block I des Abiturs
+     * zurück.
+     *
+     * @return die anrechenbaren Kursen für Block I des Abiturs
+     */
+    getAnrechenbareKurseBlockI(): number;
+    /**
+     * Gibt für die Notenpunkte für die Halbjahresbelegung zurück
+     *
+     * @param belegungHalbjahr   die Halbjahresbelegung
+     *
+     * @return die Notenpunkte oder null, falls das Fach in dem Halbjahr nicht gewählt wurde
+     */
+    getNotenpunkteOfFachbelegungHalbjahr(belegungHalbjahr: AbiturFachbelegungHalbjahr | null): number | null;
+    /**
+     * Gibt für die übergebene Fach-ID und das übergebene Halbjahr die Notenpunkte zurück, sofern eine
+     * Belegung vorliegt, welche eine Note hat, und ansonsten null.
+     *
+     * @param idFach     die ID des Faches
+     * @param halbjahr   das Halbjahr
+     *
+     * @return die Notenpunkte oder null
+     */
+    getNotenpunkteByFachIDAndHalbjahr(idFach: number, halbjahr: GostHalbjahr): number | null;
+    /**
+     * Prüft, ob bei der Fachbelegung in allen Halbjahren der Qualifikationsphase eine Belegung vorliegt und
+     * der Kurs jeweils als angerechnet markiert ist.
+     *
+     * @param belegung   die Fachbelegung
+     *
+     * @return true, falls alle Kurse der Fachbelegung in der Qualifikationsphase als angerechnet markiert sind, und ansonsten false
+     */
+    hatMarkierungQualifikationsphase(belegung: AbiturFachbelegung | null): boolean;
+    /**
+     * Prüft, ob eine Belegung eines der angegebenen Fächer mit den angegebenen Halbjahren existiert,
+     * bei dem alle Halbjahre der Qualifikationsphase markiert sind und keine 0-Punkte Kurse beinhalten.
+     * Die erste gefundene Belegung wird dann zurückgegeben.
+     * Ist keine solche Fachbelegung gegeben, so schlägt die Prüfung fehl und es wird null zurückgegeben.
+     * In dieser Methode wird ggf. auch geprüft, ob weitere Fachbelegungen existieren, welche das gleiche
+     * Statistik-Kürzel haben und Ersatzweise eine Halbjahres-Belegung ersetzen können. Dies ist z.B. bei bilingualen
+     * Fächern nötig oder bei der Unterscheidung von Sport-Profilen. In einem solchen Fall wird
+     * die erste Belegung für das Fach zurückgegeben, welches evtl. nicht alle Belegungen beinhaltet
+     *
+     * @param fachbelegungen    die zu prüfenden Fachbelegungen
+     *
+     * @return eine Fachbelegung mit den Markierung in den Halbjahren der Qualifikationsphase und ansonsten null
+     */
+    pruefeMarkierungExistiertDurchgaengig(fachbelegungen: List<AbiturFachbelegung> | null): AbiturFachbelegung | null;
+    /**
+     * Zählt die Anzahl der Markierungen bei der Fachbelegung in allen Halbjahren der Qualifikationsphase.
+     * Ist belegung null, so wird 0 zurückgegeben.
+     *
+     * @param belegung   die Fachbelegung
+     *
+     * @return die Anzahl der Markierungen bei der Fachbelegung
+     */
+    zaehleMarkierungenQualifikationsphase(belegung: AbiturFachbelegung | null): number;
+    /**
+     * Zähle die Anzahl der Markierungen bei den Fachbelegungen in allen Halbjahren der Qualifikationsphase.
+     *
+     * @param belegungen   die Fachbelegungen
+     *
+     * @return die Anzahl der Markierungen bei den Fachbelegungen
+     */
+    zaehleAlleMarkierungenQualifikationsphase(belegungen: List<AbiturFachbelegung>): number;
+    /**
+     * Zähle die Anzahl der markierten Fachbelegungen ohne Wertung oder mit 0 Punkten in allen Halbjahren der Qualifikationsphase.
+     *
+     * @param belegungen   die Fachbelegungen
+     *
+     * @return die Anzahl der markierten Fachbelegungen ohne Wertung oder mit 0 Punkten bei den Fachbelegungen
+     */
+    zaehleMarkierungenOhneWertungOderMitNullPunkten(belegungen: List<AbiturFachbelegung>): number;
+    /**
+     * Zähle die Anzahl der markierten Defizite bei den Fachbelegungen in allen Halbjahren der Qualifikationsphase.
+     *
+     * @param belegungen   die Fachbelegungen
+     *
+     * @return die Anzahl der Markierungen mit Defiziten bei den Fachbelegungen
+     */
+    zaehleMarkierungenMitDefiziten(belegungen: List<AbiturFachbelegung>): number;
+    /**
+     * Zähle die Anzahl der nicht markierten Kurse ohne Defizite bei den Fachbelegungen in allen Halbjahren der Qualifikationsphase.
+     *
+     * @param belegungen   die Fachbelegungen
+     *
+     * @return die Anzahl der nicht markierten Kurse ohne Defiziten bei den Fachbelegungen
+     */
+    zaehleOhneMarkierungenUndOhneDefizite(belegungen: List<AbiturFachbelegung>): number;
+    /**
+     * Berechnet den Durchschnitte der Notenpunkte aller markierten Kurse.
+     * Dabei fließen die Notenpunkte der Leistungskurse doppelt ein.
+     *
+     * @return der Durchschnitte der Notenpunkte aller markierten Kurse
+     */
+    berechneMarkierungenDurchschnittspunkte(): number;
+    /**
+     * Prüft, ob bei der Fachbelegung in dem angegebenen Halbjahr der Qualifikationsphase eine Belegung vorliegt und
+     * der Kurs jeweils als angerechnet markiert ist.
+     *
+     * @param belegung   die Fachbelegung
+     * @param halbjahr   das Halbjahr
+     *
+     * @return true, falls alle Kurse der Fachbelegung in der Qualifikationsphase als angerechnet markiert sind, und ansonsten false
+     */
+    hatMarkierungHalbjahr(belegung: AbiturFachbelegung | null, halbjahr: GostHalbjahr): boolean;
+    /**
+     * Ermittelt die Informationen zu markierten Kursen in dem angegeben Halbjahr und gibt diese in einem Array
+     * zurück. Diese sind:
+     * - Notenpunktsumme mit doppelter Wertung der LKs (Index 0)
+     * - Anzahl der Kurse (Index 1)
+     * - Anzahl der Kurse mit doppelter Zählung der LKs (Index 2)
+     * - Anzahl der markierten Defizite im LK-Bereich (Index 3)
+     * - Anzahl der markierten Defizite im GK-Bereich (Index 4)
+     * - Anzahl der markierten Defizite (Index 5)
+     *
+     * @param halbjahr   das Halbjahr
+     *
+     * @return die Informationen zu den markierten Kursen
+     */
+    getKursinformationenOfMarkierteKurseByHalbjahr(halbjahr: GostHalbjahr): Array<number>;
+    /**
+     * Gibt das Ergebnis des Markierprüfungsalgorithmus zurück. Dieses enthält, ob der Algorithmus erfolgreich gewesen ist
+     * und im Fehlerfall den Log des Prüfungsergebnisses.
+     *
+     * @return das Ergebnis der Markierprüfungsalgorithmus
+     */
+    getErgebnisMarkierpruefung(): GostAbiturMarkierungspruefungErgebnis;
+    /**
+     * Führt eine Prüfung der aktuellen Markierungen der Kurse durch.
+     */
+    pruefeMarkierungen(): void;
+    /**
+     * Gibt das Ergebnis des Markierungsalgorithmus zurück. Dieses enthält, ob der Algorithmus erfolgreich gewesen ist
+     * und im Erfolgsfall ein Liste für die einzelnen Belegungen der Qualifikationsphase, ob diese markiert wurden.
+     *
+     * @return das Ergebnis des Markierungsalgorithmus
+     */
+    getErgebnisMarkierungsalgorithmus(): GostAbiturMarkierungsalgorithmusErgebnis;
+    /**
+     * Führt die Berechnung der Zulassung und Nutzung der zuvor markierten Kurse durch.
+     */
+    pruefeZulassung(): void;
+    /**
+     * Wendet das Ergebnis des Markierungsergebnis auf diese Belegung an.
+     *
+     * @return true, wenn es erfolgreich angewendet wurde, und ansonsten false
+     */
+    applyErgebnisMarkierungsalgorithmus(): boolean;
+    /**
+     * Gibt die Belegungsart für die Halbjahresbelegung zurück: Nicht belegt, mündlich oder schriftlich
+     *
+     * @param belegungHalbjahr   die Halbjahresbelegung
+     *
+     * @return die Belegungsart
+     */
+    static getBelegungsartFromHalbjahresbelegung(belegungHalbjahr: AbiturFachbelegungHalbjahr | null): AbiturBelegungsart;
+    /**
+     * Gibt die Markierungsinformation für die Halbjahresbelegung zurück
+     *
+     * @param belegungHalbjahr   die Halbjahresbelegung
+     *
+     * @return die Markierungsinformation
+     */
+    static getKursmarkierungFromHalbjahresbelegung(belegungHalbjahr: AbiturFachbelegungHalbjahr | null): AbiturKursMarkierung | null;
+    /**
+     * Wandelt das Noten-Kürzel der übergebenen Halbjahresbelegung in den zugehörigen Notenpunkte-String um.
+     *
+     * @param belegungHalbjahr   die Halbjahresbelegung
+     *
+     * @return die Notenpunkte als zweistelliger String, "AT" oder null
+     */
+    getNotenpunkteStringHalbjahresbelegung(belegungHalbjahr: AbiturFachbelegungHalbjahr | null): string | null;
+    /**
+     * Wandelt das übergebene Noten-Kürzel in die zugehörigen Notepunkte um.
+     *
+     * @param kuerzel   das Notenkürzel
+     *
+     * @return die Notenpunkte oder null
+     */
+    getNotenpunkteFromKuerzel(kuerzel: string | null): number | null;
+    /**
+     * Wandelt das übergebene Noten-Kürzel in die zugehörigen Notepunkte um.
+     *
+     * @param kuerzel     das Notenkürzel
+     * @param schuljahr   das Schuljahr, in welchem die Abiturprüfung stattfindet
+     *
+     * @return die Notenpunkte oder null
+     */
+    private static getNotenpunkteFromKuerzelInternal;
+    /**
+     * Diese Methode berechnet das Prüfungsergebnis für Block II und das Gesamtergebnis,
+     * sofern die Daten vollständig vorliegen. Ist dies nicht der Fall, so wird das Ergebnis soweit
+     * wie möglich berechnet. Diese Methode setzt die vorherige Berechnung der Zulassung voraus.
+     *
+     * @param abidaten                       die Abiturdaten, welche zur Berechnung verwendet werden
+     * @param berechnePflichtpruefungenNeu   gibt an, ob die Pflichtprüfungen neu berechnet/gesetzt werden sollen oder nicht
+     *
+     * @return true, wenn die Berechnung vollständig durchgeführt werden konnte
+     */
+    static berechnePruefungsergebnis(abidaten: Abiturdaten, berechnePflichtpruefungenNeu: boolean): boolean;
+    transpilerCanonicalName(): string;
+    isTranspiledInstanceOf(name: string): boolean;
+    static readonly class: Class<AbiturdatenManager>;
+}
+export declare function cast_de_svws_nrw_core_abschluss_gost_AbiturdatenManager(obj: unknown): AbiturdatenManager;
+//# sourceMappingURL=AbiturdatenManager.d.ts.map