ts-api/dist/core/abschluss/gost/AbiturdatenManager.d.ts

import { JavaObject } from '../../../java/lang/JavaObject';
import { GostBelegpruefungsArt } from '../../../core/abschluss/gost/GostBelegpruefungsArt';
import { AbiturFachbelegungHalbjahr } from '../../../core/data/gost/AbiturFachbelegungHalbjahr';
import { GostBelegpruefungErgebnis } from '../../../core/abschluss/gost/GostBelegpruefungErgebnis';
import { GostKursart } from '../../../core/types/gost/GostKursart';
import { Sprachendaten } from '../../../core/data/Sprachendaten';
import { GostFachbereich } from '../../../core/types/gost/GostFachbereich';
import { GostHalbjahr } from '../../../core/types/gost/GostHalbjahr';
import { GostSchriftlichkeit } from '../../../core/types/gost/GostSchriftlichkeit';
import { List } from '../../../java/util/List';
import { Vector } from '../../../java/util/Vector';
import { GostFach } from '../../../core/data/gost/GostFach';
import { GostAbiturFach } from '../../../core/types/gost/GostAbiturFach';
import { AbiturFachbelegung } from '../../../core/data/gost/AbiturFachbelegung';
import { GostBelegpruefung } from '../../../core/abschluss/gost/GostBelegpruefung';
import { Abiturdaten } from '../../../core/data/gost/Abiturdaten';
export declare class AbiturdatenManager extends JavaObject {
    private readonly abidaten;
    private readonly gostFaecher;
    private readonly pruefungsArt;
    private readonly mapFachbereiche;
    private belegpruefungen;
    private belegpruefungsfehler;
    private belegpruefungErfolgreich;
    /**
     * Erstellt ein neues Manager-Objekt, welches mit den übergebenen Abiturdaten verknüpft wird.
     *
     * @param abidaten       die Abiturdaten
     * @param gostFaecher    die Fächer der Gymnasialen Oberstufe, die bei dem Abiturjahrgang zur Verfügung stehen.
     * @param pruefungsArt   die Art der Belegpruefung (z.B. EF1 oder GESAMT)
     */
    constructor(abidaten: Abiturdaten, gostFaecher: List<GostFach>, pruefungsArt: GostBelegpruefungsArt);
    /**
     * Führt die Belegprüfung der Art pruefungs_art für einen Schüler durch, dessen Abiturdaten mit dem angegebenen
     * Manager verwaltet werden.
     *
     * @param pruefungs_art    die Art der Prüfung, die durchgeführt wird
     *
     * @return eine Liste mit den durchgefuehrten Belegpruefungen
     */
    getPruefungen(pruefungs_art: GostBelegpruefungsArt): Vector<GostBelegpruefung>;
    /**
     * Initialisiert bzw. reinitialisert die Datenstrukturen, die für den schnellen Zugriff auf die Daten
     * eingerichtet werden.
     */
    init(): void;
    /**
     * Initialisiert bzw. reinitialisiert die Map für den schnellen Zugriff auf Fachbelegungen
     * anhand des Fachbereichs.
     */
    private initMapFachbereiche;
    /**
     * Liefert die in den Abiturdaten enthaltenen Sprachendaten.
     *
     * @return Die Sprachendaten (siehe {@link Sprachendaten})
     */
    getSprachendaten(): Sprachendaten | null;
    /**
     * 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> | null;
    /**
     * 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> | null;
    /**
     * 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 das Faches 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 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;
    /**
     * 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 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 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> | 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 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
     */
    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 Fachnbelegungen
     * @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 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.
     *
     * @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 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 Fachbelegungen, die bilingual unterrichtet wurden.
     *
     * @return eine Liste der Fachbelegungen
     */
    getFachbelegungenBilingual(): List<AbiturFachbelegung>;
    /**
     * 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>;
    /**
     * 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;
    /**
     * 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 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;
    /**
     * 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>): Vector<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;
    /**
     * Gibt an, ob am Ende der EF eine Muttersprachenprüfung geplant bzw. erfolgt ist.
     *
     * @return true, falls eine Muttersprachenprüfung am Ende der EF vorliegt, sonst false
     */
    hatMuttersprachenPruefungEndeEF(): boolean;
    /**
     * Gibt an, ob die zweite Fremdsprache in der Sekundarstufe manuell erfolgreich
     * geprüft wurde und dort eine entsprechende Belegung existiert.
     *
     * @return true, falls in der Sek I eine zweite Fremdsprache belegt wurde
     */
    istSekIZweiteFremdspracheManuellGeprueft(): 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 vokalpraktische 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, sonsta false
     */
    istBelegtSeitEF(fachbelegung: AbiturFachbelegung): boolean;
    /**
     * 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;
    isTranspiledInstanceOf(name: string): boolean;
}
export declare function cast_de_nrw_schule_svws_core_abschluss_gost_AbiturdatenManager(obj: unknown): AbiturdatenManager;