@hmt/svws-core 1.5.2 → 1.5.3

package/dist/core/utils/uv/UvManager.d.ts

@@ -0,0 +1,2442 @@
+import { JavaObject } from '../../../java/lang/JavaObject';
+import { UvLehrer } from '../../../core/data/uv/UvLehrer';
+import { LehrerUnterrichtsfach } from '../../../core/data/lehrer/LehrerUnterrichtsfach';
+import { UvPlanungsabschnittSchueler } from '../../../core/data/uv/UvPlanungsabschnittSchueler';
+import { UvSchuelergruppeSchueler } from '../../../core/data/uv/UvSchuelergruppeSchueler';
+import { FachDaten } from '../../../core/data/fach/FachDaten';
+import type { List } from '../../../java/util/List';
+import { UvZeitrasterEintrag } from '../../../core/data/uv/UvZeitrasterEintrag';
+import { UvKurs } from '../../../core/data/uv/UvKurs';
+import { UvLerngruppenSchiene } from '../../../core/data/uv/UvLerngruppenSchiene';
+import { UvRaumgruppe } from '../../../core/data/uv/UvRaumgruppe';
+import { UvLerngruppe } from '../../../core/data/uv/UvLerngruppe';
+import { UvUnterrichtRaum } from '../../../core/data/uv/UvUnterrichtRaum';
+import type { Collection } from '../../../java/util/Collection';
+import { Class } from '../../../java/lang/Class';
+import { UvSchuelergruppe } from '../../../core/data/uv/UvSchuelergruppe';
+import type { JavaSet } from '../../../java/util/JavaSet';
+import { UvLehrerPflichtstundensoll } from '../../../core/data/uv/UvLehrerPflichtstundensoll';
+import { JahrgangsDaten } from '../../../core/data/jahrgang/JahrgangsDaten';
+import { UvGrunddatenBundle } from '../../../core/data/uv/UvGrunddatenBundle';
+import { UvZeitraster } from '../../../core/data/uv/UvZeitraster';
+import { UvRaum } from '../../../core/data/uv/UvRaum';
+import { UvUnterricht } from '../../../core/data/uv/UvUnterricht';
+import { UvPlanungsabschnitt } from '../../../core/data/uv/UvPlanungsabschnitt';
+import { UvPlanungsabschnittsdatenBundle } from '../../../core/data/uv/UvPlanungsabschnittsdatenBundle';
+import { UvLerngruppenLehrer } from '../../../core/data/uv/UvLerngruppenLehrer';
+import { UvStundentafel } from '../../../core/data/uv/UvStundentafel';
+import { UvPlanungsabschnittZeitraster } from '../../../core/data/uv/UvPlanungsabschnittZeitraster';
+import { UvStundentafelFach } from '../../../core/data/uv/UvStundentafelFach';
+import { UvSchiene } from '../../../core/data/uv/UvSchiene';
+import { UvFach } from '../../../core/data/uv/UvFach';
+import { UvLehrerAnrechnungsstunden } from '../../../core/data/uv/UvLehrerAnrechnungsstunden';
+import { UvUnterrichtLerngruppenlehrer } from '../../../core/data/uv/UvUnterrichtLerngruppenlehrer';
+import { UvPlanungsabschnittLehrer } from '../../../core/data/uv/UvPlanungsabschnittLehrer';
+import { UvKlasse } from '../../../core/data/uv/UvKlasse';
+import { UvKlassenLehrer } from '../../../core/data/uv/UvKlassenLehrer';
+export declare class UvManager extends JavaObject {
+    private jahrgangById;
+    private fachdatenById;
+    private readonly planungsabschnittById;
+    private readonly planungsabschnittMenge;
+    private readonly lehrerById;
+    private readonly lehrerMenge;
+    private readonly lehrerByIdKLehrer;
+    private readonly lehrerUnterrichtsfachByIstKLehrerAndId;
+    private readonly lehrerUnterrichtsfachMenge;
+    private lehrerUnterrichtsfachByIdKLehrerAndIdFach;
+    private lehrerUnterrichtsfachByIdLehrerAndIdFach;
+    private lehrerMengeByIdFachAndSek;
+    private planungsabschnittLehrerByIdPlanungsabschnittAndIdLehrer;
+    private readonly planungsabschnittLehrerMenge;
+    private readonly lehrerAnrechnungsstundenById;
+    private readonly lehrerAnrechnungsstundenMenge;
+    private readonly lehrerAnrechnungsstundenMengeByLehrerId;
+    private readonly lehrerPflichtstundensollById;
+    private readonly lehrerPflichtstundensollMenge;
+    private readonly lehrerPflichtstundensollMengeByLehrerId;
+    private readonly raumMenge;
+    private readonly raumgruppeById;
+    private readonly raumgruppeMenge;
+    private raumByIdRaumgruppeAndIdRaum;
+    private readonly raumByKuerzel;
+    private readonly stundentafelById;
+    private readonly stundentafelMenge;
+    private stundentafelFachByIdStundentafelAndAbschnittAndIdFachAndIdStundentafelFach;
+    private readonly stundentafelFachMenge;
+    private readonly fachById;
+    private readonly fachMenge;
+    private fachMengeByIdFach;
+    private readonly zeitrasterById;
+    private readonly zeitrasterMenge;
+    private zeitrasterEintragByIdZeitrasterAndIdZeitrasterEintrag;
+    private readonly zeitrasterEintragMenge;
+    private planungsabschnittZeitrasterByIdPlanungsabschnittAndIdZeitraster;
+    private readonly planungsabschnittZeitrasterMenge;
+    private planungsabschnittSchuelerByIdPlanungsabschnittAndIdJahrgangAndIdKlasseAndIdSchueler;
+    private readonly planungsabschnittSchuelerMenge;
+    private schuelergruppeByIdPlanungsabschnittAndIdSchuelergruppe;
+    private readonly schuelergruppeMenge;
+    private schuelergruppeSchuelerByIdPlanungsabschnittAndIdSchuelergruppeAndIdSchueler;
+    private readonly schuelergruppeSchuelerMenge;
+    private planungsabschnittSchuelerMengeByIdPlanungsabschnittAndIdSchuelergruppe;
+    private klasseByIdPlanungsabschnittAndIdSchuelergruppeAndIdKlasse;
+    private readonly klasseMenge;
+    private klassenLehrerByIdPlanungsabschnittAndIdKlasseAndIdLehrer;
+    private readonly klassenLehrerMenge;
+    private kursByIdPlanungsabschnittAndIdSchuelergruppeAndIdKurs;
+    private readonly kursMenge;
+    private schieneByIdPlanungsabschnittAndNummerAndIdSchiene;
+    private readonly schieneMenge;
+    private lerngruppeByIdPlanungsabschnittAndIdLerngruppe;
+    private readonly lerngruppeMenge;
+    private lerngruppeMengeByIdSchuelergruppe;
+    private lerngruppeByIdKursAndIdKlasseAndIdFach;
+    private lerngruppenSchieneByIdPlanungsabschnittAndIdLerngruppeAndIdSchiene;
+    private readonly lerngruppenSchieneMenge;
+    private lerngruppenLehrerByIdPlanungsabschnittAndIdLerngruppeAndIdLehrer;
+    private readonly lerngruppenLehrerMenge;
+    private unterrichtByIdPlanungsabschnittAndIdLerngruppeAndIdZeitrasterEintragAndIdUnterricht;
+    private readonly unterrichtMenge;
+    private unterrichtRaumByIdPlanungsabschnittAndIdUnterrichtAndIdRaum;
+    private readonly unterrichtRaumMenge;
+    private unterrichtLerngruppenlehrerByIdPlanungsabschnittAndIdUnterrichtAndIdLerngruppenlehrer;
+    private readonly unterrichtLerngruppenlehrerMenge;
+    private readonly compJahrgangsdaten;
+    private readonly compLehrer;
+    private readonly compPlanungsabschnittLehrer;
+    private readonly compLehrerPflichtstundensoll;
+    private readonly compLehrerAnrechnungsstunden;
+    private readonly compRaumgruppe;
+    private readonly compRaum;
+    private readonly compStundentafel;
+    private readonly compFach;
+    private readonly compStundentafelFach;
+    private readonly compZeitraster;
+    private readonly compZeitrasterEintrag;
+    private readonly compPlanungsabschnittZeitraster;
+    private readonly compPlanungsabschnittSchueler;
+    private readonly compSchuelergruppe;
+    private readonly compSchuelergruppeSchueler;
+    private readonly compKlasse;
+    private readonly compKurs;
+    private readonly compSchiene;
+    private readonly compLerngruppe;
+    private readonly compLerngruppenLehrer;
+    private readonly compKlassenLehrer;
+    private readonly compUnterricht;
+    /**
+     * Konstruktor
+     */
+    constructor();
+    /**
+     * Konstruktor
+     * @param jahrgaenge die {@link JahrgangsDaten}-Objekte, die hinzugefügt werden sollen
+     * @param fachdaten die {@link FachDaten}-Objekte, die hinzugefügt werden sollen
+     */
+    constructor(jahrgaenge: Collection<JahrgangsDaten>, fachdaten: Collection<FachDaten>);
+    /**
+     * Füge alle Grunddaten zum Manager hinzu.
+     * @param gData die {@link UvGrunddatenBundle}, die hinzugefügt werden sollen
+     */
+    grunddatenBundleAdd(gData: UvGrunddatenBundle): void;
+    private grunddatenBundleAddOhneUpdate;
+    /**
+     * Füge alle Planungsabschnitts-Daten zum Manager hinzu.
+     * @param pData die Datensammlung
+     */
+    planungsabschnittsdatenBundleAdd(pData: UvPlanungsabschnittsdatenBundle): void;
+    private planungsabschnittsdatenBundleAddOhneUpdate;
+    private updateAll;
+    private updateLehrerByIdKLehrer;
+    private updateLehrerPflichtstundensollMengeByLehrerId;
+    private updateLehrerAnrechnungsstundenMengeByLehrerId;
+    private updatePlanungsabschnittLehrerByIdPlanungsabschnittAndIdLehrer;
+    private updateRaumByIdRaumgruppeAndIdRaum;
+    private updateRaumByKuerzel;
+    private updateStundentafelFachByIdStundentafelAndAbschnittAndIdFachAndIdStundentafelFach;
+    private updateFachMengeByIdFach;
+    private updateZeitrasterEintragByIdZeitrasterAndIdZeitrasterEintrag;
+    private updatePlanungsabschnittZeitrasterByIdPlanungsabschnittAndIdZeitraster;
+    private updatePlanungsabschnittSchuelerByIdPlanungsabschnittAndIdJahrgangAndIdKlasseAndIdSchueler;
+    private updateSchuelergruppeMenge;
+    private updateSchuelergruppeByIdPlanungsabschnittAndIdSchuelergruppe;
+    private updateSchuelergruppeSchuelerMenge;
+    private updateSchuelergruppeSchuelerByIdPlanungsabschnittAndIdSchuelergruppeAndIdSchueler;
+    private updateKlasseMenge;
+    private updateKlasseByIdPlanungsabschnittAndIdSchuelergruppeAndIdKlasse;
+    private updateKlassenLehrerMenge;
+    private updateKlassenLehrerByIdPlanungsabschnittAndIdKlasseAndIdLehrer;
+    private updateKursMenge;
+    private updateKursByIdPlanungsabschnittAndIdSchuelergruppeAndIdKurs;
+    private updateSchieneMenge;
+    private updateSchieneByIdPlanungsabschnittAndNummerAndIdSchiene;
+    private updateLerngruppeMenge;
+    private updateLerngruppeByIdPlanungsabschnittAndIdLerngruppe;
+    private updateLerngruppenLehrerMenge;
+    private updateLerngruppenLehrerByIdPlanungsabschnittAndIdLerngruppeAndIdLehrer;
+    private updateLerngruppenSchieneMenge;
+    private updateLerngruppenSchieneByIdPlanungsabschnittAndIdLerngruppeAndIdSchiene;
+    private updatePlanungsabschnittSchuelerMengeByIdPlanungsabschnittAndIdSchuelergruppe;
+    private updateLerngruppeMengeByIdSchuelergruppe;
+    private updateLerngruppeByIdKursAndIdKlasseAndIdFach;
+    private updateUnterrichtMenge;
+    private updateUnterrichtByIdPlanungsabschnittAndIdLerngruppeAndIdZeitrasterEintragAndIdUnterricht;
+    private updateUnterrichtRaumMenge;
+    private updateUnterrichtRaumByIdPlanungsabschnittAndIdUnterrichtAndIdRaum;
+    private updateUnterrichtLerngruppenlehrerMenge;
+    private updateUnterrichtLerngruppenlehrerByIdPlanungsabschnittAndIdUnterrichtAndIdLerngruppenlehrer;
+    private updateLehrerMengeByIdFachAndSek;
+    /**
+     * Fügt alle {@link JahrgangsDaten}-Objekte hinzu.
+     * @param jahrgaenge eine Sammlung der hinzuzufügenden {@link JahrgangsDaten}-Objekte
+     */
+    private jahrgangsdatenAddAll;
+    private jahrgangsdatenByIdMapGet;
+    /**
+     * Liefert die Jahrgangsdaten zu einer ID
+     * @param id die ID, zu der die Jahrgangsdaten gesucht werden
+     * @return die {@link JahrgangsDaten}
+     */
+    jahrgangsdatenGetById(id: number): JahrgangsDaten;
+    /**
+     * Gibt alle {@link JahrgangsDaten}-Objekte zurück.
+     * Hinweis: Wenn es keine {@link JahrgangsDaten}-Objekte gibt, ist die Liste leer.
+     * @return eine List aller {@link JahrgangsDaten}-Objekte
+     */
+    jahrgangsdatenGetMenge(): List<JahrgangsDaten>;
+    /**
+     * Liefert das zur Stundentafel zugehörige {@link JahrgangsDaten}-Objekt. <br>
+     * @param st die {@link UvStundentafel}
+     * @return das zur Stundentafel zugehörige {@link JahrgangsDaten}-Objekt.
+     */
+    jahrgangsdatenGetByStundentafel(st: UvStundentafel): JahrgangsDaten;
+    /**
+     * Fügt alle {@link FachDaten}-Objekte hinzu.
+     * @param fachdaten eine Sammlung der hinzuzufügenden {@link FachDaten}-Objekte
+     */
+    private fachdatenAddAll;
+    /**
+     * Gibt alle {@link FachDaten}-Objekte zurück.
+     * @return eine List aller {@link FachDaten}-Objekte
+     */
+    fachdatenGetMenge(): List<FachDaten>;
+    /**
+     * Liefert das zum {@link UvStundentafelFach} zugehörige {@link FachDaten}-Objekt. <br>
+     * @param stf das {@link UvStundentafelFach}
+     * @return das zum {@link UvStundentafelFach} zugehörige {@link FachDaten}-Objekt.
+     */
+    fachdatenGetByStundentafelFach(stf: UvStundentafelFach): FachDaten;
+    /**
+     * Liefert das zum {@link UvFach} zugehörige {@link FachDaten}-Objekt. <br>
+     * @param fach das {@link UvFach}
+     * @return das zum {@link UvFach} zugehörige {@link FachDaten}-Objekt.
+     */
+    fachdatenGetByFach(fach: UvFach): FachDaten;
+    /**
+     * Liefert das zum {@link LehrerUnterrichtsfach} zugehörige {@link FachDaten}-Objekt. <br>
+     * @param fach das {@link LehrerUnterrichtsfach}
+     * @return das zum {@link LehrerUnterrichtsfach} zugehörige {@link FachDaten}-Objekt.
+     */
+    fachdatenGetByLehrerUnterrichtsfach(fach: LehrerUnterrichtsfach): FachDaten;
+    /**
+     * Fügt ein {@link UvPlanungsabschnitt}-Objekt hinzu.
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}, der hinzugefügt werden soll
+     */
+    planungsabschnittAdd(planungsabschnitt: UvPlanungsabschnitt): void;
+    private planungsabschnittAddOhneUpdate;
+    /**
+     * Ersetzt das vorhandene {@link UvPlanungsabschnitt}-Objekt durch das neue DTO ohne Löschkaskade
+     * und baut die Indizes neu auf. Das bisherige Objekt wird nicht verändert.
+     *
+     * @param planungsabschnitt die vollständigen neuen Daten mit unveränderter ID
+     */
+    planungsabschnittPatchAttributes(planungsabschnitt: UvPlanungsabschnitt): void;
+    /**
+     * Liefert das zur ID zugehörige {@link UvPlanungsabschnitt}-Objekt. <br>
+     * @param idPlanungsabschnitt   Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvPlanungsabschnitt}-Objekt.
+     */
+    planungsabschnittGetByIdOrException(idPlanungsabschnitt: number): UvPlanungsabschnitt;
+    /**
+     * Prüft, ob ein {@link UvPlanungsabschnitt}-Objekt im Manager existiert.
+     * @param planungsabschnitt das zu prüfende {@link UvPlanungsabschnitt}-Objekt
+     * @return {@code true}, wenn das Objekt im Manager existiert, sonst {@code false}
+     */
+    planungsabschnittIsGeladen(planungsabschnitt: UvPlanungsabschnitt): boolean;
+    private updateLehrerMenge;
+    /**
+     * Fügt ein {@link UvLehrer}-Objekt hinzu.
+     * @param lehrer Das {@link UvLehrer}-Objekt, welches hinzugefügt werden soll.
+     */
+    lehrerAdd(lehrer: UvLehrer): void;
+    private lehrerAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvLehrer}-Objekte hinzu.
+     * @param listLehrer Die Menge der {@link UvLehrer}-Objekte, welche hinzugefügt werden soll.
+     */
+    lehrerAddAll(listLehrer: Collection<UvLehrer>): void;
+    private lehrerAddAllOhneUpdate;
+    private static lehrerCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvLehrer}-Objekt. <br>
+     * @param idLehrer Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvLehrer}-Objekt.
+     */
+    lehrerGetByIdOrException(idLehrer: number): UvLehrer;
+    /**
+     * Liefert das zur ID gehörende {@link UvLehrer}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idLehrer die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    lehrerGetByIdOrNull(idLehrer: number): UvLehrer | null;
+    /**
+     * Liefert eine Liste aller {@link UvLehrer}-Objekte. <br>
+     * @return eine Liste aller {@link UvLehrer}-Objekte.
+     */
+    lehrerGetMengeAsList(): List<UvLehrer>;
+    /**
+     * Aktualisiert das vorhandene {@link UvLehrer}-Objekt durch das neue Objekt.
+     * @param lehrer Das neue {@link UvLehrer}-Objekt.
+     */
+    lehrerAllPatchAttributes(lehrer: Collection<UvLehrer>): void;
+    private lehrerAllPatchAttributesOhneUpdate;
+    private lehrerRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvLehrer}-Objekt.
+     * @param idLehrer Die ID des {@link UvLehrer}-Objekts.
+     */
+    lehrerRemoveById(idLehrer: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvLehrer}-Objekt.
+     * @param lehrer das zu entfernende {@link UvLehrer}-Objekt.
+     */
+    lehrerRemove(lehrer: UvLehrer): void;
+    private lehrerRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvLehrer}-Objekte.
+     * @param listLehrer Die Liste der zu entfernenden {@link UvLehrer}-Objekte.
+     */
+    lehrerRemoveAll(listLehrer: Collection<UvLehrer>): void;
+    private lehrerRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvLehrer}-Objekte.
+     * @param listLehrerIds Die Liste der zu entfernenden {@link UvLehrer}-Objekte.
+     */
+    lehrerRemoveAllById(listLehrerIds: List<number>): void;
+    private updateLehrerUnterrichtsfachMenge;
+    private updateLehrerUnterrichtsfachByIdKLehrerAndIdFach;
+    private updateLehrerUnterrichtsfachByIdLehrerAndIdFach;
+    /**
+     * Fügt ein {@link LehrerUnterrichtsfach}-Objekt hinzu.
+     * @param unterrichtsfach Das {@link LehrerUnterrichtsfach}-Objekt, welches hinzugefügt werden soll.
+     */
+    lehrerUnterrichtsfachAdd(unterrichtsfach: LehrerUnterrichtsfach): void;
+    /**
+     * Fügt alle {@link LehrerUnterrichtsfach}-Objekte hinzu.
+     * @param list Die Menge der {@link LehrerUnterrichtsfach}-Objekte, welche hinzugefügt werden soll.
+     */
+    lehrerUnterrichtsfachAddAll(list: Collection<LehrerUnterrichtsfach>): void;
+    private lehrerUnterrichtsfachAddAllOhneUpdate;
+    private static lehrerUnterrichtsfachCheck;
+    /**
+     * Liefert das zugehörige {@link LehrerUnterrichtsfach}-Objekt. <br>
+     * @param istKLehrer gibt an, ob der Eintrag zu einem K-Lehrer gehört.
+     * @param idUnterrichtsfach Die ID des angefragten Objektes.
+     * @return das zugehörige {@link LehrerUnterrichtsfach}-Objekt.
+     */
+    lehrerUnterrichtsfachGetByIdOrException(istKLehrer: boolean, idUnterrichtsfach: number): LehrerUnterrichtsfach;
+    /**
+     * Liefert eine Liste aller {@link LehrerUnterrichtsfach}-Objekte. <br>
+     * @return eine Liste aller {@link LehrerUnterrichtsfach}-Objekte.
+     */
+    lehrerUnterrichtsfachGetMengeAsList(): List<LehrerUnterrichtsfach>;
+    /**
+     * Aktualisiert das vorhandene {@link LehrerUnterrichtsfach}-Objekt durch das neue Objekt.
+     * @param unterrichtsfaecher Die neuen {@link LehrerUnterrichtsfach}-Objekte.
+     */
+    lehrerUnterrichtsfachAllPatchAttributes(unterrichtsfaecher: Collection<LehrerUnterrichtsfach>): void;
+    private lehrerUnterrichtsfachRemoveOhneUpdate;
+    /**
+     * Entfernt ein existierendes {@link LehrerUnterrichtsfach}-Objekt.
+     * @param istKLehrer gibt an, ob der Eintrag zu einem K-Lehrer gehört.
+     * @param idUnterrichtsfach Die ID des {@link LehrerUnterrichtsfach}-Objekts.
+     */
+    lehrerUnterrichtsfachRemoveById(istKLehrer: boolean, idUnterrichtsfach: number): void;
+    /**
+     * Entfernt ein existierendes {@link LehrerUnterrichtsfach}-Objekt.
+     * @param unterrichtsfach das zu entfernende {@link LehrerUnterrichtsfach}-Objekt.
+     */
+    lehrerUnterrichtsfachRemove(unterrichtsfach: LehrerUnterrichtsfach): void;
+    /**
+     * Entfernt alle {@link LehrerUnterrichtsfach}-Objekte.
+     * @param list Die Liste der zu entfernenden {@link LehrerUnterrichtsfach}-Objekte.
+     */
+    lehrerUnterrichtsfachRemoveAll(list: Collection<LehrerUnterrichtsfach>): void;
+    private lehrerUnterrichtsfachRemoveAllOhneUpdate;
+    /**
+     * Liefert die Liste der {@link LehrerUnterrichtsfach}-Objekte zu einem {@link UvLehrer}.
+     * @param lehrer der {@link UvLehrer}
+     * @return die Liste der {@link LehrerUnterrichtsfach}-Objekte, oder eine leere Liste
+     */
+    lehrerUnterrichtsfachGetMengeByLehrer(lehrer: UvLehrer): List<LehrerUnterrichtsfach>;
+    private updatePlanungsabschnittLehrerMenge;
+    /**
+     * Fügt ein {@link UvPlanungsabschnittLehrer}-Objekt hinzu.
+     * @param lehrer Das {@link UvPlanungsabschnittLehrer}-Objekt, welches hinzugefügt werden soll.
+     */
+    planungsabschnittLehrerAdd(lehrer: UvPlanungsabschnittLehrer): void;
+    private planungsabschnittLehrerAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvPlanungsabschnittLehrer}-Objekte hinzu.
+     * @param listLehrer Die Menge der {@link UvPlanungsabschnittLehrer}-Objekte, welche hinzugefügt werden soll.
+     */
+    planungsabschnittLehrerAddAll(listLehrer: Collection<UvPlanungsabschnittLehrer>): void;
+    private planungsabschnittLehrerAddAllOhneUpdate;
+    private planungsabschnittLehrerCheck;
+    private planungsabschnittLehrerRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvPlanungsabschnittLehrer}-Objekt.
+     * @param idPlanungsabschnitt die ID des {@link UvPlanungsabschnitt}-Objekts.
+     * @param idLehrer Die ID des {@link UvLehrer}-Objekts.
+     */
+    planungsabschnittLehrerRemoveById(idPlanungsabschnitt: number, idLehrer: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvPlanungsabschnittLehrer}-Objekt.
+     * @param lehrer das zu entfernende {@link UvPlanungsabschnittLehrer}-Objekt.
+     */
+    planungsabschnittLehrerRemove(lehrer: UvPlanungsabschnittLehrer): void;
+    private planungsabschnittLehrerRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvPlanungsabschnittLehrer}-Objekte.
+     * @param listLehrer Die Liste der zu entfernenden {@link UvPlanungsabschnittLehrer}-Objekte.
+     */
+    planungsabschnittLehrerRemoveAll(listLehrer: Collection<UvPlanungsabschnittLehrer>): void;
+    private planungsabschnittLehrerRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvPlanungsabschnittLehrer}-Objekte.
+     * @param idPlanungsabschnitt die ID des {@link UvPlanungsabschnitt}-Objekts.
+     * @param listLehrerIds Die Liste der zu entfernenden {@link UvPlanungsabschnittLehrer}-Objekte.
+     */
+    planungsabschnittLehrerRemoveAllById(idPlanungsabschnitt: number, listLehrerIds: List<number>): void;
+    /**
+     * Liefert die Liste aller {@link UvPlanungsabschnittLehrer}-Objekte zu einem {@link UvPlanungsabschnitt}.
+     *
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @return die Liste der {@link UvPlanungsabschnittLehrer}-Objekte
+     */
+    planungsabschnittLehrerGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvPlanungsabschnittLehrer>;
+    private updateLehrerAnrechnungsstundenMenge;
+    /**
+     * Fügt ein {@link UvLehrerAnrechnungsstunden}-Objekt hinzu.
+     * @param anrechnungsstunde Das {@link UvLehrerAnrechnungsstunden}-Objekt, welches hinzugefügt werden soll.
+     */
+    lehrerAnrechnungsstundenAdd(anrechnungsstunde: UvLehrerAnrechnungsstunden): void;
+    private lehrerAnrechnungsstundenAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvLehrerAnrechnungsstunden}-Objekte hinzu.
+     * @param listAnrechnungsstunden Die Menge der {@link UvLehrerAnrechnungsstunden}-Objekte, welche hinzugefügt werden soll.
+     */
+    lehrerAnrechnungsstundenAddAll(listAnrechnungsstunden: Collection<UvLehrerAnrechnungsstunden>): void;
+    private lehrerAnrechnungsstundenAddAllOhneUpdate;
+    private lehrerAnrechnungsstundenCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvLehrerAnrechnungsstunden}-Objekt. <br>
+     * @param idAnrechnungsstunde Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvLehrerAnrechnungsstunden}-Objekt.
+     */
+    lehrerAnrechnungsstundenGetByIdOrException(idAnrechnungsstunde: number): UvLehrerAnrechnungsstunden;
+    /**
+     * Liefert eine Liste aller {@link UvLehrerAnrechnungsstunden}-Objekte. <br>
+     * @return eine Liste aller {@link UvLehrerAnrechnungsstunden}-Objekte.
+     */
+    lehrerAnrechnungsstundenGetMengeAsList(): List<UvLehrerAnrechnungsstunden>;
+    /**
+     * Aktualisiert das vorhandene {@link UvLehrerAnrechnungsstunden}-Objekt durch das neue Objekt.
+     * @param anrechnungsstunden Die neuen {@link UvLehrerAnrechnungsstunden}-Objekte.
+     */
+    lehrerAnrechnungsstundenAllPatchAttributes(anrechnungsstunden: Collection<UvLehrerAnrechnungsstunden>): void;
+    private lehrerAnrechnungsstundenAllPatchAttributesOhneUpdate;
+    private lehrerAnrechnungsstundenRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvLehrerAnrechnungsstunden}-Objekt.
+     * @param idAnrechnungsstunde Die ID des {@link UvLehrerAnrechnungsstunden}-Objekts.
+     */
+    lehrerAnrechnungsstundenRemoveById(idAnrechnungsstunde: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvLehrerAnrechnungsstunden}-Objekt.
+     * @param anrechnungsstunde das zu entfernende {@link UvLehrerAnrechnungsstunden}-Objekt.
+     */
+    lehrerAnrechnungsstundenRemove(anrechnungsstunde: UvLehrerAnrechnungsstunden): void;
+    private lehrerAnrechnungsstundenRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvLehrerAnrechnungsstunden}-Objekte.
+     * @param listAnrechnungsstunden Die Liste der zu entfernenden {@link UvLehrerAnrechnungsstunden}-Objekte.
+     */
+    lehrerAnrechnungsstundenRemoveAll(listAnrechnungsstunden: Collection<UvLehrerAnrechnungsstunden>): void;
+    private lehrerAnrechnungsstundenRemoveAllOhneUpdate;
+    private updateLehrerPflichtstundensollMenge;
+    /**
+     * Fügt ein {@link UvLehrerPflichtstundensoll}-Objekt hinzu.
+     * @param pflichtstundensoll Das {@link UvLehrerPflichtstundensoll}-Objekt, welches hinzugefügt werden soll.
+     */
+    lehrerPflichtstundensollAdd(pflichtstundensoll: UvLehrerPflichtstundensoll): void;
+    private lehrerPflichtstundensollAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvLehrerPflichtstundensoll}-Objekte hinzu.
+     * @param listPflichtstundensoll Die Menge der {@link UvLehrerPflichtstundensoll}-Objekte, welche hinzugefügt werden soll.
+     */
+    lehrerPflichtstundensollAddAll(listPflichtstundensoll: Collection<UvLehrerPflichtstundensoll>): void;
+    private lehrerPflichtstundensollAddAllOhneUpdate;
+    private lehrerPflichtstundensollCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvLehrerPflichtstundensoll}-Objekt. <br>
+     * @param idPflichtstundensoll Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvLehrerPflichtstundensoll}-Objekt.
+     */
+    lehrerPflichtstundensollGetByIdOrException(idPflichtstundensoll: number): UvLehrerPflichtstundensoll;
+    /**
+     * Liefert eine Liste aller {@link UvLehrerPflichtstundensoll}-Objekte. <br>
+     * @return eine Liste aller {@link UvLehrerPflichtstundensoll}-Objekte.
+     */
+    lehrerPflichtstundensollGetMengeAsList(): List<UvLehrerPflichtstundensoll>;
+    /**
+     * Aktualisiert das vorhandene {@link UvLehrerPflichtstundensoll}-Objekt durch das neue Objekt.
+     * @param pflichtstundensoll Die neuen {@link UvLehrerPflichtstundensoll}-Objekte.
+     */
+    lehrerPflichtstundensollAllPatchAttributes(pflichtstundensoll: Collection<UvLehrerPflichtstundensoll>): void;
+    private lehrerPflichtstundensollAllPatchAttributesOhneUpdate;
+    private lehrerPflichtstundensollRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvLehrerPflichtstundensoll}-Objekt.
+     * @param idPflichtstundensoll Die ID des {@link UvLehrerPflichtstundensoll}-Objekts.
+     */
+    lehrerPflichtstundensollRemoveById(idPflichtstundensoll: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvLehrerPflichtstundensoll}-Objekt.
+     * @param pflichtstundensoll das zu entfernende {@link UvLehrerPflichtstundensoll}-Objekt.
+     */
+    lehrerPflichtstundensollRemove(pflichtstundensoll: UvLehrerPflichtstundensoll): void;
+    private lehrerPflichtstundensollRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvLehrerPflichtstundensoll}-Objekte.
+     * @param listPflichtstundensoll Die Liste der zu entfernenden {@link UvLehrerPflichtstundensoll}-Objekte.
+     */
+    lehrerPflichtstundensollRemoveAll(listPflichtstundensoll: Collection<UvLehrerPflichtstundensoll>): void;
+    private lehrerPflichtstundensollRemoveAllOhneUpdate;
+    private updateRaumMenge;
+    /**
+     * Fügt ein {@link UvRaum}-Objekt hinzu.
+     * @param raum Das {@link UvRaum}-Objekt, welches hinzugefügt werden soll.
+     */
+    raumAdd(raum: UvRaum): void;
+    private raumAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvRaum}-Objekte hinzu.
+     * @param listRaeume Die Menge der {@link UvRaum}-Objekte, welche hinzugefügt werden soll.
+     */
+    raumAddAll(listRaeume: Collection<UvRaum>): void;
+    private raumAddAllOhneUpdate;
+    private raumCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvRaum}-Objekt. <br>
+     * @param idRaum Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvRaum}-Objekt.
+     */
+    raumGetByIdOrException(idRaum: number): UvRaum;
+    /**
+     * Liefert das zur ID gehörende {@link UvRaum}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idRaum die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    raumGetByIdOrNull(idRaum: number): UvRaum | null;
+    /**
+     * Liefert eine Liste aller {@link UvRaum}-Objekte. <br>
+     * @return eine Liste aller {@link UvRaum}-Objekte.
+     */
+    raumGetMengeAsList(): List<UvRaum>;
+    /**
+     * Aktualisiert das vorhandene {@link UvRaum}-Objekt durch das neue Objekt.
+     * @param raeume Die neuen {@link UvRaum}-Objekte.
+     */
+    raumAllPatchAttributes(raeume: Collection<UvRaum>): void;
+    private raumAllPatchAttributesOhneUpdate;
+    private raumRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvRaum}-Objekt.
+     * @param idRaum Die ID des {@link UvRaum}-Objekts.
+     */
+    raumRemoveById(idRaum: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvRaum}-Objekt.
+     * @param raum das zu entfernende {@link UvRaum}-Objekt.
+     */
+    raumRemove(raum: UvRaum): void;
+    private raumRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvRaum}-Objekte.
+     * @param listRaeume Die Liste der zu entfernenden {@link UvRaum}-Objekte.
+     */
+    raumRemoveAll(listRaeume: Collection<UvRaum>): void;
+    private raumRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvRaum}-Objekte.
+     * @param listRaumIds Die Liste der zu entfernenden {@link UvRaum}-Objekte.
+     */
+    raumRemoveAllById(listRaumIds: List<number>): void;
+    private updateRaumgruppeMenge;
+    /**
+     * Fügt eine {@link UvRaumgruppe} hinzu.
+     * @param raumgruppe Die {@link UvRaumgruppe}, die hinzugefügt werden soll.
+     */
+    raumgruppeAdd(raumgruppe: UvRaumgruppe): void;
+    private raumgruppeAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvRaumgruppe}-Objekte hinzu.
+     * @param listRaumgruppen Die Menge der {@link UvRaumgruppe}-Objekte, welche hinzugefügt werden soll.
+     */
+    raumgruppeAddAll(listRaumgruppen: Collection<UvRaumgruppe>): void;
+    private raumgruppeAddAllOhneUpdate;
+    private static raumgruppeCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvRaumgruppe}-Objekt. <br>
+     * @param idRaumgruppe Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvRaumgruppe}-Objekt.
+     */
+    raumgruppeGetByIdOrException(idRaumgruppe: number): UvRaumgruppe;
+    /**
+     * Liefert das zur ID gehörende {@link UvRaumgruppe}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idRaumgruppe die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    raumgruppeGetByIdOrNull(idRaumgruppe: number): UvRaumgruppe | null;
+    /**
+     * Liefert eine Liste aller {@link UvRaumgruppe}-Objekte. <br>
+     * @return eine Liste aller {@link UvRaumgruppe}-Objekte.
+     */
+    raumgruppeGetMengeAsList(): List<UvRaumgruppe>;
+    /**
+     * Aktualisiert das vorhandene {@link UvRaumgruppe}-Objekt durch das neue Objekt.
+     * @param raumgruppen Die neuen {@link UvRaumgruppe}-Objekte.
+     */
+    raumgruppeAllPatchAttributes(raumgruppen: Collection<UvRaumgruppe>): void;
+    private raumgruppeAllPatchAttributesOhneUpdate;
+    private raumgruppeRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvRaumgruppe}-Objekt.
+     * @param idRaumgruppe Die ID des {@link UvRaumgruppe}-Objekts.
+     */
+    raumgruppeRemoveById(idRaumgruppe: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvRaumgruppe}-Objekt.
+     * @param raumgruppe das zu entfernende {@link UvRaumgruppe}-Objekt.
+     */
+    raumgruppeRemove(raumgruppe: UvRaumgruppe): void;
+    private raumgruppeRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvRaumgruppe}-Objekte.
+     * @param listRaumgruppen Die Liste der zu entfernenden {@link UvRaumgruppe}-Objekte.
+     */
+    raumgruppeRemoveAll(listRaumgruppen: Collection<UvRaumgruppe>): void;
+    private raumgruppeRemoveAllOhneUpdate;
+    private updateStundentafelMenge;
+    /**
+     * Fügt ein {@link UvStundentafel}-Objekt hinzu.
+     * @param stundentafel Das {@link UvStundentafel}-Objekt, welches hinzugefügt werden soll.
+     */
+    stundentafelAdd(stundentafel: UvStundentafel): void;
+    private stundentafelAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvStundentafel}-Objekte hinzu.
+     * @param listStundentafeln Die Menge der {@link UvStundentafel}-Objekte, welche hinzugefügt werden soll.
+     */
+    stundentafelAddAll(listStundentafeln: Collection<UvStundentafel>): void;
+    private stundentafelAddAllOhneUpdate;
+    private static stundentafelCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvStundentafel}-Objekt. <br>
+     * @param idStundentafel Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvStundentafel}-Objekt.
+     */
+    stundentafelGetByIdOrException(idStundentafel: number): UvStundentafel;
+    /**
+     * Liefert das zur ID gehörende {@link UvStundentafel}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idStundentafel die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    stundentafelGetByIdOrNull(idStundentafel: number): UvStundentafel | null;
+    /**
+     * Liefert eine Liste aller {@link UvStundentafel}-Objekte. <br>
+     * @return eine Liste aller {@link UvStundentafel}-Objekte.
+     */
+    stundentafelGetMengeAsList(): List<UvStundentafel>;
+    /**
+     * Aktualisiert das vorhandene {@link UvStundentafel}-Objekt durch das neue Objekt.
+     * @param stundentafeln Die neuen {@link UvStundentafel}-Objekte.
+     */
+    stundentafelAllPatchAttributes(stundentafeln: Collection<UvStundentafel>): void;
+    private stundentafelAllPatchAttributesOhneUpdate;
+    private stundentafelRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvStundentafel}-Objekt.
+     * @param idStundentafel Die ID des {@link UvStundentafel}-Objekts.
+     */
+    stundentafelRemoveById(idStundentafel: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvStundentafel}-Objekt.
+     * @param stundentafel das zu entfernende {@link UvStundentafel}-Objekt.
+     */
+    stundentafelRemove(stundentafel: UvStundentafel): void;
+    private stundentafelRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvStundentafel}-Objekte.
+     * @param listStundentafeln Die Liste der zu entfernenden {@link UvStundentafel}-Objekte.
+     */
+    stundentafelRemoveAll(listStundentafeln: Collection<UvStundentafel>): void;
+    private stundentafelRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvStundentafel}-Objekte.
+     * @param listStundentafelIds Die Liste der IDs der zu entfernenden {@link UvStundentafel}-Objekte.
+     */
+    stundentafelRemoveAllById(listStundentafelIds: List<number>): void;
+    private updateStundentafelFachMenge;
+    /**
+     * Fügt ein {@link UvStundentafelFach}-Objekt hinzu.
+     * @param fach Das {@link UvStundentafelFach}-Objekt, welches hinzugefügt werden soll.
+     */
+    stundentafelFachAdd(fach: UvStundentafelFach): void;
+    private stundentafelFachAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvStundentafelFach}-Objekte hinzu.
+     * @param listFaecher Die Menge der {@link UvStundentafelFach}-Objekte, welche hinzugefügt werden soll.
+     */
+    stundentafelFachAddAll(listFaecher: Collection<UvStundentafelFach>): void;
+    private stundentafelFachAddAllOhneUpdate;
+    private stundentafelFachCheck;
+    /**
+     * Liefert eine Liste aller {@link UvStundentafelFach}-Objekte. <br>
+     * @return eine Liste aller {@link UvStundentafelFach}-Objekte.
+     */
+    stundentafelFachGetMengeAsList(): List<UvStundentafelFach>;
+    /**
+     * Liefert das zur ID gehörige {@link UvStundentafelFach}-Objekt zurück.
+     * @param idStundentafelfach die ID des {@link UvStundentafelFach}-Objekts.
+     * @return das {@link UvStundentafelFach}-Objekt
+     */
+    stundentafelFachGetByIdOrException(idStundentafelfach: number): UvStundentafelFach;
+    /**
+     * Aktualisiert das vorhandene {@link UvStundentafelFach}-Objekt durch das neue Objekt.
+     * @param faecher Die neuen {@link UvStundentafelFach}-Objekte.
+     */
+    stundentafelFachAllPatchAttributes(faecher: Collection<UvStundentafelFach>): void;
+    private stundentafelFachAllPatchAttributesOhneUpdate;
+    private stundentafelFachRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvStundentafelFach}-Objekt.
+     * @param idFach Die ID des {@link UvStundentafelFach}-Objekts.
+     */
+    stundentafelFachRemoveById(idFach: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvStundentafelFach}-Objekt.
+     * @param fach das zu entfernende {@link UvStundentafelFach}-Objekt.
+     */
+    stundentafelFachRemove(fach: UvStundentafelFach): void;
+    private stundentafelFachRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvStundentafelFach}-Objekte.
+     * @param listFaecher Die Liste der zu entfernenden {@link UvStundentafelFach}-Objekte.
+     */
+    stundentafelFachRemoveAll(listFaecher: Collection<UvStundentafelFach>): void;
+    private stundentafelFachRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvStundentafelFach}-Objekte mit den angegebenen IDs.
+     * @param listIds Die Liste der IDs der zu entfernenden {@link UvStundentafelFach}-Objekte.
+     */
+    stundentafelFachRemoveAllById(listIds: List<number>): void;
+    private updateFachMenge;
+    /**
+     * Fügt ein {@link UvFach}-Objekt hinzu.
+     * @param fach Das {@link UvFach}-Objekt, welches hinzugefügt werden soll.
+     */
+    fachAdd(fach: UvFach): void;
+    private fachAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvFach}-Objekte hinzu.
+     * @param listFaecher Die Menge der {@link UvFach}-Objekte, welche hinzugefügt werden soll.
+     */
+    fachAddAll(listFaecher: Collection<UvFach>): void;
+    private fachAddAllOhneUpdate;
+    private static fachCheck;
+    /**
+     * Liefert das {@link UvFach}-Objekt zur angegebenen ID
+     * @param idFach die ID des Fachs
+     * @return das {@link UvFach}
+     */
+    fachGetByIdOrException(idFach: number): UvFach;
+    /**
+     * Liefert das zur ID gehörende {@link UvFach}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idFach die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    fachGetByIdOrNull(idFach: number): UvFach | null;
+    /**
+     * Liefert eine Liste aller {@link UvFach}-Objekte. <br>
+     * @return eine Liste aller {@link UvFach}-Objekte.
+     */
+    fachGetMengeAsList(): List<UvFach>;
+    /**
+     * Aktualisiert das vorhandene {@link UvFach}-Objekt durch das neue Objekt.
+     * @param faecher Die neuen {@link UvFach}-Objekte.
+     */
+    fachAllPatchAttributes(faecher: Collection<UvFach>): void;
+    /**
+     * Aktualisiert das vorhandene {@link UvFach}-Objekt durch das neue Objekt.
+     * @param fach das neue {@link UvFach}-Objekt.
+     */
+    fachPatchAttributes(fach: UvFach): void;
+    private fachAllPatchAttributesOhneUpdate;
+    private fachRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvFach}-Objekt.
+     * @param idFach Die ID des {@link UvFach}-Objekts.
+     */
+    fachRemoveById(idFach: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvFach}-Objekt.
+     * @param fach das zu entfernende {@link UvFach}-Objekt.
+     */
+    fachRemove(fach: UvFach): void;
+    private fachRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvFach}-Objekte.
+     * @param listFaecher Die Liste der zu entfernenden {@link UvFach}-Objekte.
+     */
+    fachRemoveAll(listFaecher: Collection<UvFach>): void;
+    private fachRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvFach}-Objekte mit den angegebenen IDs.
+     * @param listIds Die Liste der IDs der zu entfernenden {@link UvFach}-Objekte.
+     */
+    fachRemoveAllById(listIds: List<number>): void;
+    private updateZeitrasterMenge;
+    /**
+     * Fügt ein {@link UvZeitraster}-Objekt hinzu.
+     * @param zeitraster Das {@link UvZeitraster}-Objekt, welches hinzugefügt werden soll.
+     */
+    zeitrasterAdd(zeitraster: UvZeitraster): void;
+    private zeitrasterAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvZeitraster}-Objekte hinzu.
+     * @param listZeitraster Die Menge der {@link UvZeitraster}-Objekte, welche hinzugefügt werden soll.
+     */
+    zeitrasterAddAll(listZeitraster: Collection<UvZeitraster>): void;
+    private zeitrasterAddAllOhneUpdate;
+    private static zeitrasterCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvZeitraster}-Objekt. <br>
+     * @param idZeitraster Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvZeitraster}-Objekt.
+     */
+    zeitrasterGetByIdOrException(idZeitraster: number): UvZeitraster;
+    /**
+     * Liefert das zur ID zugehörige {@link UvZeitraster}-Objekt oder {@code null}. <br>
+     * @param idZeitraster Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvZeitraster}-Objekt oder {@code null}.
+     */
+    zeitrasterGetByIdOrNull(idZeitraster: number): UvZeitraster | null;
+    /**
+     * Liefert eine Liste aller {@link UvZeitraster}-Objekte. <br>
+     * @return eine Liste aller {@link UvZeitraster}-Objekte.
+     */
+    zeitrasterGetMengeAsList(): List<UvZeitraster>;
+    /**
+     * Aktualisiert das vorhandene {@link UvZeitraster}-Objekt durch das neue Objekt.
+     * @param listZeitraster Die neuen {@link UvZeitraster}-Objekte.
+     */
+    zeitrasterAllPatchAttributes(listZeitraster: Collection<UvZeitraster>): void;
+    private zeitrasterAllPatchAttributesOhneUpdate;
+    private zeitrasterRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvZeitraster}-Objekt.
+     * @param idZeitraster Die ID des {@link UvZeitraster}-Objekts.
+     */
+    zeitrasterRemoveById(idZeitraster: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvZeitraster}-Objekt.
+     * @param zeitraster das zu entfernende {@link UvZeitraster}-Objekt.
+     */
+    zeitrasterRemove(zeitraster: UvZeitraster): void;
+    private zeitrasterRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvZeitraster}-Objekte.
+     * @param listZeitraster Die Liste der zu entfernenden {@link UvZeitraster}-Objekte.
+     */
+    zeitrasterRemoveAll(listZeitraster: Collection<UvZeitraster>): void;
+    private zeitrasterRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvZeitraster}-Objekte mit den angegebenen IDs.
+     * @param listIds Die Liste der IDs der zu entfernenden {@link UvZeitraster}-Objekte.
+     */
+    zeitrasterRemoveAllById(listIds: List<number>): void;
+    private updateZeitrasterEintragMenge;
+    /**
+     * Fügt ein {@link UvZeitrasterEintrag}-Objekt hinzu.
+     * @param eintrag Das {@link UvZeitrasterEintrag}-Objekt, welches hinzugefügt werden soll.
+     */
+    zeitrasterEintragAdd(eintrag: UvZeitrasterEintrag): void;
+    private zeitrasterEintragAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvZeitrasterEintrag}-Objekte hinzu.
+     * @param listEintraege Die Menge der {@link UvZeitrasterEintrag}-Objekte, welche hinzugefügt werden soll.
+     */
+    zeitrasterEintragAddAll(listEintraege: Collection<UvZeitrasterEintrag>): void;
+    private zeitrasterEintragAddAllOhneUpdate;
+    private zeitrasterEintragCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvZeitrasterEintrag}-Objekt. <br>
+     * @param idZeitraster Die ID des Zeitrasters.
+     * @param idEintrag Die ID des angefragten Eintrags.
+     * @return das zur ID zugehörige {@link UvZeitrasterEintrag}-Objekt.
+     */
+    zeitrasterEintragGetByIdOrException(idZeitraster: number, idEintrag: number): UvZeitrasterEintrag;
+    /**
+     * Liefert den Zeitrastereintrag direkt anhand seiner Datensatz-ID oder {@code null}.
+     *
+     * @param idEintrag die ID des Zeitrastereintrags
+     * @return der gespeicherte Eintrag oder {@code null}, falls er nicht vorhanden ist
+     */
+    zeitrasterEintragGetByIdOrNull(idEintrag: number): UvZeitrasterEintrag | null;
+    /**
+     * Liefert eine Liste aller {@link UvZeitrasterEintrag}-Objekte. <br>
+     * @return eine Liste aller {@link UvZeitrasterEintrag}-Objekte.
+     */
+    zeitrasterEintragGetMengeAsList(): List<UvZeitrasterEintrag>;
+    /**
+     * Aktualisiert das vorhandene {@link UvZeitrasterEintrag}-Objekt durch das neue Objekt.
+     * @param listEintraege Die neuen {@link UvZeitrasterEintrag}-Objekte.
+     */
+    zeitrasterEintragAllPatchAttributes(listEintraege: Collection<UvZeitrasterEintrag>): void;
+    private zeitrasterEintragAllPatchAttributesOhneUpdate;
+    private zeitrasterEintragRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvZeitrasterEintrag}-Objekt.
+     * @param idZeitraster Die ID des Zeitrasters.
+     * @param idEintrag Die ID des {@link UvZeitrasterEintrag}-Objekts.
+     */
+    zeitrasterEintragRemoveById(idZeitraster: number, idEintrag: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvZeitrasterEintrag}-Objekt.
+     * @param eintrag das zu entfernende {@link UvZeitrasterEintrag}-Objekt.
+     */
+    zeitrasterEintragRemove(eintrag: UvZeitrasterEintrag): void;
+    private zeitrasterEintragRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvZeitrasterEintrag}-Objekte.
+     * @param listEintraege Die Liste der zu entfernenden {@link UvZeitrasterEintrag}-Objekte.
+     */
+    zeitrasterEintragRemoveAll(listEintraege: Collection<UvZeitrasterEintrag>): void;
+    private zeitrasterEintragRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvZeitrasterEintrag}-Objekte für ein bestimmtes Zeitraster.
+     * @param idZeitraster Die ID des Zeitrasters.
+     */
+    zeitrasterEintragRemoveAllByZeitraster(idZeitraster: number): void;
+    private updatePlanungsabschnittZeitrasterMenge;
+    /**
+     * Fügt ein {@link UvPlanungsabschnittZeitraster}-Objekt hinzu.
+     * @param zuordnung Das {@link UvPlanungsabschnittZeitraster}-Objekt, welches hinzugefügt werden soll.
+     */
+    planungsabschnittZeitrasterAdd(zuordnung: UvPlanungsabschnittZeitraster): void;
+    private planungsabschnittZeitrasterAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvPlanungsabschnittZeitraster}-Objekte hinzu.
+     * @param listZuordnungen Die Menge der {@link UvPlanungsabschnittZeitraster}-Objekte, welche hinzugefügt werden soll.
+     */
+    planungsabschnittZeitrasterAddAll(listZuordnungen: Collection<UvPlanungsabschnittZeitraster>): void;
+    private planungsabschnittZeitrasterAddAllOhneUpdate;
+    private planungsabschnittZeitrasterCheck;
+    /**
+     * Aktualisiert das vorhandene {@link UvPlanungsabschnittZeitraster}-Objekt durch das neue Objekt.
+     * @param pazr Die neuen {@link UvPlanungsabschnittZeitraster}-Objekte.
+     */
+    planungsabschnittZeitrasterAllPatchAttributes(pazr: Collection<UvPlanungsabschnittZeitraster>): void;
+    private planungsabschnittZeitrasterAllPatchAttributesOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvPlanungsabschnittZeitraster}-Objekte. <br>
+     * @return eine Liste aller {@link UvPlanungsabschnittZeitraster}-Objekte.
+     */
+    planungsabschnittZeitrasterGetMengeAsList(): List<UvPlanungsabschnittZeitraster>;
+    private planungsabschnittZeitrasterRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvPlanungsabschnittZeitraster}-Objekt.
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idZeitraster Die ID des Zeitrasters.
+     */
+    planungsabschnittZeitrasterRemoveById(idPlanungsabschnitt: number, idZeitraster: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvPlanungsabschnittZeitraster}-Objekt.
+     * @param zuordnung das zu entfernende {@link UvPlanungsabschnittZeitraster}-Objekt.
+     */
+    planungsabschnittZeitrasterRemove(zuordnung: UvPlanungsabschnittZeitraster): void;
+    private planungsabschnittZeitrasterRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvPlanungsabschnittZeitraster}-Objekte.
+     * @param listZuordnungen Die Liste der zu entfernenden {@link UvPlanungsabschnittZeitraster}-Objekte.
+     */
+    planungsabschnittZeitrasterRemoveAll(listZuordnungen: Collection<UvPlanungsabschnittZeitraster>): void;
+    private planungsabschnittZeitrasterRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvPlanungsabschnittZeitraster}-Objekte für einen Planungsabschnitt.
+     * @param idPlanungsabschnitt die ID des {@link UvPlanungsabschnitt}-Objekts.
+     * @param listZeitrasterIds Die Liste der IDs der zu entfernenden Zeitraster.
+     */
+    planungsabschnittZeitrasterRemoveAllById(idPlanungsabschnitt: number, listZeitrasterIds: List<number>): void;
+    /**
+     * Entfernt alle {@link UvPlanungsabschnittZeitraster}-Objekte für einen Planungsabschnitt.
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     */
+    planungsabschnittZeitrasterRemoveAllByPlanungsabschnitt(idPlanungsabschnitt: number): void;
+    private updatePlanungsabschnittSchuelerMenge;
+    /**
+     * Fügt ein {@link UvPlanungsabschnittSchueler}-Objekt hinzu.
+     * @param zuordnung Das {@link UvPlanungsabschnittSchueler}-Objekt, welches hinzugefügt werden soll.
+     */
+    planungsabschnittSchuelerAdd(zuordnung: UvPlanungsabschnittSchueler): void;
+    private planungsabschnittSchuelerAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvPlanungsabschnittSchueler}-Objekte hinzu.
+     * @param listZuordnungen Die Menge der {@link UvPlanungsabschnittSchueler}-Objekte, welche hinzugefügt werden soll.
+     */
+    planungsabschnittSchuelerAddAll(listZuordnungen: Collection<UvPlanungsabschnittSchueler>): void;
+    private planungsabschnittSchuelerAddAllOhneUpdate;
+    private planungsabschnittSchuelerCheck;
+    /**
+     * Aktualisiert die vorhandenen {@link UvPlanungsabschnittSchueler}-Objekte durch die neuen Objekte.
+     * @param pas Die neuen {@link UvPlanungsabschnittSchueler}-Objekte.
+     */
+    planungsabschnittSchuelerAllPatchAttributes(pas: Collection<UvPlanungsabschnittSchueler>): void;
+    private planungsabschnittSchuelerAllPatchAttributesOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvPlanungsabschnittSchueler}-Objekte. <br>
+     * @return eine Liste aller {@link UvPlanungsabschnittSchueler}-Objekte.
+     */
+    planungsabschnittSchuelerGetMengeAsList(): List<UvPlanungsabschnittSchueler>;
+    private planungsabschnittSchuelerRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvPlanungsabschnittSchueler}-Objekt.
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idSchueler Die ID des Schülers.
+     */
+    planungsabschnittSchuelerRemoveById(idPlanungsabschnitt: number, idSchueler: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvPlanungsabschnittSchueler}-Objekt.
+     * @param zuordnung das zu entfernende {@link UvPlanungsabschnittSchueler}-Objekt.
+     */
+    planungsabschnittSchuelerRemove(zuordnung: UvPlanungsabschnittSchueler): void;
+    private planungsabschnittSchuelerRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvPlanungsabschnittSchueler}-Objekte.
+     * @param listZuordnungen Die Liste der zu entfernenden {@link UvPlanungsabschnittSchueler}-Objekte.
+     */
+    planungsabschnittSchuelerRemoveAll(listZuordnungen: Collection<UvPlanungsabschnittSchueler>): void;
+    private planungsabschnittSchuelerRemoveAllOhneUpdate;
+    /**
+     * Entfernt alle {@link UvPlanungsabschnittSchueler}-Objekte für einen Planungsabschnitt.
+     * @param idPlanungsabschnitt die ID des {@link UvPlanungsabschnitt}-Objekts.
+     * @param listSchuelerIds Die Liste der IDs der zu entfernenden Schüler.
+     */
+    planungsabschnittSchuelerRemoveAllById(idPlanungsabschnitt: number, listSchuelerIds: List<number>): void;
+    /**
+     * Entfernt alle {@link UvPlanungsabschnittSchueler}-Objekte für einen Planungsabschnitt.
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     */
+    planungsabschnittSchuelerRemoveAllByPlanungsabschnitt(idPlanungsabschnitt: number): void;
+    /**
+     * Liefert das zur ID zugehörige {@link UvPlanungsabschnittSchueler}-Objekt. <br>
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idSchueler die ID des Schülers.
+     * @return das zur ID zugehörige {@link UvPlanungsabschnittSchueler}-Objekt.
+     */
+    planungsabschnittSchuelerGetByIdOrException(idPlanungsabschnitt: number, idSchueler: number): UvPlanungsabschnittSchueler;
+    /**
+     * Liefert das zur ID zugehörige {@link UvPlanungsabschnittSchueler}-Objekt oder {@code null}.
+     *
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts
+     * @param idSchueler die ID des Schülers
+     * @return das zugehörige {@link UvPlanungsabschnittSchueler}-Objekt oder {@code null}
+     */
+    planungsabschnittSchuelerGetByIdOrNull(idPlanungsabschnitt: number, idSchueler: number): UvPlanungsabschnittSchueler | null;
+    /**
+     * Fügt ein {@link UvSchuelergruppe}-Objekt hinzu.
+     * @param schuelergruppe Das {@link UvSchuelergruppe}-Objekt, welches hinzugefügt werden soll.
+     */
+    schuelergruppeAdd(schuelergruppe: UvSchuelergruppe): void;
+    private schuelergruppeAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvSchuelergruppe}-Objekte hinzu.
+     * @param listSchuelergruppen Die Menge der {@link UvSchuelergruppe}-Objekte, welche hinzugefügt werden soll.
+     */
+    schuelergruppeAddAll(listSchuelergruppen: Collection<UvSchuelergruppe>): void;
+    private schuelergruppeAddAllOhneUpdate;
+    /**
+     * Ersetzt das vorhandene {@link UvSchuelergruppe}-Objekt anhand seiner ID ohne Löschkaskade
+     * und baut die Indizes neu auf. Das übergebene Objekt muss die vollständigen neuen Daten
+     * enthalten; das bisherige Manager-Objekt darf zuvor nicht verändert werden.
+     *
+     * @param schuelergruppe die neuen Daten mit unveränderter ID und unverändertem Planungsabschnitt
+     */
+    schuelergruppePatchAttributes(schuelergruppe: UvSchuelergruppe): void;
+    private schuelergruppeCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvSchuelergruppe}-Objekt. <br>
+     * @param idSchuelergruppe Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvSchuelergruppe}-Objekt.
+     */
+    schuelergruppeGetByIdOrException(idSchuelergruppe: number): UvSchuelergruppe;
+    /**
+     * Liefert das zur ID gehörende {@link UvSchuelergruppe}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idSchuelergruppe die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    schuelergruppeGetByIdOrNull(idSchuelergruppe: number): UvSchuelergruppe | null;
+    /**
+     * Liefert eine Liste aller {@link UvSchuelergruppe}-Objekte. <br>
+     * @return eine Liste aller {@link UvSchuelergruppe}-Objekte.
+     */
+    schuelergruppeGetMengeAsList(): List<UvSchuelergruppe>;
+    private schuelergruppeRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvSchuelergruppe}-Objekt.
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idSchuelergruppe Die ID der Schülergruppe.
+     */
+    schuelergruppeRemoveById(idPlanungsabschnitt: number, idSchuelergruppe: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvSchuelergruppe}-Objekt.
+     * @param schuelergruppe das zu entfernende {@link UvSchuelergruppe}-Objekt.
+     */
+    schuelergruppeRemove(schuelergruppe: UvSchuelergruppe): void;
+    private schuelergruppeRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvSchuelergruppe}-Objekte.
+     * @param listSchuelergruppen Die Liste der zu entfernenden {@link UvSchuelergruppe}-Objekte.
+     */
+    schuelergruppeRemoveAll(listSchuelergruppen: Collection<UvSchuelergruppe>): void;
+    private schuelergruppeRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvSchuelergruppe}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvSchuelergruppe}-Objekte für den Planungsabschnitt.
+     */
+    schuelergruppeGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvSchuelergruppe>;
+    /**
+     * Fügt ein {@link UvSchuelergruppeSchueler}-Objekt hinzu.
+     * @param zuordnung Das {@link UvSchuelergruppeSchueler}-Objekt, welches hinzugefügt werden soll.
+     */
+    schuelergruppeSchuelerAdd(zuordnung: UvSchuelergruppeSchueler): void;
+    private schuelergruppeSchuelerAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvSchuelergruppeSchueler}-Objekte hinzu.
+     * @param listZuordnungen Die Menge der {@link UvSchuelergruppeSchueler}-Objekte, welche hinzugefügt werden soll.
+     */
+    schuelergruppeSchuelerAddAll(listZuordnungen: Collection<UvSchuelergruppeSchueler>): void;
+    private schuelergruppeSchuelerAddAllOhneUpdate;
+    private schuelergruppeSchuelerCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvSchuelergruppeSchueler}-Objekt. <br>
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idSchuelergruppe Die ID der Schülergruppe.
+     * @param idSchueler Die ID des Schülers.
+     * @return das zur ID zugehörige {@link UvSchuelergruppeSchueler}-Objekt.
+     */
+    schuelergruppeSchuelerGetByIdOrException(idPlanungsabschnitt: number, idSchuelergruppe: number, idSchueler: number): UvSchuelergruppeSchueler;
+    /**
+     * Liefert eine Liste aller {@link UvSchuelergruppeSchueler}-Objekte. <br>
+     * @return eine Liste aller {@link UvSchuelergruppeSchueler}-Objekte.
+     */
+    schuelergruppeSchuelerGetMengeAsList(): List<UvSchuelergruppeSchueler>;
+    private schuelergruppeSchuelerRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvSchuelergruppeSchueler}-Objekt.
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idSchuelergruppe Die ID der Schülergruppe.
+     * @param idSchueler Die ID des Schülers.
+     */
+    schuelergruppeSchuelerRemoveById(idPlanungsabschnitt: number, idSchuelergruppe: number, idSchueler: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvSchuelergruppeSchueler}-Objekt.
+     * @param zuordnung das zu entfernende {@link UvSchuelergruppeSchueler}-Objekt.
+     */
+    schuelergruppeSchuelerRemove(zuordnung: UvSchuelergruppeSchueler): void;
+    private schuelergruppeSchuelerRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvSchuelergruppeSchueler}-Objekte.
+     * @param listZuordnungen Die Liste der zu entfernenden {@link UvSchuelergruppeSchueler}-Objekte.
+     */
+    schuelergruppeSchuelerRemoveAll(listZuordnungen: Collection<UvSchuelergruppeSchueler>): void;
+    private schuelergruppeSchuelerRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvSchuelergruppeSchueler}-Objekte für einen Planungsabschnitt. <br>
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @return eine Liste aller {@link UvSchuelergruppeSchueler}-Objekte für den Planungsabschnitt.
+     */
+    schuelergruppeSchuelerGetMengeByPlanungsabschnitt(idPlanungsabschnitt: number): List<UvSchuelergruppeSchueler>;
+    /**
+     * Liefert eine Liste aller {@link UvSchuelergruppeSchueler}-Objekte für eine Schülergruppe. <br>
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idSchuelergruppe die ID der Schülergruppe.
+     * @return eine Liste aller {@link UvSchuelergruppeSchueler}-Objekte für die Schülergruppe.
+     */
+    schuelergruppeSchuelerGetMengeBySchuelergruppe(idPlanungsabschnitt: number, idSchuelergruppe: number): List<UvSchuelergruppeSchueler>;
+    /**
+     * Fügt ein {@link UvKlasse}-Objekt hinzu.
+     * @param klasse Das {@link UvKlasse}-Objekt, welches hinzugefügt werden soll.
+     */
+    klasseAdd(klasse: UvKlasse): void;
+    private klasseAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvKlasse}-Objekte hinzu.
+     * @param listKlassen Die Menge der {@link UvKlasse}-Objekte, welche hinzugefügt werden soll.
+     */
+    klasseAddAll(listKlassen: Collection<UvKlasse>): void;
+    private klasseAddAllOhneUpdate;
+    /**
+     * Ersetzt das vorhandene {@link UvKlasse}-Objekt anhand seiner ID ohne Löschkaskade
+     * und baut die Indizes neu auf. Das übergebene Objekt muss die vollständigen neuen Daten
+     * enthalten; das bisherige Manager-Objekt darf zuvor nicht verändert werden.
+     *
+     * @param klasse die neuen Daten mit unveränderter ID und unverändertem Planungsabschnitt
+     */
+    klassePatchAttributes(klasse: UvKlasse): void;
+    private klasseCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvKlasse}-Objekt. <br>
+     * @param idKlasse Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvKlasse}-Objekt.
+     */
+    klasseGetByIdOrException(idKlasse: number): UvKlasse;
+    /**
+     * Liefert das zur ID gehörende {@link UvKlasse}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idKlasse die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    klasseGetByIdOrNull(idKlasse: number): UvKlasse | null;
+    /**
+     * Liefert eine Liste aller {@link UvKlasse}-Objekte. <br>
+     * @return eine Liste aller {@link UvKlasse}-Objekte.
+     */
+    klasseGetMengeAsList(): List<UvKlasse>;
+    private klasseRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvKlasse}-Objekt.
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idKlasse Die ID der Klasse.
+     */
+    klasseRemoveById(idPlanungsabschnitt: number, idKlasse: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvKlasse}-Objekt.
+     * @param klasse das zu entfernende {@link UvKlasse}-Objekt.
+     */
+    klasseRemove(klasse: UvKlasse): void;
+    private klasseRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvKlasse}-Objekte.
+     * @param listKlassen Die Liste der zu entfernenden {@link UvKlasse}-Objekte.
+     */
+    klasseRemoveAll(listKlassen: Collection<UvKlasse>): void;
+    private klasseRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvKlasse}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvKlasse}-Objekte für den Planungsabschnitt.
+     */
+    klasseGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvKlasse>;
+    /**
+     * Fügt ein {@link UvKlassenLehrer}-Objekt hinzu.
+     * @param zuordnung Das {@link UvKlassenLehrer}-Objekt, welches hinzugefügt werden soll.
+     */
+    klassenLehrerAdd(zuordnung: UvKlassenLehrer): void;
+    private klassenLehrerAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvKlassenLehrer}-Objekte hinzu.
+     * @param listZuordnungen Die Menge der {@link UvKlassenLehrer}-Objekte, welche hinzugefügt werden soll.
+     */
+    klassenLehrerAddAll(listZuordnungen: Collection<UvKlassenLehrer>): void;
+    private klassenLehrerAddAllOhneUpdate;
+    private klassenLehrerCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvKlassenLehrer}-Objekt. <br>
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idKlasse Die ID der Klasse.
+     * @param idLehrer Die ID des Lehrers.
+     * @return das zur ID zugehörige {@link UvKlassenLehrer}-Objekt.
+     */
+    klassenLehrerGetByIdOrException(idPlanungsabschnitt: number, idKlasse: number, idLehrer: number): UvKlassenLehrer;
+    /**
+     * Liefert eine Liste aller {@link UvKlassenLehrer}-Objekte. <br>
+     * @return eine Liste aller {@link UvKlassenLehrer}-Objekte.
+     */
+    klassenLehrerGetMengeAsList(): List<UvKlassenLehrer>;
+    private klassenLehrerRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvKlassenLehrer}-Objekt.
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idKlasse Die ID der Klasse.
+     * @param idLehrer Die ID des Lehrers.
+     */
+    klassenLehrerRemoveById(idPlanungsabschnitt: number, idKlasse: number, idLehrer: number): void;
+    /**
+     * Entfernt alle {@link UvKlassenLehrer}-Objekte für die angegebene {@link UvKlasse}.
+     * @param klasse die {@link UvKlasse}, deren Klassenlehrer entfernt werden sollen.
+     */
+    private klassenLehrerRemoveByKlasseOhneUpdate;
+    /**
+     * Entfernt ein existierendes {@link UvKlassenLehrer}-Objekt.
+     * @param zuordnung das zu entfernende {@link UvKlassenLehrer}-Objekt.
+     */
+    klassenLehrerRemove(zuordnung: UvKlassenLehrer): void;
+    private klassenLehrerRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvKlassenLehrer}-Objekte.
+     * @param listZuordnungen Die Liste der zu entfernenden {@link UvKlassenLehrer}-Objekte.
+     */
+    klassenLehrerRemoveAll(listZuordnungen: Collection<UvKlassenLehrer>): void;
+    private klassenLehrerRemoveAllOhneUpdate;
+    /**
+     * Aktualisiert die vorhandenen {@link UvKlassenLehrer}-Objekte anhand der übergebenen neuen Werte.
+     * @param listZuordnungen die Sammlung der aktualisierten {@link UvKlassenLehrer}-Objekte
+     */
+    klassenLehrerAllPatchAttributes(listZuordnungen: Collection<UvKlassenLehrer>): void;
+    private klassenLehrerAllPatchAttributesOhneUpdate;
+    /**
+     * Liefert die aktuelle Klassenlehrerzuordnung anhand ihrer unveränderlichen Datensatz-ID.
+     *
+     * @param id die ID der Zuordnung
+     * @return die gespeicherte Zuordnung
+     */
+    klassenLehrerGetByZuordnungsIdOrException(id: number): UvKlassenLehrer;
+    /**
+     * Liefert eine Liste aller {@link UvKlassenLehrer}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvKlassenLehrer}-Objekte für den Planungsabschnitt.
+     */
+    klassenLehrerGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvKlassenLehrer>;
+    /**
+     * Liefert eine Liste aller {@link UvKlassenLehrer}-Objekte für eine {@link UvKlasse}. <br>
+     * @param klasse die {@link UvKlasse}.
+     * @return eine Liste aller {@link UvKlassenLehrer}-Objekte für die {@link UvKlasse}.
+     */
+    klassenLehrerGetMengeByKlasse(klasse: UvKlasse): List<UvKlassenLehrer>;
+    /**
+     * Fügt ein {@link UvKurs}-Objekt hinzu.
+     * @param kurs Das {@link UvKurs}-Objekt, welches hinzugefügt werden soll.
+     */
+    kursAdd(kurs: UvKurs): void;
+    private kursAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvKurs}-Objekte hinzu.
+     * @param listKurse Die Menge der {@link UvKurs}-Objekte, welche hinzugefügt werden soll.
+     */
+    kursAddAll(listKurse: Collection<UvKurs>): void;
+    private kursAddAllOhneUpdate;
+    /**
+     * Ersetzt das vorhandene {@link UvKurs}-Objekt anhand seiner ID ohne Löschkaskade
+     * und baut die Indizes neu auf. Das übergebene Objekt muss die vollständigen neuen Daten
+     * enthalten; das bisherige Manager-Objekt darf zuvor nicht verändert werden.
+     *
+     * @param kurs die neuen Daten mit unveränderter ID und unverändertem Planungsabschnitt
+     */
+    kursPatchAttributes(kurs: UvKurs): void;
+    private kursCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvKurs}-Objekt. <br>
+     * @param idKurs Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvKurs}-Objekt.
+     */
+    kursGetByIdOrException(idKurs: number): UvKurs;
+    /**
+     * Liefert das zur ID gehörende {@link UvKurs}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idKurs die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    kursGetByIdOrNull(idKurs: number): UvKurs | null;
+    /**
+     * Liefert eine Liste aller {@link UvKurs}-Objekte. <br>
+     * @return eine Liste aller {@link UvKurs}-Objekte.
+     */
+    kursGetMengeAsList(): List<UvKurs>;
+    private kursRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvKurs}-Objekt.
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idKurs Die ID des Kurses.
+     */
+    kursRemoveById(idPlanungsabschnitt: number, idKurs: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvKurs}-Objekt.
+     * @param kurs das zu entfernende {@link UvKurs}-Objekt.
+     */
+    kursRemove(kurs: UvKurs): void;
+    private kursRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvKurs}-Objekte.
+     * @param listKurse Die Liste der zu entfernenden {@link UvKurs}-Objekte.
+     */
+    kursRemoveAll(listKurse: Collection<UvKurs>): void;
+    private kursRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvKurs}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvKurs}-Objekte für den Planungsabschnitt.
+     */
+    kursGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvKurs>;
+    /**
+     * Fügt ein {@link UvSchiene}-Objekt hinzu.
+     * @param schiene Das {@link UvSchiene}-Objekt, welches hinzugefügt werden soll.
+     */
+    schieneAdd(schiene: UvSchiene): void;
+    private schieneAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvSchiene}-Objekte hinzu.
+     * @param listSchienen Die Menge der {@link UvSchiene}-Objekte, welche hinzugefügt werden soll.
+     */
+    schieneAddAll(listSchienen: Collection<UvSchiene>): void;
+    private schieneAddAllOhneUpdate;
+    /**
+     * Ersetzt das vorhandene {@link UvSchiene}-Objekt anhand seiner ID ohne Löschkaskade
+     * und baut die Indizes neu auf. Das übergebene Objekt muss die vollständigen neuen Daten
+     * enthalten; das bisherige Manager-Objekt darf zuvor nicht verändert werden.
+     *
+     * @param schiene die neuen Daten mit unveränderter ID und unverändertem Planungsabschnitt
+     */
+    schienePatchAttributes(schiene: UvSchiene): void;
+    private schieneCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvSchiene}-Objekt. <br>
+     * @param idSchiene Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvSchiene}-Objekt.
+     */
+    schieneGetByIdOrException(idSchiene: number): UvSchiene;
+    /**
+     * Liefert das zur ID gehörende {@link UvSchiene}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idSchiene die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    schieneGetByIdOrNull(idSchiene: number): UvSchiene | null;
+    /**
+     * Liefert eine Liste aller {@link UvSchiene}-Objekte. <br>
+     * @return eine Liste aller {@link UvSchiene}-Objekte.
+     */
+    schieneGetMengeAsList(): List<UvSchiene>;
+    private schieneRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvSchiene}-Objekt.
+     * @param idSchiene Die ID der Schiene.
+     */
+    schieneRemoveById(idSchiene: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvSchiene}-Objekt.
+     * @param schiene das zu entfernende {@link UvSchiene}-Objekt.
+     */
+    schieneRemove(schiene: UvSchiene): void;
+    private schieneRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvSchiene}-Objekte.
+     * @param listSchienen Die Liste der zu entfernenden {@link UvSchiene}-Objekte.
+     */
+    schieneRemoveAll(listSchienen: Collection<UvSchiene>): void;
+    private schieneRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvSchiene}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvSchiene}-Objekte für den Planungsabschnitt.
+     */
+    schieneGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvSchiene>;
+    /**
+     * Fügt ein {@link UvLerngruppe}-Objekt hinzu.
+     * @param lerngruppe Das {@link UvLerngruppe}-Objekt, welches hinzugefügt werden soll.
+     */
+    lerngruppeAdd(lerngruppe: UvLerngruppe): void;
+    private lerngruppeAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvLerngruppe}-Objekte hinzu.
+     * @param listLerngruppen Die Menge der {@link UvLerngruppe}-Objekte, welche hinzugefügt werden soll.
+     */
+    lerngruppeAddAll(listLerngruppen: Collection<UvLerngruppe>): void;
+    private lerngruppeAddAllOhneUpdate;
+    /**
+     * Ersetzt das vorhandene {@link UvLerngruppe}-Objekt anhand seiner ID ohne Löschkaskade
+     * und baut die Indizes neu auf. Das übergebene Objekt muss die vollständigen neuen Daten
+     * enthalten; das bisherige Manager-Objekt darf zuvor nicht verändert werden.
+     *
+     * @param lerngruppe die neuen Daten mit unveränderter ID und unverändertem Planungsabschnitt
+     */
+    lerngruppePatchAttributes(lerngruppe: UvLerngruppe): void;
+    private lerngruppeCheck;
+    /**
+     * Prüft ausschließlich die Zuordnung einer Lerngruppe: entweder Kurs ohne Klasse und Fach
+     * oder Klasse und Fach ohne Kurs. Die Existenz der referenzierten Objekte wird nicht geprüft.
+     * Bei einem Patch muss der vollständige resultierende Datensatz übergeben werden.
+     *
+     * @param lerngruppe die zu prüfende Lerngruppe
+     * @throws DeveloperNotificationException falls die Zuordnung unvollständig oder widersprüchlich ist
+     */
+    static lerngruppeCheckZuordnung(lerngruppe: UvLerngruppe): void;
+    /**
+     * Prüft, ob die angegebene Lerngruppe ein Korrekturfach ist.
+     *
+     * Eine Lerngruppe ist ein Korrekturfach, wenn
+     * - sie einem Leistungskurs zugeordnet ist oder
+     * - das zugehörige Fach Mathematik, Deutsch, Englisch, Latein oder Französisch ist.
+     *
+     * @param lerngruppe   Die zu prüfende {@link UvLerngruppe}.
+     *
+     * @return {@code true}, wenn die Lerngruppe ein Korrekturfach ist, sonst {@code false}.
+     */
+    lerngruppeIstKorrekturfach(lerngruppe: UvLerngruppe): boolean;
+    /**
+     * Liefert das zur ID zugehörige {@link UvLerngruppe}-Objekt. <br>
+     * @param idLerngruppe Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvLerngruppe}-Objekt.
+     */
+    lerngruppeGetByIdOrException(idLerngruppe: number): UvLerngruppe;
+    /**
+     * Liefert das zur ID gehörende {@link UvLerngruppe}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idLerngruppe die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    lerngruppeGetByIdOrNull(idLerngruppe: number): UvLerngruppe | null;
+    /**
+     * Liefert eine Liste aller {@link UvLerngruppe}-Objekte. <br>
+     * @return eine Liste aller {@link UvLerngruppe}-Objekte.
+     */
+    lerngruppeGetMengeAsList(): List<UvLerngruppe>;
+    /**
+     * Liefert die einem Kurs zugeordnete {@link UvLerngruppe} oder {@code null}.
+     *
+     * @param idKurs die ID des Kurses
+     * @return die zugeordnete {@link UvLerngruppe} oder {@code null}
+     */
+    lerngruppeGetByKursIdOrNull(idKurs: number): UvLerngruppe | null;
+    private lerngruppeRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvLerngruppe}-Objekt.
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idLerngruppe Die ID der Lerngruppe.
+     */
+    lerngruppeRemoveById(idPlanungsabschnitt: number, idLerngruppe: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvLerngruppe}-Objekt.
+     * @param lerngruppe das zu entfernende {@link UvLerngruppe}-Objekt.
+     */
+    lerngruppeRemove(lerngruppe: UvLerngruppe): void;
+    private lerngruppeRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvLerngruppe}-Objekte.
+     * @param listLerngruppen Die Liste der zu entfernenden {@link UvLerngruppe}-Objekte.
+     */
+    lerngruppeRemoveAll(listLerngruppen: Collection<UvLerngruppe>): void;
+    private lerngruppeRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvLerngruppe}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvLerngruppe}-Objekte für den Planungsabschnitt.
+     */
+    lerngruppeGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvLerngruppe>;
+    /**
+     * Fügt ein {@link UvLerngruppenLehrer}-Objekt hinzu.
+     * @param zuordnung Das {@link UvLerngruppenLehrer}-Objekt, welches hinzugefügt werden soll.
+     */
+    lerngruppenLehrerAdd(zuordnung: UvLerngruppenLehrer): void;
+    private lerngruppenLehrerAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvLerngruppenLehrer}-Objekte hinzu.
+     * @param listZuordnungen Die Menge der {@link UvLerngruppenLehrer}-Objekte, welche hinzugefügt werden soll.
+     */
+    lerngruppenLehrerAddAll(listZuordnungen: Collection<UvLerngruppenLehrer>): void;
+    private lerngruppenLehrerAddAllOhneUpdate;
+    private lerngruppenLehrerCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvLerngruppenLehrer}-Objekt. <br>
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idLerngruppe Die ID der Lerngruppe.
+     * @param idLehrer Die ID des Lehrers.
+     * @return das zur ID zugehörige {@link UvLerngruppenLehrer}-Objekt.
+     */
+    lerngruppenLehrerGetByIdOrException(idPlanungsabschnitt: number, idLerngruppe: number, idLehrer: number): UvLerngruppenLehrer;
+    /**
+     * Liefert eine Liste aller {@link UvLerngruppenLehrer}-Objekte. <br>
+     * @return eine Liste aller {@link UvLerngruppenLehrer}-Objekte.
+     */
+    lerngruppenLehrerGetMengeAsList(): List<UvLerngruppenLehrer>;
+    private lerngruppenLehrerRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvLerngruppenLehrer}-Objekt.
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idLerngruppe Die ID der Lerngruppe.
+     * @param idLehrer Die ID des Lehrers.
+     */
+    lerngruppenLehrerRemoveById(idPlanungsabschnitt: number, idLerngruppe: number, idLehrer: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvLerngruppenLehrer}-Objekt.
+     * @param zuordnung das zu entfernende {@link UvLerngruppenLehrer}-Objekt.
+     */
+    lerngruppenLehrerRemove(zuordnung: UvLerngruppenLehrer): void;
+    private lerngruppenLehrerRemoveOhneUpdate;
+    private lerngruppenLehrerRemoveOhneKaskadeOhneUpdate;
+    /**
+     * Entfernt alle {@link UvLerngruppenLehrer}-Objekte.
+     * @param listZuordnungen Die Liste der zu entfernenden {@link UvLerngruppenLehrer}-Objekte.
+     */
+    lerngruppenLehrerRemoveAll(listZuordnungen: Collection<UvLerngruppenLehrer>): void;
+    private lerngruppenLehrerRemoveAllOhneUpdate;
+    /**
+     * Aktualisiert die vorhandenen {@link UvLerngruppenLehrer}-Objekte anhand der übergebenen neuen Werte.
+     * @param listZuordnungen die Sammlung der aktualisierten {@link UvLerngruppenLehrer}-Objekte
+     */
+    lerngruppenLehrerAllPatchAttributes(listZuordnungen: Collection<UvLerngruppenLehrer>): void;
+    private lerngruppenLehrerAllPatchAttributesOhneUpdate;
+    /**
+     * Liefert die aktuelle Lerngruppenlehrerzuordnung anhand ihrer unveränderlichen Datensatz-ID.
+     *
+     * @param id die ID der Zuordnung
+     * @return die gespeicherte Zuordnung
+     */
+    lerngruppenLehrerGetByZuordnungsIdOrException(id: number): UvLerngruppenLehrer;
+    /**
+     * Liefert eine Liste aller {@link UvLerngruppenLehrer}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvLerngruppenLehrer}-Objekte für den Planungsabschnitt.
+     */
+    lerngruppenLehrerGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvLerngruppenLehrer>;
+    /**
+     * Liefert eine Liste aller {@link UvLerngruppenLehrer}-Objekte für eine {@link UvLerngruppe}. <br>
+     * @param lerngruppe die {@link UvLerngruppe}.
+     * @return eine Liste aller {@link UvLerngruppenLehrer}-Objekte für die {@link UvLerngruppe}.
+     */
+    lerngruppenLehrerGetMengeByLerngruppe(lerngruppe: UvLerngruppe): List<UvLerngruppenLehrer>;
+    /**
+     * Fügt ein {@link UvLerngruppenSchiene}-Objekt hinzu.
+     * @param zuordnung Das {@link UvLerngruppenSchiene}-Objekt, welches hinzugefügt werden soll.
+     */
+    lerngruppenSchieneAdd(zuordnung: UvLerngruppenSchiene): void;
+    private lerngruppenSchieneAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvLerngruppenSchiene}-Objekte hinzu.
+     * @param listZuordnungen Die Menge der {@link UvLerngruppenSchiene}-Objekte, welche hinzugefügt werden soll.
+     */
+    lerngruppenSchieneAddAll(listZuordnungen: Collection<UvLerngruppenSchiene>): void;
+    private lerngruppenSchieneAddAllOhneUpdate;
+    private lerngruppenSchieneCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvLerngruppenSchiene}-Objekt. <br>
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idLerngruppe Die ID der Lerngruppe.
+     * @param idSchiene Die ID der Schiene.
+     * @return das zur ID zugehörige {@link UvLerngruppenSchiene}-Objekt.
+     */
+    lerngruppenSchieneGetByIdOrException(idPlanungsabschnitt: number, idLerngruppe: number, idSchiene: number): UvLerngruppenSchiene;
+    /**
+     * Liefert eine Liste aller {@link UvLerngruppenSchiene}-Objekte. <br>
+     * @return eine Liste aller {@link UvLerngruppenSchiene}-Objekte.
+     */
+    lerngruppenSchieneGetMengeAsList(): List<UvLerngruppenSchiene>;
+    private lerngruppenSchieneRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvLerngruppenSchiene}-Objekt.
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idLerngruppe Die ID der Lerngruppe.
+     * @param idSchiene Die ID der Schiene.
+     */
+    lerngruppenSchieneRemoveById(idPlanungsabschnitt: number, idLerngruppe: number, idSchiene: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvLerngruppenSchiene}-Objekt.
+     * @param zuordnung das zu entfernende {@link UvLerngruppenSchiene}-Objekt.
+     */
+    lerngruppenSchieneRemove(zuordnung: UvLerngruppenSchiene): void;
+    private lerngruppenSchieneRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvLerngruppenSchiene}-Objekte.
+     * @param listZuordnungen Die Liste der zu entfernenden {@link UvLerngruppenSchiene}-Objekte.
+     */
+    lerngruppenSchieneRemoveAll(listZuordnungen: Collection<UvLerngruppenSchiene>): void;
+    private lerngruppenSchieneRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvLerngruppenSchiene}-Objekte für einen Planungsabschnitt. <br>
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @return eine Liste aller {@link UvLerngruppenSchiene}-Objekte für den Planungsabschnitt.
+     */
+    lerngruppenSchieneGetMengeByPlanungsabschnitt(idPlanungsabschnitt: number): List<UvLerngruppenSchiene>;
+    /**
+     * Liefert eine Liste aller {@link UvLerngruppenSchiene}-Objekte für eine Lerngruppe. <br>
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idLerngruppe die ID der Lerngruppe.
+     * @return eine Liste aller {@link UvLerngruppenSchiene}-Objekte für die Lerngruppe.
+     */
+    lerngruppenSchieneGetMengeByLerngruppe(idPlanungsabschnitt: number, idLerngruppe: number): List<UvLerngruppenSchiene>;
+    /**
+     * Gibt die Menge der {@link UvLerngruppenSchiene}n zur übergebenen {@link UvLerngruppe} zurück.
+     * @param lerngruppe die {@link UvLerngruppe}, zu der die Schienen gesucht werden
+     * @return die Menge der zugeordneten {@link UvLerngruppenSchiene}-Objekte
+     */
+    lerngruppenSchieneGetMengeByLerngruppe(lerngruppe: UvLerngruppe): List<UvLerngruppenSchiene>;
+    /**
+     * Fügt ein {@link UvUnterricht}-Objekt hinzu.
+     * @param unterricht Das {@link UvUnterricht}-Objekt, welches hinzugefügt werden soll.
+     */
+    unterrichtAdd(unterricht: UvUnterricht): void;
+    private unterrichtAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvUnterricht}-Objekte hinzu.
+     * @param listUnterricht Die Menge der {@link UvUnterricht}-Objekte, welche hinzugefügt werden soll.
+     */
+    unterrichtAddAll(listUnterricht: Collection<UvUnterricht>): void;
+    private unterrichtAddAllOhneUpdate;
+    private unterrichtCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvUnterricht}-Objekt. <br>
+     * @param idUnterricht Die ID des angefragten-Objektes.
+     * @return das zur ID zugehörige {@link UvUnterricht}-Objekt.
+     */
+    unterrichtGetByIdOrException(idUnterricht: number): UvUnterricht;
+    /**
+     * Liefert das zur ID gehörende {@link UvUnterricht}-Objekt direkt aus dem Index oder {@code null}.
+     *
+     * @param idUnterricht die ID des gesuchten Objekts
+     * @return das gespeicherte Objekt oder {@code null}, falls es nicht vorhanden ist
+     */
+    unterrichtGetByIdOrNull(idUnterricht: number): UvUnterricht | null;
+    /**
+     * Liefert eine Liste aller {@link UvUnterricht}-Objekte. <br>
+     * @return eine Liste aller {@link UvUnterricht}-Objekte.
+     */
+    unterrichtGetMengeAsList(): List<UvUnterricht>;
+    private unterrichtRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvUnterricht}-Objekt anhand seiner ID.
+     * @param idUnterricht Die ID des Unterrichts.
+     */
+    unterrichtRemoveById(idUnterricht: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvUnterricht}-Objekt.
+     * @param unterricht das zu entfernende {@link UvUnterricht}-Objekt.
+     */
+    unterrichtRemove(unterricht: UvUnterricht): void;
+    private unterrichtRemoveOhneUpdate;
+    private unterrichtRemoveOhneKaskadeOhneUpdate;
+    /**
+     * Entfernt alle {@link UvUnterricht}-Objekte.
+     * @param listUnterricht Die Liste der zu entfernenden {@link UvUnterricht}-Objekte.
+     */
+    unterrichtRemoveAll(listUnterricht: Collection<UvUnterricht>): void;
+    private unterrichtRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvUnterricht}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvUnterricht}-Objekte für den Planungsabschnitt.
+     */
+    unterrichtGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvUnterricht>;
+    /**
+     * Liefert eine Liste aller {@link UvUnterricht}-Objekte für eine Lerngruppe. <br>
+     * @param idPlanungsabschnitt die ID des Planungsabschnitts.
+     * @param idLerngruppe die ID der Lerngruppe.
+     * @return eine Liste aller {@link UvUnterricht}-Objekte für die Lerngruppe.
+     */
+    unterrichtGetMengeByLerngruppe(idPlanungsabschnitt: number, idLerngruppe: number): List<UvUnterricht>;
+    /**
+     * Aktualisiert die vorhandenen {@link UvUnterricht}-Objekte durch die neuen Objekte.
+     * @param listUnterricht Die neuen {@link UvUnterricht}-Objekte.
+     */
+    unterrichtAllPatchAttributes(listUnterricht: Collection<UvUnterricht>): void;
+    private unterrichtAllPatchAttributesOhneUpdate;
+    /**
+     * Fügt ein {@link UvUnterrichtRaum}-Objekt hinzu.
+     * @param zuordnung Das {@link UvUnterrichtRaum}-Objekt, welches hinzugefügt werden soll.
+     */
+    unterrichtRaumAdd(zuordnung: UvUnterrichtRaum): void;
+    private unterrichtRaumAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvUnterrichtRaum}-Objekte hinzu.
+     * @param listZuordnungen Die Menge der {@link UvUnterrichtRaum}-Objekte, welche hinzugefügt werden soll.
+     */
+    unterrichtRaumAddAll(listZuordnungen: Collection<UvUnterrichtRaum>): void;
+    private unterrichtRaumAddAllOhneUpdate;
+    private unterrichtRaumCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvUnterrichtRaum}-Objekt. <br>
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idUnterricht Die ID des Unterrichts.
+     * @param idRaum Die ID des Raums.
+     * @return das zur ID zugehörige {@link UvUnterrichtRaum}-Objekt.
+     */
+    unterrichtRaumGetByIdOrException(idPlanungsabschnitt: number, idUnterricht: number, idRaum: number): UvUnterrichtRaum;
+    /**
+     * Liefert eine Liste aller {@link UvUnterrichtRaum}-Objekte. <br>
+     * @return eine Liste aller {@link UvUnterrichtRaum}-Objekte.
+     */
+    unterrichtRaumGetMengeAsList(): List<UvUnterrichtRaum>;
+    private unterrichtRaumRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvUnterrichtRaum}-Objekt.
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idUnterricht Die ID des Unterrichts.
+     * @param idRaum Die ID des Raums.
+     */
+    unterrichtRaumRemoveById(idPlanungsabschnitt: number, idUnterricht: number, idRaum: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvUnterrichtRaum}-Objekt.
+     * @param zuordnung das zu entfernende {@link UvUnterrichtRaum}-Objekt.
+     */
+    unterrichtRaumRemove(zuordnung: UvUnterrichtRaum): void;
+    private unterrichtRaumRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvUnterrichtRaum}-Objekte.
+     * @param listZuordnungen Die Liste der zu entfernenden {@link UvUnterrichtRaum}-Objekte.
+     */
+    unterrichtRaumRemoveAll(listZuordnungen: Collection<UvUnterrichtRaum>): void;
+    private unterrichtRaumRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvUnterrichtRaum}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvUnterrichtRaum}-Objekte für den Planungsabschnitt.
+     */
+    unterrichtRaumGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvUnterrichtRaum>;
+    /**
+     * Liefert eine Liste aller {@link UvUnterrichtRaum}-Objekte für einen {@link UvUnterricht}. <br>
+     * @param unterricht der {@link UvUnterricht}.
+     * @return eine Liste aller {@link UvUnterrichtRaum}-Objekte für den {@link UvUnterricht}.
+     */
+    unterrichtRaumGetMengeByUnterricht(unterricht: UvUnterricht): List<UvUnterrichtRaum>;
+    /**
+     * Fügt ein {@link UvUnterrichtLerngruppenlehrer}-Objekt hinzu.
+     * @param zuordnung Das {@link UvUnterrichtLerngruppenlehrer}-Objekt, welches hinzugefügt werden soll.
+     */
+    unterrichtLerngruppenlehrerAdd(zuordnung: UvUnterrichtLerngruppenlehrer): void;
+    private unterrichtLerngruppenlehrerAddOhneUpdate;
+    /**
+     * Fügt alle {@link UvUnterrichtLerngruppenlehrer}-Objekte hinzu.
+     * @param listZuordnungen Die Menge der {@link UvUnterrichtLerngruppenlehrer}-Objekte, welche hinzugefügt werden soll.
+     */
+    unterrichtLerngruppenlehrerAddAll(listZuordnungen: Collection<UvUnterrichtLerngruppenlehrer>): void;
+    private unterrichtLerngruppenlehrerAddAllOhneUpdate;
+    private unterrichtLerngruppenlehrerCheck;
+    /**
+     * Liefert das zur ID zugehörige {@link UvUnterrichtLerngruppenlehrer}-Objekt. <br>
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idUnterricht Die ID des Unterrichts.
+     * @param idLerngruppenLehrer Die ID des Lerngruppenlehrers.
+     * @return das zur ID zugehörige {@link UvUnterrichtLerngruppenlehrer}-Objekt.
+     */
+    unterrichtLerngruppenlehrerGetByIdOrException(idPlanungsabschnitt: number, idUnterricht: number, idLerngruppenLehrer: number): UvUnterrichtLerngruppenlehrer;
+    /**
+     * Liefert eine Liste aller {@link UvUnterrichtLerngruppenlehrer}-Objekte. <br>
+     * @return eine Liste aller {@link UvUnterrichtLerngruppenlehrer}-Objekte.
+     */
+    unterrichtLerngruppenlehrerGetMengeAsList(): List<UvUnterrichtLerngruppenlehrer>;
+    private unterrichtLerngruppenlehrerRemoveOhneUpdateById;
+    /**
+     * Entfernt ein existierendes {@link UvUnterrichtLerngruppenlehrer}-Objekt.
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idUnterricht Die ID des Unterrichts.
+     * @param idLerngruppenLehrer Die ID des Lerngruppenlehrers.
+     */
+    unterrichtLerngruppenlehrerRemoveById(idPlanungsabschnitt: number, idUnterricht: number, idLerngruppenLehrer: number): void;
+    /**
+     * Entfernt ein existierendes {@link UvUnterrichtLerngruppenlehrer}-Objekt.
+     * @param zuordnung das zu entfernende {@link UvUnterrichtLerngruppenlehrer}-Objekt.
+     */
+    unterrichtLerngruppenlehrerRemove(zuordnung: UvUnterrichtLerngruppenlehrer): void;
+    private unterrichtLerngruppenlehrerRemoveOhneUpdate;
+    /**
+     * Entfernt alle {@link UvUnterrichtLerngruppenlehrer}-Objekte.
+     * @param listZuordnungen Die Liste der zu entfernenden {@link UvUnterrichtLerngruppenlehrer}-Objekte.
+     */
+    unterrichtLerngruppenlehrerRemoveAll(listZuordnungen: Collection<UvUnterrichtLerngruppenlehrer>): void;
+    private unterrichtLerngruppenlehrerRemoveAllOhneUpdate;
+    /**
+     * Liefert eine Liste aller {@link UvUnterrichtLerngruppenlehrer}-Objekte für einen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvUnterrichtLerngruppenlehrer}-Objekte für den Planungsabschnitt.
+     */
+    unterrichtLerngruppenlehrerGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvUnterrichtLerngruppenlehrer>;
+    /**
+     * Liefert eine Liste aller {@link UvUnterrichtLerngruppenlehrer}-Objekte für einen Unterricht. <br>
+     * @param unterricht der {@link UvUnterricht}.
+     * @return eine Liste aller {@link UvUnterrichtLerngruppenlehrer}-Objekte für den Unterricht.
+     */
+    unterrichtLerngruppenlehrerGetMengeByUnterricht(unterricht: UvUnterricht): List<UvUnterrichtLerngruppenlehrer>;
+    /**
+     * Liefert eine Liste aller {@link UvLehrerPflichtstundensoll}-Objekte für einen Lehrer. <br>
+     * @param lehrer der {@link UvLehrer}
+     * @return eine Liste aller {@link UvLehrerPflichtstundensoll}-Objekte für den Lehrer.
+     */
+    lehrerPflichtstundensollGetMengeByLehrer(lehrer: UvLehrer): List<UvLehrerPflichtstundensoll>;
+    /**
+     * Liefert eine Liste aller {@link UvLehrer}-Objekte für den aktuellen Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @return eine Liste aller {@link UvLehrer}-Objekte für den aktuellen Planungsabschnitt.
+     */
+    lehrerGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvLehrer>;
+    /**
+     * Liefert einen {@link UvLehrer}, der dem angegebenen {@link UvPlanungsabschnittLehrer} zugeordnet ist.
+     *
+     * @param planungsabschnittLehrer Der {@link UvPlanungsabschnittLehrer}, für den der zugehörige {@link UvLehrer} abgerufen werden soll.
+     * @return Der {@link UvLehrer}, der dem angegebenen {@link UvPlanungsabschnittLehrer} entspricht.
+     * @throws DeveloperNotificationException Wenn kein {@link UvLehrer} mit der angegebenen ID gefunden wird.
+     */
+    lehrerGetByPlanungsabschnittLehrer(planungsabschnittLehrer: UvPlanungsabschnittLehrer): UvLehrer;
+    /**
+     * Liefert den {@link UvPlanungsabschnittSchueler}, der durch die übergebene {@link UvSchuelergruppeSchueler}
+     * identifiziert wird.
+     *
+     * @param schuelergruppeSchueler Das {@link UvSchuelergruppeSchueler}-Objekt, welches die Identifikationsinformationen
+     *                               für den Planungsabschnittsschüler beinhaltet.
+     * @return Der gefundene {@link UvPlanungsabschnittSchueler}.
+     */
+    planungsabschnittSchuelerGetBySchuelergruppeSchueler(schuelergruppeSchueler: UvSchuelergruppeSchueler): UvPlanungsabschnittSchueler;
+    /**
+     * Liefert eine Liste aller {@link UvLehrerAnrechnungsstunden}-Objekte für einen Lehrer. <br>
+     * @param lehrer der {@link UvLehrer}
+     * @return eine Liste aller {@link UvLehrerAnrechnungsstunden}-Objekte für den Lehrer.
+     */
+    lehrerAnrechnungsstundenGetMengeByLehrer(lehrer: UvLehrer): List<UvLehrerAnrechnungsstunden>;
+    /**
+     * Liefert {@code true}, wenn der Lehrer für diesen Planungsabschnitt angelegt ist.
+     * @param lehrer der {@link UvLehrer}
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @return {@code true}, wenn der Lehrer für diesen Planungsabschnitt angelegt ist.
+     */
+    lehrerIsInPlanungsabschnitt(lehrer: UvLehrer, planungsabschnitt: UvPlanungsabschnitt): boolean;
+    /**
+     * Liefert eine Liste aller fehlenden {@link UvLehrer}-Objekte, die zwar im Zeitraum des angegebenen Planungsabschnitts an der Schule tätig waren, aber
+     * nicht für den Planungsabschnitt angelegt sind.
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @return eine Liste aller fehlenden {@link UvLehrer}-Objekte für den aktuellen Planungsabschnitt.
+     */
+    lehrerGetMengeTaetigAberNichtInPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvLehrer>;
+    /**
+     * Prüft für die übergebene Menge, welche {@link UvLehrer} referenziert werden und gibt diese als Menge zurück.
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @param lehrer die zu prüfende Menge
+     * @return die Menge der verwendeten {@link UvLehrer}
+     */
+    lehrerGetMengeVerwendetInPlanungsabschnittByLehrerMenge(planungsabschnitt: UvPlanungsabschnitt, lehrer: Collection<UvLehrer>): JavaSet<UvLehrer>;
+    /**
+     * Prüft für die übergebene Menge, welche {@link UvLehrer} referenziert werden und gibt diese als Menge zurück.
+     * @param lehrer die zu prüfende Menge
+     * @return die Menge der verwendeten {@link UvLehrer}
+     */
+    lehrerGetMengeVerwendetByLehrerMenge(lehrer: Collection<UvLehrer>): JavaSet<UvLehrer>;
+    /**
+     * Liefert eine Liste aller {@link UvRaum}-Objekte für eine {@link UvRaumgruppe}. <br>
+     * @param raumgruppe die {@link UvRaumgruppe}
+     * @return eine Liste aller {@link UvRaum}-Objekte für die {@link UvRaumgruppe}.
+     */
+    raumGetMengeByRaumgruppe(raumgruppe: UvRaumgruppe): List<UvRaum>;
+    /**
+     * Liefert den {@link UvRaum} zum übergebenen Kürzel oder {@code null}, falls kein Raum mit diesem Kürzel existiert.
+     *
+     * @param kuerzel das Kürzel des gesuchten {@link UvRaum}s
+     * @return den zugehörigen {@link UvRaum} oder {@code null}, falls kein passender Raum existiert
+     */
+    raumGetByKuerzelOrNull(kuerzel: string): UvRaum | null;
+    /**
+     * Liefert eine Liste aller {@link UvStundentafelFach}-Objekte für eine Stundentafel. <br>
+     * @param stundentafel die {@link UvStundentafel}
+     * @param abschnitt der Abschnitt des Schuljahres
+     * @return eine Liste aller {@link UvStundentafelFach}-Objekte für die Stundentafel.
+     */
+    stundentafelFachGetMengeByStundentafelAndAbschnitt(stundentafel: UvStundentafel, abschnitt: number): List<UvStundentafelFach>;
+    /**
+     * Liefert das {@link UvFach}-Objekt für ein {@link UvStundentafelFach}-Objekt.
+     * @param stundentafelFach das {@link UvStundentafelFach}-Objekt
+     * @return das zugehörige {@link UvFach}-Objekt
+     */
+    fachGetByStundentafelFach(stundentafelFach: UvStundentafelFach): UvFach;
+    /**
+     * Liefert eine Liste aller {@link UvFach}-Objekte, die im Gültigkeitsintervall
+     * der übergebenen {@link UvStundentafel} gültig sind.
+     *
+     * @param stundentafel   die {@link UvStundentafel}, deren Gültigkeitsintervall geprüft wird
+     * @param abschnitt      das Halbjahr
+     * @return die Liste der Fächer, die im Gültigkeitsintervall der Stundentafel gültig sind
+     */
+    fachGetMengeGueltigUndFehlendByStundentafel(stundentafel: UvStundentafel, abschnitt: number): List<UvFach>;
+    /**
+     * Prüft, ob das übergebene {@link UvFach}-Objekt einen Gültigkeitskonflikt mit einem anderen
+     * {@link UvFach}-Objekt derselben Fachart hat.
+     *
+     * @param fach   das zu prüfende Fach
+     * @return das andere Fach mit Gültigkeitskonflikt oder {@code null}, wenn kein Konflikt besteht
+     */
+    fachGetByGueltigkeitskonfliktMitFach(fach: UvFach): UvFach | null;
+    /**
+     * Prüft, ob das übergebene {@link UvFach}-Objekt einen Gültigkeitskonflikt mit einem anderen
+     * {@link UvFach}-Objekt derselben Fachart hat.
+     *
+     * @param fach   das zu prüfende Fach
+     * @param gueltigVon der neue Beginn des Gültigkeitsintervalls
+     * @param gueltigBis das neue Ende des Gültigkeitsintervalls
+     * @return das andere Fach mit Gültigkeitskonflikt oder {@code null}, wenn kein Konflikt besteht
+     */
+    fachGetByGueltigkeitskonfliktMitNeueGueltigkeit(fach: UvFach, gueltigVon: string, gueltigBis: string | null): UvFach | null;
+    /**
+     * Liefert eine Liste aller {@link UvRaumgruppe}-Objekte, die im Gültigkeitsintervall
+     * des übergebenen {@link UvRaum} gültig sind.
+     *
+     * @param raum   der {@link UvRaum}, dessen Gültigkeitsintervall geprüft wird
+     * @return die Liste der Raumgruppen, die im Gültigkeitsintervall des Raums gültig sind
+     */
+    raumgruppeGetMengeGueltigByRaum(raum: UvRaum): List<UvRaumgruppe>;
+    /**
+     * Liefert eine Liste aller {@link UvRaumgruppe}-Objekte, die im übergebenen Gültigkeitsintervall gültig sind.
+     *
+     * @param gueltigVon Beginn des Gültigkeitsintervalls
+     * @param gueltigBis Ende des Gültigkeitsintervalls
+     * @return die Liste der Raumgruppen, die im Gültigkeitsintervall des Raums gültig sind
+     */
+    raumgruppeGetMengeGueltigByZeitraum(gueltigVon: string, gueltigBis: string | null): List<UvRaumgruppe>;
+    /**
+     * Gibt eine Liste aller {@link UvFach}-Objekte zurück, die zu den gegebenen {@link FachDaten} gehören.
+     *
+     * @param fachdaten   Die {@link FachDaten} (Schulfach).
+     *
+     * @return Eine Liste der {@link UvFach}-Objekte zu den {@link FachDaten}.
+     */
+    fachGetMengeByFachdaten(fachdaten: FachDaten): List<UvFach>;
+    /**
+     * Liefert das zum Fach und Planungsabschnitt gehörige {@link UvFach}-Objekt oder {@code null}.
+     *
+     * @param idFach die ID des Schulfachs
+     * @param planungsabschnitt der Planungsabschnitt
+     * @return das passende {@link UvFach}-Objekt oder {@code null}
+     */
+    fachGetByIdFachAndPlanungsabschnittOrNull(idFach: number, planungsabschnitt: UvPlanungsabschnitt): UvFach | null;
+    /**
+     * Liefert eine Liste aller {@link UvZeitrasterEintrag}-Objekte für ein bestimmtes Zeitraster. <br>
+     * @param idZeitraster Die ID des Zeitrasters.
+     * @return eine Liste aller {@link UvZeitrasterEintrag}-Objekte für das Zeitraster.
+     */
+    zeitrasterEintragGetMengeByZeitraster(idZeitraster: number): List<UvZeitrasterEintrag>;
+    /**
+     * Liefert das zur ID zugehörige {@link UvPlanungsabschnittZeitraster}-Objekt. <br>
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @param idZeitraster Die ID des Zeitrasters.
+     * @return das zur ID zugehörige {@link UvPlanungsabschnittZeitraster}-Objekt.
+     */
+    planungsabschnittZeitrasterGetByIdOrException(idPlanungsabschnitt: number, idZeitraster: number): UvPlanungsabschnittZeitraster;
+    /**
+     * Liefert eine Liste aller {@link UvPlanungsabschnittZeitraster}-Objekte für einen bestimmten Planungsabschnitt. <br>
+     * @param idPlanungsabschnitt Die ID des Planungsabschnitts.
+     * @return eine Liste aller {@link UvPlanungsabschnittZeitraster}-Objekte für den Planungsabschnitt.
+     */
+    planungsabschnittZeitrasterGetMengeByPlanungsabschnitt(idPlanungsabschnitt: number): List<UvPlanungsabschnittZeitraster>;
+    /**
+     * Prüft, ob ein {@link UvZeitraster} einem {@link UvPlanungsabschnitt} zugeordnet ist.
+     * @param zeitraster das {@link UvZeitraster}
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @return {@code true}, wenn das Zeitraster dem Planungsabschnitt zugeordnet ist, sonst {@code false}.
+     */
+    zeitrasterIsInPlanungsabschnitt(zeitraster: UvZeitraster, planungsabschnitt: UvPlanungsabschnitt): boolean;
+    /**
+     * Liefert eine Liste aller {@link UvZeitraster}-Objekte, die einem Planungsabschnitt zugeordnet sind. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvZeitraster}-Objekte für den Planungsabschnitt.
+     */
+    zeitrasterGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvZeitraster>;
+    /**
+     * Liefert eine Liste aller {@link UvZeitraster}-Objekte, die im Gültigkeitsintervall des übergebenen
+     * {@link UvPlanungsabschnitt} gültig sind.
+     *
+     * @param planungsabschnitt   der {@link UvPlanungsabschnitt}, dessen Gültigkeitsintervall geprüft wird
+     * @return die Liste der {@link UvZeitraster}, die im Gültigkeitsintervall gültig sind
+     */
+    zeitrasterGetMengeGueltigByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvZeitraster>;
+    /**
+     * Liefert die zu einem {@link UvPlanungsabschnittZeitraster} gehörigen Jahrgänge.
+     * @param zeitraster das {@link UvPlanungsabschnittZeitraster}-Objekt
+     * @return die Liste der zugeordneten {@link JahrgangsDaten}
+     */
+    jahrgangsdatenGetMengeByPlanungsabschnittZeitraster(zeitraster: UvPlanungsabschnittZeitraster): List<JahrgangsDaten>;
+    /**
+     * Liefert das {@link UvPlanungsabschnittZeitraster}-Objekt für den übergebenen {@link UvPlanungsabschnitt} und das {@link UvZeitraster}.
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @param zeitraster das {@link UvZeitraster}
+     * @return das zugehörige {@link UvPlanungsabschnittZeitraster}-Objekt
+     */
+    planungsabschnittZeitrasterGetByPlanungsabschnittAndZeitraster(planungsabschnitt: UvPlanungsabschnitt, zeitraster: UvZeitraster): UvPlanungsabschnittZeitraster;
+    /**
+     * Liefert die zu einem {@link UvPlanungsabschnittZeitraster} gehörigen Jahrgänge.
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @param zeitraster das {@link UvZeitraster}
+     * @return die Liste der zugeordneten {@link JahrgangsDaten}
+     */
+    jahrgangsdatenGetMengeByPlanungsabschnittAndZeitraster(planungsabschnitt: UvPlanungsabschnitt, zeitraster: UvZeitraster): List<JahrgangsDaten>;
+    /**
+     * Liefert die Liste aller in Stundentafeln verwendeter {@link UvFach}-Objekte.
+     * @return die Liste aller in Stundentafeln verwendeter {@link UvFach}-Objekte.
+     */
+    fachGetMengeVerwendetInStundentafel(): List<UvFach>;
+    /**
+     * Liefert eine Liste aller {@link UvPlanungsabschnittSchueler}-Objekte für einen bestimmten Planungsabschnitt. <br>
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}.
+     * @return eine Liste aller {@link UvPlanungsabschnittSchueler}-Objekte für den Planungsabschnitt.
+     */
+    planungsabschnittSchuelerGetMengeByPlanungsabschnitt(planungsabschnitt: UvPlanungsabschnitt): List<UvPlanungsabschnittSchueler>;
+    /**
+     * Liefert zum Planungsabschnitt und der Nummer der Schiene das {@link UvSchiene}-Objekt, falls es existiert, sonst {@code null}.
+     * @param planungsabschnitt der {@link UvPlanungsabschnitt}
+     * @param nummer die Nummer der Schiene
+     * @return die Schiene, falls sie existiert
+     */
+    schieneGetByPlanungsabschnittAndNummer(planungsabschnitt: UvPlanungsabschnitt, nummer: number): UvSchiene | null;
+    /**
+     * Liefert alle Schüler einer Gruppe
+     * @param gruppe die {@link UvSchuelergruppe}
+     * @return die Liste von {@link UvPlanungsabschnittSchueler}-Objekten
+     */
+    planungsabschnittSchuelerGetMengeBySchuelergruppe(gruppe: UvSchuelergruppe): List<UvPlanungsabschnittSchueler>;
+    /**
+     * Liefert alle Schüler einer {@link UvKlasse}
+     * @param klasse die {@link UvKlasse}
+     * @return die Liste von {@link UvPlanungsabschnittSchueler}-Objekten
+     */
+    planungsabschnittSchuelerGetMengeByKlasse(klasse: UvKlasse): List<UvPlanungsabschnittSchueler>;
+    /**
+     * Gibt zurück, ob der Schülerjahrgang in die Schülergruppe passt.
+     * @param schueler der zu prüfende {@link UvSchuelergruppeSchueler}
+     * @return {@code true}, falls der Jahrgang in der Gruppe zugelassen ist, sonst {@code false}
+     */
+    schuelergruppeSchuelerHatZurGruppePassendenJahrgang(schueler: UvSchuelergruppeSchueler): boolean;
+    /**
+     * Gibt zurück, ob die {@link UvSchuelergruppe} Schüler mit falscher Jahrgangszugehörigkeit beinhaltet
+     * @param gruppe die zu prüfende {@link UvSchuelergruppe}
+     * @return {@code true}, falls es widersprüchliche Daten gibt, sonst {@code false}
+     */
+    schuelergruppeHatSchuelerMitFalschemJahrgang(gruppe: UvSchuelergruppe): boolean;
+    /**
+     * Gibt zurück, ob der Schülerjahrgang in die Schülergruppe passt.
+     * @param schueler der zu prüfende {@link UvPlanungsabschnittSchueler}
+     * @param gruppe die zu prüfende {@link UvSchuelergruppe}
+     * @return {@code true}, falls der Jahrgang in der Gruppe zugelassen ist, sonst {@code false}
+     */
+    planungsabschnittSchuelerHatZurGruppePassendenJahrgang(schueler: UvPlanungsabschnittSchueler, gruppe: UvSchuelergruppe): boolean;
+    /**
+     * Liefert die {@link UvSchuelergruppe} zu einer {@link UvKlasse}
+     * @param klasse die {@link UvKlasse}, zu der die {@link UvSchuelergruppe} gesucht wird
+     * @return die {@link UvSchuelergruppe}
+     */
+    schuelergruppeGetByKlasse(klasse: UvKlasse): UvSchuelergruppe;
+    /**
+     * Liefert die {@link UvSchuelergruppe} zu einem {@link UvKurs}
+     * @param kurs der {@link UvKurs}, zu dem die {@link UvSchuelergruppe} gesucht wird
+     * @return die {@link UvSchuelergruppe}
+     */
+    schuelergruppeGetByKurs(kurs: UvKurs): UvSchuelergruppe;
+    /**
+     * Prüft für die übergebene Menge, welche {@link UvKlasse}n referenziert werden und gibt diese als Menge zurück.
+     * @param klassen die zu prüfende Menge
+     * @return die Menge der verwendeten {@link UvKlasse}n
+     */
+    klasseGetMengeVerwendetByKlasseMenge(klassen: Collection<UvKlasse>): JavaSet<UvKlasse>;
+    /**
+     * Prüft für die übergebene Menge, welche {@link UvSchiene}n referenziert werden und gibt diese als Menge zurück.
+     * @param schienen die zu prüfende Menge
+     * @return die Menge der verwendeten {@link UvSchiene}n
+     */
+    schieneGetMengeVerwendetBySchieneMenge(schienen: Collection<UvSchiene>): JavaSet<UvSchiene>;
+    /**
+     * Prüft für die übergebene Menge, welche {@link UvSchuelergruppe}n referenziert werden und gibt diese als Menge zurück.
+     * @param schuelergruppen die zu prüfende Menge
+     * @return die Menge der verwendeten {@link UvSchuelergruppe}n
+     */
+    schuelergruppeGetMengeVerwendetBySchuelergruppeMenge(schuelergruppen: Collection<UvSchuelergruppe>): JavaSet<UvSchuelergruppe>;
+    /**
+     * Gibt die Menge der {@link UvLerngruppenSchiene}n zur übergebenen {@link UvSchiene} zurück.
+     * @param schiene die {@link UvSchiene}, zu der die {@link UvLerngruppe}n gesucht werden
+     * @return die Menge der zugeordneten {@link UvLerngruppenSchiene}-Objekte
+     */
+    lerngruppenSchieneGetMengeBySchiene(schiene: UvSchiene): List<UvLerngruppenSchiene>;
+    /**
+     * Liefert das zur {@link UvLerngruppenSchiene} zugehörige {@link UvLerngruppe}-Objekt. <br>
+     * @param schiene die {@link UvLerngruppenSchiene}, zu der die {@link UvLerngruppe} gesucht wird.
+     * @return das zugehörige {@link UvLerngruppe}-Objekt.
+     */
+    lerngruppeGetByLerngruppenSchiene(schiene: UvLerngruppenSchiene): UvLerngruppe;
+    /**
+     * Liefert die Fachdaten zum übergebenen Kurs
+     * @param kurs der {@link UvKurs}
+     * @return die {@link FachDaten}
+     */
+    fachdatenGetByKurs(kurs: UvKurs): FachDaten;
+    /**
+     * Liefert das Fach zum übergebenen Kurs
+     * @param kurs der {@link UvKurs}
+     * @return das {@link UvFach}
+     */
+    fachGetByKurs(kurs: UvKurs): UvFach;
+    /**
+     * Liefert den Kurs zur Lerngruppe oder {@code null}, falls es sich um Klassenunterricht handelt
+     * @param lerngruppe die {@link UvLerngruppe}
+     * @return der zugeordnete {@link UvKurs} oder {@code null}, falls es sich um Klassenunterricht handelt
+     */
+    kursGetByLerngruppe(lerngruppe: UvLerngruppe): UvKurs | null;
+    /**
+     * Liefert die Klasse zur Lerngruppe oder {@code null}, falls es sich um Kursunterricht handelt
+     * @param lerngruppe die {@link UvLerngruppe}
+     * @return die zugeordnete {@link UvKlasse} oder {@code null}, falls es sich um Kursunterricht handelt
+     */
+    klasseGetByLerngruppe(lerngruppe: UvLerngruppe): UvKlasse | null;
+    /**
+     * Liefert alle {@link UvKlasse}-Objekte zur {@link UvLerngruppe}.
+     * Bei Klassenunterricht enthält die Liste genau die zugeordnete Klasse.
+     * Bei Kursunterricht enthält die Liste alle Klassen der zugehörigen Schülergruppe.
+     *
+     * @param lerngruppe die {@link UvLerngruppe}
+     * @return die zugeordneten {@link UvKlasse}-Objekte
+     */
+    klasseGetMengeByLerngruppe(lerngruppe: UvLerngruppe): List<UvKlasse>;
+    /**
+     * Liefert alle {@link JahrgangsDaten} zur {@link UvLerngruppe}.
+     * In der Regel enthält die Liste genau einen Jahrgang.
+     *
+     * @param lerngruppe die {@link UvLerngruppe}
+     * @return die zugeordneten {@link JahrgangsDaten}
+     */
+    jahrgangsdatenGetMengeByLerngruppe(lerngruppe: UvLerngruppe): List<JahrgangsDaten>;
+    /**
+     * Liefert die tatsächlich vertretenen Jahrgänge der Schüler einer Schülergruppe ohne Duplikate.
+     * Die Liste ist nach Jahrgangssortierung und bei gleicher Sortierung nach ID sortiert.
+     * Erlaubte Jahrgänge ohne zugeordnete Schüler werden nicht berücksichtigt.
+     *
+     * @param schuelergruppe die auszuwertende Schülergruppe
+     * @return die sortierten Jahrgangsdaten der zugeordneten Schüler; bei leerer Gruppe eine leere Liste
+     */
+    jahrgangsdatenGetMengeBySchuelergruppe(schuelergruppe: UvSchuelergruppe): List<JahrgangsDaten>;
+    /**
+     * Liefert die {@link UvSchuelergruppe} zur übergebenen {@link UvLerngruppe}.
+     * Bei Klassenunterricht wird die Schülergruppe über die Klasse ermittelt,
+     * bei Kursunterricht direkt über den {@link UvKurs}.
+     *
+     * @param lerngruppe die {@link UvLerngruppe}
+     * @return die zugehörige {@link UvSchuelergruppe} oder {@code null}, falls weder eine Klasse noch ein Kurs zugeordnet ist
+     */
+    schuelergruppeGetByLerngruppe(lerngruppe: UvLerngruppe): UvSchuelergruppe | null;
+    /**
+     * Liefert das {@link UvFach} zur {@link UvLerngruppe} oder {@code null}, falls kein Fach zugeordnet ist.
+     * Bei Kursunterricht wird das Fach aus dem zugeordneten {@link UvKurs} ermittelt,
+     * bei Klassenunterricht direkt aus der {@link UvLerngruppe}.
+     *
+     * @param lerngruppe die {@link UvLerngruppe}
+     * @return das zugeordnete {@link UvFach} oder {@code null}
+     */
+    fachGetByLerngruppe(lerngruppe: UvLerngruppe): UvFach | null;
+    /**
+     * Liefert zu einer {@link UvSchuelergruppe} alle zugeordneten {@link UvLerngruppe}n
+     * @param schuelergruppe die {@link UvSchuelergruppe}
+     * @return die zugeordneten {@link UvLerngruppe}n
+     */
+    lerngruppeGetMengeBySchuelergruppe(schuelergruppe: UvSchuelergruppe): List<UvLerngruppe>;
+    /**
+     * Liefert das {@link UvLehrer}-Objekt zu einem {@link UvLerngruppenLehrer}.
+     * @param lehrer der {@link UvLerngruppenLehrer}
+     * @return der {@link UvLehrer}
+     */
+    lehrerGetByLerngruppenLehrer(lehrer: UvLerngruppenLehrer): UvLehrer;
+    /**
+     * Liefert das {@link UvLehrer}-Objekt zu einem {@link UvKlassenLehrer}.
+     * @param klassenLehrer der {@link UvKlassenLehrer}
+     * @return der {@link UvLehrer}
+     */
+    lehrerGetByKlassenLehrer(klassenLehrer: UvKlassenLehrer): UvLehrer;
+    /**
+     * Liefert einen {@link UvLehrer} basierend auf dem angegebenen {@link UvLehrerPflichtstundensoll}.
+     *
+     * @param pflichtstundensoll das {@link UvLehrerPflichtstundensoll}, das die Pflichtstunden und die Lehrer-ID enthält
+     * @return der {@link UvLehrer}, der der angegebenen Lehrer-ID im {@link UvLehrerPflichtstundensoll} entspricht
+     */
+    lehrerGetByLehrerPflichtstundensoll(pflichtstundensoll: UvLehrerPflichtstundensoll): UvLehrer;
+    /**
+     * Ruft einen Lehrer basierend auf den Anrechnungsstunden ab.
+     *
+     * @param anrechnungsstunden die {@link UvLehrerAnrechnungsstunden}, die die relevanten Informationen enthalten,
+     *                           um den Lehrer zu identifizieren.
+     * @return der {@link UvLehrer}, der den angegebenen Anrechnungsstunden zugeordnet ist.
+     */
+    lehrerGetByLehrerAnrechnungsstunden(anrechnungsstunden: UvLehrerAnrechnungsstunden): UvLehrer;
+    /**
+     * Liefert das {@link UvSchiene}-Objekt zu einer {@link UvLerngruppenSchiene}.
+     * @param schiene die {@link UvLerngruppenSchiene}
+     * @return die {@link UvSchiene}
+     */
+    schieneGetByLerngruppenSchiene(schiene: UvLerngruppenSchiene): UvSchiene;
+    /**
+     * Prüft, ob der {@link UvLehrer} eine Lehrbefähigung für das angegebene {@link UvFach} besitzt.
+     *
+     * TODO: Die Prüfung berücksichtigt bislang nur den Fach-Eintrag. Die Erweiterung um Sekundarstufe
+     * und Gültigkeitszeitraum sowie den dafür benötigten Kontext noch fachlich festlegen.
+     *
+     * @param lehrer der {@link UvLehrer}
+     * @param fach   das {@link UvFach}
+     * @return {@code true}, falls der Lehrer eine Lehrbefähigung für das UV-Fach besitzt, sonst {@code false}
+     */
+    lehrerHatLehrbefaehigungFach(lehrer: UvLehrer, fach: UvFach): boolean;
+    /**
+     * Prüft, ob der {@link UvLehrer} eine Lehrbefähigung für das Fach der angegebenen {@link UvLerngruppe} besitzt.
+     * Bei Klassenunterricht wird das Fach direkt aus der {@link UvLerngruppe} ermittelt,
+     * bei Kursunterricht aus dem zugeordneten {@link UvKurs}.
+     *
+     * TODO: Die Prüfung um Sekundarstufe und Gültigkeitszeitraum anhand der Jahrgänge und des
+     * Planungsabschnitts der Lerngruppe erweitern. Zuvor die zeitliche Gültigkeitsregel und den Umgang
+     * mit gemischten oder unbekannten Jahrgangsstufen sowie fehlenden Berechtigungsangaben festlegen.
+     *
+     * @param lehrer     der {@link UvLehrer}
+     * @param lerngruppe die {@link UvLerngruppe}
+     * @return {@code true}, falls der Lehrer eine Lehrbefähigung für das Fach der Lerngruppe besitzt, sonst {@code false}
+     */
+    lehrerHatLehrbefaehigungLerngruppe(lehrer: UvLehrer, lerngruppe: UvLerngruppe): boolean;
+    /**
+     * Prüft, ob der {@link UvPlanungsabschnittLehrer} eine Lehrbefähigung für das angegebene {@link UvFach} besitzt.
+     *
+     * @param planungsabschnittLehrer der {@link UvPlanungsabschnittLehrer}
+     * @param fach                    das {@link UvFach}
+     * @return {@code true}, falls der Lehrer eine Lehrbefähigung für das Fach besitzt, sonst {@code false}
+     */
+    planungsabschnittLehrerHatLehrbefaehigungFach(planungsabschnittLehrer: UvPlanungsabschnittLehrer, fach: UvFach): boolean;
+    /**
+     * Prüft, ob der {@link UvPlanungsabschnittLehrer} eine Lehrbefähigung für das Fach der angegebenen {@link UvLerngruppe} besitzt.
+     *
+     * @param planungsabschnittLehrer der {@link UvPlanungsabschnittLehrer}
+     * @param lerngruppe              die {@link UvLerngruppe}
+     * @return {@code true}, falls der Lehrer eine Lehrbefähigung für das Fach der Lerngruppe besitzt, sonst {@code false}
+     */
+    planungsabschnittLehrerHatLehrbefaehigungLerngruppe(planungsabschnittLehrer: UvPlanungsabschnittLehrer, lerngruppe: UvLerngruppe): boolean;
+    /**
+     * Liefert das {@link UvLehrerPflichtstundensoll}, das am Beginn des {@link UvPlanungsabschnitt}s gültig ist,
+     * oder {@code null}, falls kein passendes Pflichtstundensoll existiert.
+     *
+     * @param lehrer             der {@link UvLehrer}
+     * @param planungsabschnitt  der {@link UvPlanungsabschnitt}
+     * @return das am Beginn des Planungsabschnitts gültige {@link UvLehrerPflichtstundensoll} oder {@code null}
+     */
+    lehrerPflichtstundensollGetByLehrerAndPlanungsabschnitt(lehrer: UvLehrer, planungsabschnitt: UvPlanungsabschnitt): UvLehrerPflichtstundensoll | null;
+    /**
+     * Liefert das {@link UvLehrerPflichtstundensoll}, das am Beginn des Planungsabschnitts des
+     * {@link UvPlanungsabschnittLehrer} gültig ist, oder {@code null}, falls kein passendes Pflichtstundensoll existiert.
+     *
+     * @param planungsabschnittLehrer der {@link UvPlanungsabschnittLehrer}
+     * @return das am Beginn des Planungsabschnitts gültige {@link UvLehrerPflichtstundensoll} oder {@code null}
+     */
+    lehrerPflichtstundensollGetByPlanungsabschnittLehrer(planungsabschnittLehrer: UvPlanungsabschnittLehrer): UvLehrerPflichtstundensoll | null;
+    /**
+     * Liefert den Pflichtstundensoll-Wert des {@link UvLehrer}s am Beginn des {@link UvPlanungsabschnitt}s,
+     * oder {@code null}, falls kein passendes Pflichtstundensoll existiert.
+     *
+     * @param lehrer             der {@link UvLehrer}
+     * @param planungsabschnitt  der {@link UvPlanungsabschnitt}
+     * @return der Pflichtstundensoll-Wert oder {@code null}
+     */
+    lehrerPflichtstundensollGetDoubleByLehrerAndPlanungsabschnitt(lehrer: UvLehrer, planungsabschnitt: UvPlanungsabschnitt): number | null;
+    /**
+     * Liefert den Pflichtstundensoll-Wert des {@link UvPlanungsabschnittLehrer}s am Beginn seines Planungsabschnitts,
+     * oder {@code null}, falls kein passendes Pflichtstundensoll existiert.
+     *
+     * @param planungsabschnittLehrer der {@link UvPlanungsabschnittLehrer}
+     * @return der Pflichtstundensoll-Wert oder {@code null}
+     */
+    lehrerPflichtstundensollGetDoubleByPlanungsabschnittLehrer(planungsabschnittLehrer: UvPlanungsabschnittLehrer): number | null;
+    /**
+     * Liefert die Liste der {@link UvLehrerAnrechnungsstunden}, die am Beginn des {@link UvPlanungsabschnitt}s gültig sind.
+     *
+     * @param lehrer             der {@link UvLehrer}
+     * @param planungsabschnitt  der {@link UvPlanungsabschnitt}
+     * @return die Liste der am Beginn des Planungsabschnitts gültigen {@link UvLehrerAnrechnungsstunden}
+     */
+    lehrerAnrechnungsstundenGetMengeByLehrerAndPlanungsabschnitt(lehrer: UvLehrer, planungsabschnitt: UvPlanungsabschnitt): List<UvLehrerAnrechnungsstunden>;
+    /**
+     * Liefert die Liste der {@link UvLehrerAnrechnungsstunden}, die am Beginn des Planungsabschnitts des
+     * {@link UvPlanungsabschnittLehrer} gültig sind.
+     *
+     * @param planungsabschnittLehrer der {@link UvPlanungsabschnittLehrer}
+     * @return die Liste der am Beginn des Planungsabschnitts gültigen {@link UvLehrerAnrechnungsstunden}
+     */
+    lehrerAnrechnungsstundenGetMengeByPlanungsabschnittLehrer(planungsabschnittLehrer: UvPlanungsabschnittLehrer): List<UvLehrerAnrechnungsstunden>;
+    /**
+     * Liefert die Summe der Anrechnungsstunden des {@link UvLehrer}s, die am Beginn des {@link UvPlanungsabschnitt}s gültig sind.
+     *
+     * @param lehrer             der {@link UvLehrer}
+     * @param planungsabschnitt  der {@link UvPlanungsabschnitt}
+     * @return die Summe der Anrechnungsstunden
+     */
+    lehrerAnrechnungsstundenGetDoubleByLehrerAndPlanungsabschnitt(lehrer: UvLehrer, planungsabschnitt: UvPlanungsabschnitt): number;
+    /**
+     * Liefert die Summe der Anrechnungsstunden des {@link UvPlanungsabschnittLehrer}s, die am Beginn seines Planungsabschnitts gültig sind.
+     *
+     * @param planungsabschnittLehrer der {@link UvPlanungsabschnittLehrer}
+     * @return die Summe der Anrechnungsstunden
+     */
+    lehrerAnrechnungsstundenGetDoubleByPlanungsabschnittLehrer(planungsabschnittLehrer: UvPlanungsabschnittLehrer): number;
+    /**
+     * Liefert alle {@link LehrerUnterrichtsfach}-Einträge zum übergebenen {@link UvFach}.
+     *
+     * @param fach das {@link UvFach}
+     * @return die zugeordneten {@link LehrerUnterrichtsfach}-Einträge
+     */
+    lehrerUnterrichtsfachGetMengeByFach(fach: UvFach): List<LehrerUnterrichtsfach>;
+    /**
+     * Liefert den {@link UvLehrer} zur übergebenen K-Lehrer-ID.
+     *
+     * @param idKLehrer die K-Lehrer-ID des gesuchten {@link UvLehrer}s
+     * @return den zugehörigen {@link UvLehrer}
+     * @throws DeveloperNotificationException falls kein {@link UvLehrer} mit dieser K-Lehrer-ID vorhanden ist
+     */
+    lehrerGetByKLehrerIdOrException(idKLehrer: number): UvLehrer;
+    /**
+     * Liefert den {@link UvLehrer} zur übergebenen K-Lehrer-ID oder {@code null}.
+     *
+     * @param idKLehrer die K-Lehrer-ID des gesuchten {@link UvLehrer}s
+     * @return den zugehörigen {@link UvLehrer} oder {@code null}
+     */
+    lehrerGetByKLehrerIdOrNull(idKLehrer: number): UvLehrer | null;
+    /**
+     * Liefert den {@link UvLehrer} zu einem {@link LehrerUnterrichtsfach}.
+     *
+     * @param unterrichtsfach das {@link LehrerUnterrichtsfach}
+     * @return den zugehörigen {@link UvLehrer}
+     */
+    lehrerGetByLehrerUnterrichtsfachOrException(unterrichtsfach: LehrerUnterrichtsfach): UvLehrer;
+    /**
+     * Liefert den Wert des größten Wochentages.
+     *
+     * @return den Wert des größten Wochentages.
+     */
+    zeitrasterGetMaxWochentag(): number;
+    /**
+     * Liefert den Wert des größtmöglichen letzten Stunde.
+     *
+     * @return den Wert des größtmöglichen letzten Stunde.
+     */
+    zeitrasterGetMaxStunde(): number;
+    /**
+     * Liefert den Wert des größtmöglichen Wochentyps oder 0, falls jede Woche gleich ist.
+     * <br>Hinweis: 0 = Jede Woche gleich, 1 = ungültiger Wert, 2 = A-B-Wochen, 3 = A-B-C-Wochen, ...
+     *
+     * @return den Wert des größtmöglichen Wochentyps oder 0, falls jede Woche gleich ist.
+     */
+    zeitrasterGetWochentypmodell(): number;
+    transpilerCanonicalName(): string;
+    isTranspiledInstanceOf(name: string): boolean;
+    static readonly class: Class<UvManager>;
+}
+export declare function cast_de_svws_nrw_core_utils_uv_UvManager(obj: unknown): UvManager;
+//# sourceMappingURL=UvManager.d.ts.map