import { BaseApi } from '../api/BaseApi';
import { Abiturdaten } from '../core/data/gost/Abiturdaten';
import { BenutzerListeEintrag } from '../core/data/benutzer/BenutzerListeEintrag';
import { BetriebListeEintrag } from '../core/data/betrieb/BetriebListeEintrag';
import { BetriebStammdaten } from '../core/data/betrieb/BetriebStammdaten';
import { DBSchemaListeEintrag } from '../core/data/db/DBSchemaListeEintrag';
import { ENMDaten } from '../core/data/enm/ENMDaten';
import { Erzieherart } from '../core/data/erzieher/Erzieherart';
import { ErzieherListeEintrag } from '../core/data/erzieher/ErzieherListeEintrag';
import { ErzieherStammdaten } from '../core/data/erzieher/ErzieherStammdaten';
import { FachDaten } from '../core/data/fach/FachDaten';
import { FaecherListeEintrag } from '../core/data/fach/FaecherListeEintrag';
import { GEAbschlussFaecher } from '../core/data/abschluss/GEAbschlussFaecher';
import { GostBelegpruefungErgebnis } from '../core/abschluss/gost/GostBelegpruefungErgebnis';
import { GostBlockungKurs } from '../core/data/gost/GostBlockungKurs';
import { GostBlockungListeneintrag } from '../core/data/gost/GostBlockungListeneintrag';
import { GostBlockungRegel } from '../core/data/gost/GostBlockungRegel';
import { GostBlockungSchiene } from '../core/data/gost/GostBlockungSchiene';
import { GostBlockungsdaten } from '../core/data/gost/GostBlockungsdaten';
import { GostFach } from '../core/data/gost/GostFach';
import { GostJahrgang } from '../core/data/gost/GostJahrgang';
import { GostJahrgangsdaten } from '../core/data/gost/GostJahrgangsdaten';
import { GostLeistungen } from '../core/data/gost/GostLeistungen';
import { GostSchuelerFachwahl } from '../core/data/gost/GostSchuelerFachwahl';
import { GostStatistikFachwahl } from '../core/data/gost/GostStatistikFachwahl';
import { JahrgangsDaten } from '../core/data/jahrgang/JahrgangsDaten';
import { JahrgangsListeEintrag } from '../core/data/jahrgang/JahrgangsListeEintrag';
import { KatalogEintrag } from '../core/data/kataloge/KatalogEintrag';
import { KatalogEintragStrassen } from '../core/data/kataloge/KatalogEintragStrassen';
import { KlassenDaten } from '../core/data/klassen/KlassenDaten';
import { KlassenListeEintrag } from '../core/data/klassen/KlassenListeEintrag';
import { KursDaten } from '../core/data/kurse/KursDaten';
import { KursListeEintrag } from '../core/data/kurse/KursListeEintrag';
import { LehrerKatalogAbgangsgrundEintrag } from '../core/data/lehrer/LehrerKatalogAbgangsgrundEintrag';
import { LehrerKatalogAnrechnungsgrundEintrag } from '../core/data/lehrer/LehrerKatalogAnrechnungsgrundEintrag';
import { LehrerKatalogBeschaeftigungsartEintrag } from '../core/data/lehrer/LehrerKatalogBeschaeftigungsartEintrag';
import { LehrerKatalogEinsatzstatusEintrag } from '../core/data/lehrer/LehrerKatalogEinsatzstatusEintrag';
import { LehrerKatalogFachrichtungAnerkennungEintrag } from '../core/data/lehrer/LehrerKatalogFachrichtungAnerkennungEintrag';
import { LehrerKatalogFachrichtungEintrag } from '../core/data/lehrer/LehrerKatalogFachrichtungEintrag';
import { LehrerKatalogLehramtAnerkennungEintrag } from '../core/data/lehrer/LehrerKatalogLehramtAnerkennungEintrag';
import { LehrerKatalogLehramtEintrag } from '../core/data/lehrer/LehrerKatalogLehramtEintrag';
import { LehrerKatalogLehrbefaehigungAnerkennungEintrag } from '../core/data/lehrer/LehrerKatalogLehrbefaehigungAnerkennungEintrag';
import { LehrerKatalogLehrbefaehigungEintrag } from '../core/data/lehrer/LehrerKatalogLehrbefaehigungEintrag';
import { LehrerKatalogLeitungsfunktionEintrag } from '../core/data/lehrer/LehrerKatalogLeitungsfunktionEintrag';
import { LehrerKatalogMehrleistungsartEintrag } from '../core/data/lehrer/LehrerKatalogMehrleistungsartEintrag';
import { LehrerKatalogMinderleistungsartEintrag } from '../core/data/lehrer/LehrerKatalogMinderleistungsartEintrag';
import { LehrerKatalogRechtsverhaeltnisEintrag } from '../core/data/lehrer/LehrerKatalogRechtsverhaeltnisEintrag';
import { LehrerKatalogZugangsgrundEintrag } from '../core/data/lehrer/LehrerKatalogZugangsgrundEintrag';
import { LehrerListeEintrag } from '../core/data/lehrer/LehrerListeEintrag';
import { LehrerPersonaldaten } from '../core/data/lehrer/LehrerPersonaldaten';
import { LehrerStammdaten } from '../core/data/lehrer/LehrerStammdaten';
import { List } from '../java/util/List';
import { NationalitaetKatalogEintrag } from '../core/data/kataloge/NationalitaetKatalogEintrag';
import { OrtKatalogEintrag } from '../core/data/kataloge/OrtKatalogEintrag';
import { OrtsteilKatalogEintrag } from '../core/data/kataloge/OrtsteilKatalogEintrag';
import { ReligionKatalogEintrag } from '../core/data/kataloge/ReligionKatalogEintrag';
import { SchuelerBetriebsdaten } from '../core/data/schueler/SchuelerBetriebsdaten';
import { SchuelerLernabschnittListeEintrag } from '../core/data/schueler/SchuelerLernabschnittListeEintrag';
import { SchuelerLernabschnittsdaten } from '../core/data/schueler/SchuelerLernabschnittsdaten';
import { SchuelerListeEintrag } from '../core/data/schueler/SchuelerListeEintrag';
import { SchuelerSchulbesuchsdaten } from '../core/data/schueler/SchuelerSchulbesuchsdaten';
import { SchuelerStammdaten } from '../core/data/schueler/SchuelerStammdaten';
import { SchuleStammdaten } from '../core/data/schule/SchuleStammdaten';
export declare class ApiServer extends BaseApi {
    /**
     *
     * Erstellt eine neue API mit der übergebenen Konfiguration.
     *
     * @param {string} url - die URL des Servers: Alle Pfadangaben sind relativ zu dieser URL
     * @param {string} username - der Benutzername für den API-Zugriff
     * @param {string} password - das Kennwort des Benutzers für den API-Zugriff
     */
    constructor(url: string, username: string, password: string);
    /**
     * Implementierung der GET-Methode getConfigCertificate für den Zugriff auf die URL https://{hostname}/config/certificate
     *
     * Gibt das Zertifikat des Server zurück.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Das Zertifikat des Servers
     *     - Mime-Type: text/plain
     *     - Rückgabe-Typ: String
     *   Code 500: Das Zertifikat wurde nicht gefunden
     *
     * @returns Das Zertifikat des Servers
     */
    getConfigCertificate(): Promise<String>;
    /**
     * Implementierung der GET-Methode getConfigCertificateBase64 für den Zugriff auf die URL https://{hostname}/config/certificate_base64
     *
     * Gibt das Zertifikat des Server in Base64-Kodierung zurück.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Das Base-64-kodierte Zertifikat des Servers
     *     - Mime-Type: text/plain
     *     - Rückgabe-Typ: String
     *   Code 500: Das Zertifikat wurde nicht gefunden
     *
     * @returns Das Base-64-kodierte Zertifikat des Servers
     */
    getConfigCertificateBase64(): Promise<String>;
    /**
     * Implementierung der GET-Methode getConfigDBSchemata für den Zugriff auf die URL https://{hostname}/config/db/schemata
     *
     * Gibt eine sortierte Übersicht von allen konfigurierten DB-Schemata zurück.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von DB-Schema-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<DBSchemaListeEintrag>
     *
     * @returns Eine Liste von DB-Schema-Listen-Einträgen
     */
    getConfigDBSchemata(): Promise<List<DBSchemaListeEintrag>>;
    /**
     * Implementierung der GET-Methode getConfigPublicKeyBase64 für den Zugriff auf die URL https://{hostname}/config/publickey_base64
     *
     * Gibt den öffentlichen Schlüssel des Server in Base64-Kodierung zurück.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Base-64-kodierte, öffentliche Schlüssel des Servers
     *     - Mime-Type: text/plain
     *     - Rückgabe-Typ: String
     *   Code 500: Der öffentliche Schlüssel wurde nicht gefunden
     *
     * @returns Der Base-64-kodierte, öffentliche Schlüssel des Servers
     */
    getConfigPublicKeyBase64(): Promise<String>;
    /**
     * Implementierung der GET-Methode getBenutzerliste für den Zugriff auf die URL https://{hostname}/db/{schema}/benutzer/
     *
     * Erstellt eine Liste aller Benutzer unter Angabe.Es wird geprüft, ob der SVWS-Benutzer die notwendige Administrator-Berechtigung besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Benutzer-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<BenutzerListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerdaten anzusehen.
     *   Code 404: Keine Schüler-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Benutzer-Einträgen
     */
    getBenutzerliste(schema: string): Promise<List<BenutzerListeEintrag>>;
    /**
     * Implementierung der GET-Methode getBetriebe für den Zugriff auf die URL https://{hostname}/db/{schema}/betriebe/
     *
     * Erstellt eine Liste aller in der Datenbank vorhandenen Betriebe unter Angabe der ID, der Betriebsart , des Betriebnamens, Kontaktdaten, ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Betriebsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Betrieb-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<BetriebListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Betriebdaten anzusehen.
     *   Code 404: Keine Betrieb-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Betrieb-Listen-Einträgen
     */
    getBetriebe(schema: string): Promise<List<BetriebListeEintrag>>;
    /**
     * Implementierung der PATCH-Methode patchSchuelerBetriebsdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/betriebe/{id : \d+}/betrieb
     *
     * Passt die Schüler-Betriebsdaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern von Schülerbetreibsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Schüler-Betriebsdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerdaten zu ändern.
     *   Code 404: Kein Schülerbetrieb-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {SchuelerBetriebsdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchSchuelerBetriebsdaten(data: Partial<SchuelerBetriebsdaten>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getSchuelerBetriebsdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/betriebe/{id : \d+}/betrieb
     *
     * Liest die Daten des Schülerbetriebs zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen vom Schülerbetriebbesitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Stammdaten des Schülerbetriebs.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<SchuelerBetriebsdaten>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerbetreibe anzusehen.
     *   Code 404: Kein Schülerbetrieb gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Stammdaten des Schülerbetriebs.
     */
    getSchuelerBetriebsdaten(schema: string, id: number): Promise<List<SchuelerBetriebsdaten>>;
    /**
     * Implementierung der GET-Methode getBetriebStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/betriebe/{id : \d+}/stammdaten
     *
     * Liest die Stammdaten des Betriebs zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Stammdaten eines Betriebs
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: BetriebStammdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Betriebsdaten anzusehen.
     *   Code 404: Kein Betrieb-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Stammdaten eines Betriebs
     */
    getBetriebStammdaten(schema: string, id: number): Promise<BetriebStammdaten>;
    /**
     * Implementierung der PATCH-Methode patchBetriebStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/betriebe/{id : \d+}/stammdaten
     *
     * Passt die Betrieb-Stammdaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern von Erzieherdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Betrieb-Stammdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Betriebdaten zu ändern.
     *   Code 404: Kein Betrieb-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {BetriebStammdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchBetriebStammdaten(data: Partial<BetriebStammdaten>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der PUT-Methode setClientConfigGlobalKey für den Zugriff auf die URL https://{hostname}/db/{schema}/client/config/{app}/global/{key}
     *
     * Schreibt den Konfigurationseintrag der angegebenen Anwendung für den angebenen Schlüsselwert in die globale Konfiguration. Dabei wird geprüft, ob der angemeldete Benutzer administrative Rechte hat.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Konfigurationseintrag wurde erfolgreich geschrieben
     *
     * @param {String} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {string} app - der Pfad-Parameter app
     * @param {string} key - der Pfad-Parameter key
     */
    setClientConfigGlobalKey(data: String, schema: string, app: string, key: string): Promise<void>;
    /**
     * Implementierung der GET-Methode getClientConfigUserKey für den Zugriff auf die URL https://{hostname}/db/{schema}/client/config/{app}/user/{key}
     *
     * Liest den Schlüsselwert aus der Konfiguration für den Client aus. Ist sowohl ein globaler als auch eine benutzerspezifischer Konfigurationseintrag unter den Name vorhanden,so wird der benutzerspezifische Eintrag zurückgegeben. Die benutzerspezifische Konfiguration kann somit globale Einstellungen 'überschreiben'. Ist kein Wert vorhanden, so wird ein leerer String zurückgegeben.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Wert des Konfigurationseintrags
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: String
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {string} app - der Pfad-Parameter app
     * @param {string} key - der Pfad-Parameter key
     *
     * @returns Der Wert des Konfigurationseintrags
     */
    getClientConfigUserKey(schema: string, app: string, key: string): Promise<String>;
    /**
     * Implementierung der PUT-Methode setClientConfigUserKey für den Zugriff auf die URL https://{hostname}/db/{schema}/client/config/{app}/user/{key}
     *
     * Schreibt den Konfigurationseintrag der angegebenen Anwendung für den angebenen Schlüsselwert in die benutzerspezifische Konfiguration.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Konfigurationseintrag wurde erfolgreich geschrieben
     *
     * @param {String} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {string} app - der Pfad-Parameter app
     * @param {string} key - der Pfad-Parameter key
     */
    setClientConfigUserKey(data: String, schema: string, app: string, key: string): Promise<void>;
    /**
     * Implementierung der GET-Methode getLehrerENMDaten für den Zugriff auf die URL https://{hostname}/db/{schema}/enm/lehrer/{id : \d+}
     *
     * Liest die Daten des Externen Notenmoduls (ENM) des Lehrers zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Auslesen der Notendaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Daten des Externen Notenmoduls (ENM) des Lehrers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: ENMDaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Daten des ENM auszulesen.
     *   Code 404: Kein Lehrer-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Daten des Externen Notenmoduls (ENM) des Lehrers
     */
    getLehrerENMDaten(schema: string, id: number): Promise<ENMDaten>;
    /**
     * Implementierung der GET-Methode getErzieher für den Zugriff auf die URL https://{hostname}/db/{schema}/erzieher/
     *
     * Erstellt eine Liste aller in der Datenbank vorhandenen Erzieher unter Angabe der ID, des Kürzels, des Vor- und Nachnamens, Erzieherart, Kontaktdaten, ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Erzieherdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Erzieher-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<ErzieherListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Erzieherdaten anzusehen.
     *   Code 404: Keine Erzieher-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Erzieher-Listen-Einträgen
     */
    getErzieher(schema: string): Promise<List<ErzieherListeEintrag>>;
    /**
     * Implementierung der GET-Methode getErzieherStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/erzieher/{id : \d+}/stammdaten
     *
     * Liest die Stammdaten des Erziehers zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Erzieherdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Stammdaten des Erziehers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: ErzieherStammdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Erzieherdaten anzusehen.
     *   Code 404: Kein Erzieher-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Stammdaten des Erziehers
     */
    getErzieherStammdaten(schema: string, id: number): Promise<ErzieherStammdaten>;
    /**
     * Implementierung der PATCH-Methode patchErzieherStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/erzieher/{id : \d+}/stammdaten
     *
     * Passt die Erzieher-Stammdaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern von Erzieherdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Erzieher-Stammdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Erzieherdaten zu ändern.
     *   Code 404: Kein Erzieher-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {ErzieherStammdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchErzieherStammdaten(data: Partial<ErzieherStammdaten>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getErzieherArten für den Zugriff auf die URL https://{hostname}/db/{schema}/erzieher/arten
     *
     * Erstellt eine Liste aller in der Datenbank vorhandenen Erzieherarten unter Angabe der ID, der Beschreibung, Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Erzieherarten
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<Erzieherart>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalogdaten anzusehen.
     *   Code 404: Keine Erzieherart-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Erzieherarten
     */
    getErzieherArten(schema: string): Promise<List<Erzieherart>>;
    /**
     * Implementierung der GET-Methode getFaecher für den Zugriff auf die URL https://{hostname}/db/{schema}/faecher/
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Fächer unter Angabe der ID, des Kürzels, des verwendeten Statistik-Kürzels, der Bezeichnung des Faches, ob es ein Fach der Oberstufe ist, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Fächerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Fächer-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<FaecherListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Fächerdaten anzusehen.
     *   Code 404: Keine Fächer-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Fächer-Listen-Einträgen
     */
    getFaecher(schema: string): Promise<List<FaecherListeEintrag>>;
    /**
     * Implementierung der GET-Methode getFach für den Zugriff auf die URL https://{hostname}/db/{schema}/faecher/{id : \d+}
     *
     * Liest die Daten des Faches zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Fächerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Daten des Faches
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: FachDaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Fächerdaten anzusehen.
     *   Code 404: Kein Fach-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Daten des Faches
     */
    getFach(schema: string, id: number): Promise<FachDaten>;
    /**
     * Implementierung der GET-Methode getGesamtschuleSchuelerPrognoseLeistungsdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/gesamtschule/schueler/{id : \d+}/prognose_leistungsdaten
     *
     * Liest die Leistungsdaten des aktuellen Lernabschnittes in Bezug auf die Prognose- bzw. Abschlussberechnung in der Sek I der Gesamtschule des Schülers mit der angegebene ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Leistungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Leistungsdaten des Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GEAbschlussFaecher
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Leistungsdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Leistungsdaten des Schülers
     */
    getGesamtschuleSchuelerPrognoseLeistungsdaten(schema: string, id: number): Promise<GEAbschlussFaecher>;
    /**
     * Implementierung der GET-Methode getGesamtschuleSchuelerPrognosLeistungsdatenFuerAbschnitt für den Zugriff auf die URL https://{hostname}/db/{schema}/gesamtschule/schueler/{id : \d+}/prognose_leistungsdaten/abschnitt/{abschnittID : \d+}
     *
     * Liest die Leistungsdaten des angegebenen Lernabschnittes in Bezug auf die Prognose- bzw. Abschlussberechnung in der Sek I der Gesamtschule des Schülers mit der angegebene ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Leistungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Leistungsdaten des Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GEAbschlussFaecher
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Leistungsdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     * @param {number} abschnittID - der Pfad-Parameter abschnittID
     *
     * @returns Die Leistungsdaten des Schülers
     */
    getGesamtschuleSchuelerPrognosLeistungsdatenFuerAbschnitt(schema: string, id: number, abschnittID: number): Promise<GEAbschlussFaecher>;
    /**
     * Implementierung der POST-Methode getGostAbiturBelegpruefungEF1 für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abitur/belegpruefung/EF1
     *
     * Prüft anhand der übergeben Abiturdaten, ob die Belegung in den Abiturdaten korrekt ist oder nicht. Es werden ggf. auch Belegungsfehler und Hinweise zur Belegung zurückgegeben.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Das Ergebnis der Belegprüfung, ggf. mit Belegungsfehlern
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostBelegpruefungErgebnis
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Belegprüfung durchzuführen.
     *   Code 404: Es wurden keine Fächerdaten zur gymnasialen Oberstufe gefunden
     *
     * @param {Abiturdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Das Ergebnis der Belegprüfung, ggf. mit Belegungsfehlern
     */
    getGostAbiturBelegpruefungEF1(data: Abiturdaten, schema: string): Promise<GostBelegpruefungErgebnis>;
    /**
     * Implementierung der POST-Methode getGostAbiturBelegpruefungGesamt für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abitur/belegpruefung/gesamt
     *
     * Prüft anhand der übergeben Abiturdaten, ob die Belegung in den Abiturdaten korrekt ist oder nicht. Es werden ggf. auch Belegungsfehler und Hinweise zur Belegung zurückgegeben.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Das Ergebnis der Belegprüfung, ggf. mit Belegungsfehlern
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostBelegpruefungErgebnis
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Belegprüfung durchzuführen.
     *   Code 404: Es wurden keine Fächerdaten zur gymnasialen Oberstufe gefunden
     *
     * @param {Abiturdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Das Ergebnis der Belegprüfung, ggf. mit Belegungsfehlern
     */
    getGostAbiturBelegpruefungGesamt(data: Abiturdaten, schema: string): Promise<GostBelegpruefungErgebnis>;
    /**
     * Implementierung der GET-Methode getGostAbiturjahrgaenge für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgaenge
     *
     * Liefert eine Liste aller Abiturjahrgänge, welche in der Datenbank für die Laufbahnplanung angelegt sind.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Auslesen von Kataloginformationen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Liste der Abiturjahrgänge.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<GostJahrgang>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Liste der Abiturjahrgänge auszulesen.
     *   Code 404: Kein Abiturjahrgang gefunden oder keine gymnasiale Oberstufe bei der Schulform vorhanden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Die Liste der Abiturjahrgänge.
     */
    getGostAbiturjahrgaenge(schema: string): Promise<List<GostJahrgang>>;
    /**
     * Implementierung der GET-Methode getGostAbiturjahrgang für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}
     *
     * Liest die Grunddaten des Jahrgangs der gymnasialen Oberstufe zu dem Jahr, in welchem der Jahrgang Abitur machen wird, aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Jahrgangsinformationen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Grunddaten des Jahrgangs der gymnasialen Oberstufe
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostJahrgangsdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Grunddaten der Gymnasialen Oberstufe anzusehen.
     *   Code 404: Kein Eintrag für einen Jahrgang der gymnasialen Oberstufe mit dem angegebenen Abiturjahr gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abiturjahr - der Pfad-Parameter abiturjahr
     *
     * @returns Die Grunddaten des Jahrgangs der gymnasialen Oberstufe
     */
    getGostAbiturjahrgang(schema: string, abiturjahr: number): Promise<GostJahrgangsdaten>;
    /**
     * Implementierung der PATCH-Methode patchGostAbiturjahrgang für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}
     *
     * Passt die Daten des Jahrganges der gymnasialen Oberstufe zu dem Jahr an, in welchem der Jahrgang Abitur machen wird. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Anpassen der Jahrgangsinformationen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Jahrgangsdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Jahrgangsdaten zu ändern.
     *   Code 404: Kein Abiturjahrgangs-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {GostJahrgangsdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abiturjahr - der Pfad-Parameter abiturjahr
     */
    patchGostAbiturjahrgang(data: Partial<GostJahrgangsdaten>, schema: string, abiturjahr: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getGostAbiturjahrgangBlockungsliste für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/{halbjahr : \d+}/blockungen
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Blockungen der gymnasialen Oberstufe, welche für den angebenen Abitur-Jahrgang und das angegebene Halbjahr festgelegt wurden.. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Blockungs-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<GostBlockungListeneintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Blockungsdaten anzusehen.
     *   Code 404: Keine Blockungs-Einträge gefunden oder keine gymnasiale Oberstufe bei der Schulform vorhanden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abiturjahr - der Pfad-Parameter abiturjahr
     * @param {number} halbjahr - der Pfad-Parameter halbjahr
     *
     * @returns Eine Liste von Blockungs-Listen-Einträgen
     */
    getGostAbiturjahrgangBlockungsliste(schema: string, abiturjahr: number, halbjahr: number): Promise<List<GostBlockungListeneintrag>>;
    /**
     * Implementierung der POST-Methode createGostAbiturjahrgangBlockung für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/{halbjahr : \d+}/blockungen/new/{name}
     *
     * Erstellt eine neue Blockung und gibt die ID dieser Blockung zurück.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Erstellen der Fachwahlen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Blockung wurde erfolgreich angelegt.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: Long
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um eine Blockung anzulegen.
     *   Code 404: Keine Fachwahlinformationen zum Anlegen einer Blockung gefunden
     *   Code 409: Die übergebenen Daten (Anzahl der Schienen) sind fehlerhaft, da eine Rahmenbedingung nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {Integer} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abiturjahr - der Pfad-Parameter abiturjahr
     * @param {number} halbjahr - der Pfad-Parameter halbjahr
     * @param {string} name - der Pfad-Parameter name
     *
     * @returns Die Blockung wurde erfolgreich angelegt.
     */
    createGostAbiturjahrgangBlockung(data: Number, schema: string, abiturjahr: number, halbjahr: number, name: string): Promise<Number>;
    /**
     * Implementierung der GET-Methode getGostAbiturjahrgangFach für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/fach/{id : \d+}
     *
     * Liefert die Informationen bezüglich eines Abiturjahrgangs der gymnasialen Oberstufe zu dem Fach mit der angegebenen ID. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Fachinformationen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Daten des Faches bezüglich eines Abiturjahrgangs der gymnasialen Oberstufe
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostFach
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Fachinformationen der Gymnasialen Oberstufe anzusehen.
     *   Code 404: Kein Eintrag für das Fach der gymnasialen Oberstufe mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abiturjahr - der Pfad-Parameter abiturjahr
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Daten des Faches bezüglich eines Abiturjahrgangs der gymnasialen Oberstufe
     */
    getGostAbiturjahrgangFach(schema: string, abiturjahr: number, id: number): Promise<GostFach>;
    /**
     * Implementierung der PATCH-Methode patchGostAbiturjahrgangFach für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/fach/{id : \d+}
     *
     * Passt die Daten eines Faches in Bezug auf den Abiturjahrgang der Gymnasiale Oberstufe an. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Anpassen der Fachinformationen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Fachinformationen integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Fachdaten zu ändern.
     *   Code 404: Kein Fach-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {GostFach} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abiturjahr - der Pfad-Parameter abiturjahr
     * @param {number} id - der Pfad-Parameter id
     */
    patchGostAbiturjahrgangFach(data: Partial<GostFach>, schema: string, abiturjahr: number, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getGostAbiturjahrgangFachwahlen für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/fachwahlen
     *
     * Erstellt eine Liste aller in der Datenbank für den angebenen Abitur-Jahrgang vorhanden Fachwahlen der gymnasialen Oberstufe. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Fächerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste der Fachwahlen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<GostStatistikFachwahl>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Fachwahlen anzusehen.
     *   Code 404: Keine Fachwahlen gefunden oder keine gymnasiale Oberstufe bei der Schulform vorhanden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abiturjahr - der Pfad-Parameter abiturjahr
     *
     * @returns Eine Liste der Fachwahlen
     */
    getGostAbiturjahrgangFachwahlen(schema: string, abiturjahr: number): Promise<List<GostStatistikFachwahl>>;
    /**
     * Implementierung der GET-Methode getGostAbiturjahrgangFaecher für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/faecher
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Fächer der gymnasialen Oberstufe, welche für den angebenen Abitur-Jahrgang festgelegt wurden.. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Fächerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Fächer-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<GostFach>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Fächerdaten anzusehen.
     *   Code 404: Keine Fächer-Einträge gefunden oder keine gymnasiale Oberstufe bei der Schulform vorhanden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abiturjahr - der Pfad-Parameter abiturjahr
     *
     * @returns Eine Liste von Fächer-Listen-Einträgen
     */
    getGostAbiturjahrgangFaecher(schema: string, abiturjahr: number): Promise<List<GostFach>>;
    /**
     * Implementierung der POST-Methode createGostAbiturjahrgang für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/abiturjahrgang/new/{jahrgangid}
     *
     * Erstellt einen neuen Abiturjahrgang und gibt das Abiturjahr zurück.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Erstellen eine Abiturjahrgangs besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Abiturjahrgang wurde erfolgreich angelegt.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: Integer
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um einen Abiturjahrgang anzulegen.
     *   Code 404: Keine Daten beim angegebenen Jahrgang gefunden, um einen Abiturjahrgang anzulegen
     *   Code 409: Der Abiturjahrgang existiert bereits
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} jahrgangid - der Pfad-Parameter jahrgangid
     *
     * @returns Der Abiturjahrgang wurde erfolgreich angelegt.
     */
    createGostAbiturjahrgang(schema: string, jahrgangid: number): Promise<Number>;
    /**
     * Implementierung der DELETE-Methode deleteGostBlockung für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/{blockungsid : \d+}
     *
     * Entfernt die angegebene Blockung der gymnasialen Oberstufe. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Entfernen der Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 204: Die Blockungsdaten der gymnasialen Oberstfue für die angegebene ID wurden erfolgreich gelöscht.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Blockungsdaten der Gymnasialen Oberstufe zu löschen.
     *   Code 404: Keine Blockung mit der angebenen ID gefunden.
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} blockungsid - der Pfad-Parameter blockungsid
     */
    deleteGostBlockung(schema: string, blockungsid: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getGostBlockung für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/{blockungsid : \d+}
     *
     * Liest für die angegebene Blockung der gymnasialen Oberstufe die grundlegenden Daten aus. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Auslesen der Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Blockungsdaten der gymnasialen Oberstfue für die angegebene ID
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostBlockungsdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Blockungsdaten der Gymnasialen Oberstufe auszulesen.
     *   Code 404: Keine Blockung mit der angebenen ID gefunden.
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} blockungsid - der Pfad-Parameter blockungsid
     *
     * @returns Die Blockungsdaten der gymnasialen Oberstfue für die angegebene ID
     */
    getGostBlockung(schema: string, blockungsid: number): Promise<GostBlockungsdaten>;
    /**
     * Implementierung der PATCH-Methode patchGostBlockung für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/{blockungsid : \d+}
     *
     * Passt die Blockungsdaten der Gymnasiale Oberstufe mit der angegebenen ID an.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Anpassen der Fachwahlen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Blockungsdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Blockungsdaten zu ändern.
     *   Code 404: Kein Blockungsdaten-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {GostBlockungsdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} blockungsid - der Pfad-Parameter blockungsid
     */
    patchGostBlockung(data: Partial<GostBlockungsdaten>, schema: string, blockungsid: number): Promise<void>;
    /**
     * Implementierung der POST-Methode rechneGostBlockung für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/{blockungsid : \d+}/rechne/{zeit : \d+}
     *
     * Berechnet für die angegebene Blockung der gymnasialen Oberstufe Zwischenergebnisse und speichert diese in der DB. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Rechnen einer Blockung besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste der IDs der Zwischenergebnisse
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<Long>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Blockungsdaten der Gymnasialen Oberstufe auf dem Server zu rechnen.
     *   Code 404: Keine Blockung mit der angebenen ID gefunden.
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} blockungsid - der Pfad-Parameter blockungsid
     * @param {number} zeit - der Pfad-Parameter zeit
     *
     * @returns Eine Liste der IDs der Zwischenergebnisse
     */
    rechneGostBlockung(schema: string, blockungsid: number, zeit: number): Promise<List<Number>>;
    /**
     * Implementierung der GET-Methode getGostBlockungKurs für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/kurse/{kursid : \d+}
     *
     * Liest den angegebenen Kurs einer Blockung der gymnasialen Oberstufe aus. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Auslesen der Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Kurs der Blockung der gymnasialen Oberstfue für die angegebene ID
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostBlockungKurs
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Blockungsdaten der Gymnasialen Oberstufe auszulesen.
     *   Code 404: Kein Kurs einer Blockung mit der angebenen ID gefunden.
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} kursid - der Pfad-Parameter kursid
     *
     * @returns Der Kurs der Blockung der gymnasialen Oberstfue für die angegebene ID
     */
    getGostBlockungKurs(schema: string, kursid: number): Promise<GostBlockungKurs>;
    /**
     * Implementierung der PATCH-Methode patchGostBlockungKurs für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/kurse/{kursid : \d+}
     *
     * Passt den angebenene Kurs der Gymnasiale Oberstufe mit der angegebenen ID an.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Anpassen von Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Blockungsdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Blockungsdaten zu ändern.
     *   Code 404: Kein Kurs einer Blockung mit der angebenen ID gefunden.
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {GostBlockungKurs} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} kursid - der Pfad-Parameter kursid
     */
    patchGostBlockungKurs(data: Partial<GostBlockungKurs>, schema: string, kursid: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getGostBlockungRegel für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/regeln/{regelid : \d+}
     *
     * Liest die angegebene Regel einer Blockung der gymnasialen Oberstufe aus. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Auslesen der Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Regel der Blockung der gymnasialen Oberstfue für die angegebene ID
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostBlockungRegel
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Blockungsdaten der Gymnasialen Oberstufe auszulesen.
     *   Code 404: Keine Regel einer Blockung mit der angebenen ID gefunden.
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} regelid - der Pfad-Parameter regelid
     *
     * @returns Die Regel der Blockung der gymnasialen Oberstfue für die angegebene ID
     */
    getGostBlockungRegel(schema: string, regelid: number): Promise<GostBlockungRegel>;
    /**
     * Implementierung der PATCH-Methode patchGostBlockungRegel für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/regeln/{regelid : \d+}
     *
     * Passt die angegebene Regel der Gymnasiale Oberstufe mit der angegebenen ID an.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Anpassen von Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Blockungsdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Blockungsdaten zu ändern.
     *   Code 404: Keine Regel einer Blockung mit der angebenen ID gefunden.
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {GostBlockungRegel} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} regelid - der Pfad-Parameter regelid
     */
    patchGostBlockungRegel(data: Partial<GostBlockungRegel>, schema: string, regelid: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getGostBlockungSchiene für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/schiene/{schienenid : \d+}
     *
     * Liest die angegebene Schiene einer Blockung der gymnasialen Oberstufe aus. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Auslesen der Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Schiene der Blockung der gymnasialen Oberstfue für die angegebene ID
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostBlockungSchiene
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Blockungsdaten der Gymnasialen Oberstufe auszulesen.
     *   Code 404: Keine Schiene einer Blockung mit der angebenen ID gefunden.
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} schienenid - der Pfad-Parameter schienenid
     *
     * @returns Die Schiene der Blockung der gymnasialen Oberstfue für die angegebene ID
     */
    getGostBlockungSchiene(schema: string, schienenid: number): Promise<GostBlockungSchiene>;
    /**
     * Implementierung der PATCH-Methode patchGostBlockungSchiene für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/blockungen/schiene/{schienenid : \d+}
     *
     * Passt die angegebene Schiene der Gymnasiale Oberstufe mit der angegebenen ID an.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Anpassen von Blockungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Blockungsdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Blockungsdaten zu ändern.
     *   Code 404: Keine Schiene einer Blockung mit der angebenen ID gefunden.
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {GostBlockungSchiene} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} schienenid - der Pfad-Parameter schienenid
     */
    patchGostBlockungSchiene(data: Partial<GostBlockungSchiene>, schema: string, schienenid: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getGostFach für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/fach/{id : \d+}
     *
     * Liefert die Informationen bezüglich der gymnasialen Oberstufe zu dem Fach mit der angegebenen ID. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Fachinformationen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Daten des Faches bezüglich der gymnasialen Oberstufe
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostFach
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Fachiformationen der Gymnasialen Oberstufe anzusehen.
     *   Code 404: Kein Eintrag für das Fach der gymnasialen Oberstufe mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Daten des Faches bezüglich der gymnasialen Oberstufe
     */
    getGostFach(schema: string, id: number): Promise<GostFach>;
    /**
     * Implementierung der PATCH-Methode patchGostFach für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/fach/{id : \d+}
     *
     * Passt die Daten eines Faches in Bezug auf die Gymnasiale Oberstufe an. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Anpassen der Fachinformationen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Fachinformationen integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Fachdaten zu ändern.
     *   Code 404: Kein Fach-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {GostFach} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchGostFach(data: Partial<GostFach>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getGostFaecher für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/faecher
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Fächer der gymnasialen Oberstufe. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Fächerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Fächer-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<GostFach>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Fächerdaten anzusehen.
     *   Code 404: Keine Fächer-Einträge gefunden oder keine gymnasiale Oberstufe bei der Schulform vorhanden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Fächer-Listen-Einträgen
     */
    getGostFaecher(schema: string): Promise<List<GostFach>>;
    /**
     * Implementierung der GET-Methode getGostSchuelerAbiturdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/schueler/{id : \d+}/abiturdaten
     *
     * Liest die Abiturdaten aus den Abiturtabellen des Schülers mit der angegebene ID und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Leistungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Abiturdaten des Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: Abiturdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Leistungsdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Abiturdaten des Schülers
     */
    getGostSchuelerAbiturdaten(schema: string, id: number): Promise<Abiturdaten>;
    /**
     * Implementierung der GET-Methode getGostSchuelerAbiturdatenAusLeistungsdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/schueler/{id : \d+}/abiturdatenAusLeistungsdaten
     *
     * Liest die Abiturdaten aus den Leistungsdaten der gymnasiale Oberstufe des Schülers mit der angegebene ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Leistungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Abiturdaten des Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: Abiturdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Leistungsdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Abiturdaten des Schülers
     */
    getGostSchuelerAbiturdatenAusLeistungsdaten(schema: string, id: number): Promise<Abiturdaten>;
    /**
     * Implementierung der GET-Methode getGostSchuelerLaufbahnplanung für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/schueler/{id : \d+}/laufbahnplanung
     *
     * Liest die Laufbahnplanungsdaten für die gymnasiale Oberstufe zu dem Schüler mit der angegebenen ID aus der Datenbank aus und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Auslesen der Laufbahnplanungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Laufbahnplanungsdaten der gymnasialen Oberstfue des angegebenen Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: Abiturdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Laufbahnplanungsdaten der Gymnasialen Oberstufe eines Schülers auszulesen.
     *   Code 404: Kein Eintrag für einen Schüler mit Laufbahnplanungsdaten der gymnasialen Oberstufe für die angegebene ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Laufbahnplanungsdaten der gymnasialen Oberstfue des angegebenen Schülers
     */
    getGostSchuelerLaufbahnplanung(schema: string, id: number): Promise<Abiturdaten>;
    /**
     * Implementierung der GET-Methode getGostSchuelerLeistungsdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/schueler/{id : \d+}/leistungsdaten
     *
     * Liest die Leistungsdaten in Bezug auf die gymnasiale Oberstufe des Schülers mit der angegebene ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Leistungsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Leistungsdaten des Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: GostLeistungen
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Leistungsdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Leistungsdaten des Schülers
     */
    getGostSchuelerLeistungsdaten(schema: string, id: number): Promise<GostLeistungen>;
    /**
     * Implementierung der GET-Methode getGostSchuelerPDFWahlbogen für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/schueler/{id : \d+}/wahlbogen
     *
     * Erstellt den PDF-Wahlbogen für die gymnasiale Oberstufe zu dem Schüler mit der angegebenen ID. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Erstellen des Wahlbogens besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der PDF-Wahlbogen für die gymnasialen Oberstufe des angegebenen Schülers
     *     - Mime-Type: application/pdf
     *     - Rückgabe-Typ: Blob
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um den Wahlbogen für die Gymnasialen Oberstufe eines Schülers zu erstellen.
     *   Code 404: Kein Eintrag für einen Schüler mit Laufbahnplanungsdaten der gymnasialen Oberstufe für die angegebene ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Der PDF-Wahlbogen für die gymnasialen Oberstufe des angegebenen Schülers
     */
    getGostSchuelerPDFWahlbogen(schema: string, id: number): Promise<Blob>;
    /**
     * Implementierung der GET-Methode getGostSchuelerFachwahl für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/schueler/{schuelerid : \d+}/fachwahl/{fachid : \d+}
     *
     * Liest für die gymnasiale Oberstufe die Fachwahlen zu einem Fach von dem angegebenen Schüler aus. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Auslesen der Fachwahlen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Fachwahlen der gymnasialen Oberstfue für das angegebene Fach und den angegebenen Schüler
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: Abiturdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Fachwahlen der Gymnasialen Oberstufe eines Schülers auszulesen.
     *   Code 404: Kein Eintrag für einen Schüler mit Laufbahnplanungsdaten der gymnasialen Oberstufe für die angegebene ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} schuelerid - der Pfad-Parameter schuelerid
     * @param {number} fachid - der Pfad-Parameter fachid
     *
     * @returns Die Fachwahlen der gymnasialen Oberstfue für das angegebene Fach und den angegebenen Schüler
     */
    getGostSchuelerFachwahl(schema: string, schuelerid: number, fachid: number): Promise<Abiturdaten>;
    /**
     * Implementierung der PATCH-Methode patchGostSchuelerFachwahl für den Zugriff auf die URL https://{hostname}/db/{schema}/gost/schueler/{schuelerid : \d+}/fachwahl/{fachid : \d+}
     *
     * Passt die Fachwahl eines Schüler in Bezug auf ein Fach der Gymnasiale Oberstufe an. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Anpassen der Fachwahlen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Fachwahlen integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Fachwahlen zu ändern.
     *   Code 404: Kein Schüler- oder Fach-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {GostSchuelerFachwahl} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} schuelerid - der Pfad-Parameter schuelerid
     * @param {number} fachid - der Pfad-Parameter fachid
     */
    patchGostSchuelerFachwahl(data: Partial<GostSchuelerFachwahl>, schema: string, schuelerid: number, fachid: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getJahrgaenge für den Zugriff auf die URL https://{hostname}/db/{schema}/jahrgaenge/
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Jahrgänge unter Angabe der ID, des Kürzels, des verwendeten Statistik-Kürzels, der Bezeichnung des Jahrgangs, die Schulgliederung zu der der Jahrgang gehört, die ID eines Folgejahrgangs, sofern definiert, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Jahrgangsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Jahrgangs-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<JahrgangsListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Jahrgangsdaten anzusehen.
     *   Code 404: Keine Jahrgangs-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Jahrgangs-Listen-Einträgen
     */
    getJahrgaenge(schema: string): Promise<List<JahrgangsListeEintrag>>;
    /**
     * Implementierung der GET-Methode getJahrgang für den Zugriff auf die URL https://{hostname}/db/{schema}/jahrgaenge/{id : \d+}
     *
     * Liest die Daten des Jahrgangs zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Jahrgangsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Daten des Jahrgangs
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: JahrgangsDaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Jahrgangsdaten anzusehen.
     *   Code 404: Kein Jahrgangs-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Daten des Jahrgangs
     */
    getJahrgang(schema: string, id: number): Promise<JahrgangsDaten>;
    /**
     * Implementierung der GET-Methode getKatalogBeschaeftigungsart für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/beschaeftigungsart
     *
     * Erstellt eine Liste aller in dem Katalog vorhandenen Beschäftigungsarten unter Angabe der ID, eines Kürzels und der textuellen Beschreibung sowie der Information, ob der Eintrag in der Anwendung sichtbar bzw. änderbar sein soll, undgibt diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Katalog-Einträgen zu den Beschäftigungsarten.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Katalog-Einträgen zu den Beschäftigungsarten.
     */
    getKatalogBeschaeftigungsart(schema: string): Promise<List<KatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getKatalogBeschaeftigungsartmitID für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/beschaeftigungsart/{id : \d+}
     *
     * Liest die Daten der Beschäftigunsart zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Beschäftigungsartbesitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Katalog-Eintrag zu den Beschäftigungsarten.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Katalog-Eintrag zu den Beschäftigungsarten.
     */
    getKatalogBeschaeftigungsartmitID(schema: string, id: number): Promise<List<KatalogEintrag>>;
    /**
     * Implementierung der PATCH-Methode patchBeschaeftigungsart für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/beschaeftigungsart/{id : \d+}
     *
     * Passt die Beschäftigungsart-Stammdaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern der Daten der Beschäftigungsart besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Beschäftigungsart-Daten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Beschäftigungsart-Daten zu ändern.
     *   Code 404: Keine Beschäftigungsart mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {KatalogEintrag} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchBeschaeftigungsart(data: Partial<KatalogEintrag>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getKatalogBetriebsartmitID für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/beschaeftigungsart/{id : \d+}
     *
     * Liest die Daten der Betriebsart zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Betriebsartenbesitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Katalog-Eintrag zu den Betriebsarten.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Katalog-Eintrag zu den Betriebsarten.
     */
    getKatalogBetriebsartmitID(schema: string, id: number): Promise<List<KatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getKatalogBetriebsart für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/betriebsart
     *
     * Erstellt eine Liste aller in dem Katalog vorhandenen Betriebsarten unter Angabe der ID, eines Kürzels und der textuellen Beschreibung sowie der Information, ob der Eintrag in der Anwendung sichtbar bzw. änderbar sein soll, undgibt diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Katalog-Einträgen zu den Betriebsarten.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Katalog-Einträgen zu den Betriebsarten.
     */
    getKatalogBetriebsart(schema: string): Promise<List<KatalogEintrag>>;
    /**
     * Implementierung der PATCH-Methode patchBetriebsart für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/betriebsart/{id : \d+}
     *
     * Passt die Beschäftigungsart-Stammdaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern der Daten der Betriebssart besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Beschäftigungsart-Daten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Beschäftigungsart-Daten zu ändern.
     *   Code 404: Keine Beschäftigungsart mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {KatalogEintrag} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchBetriebsart(data: Partial<KatalogEintrag>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getKatalogHaltestellen für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/haltestellen
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Haltestellen unter Angabe der ID, eines Kürzels und der textuellen Beschreibung sowie der Information, ob der Eintrag in der Anwendung sichtbar bzw. änderbar sein soll, undgibt diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Katalog-Einträgen zu den Haltestellen.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Katalog-Einträgen zu den Haltestellen.
     */
    getKatalogHaltestellen(schema: string): Promise<List<KatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getKatalogNationaelitaeten für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/nationalitaeten
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Nationalitäten unter Angabe der ID, des Landes, der Staatsangehörigkeit, einem Statistik-Kürzel, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Nationalitäten-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<NationalitaetKatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Nationalitäten-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Nationalitäten-Katalog-Einträgen
     */
    getKatalogNationaelitaeten(schema: string): Promise<List<NationalitaetKatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getKatalogOrte für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/orte
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Orte unter Angabe der ID, der PLZ, des Ortes, ggf. des Kreises, dem Bundesland, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Orts-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<OrtKatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Ort-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Orts-Katalog-Einträgen
     */
    getKatalogOrte(schema: string): Promise<List<OrtKatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getKatalogOrtsteile für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/ortsteile
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Ortsteile unter Angabe der ID, der zugehörigenOrt-ID, dem Namen des Ortsteils, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Ortsteil-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<OrtsteilKatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Ortsteil-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Ortsteil-Katalog-Einträgen
     */
    getKatalogOrtsteile(schema: string): Promise<List<OrtsteilKatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getKatalogReligionen für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/religionen
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Religionen unter Angabe der ID, der Bezeichnung sowie der Bezeichnung, welche auf dem Zeugnis erscheint, einem Statistik-Kürzel, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Religion-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<ReligionKatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Religion-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Religion-Katalog-Einträgen
     */
    getKatalogReligionen(schema: string): Promise<List<ReligionKatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getKatalogStrassen für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/strassen
     *
     * Erstellt eine Liste aller in dem Katalog vorhandenen Strassen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Straßen-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintragStrassen>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Straßen-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Straßen-Katalog-Einträgen
     */
    getKatalogStrassen(schema: string): Promise<List<KatalogEintragStrassen>>;
    /**
     * Implementierung der GET-Methode getKatalogVerkehrssprachen für den Zugriff auf die URL https://{hostname}/db/{schema}/kataloge/verkehrsprachen
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Verkehrssprachen unter Angabe der ID, eines Kürzels und der textuellen Beschreibung sowie der Information, ob der Eintrag in der Anwendung sichtbar bzw. änderbar sein soll, undgibt diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Katalog-Einträgen zur Verkehrssprache.
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Katalog-Einträgen zur Verkehrssprache.
     */
    getKatalogVerkehrssprachen(schema: string): Promise<List<KatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getKlasse für den Zugriff auf die URL https://{hostname}/db/{schema}/klassen/{id : \d+}
     *
     * Liest die Daten der Klasse zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Klassendaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Daten der Klasse
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: KlassenDaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Klassendaten anzusehen.
     *   Code 404: Kein Klassen-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Daten der Klasse
     */
    getKlasse(schema: string, id: number): Promise<KlassenDaten>;
    /**
     * Implementierung der GET-Methode getKlassenFuerAbschnitt für den Zugriff auf die URL https://{hostname}/db/{schema}/klassen/abschnitt/{abschnitt : \d+}
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Klassen unter Angabe der ID, des Kürzels, der Parallelität, der Kürzel des Klassenlehrers und des zweiten Klassenlehrers, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Klassendaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Klassen-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KlassenListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Klassendaten anzusehen.
     *   Code 404: Keine Klassen-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abschnitt - der Pfad-Parameter abschnitt
     *
     * @returns Eine Liste von Klassen-Listen-Einträgen
     */
    getKlassenFuerAbschnitt(schema: string, abschnitt: number): Promise<List<KlassenListeEintrag>>;
    /**
     * Implementierung der GET-Methode getKurse für den Zugriff auf die URL https://{hostname}/db/{schema}/kurse/
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Kurse unter Angabe der ID, des Kürzels, der Parallelität, der Kürzel des Klassenlehrers und des zweiten Klassenlehrers, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Klassendaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Kurs-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KursListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Kursdaten anzusehen.
     *   Code 404: Keine Kurs-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Kurs-Listen-Einträgen
     */
    getKurse(schema: string): Promise<List<KursListeEintrag>>;
    /**
     * Implementierung der GET-Methode getKurs für den Zugriff auf die URL https://{hostname}/db/{schema}/kurse/{id : \d+}
     *
     * Liest die Daten des Kurses zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Kursdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Daten des Kurses
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: KursDaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Kursdaten anzusehen.
     *   Code 404: Kein Kurs-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Daten des Kurses
     */
    getKurs(schema: string, id: number): Promise<KursDaten>;
    /**
     * Implementierung der GET-Methode getKurseFuerAbschnitt für den Zugriff auf die URL https://{hostname}/db/{schema}/kurse/abschnitt/{abschnitt : \d+}
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Kurse eines Schuljahresabschnittes unter Angabe der ID, des Kürzels, der Parallelität, der Kürzel des Klassenlehrers und des zweiten Klassenlehrers, einer Sortierreihenfolge und ob sie in der Anwendung sichtbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Klassendaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Kurs-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KursListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Kursdaten anzusehen.
     *   Code 404: Keine Kurs-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abschnitt - der Pfad-Parameter abschnitt
     *
     * @returns Eine Liste von Kurs-Listen-Einträgen
     */
    getKurseFuerAbschnitt(schema: string, abschnitt: number): Promise<List<KursListeEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrer für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/
     *
     * Erstellt eine Liste aller in der Datenbank vorhanden Lehrer unter Angabe der ID, des Kürzels, des Vor- und Nachnamens, der sog. Personentyps, einer Sortierreihenfolge, ob sie in der Anwendung sichtbar bzw. änderbar sein sollen sowie ob sie für die Schulstatistik relevant sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Lehrerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Lehrer-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Lehrerdaten anzusehen.
     *   Code 404: Keine Lehrer-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Lehrer-Listen-Einträgen
     */
    getLehrer(schema: string): Promise<List<LehrerListeEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerPersonaldaten für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/{id : \d+}/personaldaten
     *
     * Liest die Personaldaten des Lehrers zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Lehrerpersonaldaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Personaldaten des Lehrers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: LehrerPersonaldaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Lehrerdaten anzusehen.
     *   Code 404: Kein Lehrer-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Personaldaten des Lehrers
     */
    getLehrerPersonaldaten(schema: string, id: number): Promise<LehrerPersonaldaten>;
    /**
     * Implementierung der PATCH-Methode patchLehrerPersonaldaten für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/{id : \d+}/personaldaten
     *
     * Passt die Lehrer-Personaldaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern von Lehrer-Personaldaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Lehrer-Personaldaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Lehrer-Personaldaten zu ändern.
     *   Code 404: Kein Lehrer-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {LehrerPersonaldaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchLehrerPersonaldaten(data: Partial<LehrerPersonaldaten>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getLehrerStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/{id : \d+}/stammdaten
     *
     * Liest die Stammdaten des Lehrers zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Lehrerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Stammdaten des Lehrers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: LehrerStammdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Lehrerdaten anzusehen.
     *   Code 404: Kein Lehrer-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Stammdaten des Lehrers
     */
    getLehrerStammdaten(schema: string, id: number): Promise<LehrerStammdaten>;
    /**
     * Implementierung der PATCH-Methode patchLehrerStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/{id : \d+}/stammdaten
     *
     * Passt die Lehrer-Stammdaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern von Lehrerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Lehrer-Stammdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Lehrerdaten zu ändern.
     *   Code 404: Kein Lehrer-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {LehrerStammdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchLehrerStammdaten(data: Partial<LehrerStammdaten>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getLehrerAbgangsgruende für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/abgangsgruende
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Lehrerabgangsgründe unter Angabe der ID, der Bezeichnung und des Statistikschlüssels. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Lehrerabgangsgrund-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogAbgangsgrundEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Lehrerabgangsgrund-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Lehrerabgangsgrund-Katalog-Einträgen
     */
    getLehrerAbgangsgruende(schema: string): Promise<List<LehrerKatalogAbgangsgrundEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerAnrechnungsgruende für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/anrechnungsgruende
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Gründe für Anrechnungsstunden von Lehrern.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Einträgen für Gründe von Anrechnungsstunden von Lehrern
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogAnrechnungsgrundEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Einträgen für Gründe von Anrechnungsstunden von Lehrern
     */
    getLehrerAnrechnungsgruende(schema: string): Promise<List<LehrerKatalogAnrechnungsgrundEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerBeschaeftigungsarten für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/beschaeftigungsarten
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Beschäftigungsarten unter Angabe der ID, eines Kürzels und der Bezeichnung. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Beschäftigungsart-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogBeschaeftigungsartEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Beschäftigungsart-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Beschäftigungsart-Katalog-Einträgen
     */
    getLehrerBeschaeftigungsarten(schema: string): Promise<List<LehrerKatalogBeschaeftigungsartEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerEinsatzstatus für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/einsatzstatus
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Einsatzstatusarten unter Angabe der ID, eines Kürzels und der Bezeichnung. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Einsatzstatus-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogEinsatzstatusEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Einsatzstatus-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Einsatzstatus-Katalog-Einträgen
     */
    getLehrerEinsatzstatus(schema: string): Promise<List<LehrerKatalogEinsatzstatusEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerFachrichtungen für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/fachrichtungen
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Fachrichtungen von Lehrern. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Fachrichtungens-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogFachrichtungEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Fachrichtungs-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Fachrichtungens-Katalog-Einträgen
     */
    getLehrerFachrichtungen(schema: string): Promise<List<LehrerKatalogFachrichtungEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerFachrichtungAnerkennungen für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/fachrichtungen_anerkennungen
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Anerkennungen von Fachrichtungen für Lehrer. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Anerkennungs-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogFachrichtungAnerkennungEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Anerkennungs-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Anerkennungs-Katalog-Einträgen
     */
    getLehrerFachrichtungAnerkennungen(schema: string): Promise<List<LehrerKatalogFachrichtungAnerkennungEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerLehraemter für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/lehraemter
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Lehrämter. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Lehramt-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogLehramtEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Lehramt-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Lehramt-Katalog-Einträgen
     */
    getLehrerLehraemter(schema: string): Promise<List<LehrerKatalogLehramtEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerLehramtAnerkennungen für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/lehraemter_anerkennungen
     *
     * Erstellt eine Liste aller Anerkennungen von Lehrämtern. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Anerkennungs-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogLehramtAnerkennungEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Anerkennungs-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Anerkennungs-Katalog-Einträgen
     */
    getLehrerLehramtAnerkennungen(schema: string): Promise<List<LehrerKatalogLehramtAnerkennungEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerLehrbefaehigungen für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/lehrbefaehigungen
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Lehrbefähigungen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Lehrbefähigung-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogLehrbefaehigungEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Lehrbefähigung-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Lehrbefähigung-Katalog-Einträgen
     */
    getLehrerLehrbefaehigungen(schema: string): Promise<List<LehrerKatalogLehrbefaehigungEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerLehrbefaehigungenAnerkennungen für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/lehrbefaehigungen_anerkennungen
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Anerkennungen von Lehrbefähigungen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Einsatzstatus-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogLehrbefaehigungAnerkennungEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Anerkennungs-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Einsatzstatus-Katalog-Einträgen
     */
    getLehrerLehrbefaehigungenAnerkennungen(schema: string): Promise<List<LehrerKatalogLehrbefaehigungAnerkennungEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerLeitungsfunktionen für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/leitungsfunktionen
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Lehrerleitungsfunktionen unter Angabe der ID und der Bezeichnung. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Lehrerleitungsfunktion-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogLeitungsfunktionEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Lehrerleitungsfunktion-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Lehrerleitungsfunktion-Katalog-Einträgen
     */
    getLehrerLeitungsfunktionen(schema: string): Promise<List<LehrerKatalogLeitungsfunktionEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerMehrleistungsarten für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/mehrleistungsarten
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden die Arten von Mehrleistungen durch Lehrer. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Mehrleistungsart-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogMehrleistungsartEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Mehrleistungsart-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Mehrleistungsart-Katalog-Einträgen
     */
    getLehrerMehrleistungsarten(schema: string): Promise<List<LehrerKatalogMehrleistungsartEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerMinderleistungsarten für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/minderleistungsarten
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Arten von Minderleistungen durch Lehrer. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Minderleistungsart-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogMinderleistungsartEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Minderleistungsart-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Minderleistungsart-Katalog-Einträgen
     */
    getLehrerMinderleistungsarten(schema: string): Promise<List<LehrerKatalogMinderleistungsartEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerRechtsverhaeltnisse für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/rechtsverhaeltnisse
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Rechtsverhältnisse unter Angabe der ID, eines Kürzels und der Bezeichnung. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Rechtsverhältnis-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogRechtsverhaeltnisEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Rechtsverhältnis-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Rechtsverhältnis-Katalog-Einträgen
     */
    getLehrerRechtsverhaeltnisse(schema: string): Promise<List<LehrerKatalogRechtsverhaeltnisEintrag>>;
    /**
     * Implementierung der GET-Methode getLehrerZugangsgruende für den Zugriff auf die URL https://{hostname}/db/{schema}/lehrer/zugangsgruende
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Lehrerzugangsgründe unter Angabe der ID, der Bezeichnung und des Statistikschlüssels. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Lehrerzugangsgrund-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<LehrerKatalogZugangsgrundEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Lehrerzugangsgrund-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Lehrerzugangsgrund-Katalog-Einträgen
     */
    getLehrerZugangsgruende(schema: string): Promise<List<LehrerKatalogZugangsgrundEintrag>>;
    /**
     * Implementierung der GET-Methode getSchuelerLernabschnittsdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/abschnitt/{abschnitt : \d+}/lernabschnittsdaten
     *
     * Liest die Lernabschnittsdaten des Schülers zu der angegebenen ID und dem angegeben Schuljahresabschnitt aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Lernabschnittsdaten des Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: SchuelerLernabschnittsdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Schülerdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     * @param {number} abschnitt - der Pfad-Parameter abschnitt
     *
     * @returns Die Lernabschnittsdaten des Schülers
     */
    getSchuelerLernabschnittsdaten(schema: string, id: number, abschnitt: number): Promise<SchuelerLernabschnittsdaten>;
    /**
     * Implementierung der GET-Methode getSchuelerBetriebe für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/betriebe
     *
     * Erstellt eine Liste aller in der Datenbank vorhandenen Betriebe unter Angabe der Schüler-IDdes Vor- und Nachnamens, Erzieherart, Kontaktdaten, ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Betriebsdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Schülerbetrieben
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<SchuelerBetriebsdaten>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Erzieherdaten anzusehen.
     *   Code 404: Keine Erzieher-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Eine Liste von Schülerbetrieben
     */
    getSchuelerBetriebe(schema: string, id: number): Promise<List<SchuelerBetriebsdaten>>;
    /**
     * Implementierung der GET-Methode getSchuelerBetriebsstammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/betriebsstammdaten
     *
     * Erstellt eine Liste aller in der Datenbank vorhandenen Betriebe eines Schülers unter Angabe der ID,ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Betriebsdaten des Schülers besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von von Betriebsstammdaten eines Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<BetriebStammdaten>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Betriebdaten anzusehen.
     *   Code 404: Keine Betrieb-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Eine Liste von von Betriebsstammdaten eines Schülers
     */
    getSchuelerBetriebsstammdaten(schema: string, id: number): Promise<List<BetriebStammdaten>>;
    /**
     * Implementierung der GET-Methode getSchuelerErzieher für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/erzieher
     *
     * Erstellt eine Liste aller in der Datenbank vorhandenen Erzieher unter Angabe der Schüler-IDdes Vor- und Nachnamens, Erzieherart, Kontaktdaten, ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Erzieherdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Erzieherstammdaten
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<ErzieherStammdaten>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Erzieherdaten anzusehen.
     *   Code 404: Keine Erzieher-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Eine Liste von Erzieherstammdaten
     */
    getSchuelerErzieher(schema: string, id: number): Promise<List<ErzieherStammdaten>>;
    /**
     * Implementierung der GET-Methode getSchuelerLernabschnittsliste für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/lernabschnitte
     *
     * Liest eine Lister der Lernabschnitte des Schülers zu der angegebenen ID aus der Datenbank und liefert diese zurück.Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Schüler-Lernabschnitt-Listeneinträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<SchuelerLernabschnittListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um die Schülerdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Eine Liste von Schüler-Lernabschnitt-Listeneinträgen
     */
    getSchuelerLernabschnittsliste(schema: string, id: number): Promise<List<SchuelerLernabschnittListeEintrag>>;
    /**
     * Implementierung der GET-Methode getSchuelerSchulbesuch für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/schulbesuch
     *
     * Liest die Schulbesuchsdaten des Schülers zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Schulbesuchsdaten des Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: SchuelerSchulbesuchsdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Schulbesuchsdaten des Schülers
     */
    getSchuelerSchulbesuch(schema: string, id: number): Promise<SchuelerSchulbesuchsdaten>;
    /**
     * Implementierung der PATCH-Methode patchSchuelerSchulbesuch für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/schulbesuch
     *
     * Passt die Schüler-Schulbesuchsdaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Schüler-Schulbesuchsdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerdaten zu ändern.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {SchuelerSchulbesuchsdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchSchuelerSchulbesuch(data: Partial<SchuelerSchulbesuchsdaten>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getSchuelerStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/stammdaten
     *
     * Liest die Stammdaten des Schülers zu der angegebenen ID aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Stammdaten des Schülers
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: SchuelerStammdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerdaten anzusehen.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     *
     * @returns Die Stammdaten des Schülers
     */
    getSchuelerStammdaten(schema: string, id: number): Promise<SchuelerStammdaten>;
    /**
     * Implementierung der PATCH-Methode patchSchuelerStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/{id : \d+}/stammdaten
     *
     * Passt die Schüler-Stammdaten zu der angegebenen ID an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Schülerstammdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerdaten zu ändern.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {SchuelerStammdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} id - der Pfad-Parameter id
     */
    patchSchuelerStammdaten(data: Partial<SchuelerStammdaten>, schema: string, id: number): Promise<void>;
    /**
     * Implementierung der GET-Methode getSchuelerFuerAbschnitt für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/abschnitt/{abschnitt : \d+}
     *
     * Erstellt eine Liste aller Schüler des angegebenen Schuljahresabschnitts unter Angabe der ID, des Vor- und Nachnamens, der Klasse, des Jahrgangs, sein Status (z.B. aktiv), einer Sortierreihenfolge, ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Die schüler sind anhand der Klasse, des Nchnamens und des Vornamens sortiert.Es wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Schüler-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<SchuelerListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerdaten anzusehen.
     *   Code 404: Keine Schüler-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     * @param {number} abschnitt - der Pfad-Parameter abschnitt
     *
     * @returns Eine Liste von Schüler-Listen-Einträgen
     */
    getSchuelerFuerAbschnitt(schema: string, abschnitt: number): Promise<List<SchuelerListeEintrag>>;
    /**
     * Implementierung der GET-Methode getSchuelerAktuell für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/aktuell
     *
     * Erstellt eine Liste aller im aktuellen Schuljahresabschnitt vorhanden Schüler unter Angabe der ID, des Vor- und Nachnamens, der Klasse, des Jahrgangs, sein Status (z.B. aktiv), einer Sortierreihenfolge, ob sie in der Anwendung sichtbar bzw. änderbar sein sollen. Die schüler sind anhand der Klasse, des Nachnamens und des Vornamens sortiert.Es wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schülerdaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Schüler-Listen-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<SchuelerListeEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schülerdaten anzusehen.
     *   Code 404: Keine Schüler-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Schüler-Listen-Einträgen
     */
    getSchuelerAktuell(schema: string): Promise<List<SchuelerListeEintrag>>;
    /**
     * Implementierung der GET-Methode getSchuelerFahrschuelerarten für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/fahrschuelerarten
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Fahrschülerarten unter Angabe der ID, eines Kürzels und der Bezeichnung. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Fahrschülerarten-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Fahrschülerart-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Fahrschülerarten-Katalog-Einträgen
     */
    getSchuelerFahrschuelerarten(schema: string): Promise<List<KatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getSchuelerFoerderschwerpunkte für den Zugriff auf die URL https://{hostname}/db/{schema}/schueler/foerderschwerpunkte
     *
     * Erstellt eine Liste aller in dem Katalog vorhanden Förderschwerpunkte unter Angabe der ID, eines Kürzels und der Bezeichnung. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Katalogen besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Eine Liste von Förderschwerpunkte-Katalog-Einträgen
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: List<KatalogEintrag>
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Katalog-Einträge anzusehen.
     *   Code 404: Keine Förderschwerpunkt-Katalog-Einträge gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Eine Liste von Förderschwerpunkte-Katalog-Einträgen
     */
    getSchuelerFoerderschwerpunkte(schema: string): Promise<List<KatalogEintrag>>;
    /**
     * Implementierung der GET-Methode getSchullogo für den Zugriff auf die URL https://{hostname}/db/{schema}/schule/logo
     *
     * Liest das Logo der Schule zum angegebenen Schema aus der Datenbank und liefert dieses zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schuldaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Das Logo der Schule
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: String
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schuldaten anzusehen.
     *   Code 404: Kein Eintrag mit dem angegebenen Schema gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Das Logo der Schule
     */
    getSchullogo(schema: string): Promise<String>;
    /**
     * Implementierung der PUT-Methode putSchullogo für den Zugriff auf die URL https://{hostname}/db/{schema}/schule/logo
     *
     * Setzt das Logo der Schule. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schuldaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Das Logo der Schule wurde gesetzt
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schuldaten zu ändern.
     *   Code 404: Kein Eintrag für die Schule gefunden
     *
     * @param {String} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     */
    putSchullogo(data: String, schema: string): Promise<void>;
    /**
     * Implementierung der GET-Methode getSchuleNummer für den Zugriff auf die URL https://{hostname}/db/{schema}/schule/nummer
     *
     * Liefert die Schulnummer der Schule. Es wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen der Schuldaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Schulnummer
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: Integer
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schuldaten anzusehen.
     *   Code 404: Keine Schule in der Datenbank vorhanden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Die Schulnummer
     */
    getSchuleNummer(schema: string): Promise<Number>;
    /**
     * Implementierung der GET-Methode getSchuleStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/schule/stammdaten
     *
     * Liest die Stammdaten der Schule zum angegebenen Schema aus der Datenbank und liefert diese zurück. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ansehen von Schuldaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Die Stammdaten der Schule
     *     - Mime-Type: application/json
     *     - Rückgabe-Typ: SchuleStammdaten
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schuldaten anzusehen.
     *   Code 404: Kein Eintrag mit dem angegebenen Schema gefunden
     *
     * @param {string} schema - der Pfad-Parameter schema
     *
     * @returns Die Stammdaten der Schule
     */
    getSchuleStammdaten(schema: string): Promise<SchuleStammdaten>;
    /**
     * Implementierung der PATCH-Methode patchSchuleStammdaten für den Zugriff auf die URL https://{hostname}/db/{schema}/schule/stammdaten
     *
     * Passt die Schul-Stammdaten an und speichert das Ergebnis in der Datenbank. Dabei wird geprüft, ob der SVWS-Benutzer die notwendige Berechtigung zum Ändern von Schuldaten besitzt.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Patch wurde erfolgreich in die Schul-Stammdaten integriert.
     *   Code 400: Der Patch ist fehlerhaft aufgebaut.
     *   Code 403: Der SVWS-Benutzer hat keine Rechte, um Schuldaten zu ändern.
     *   Code 404: Kein Schüler-Eintrag mit der angegebenen ID gefunden
     *   Code 409: Der Patch ist fehlerhaft, da zumindest eine Rahmenbedingung für einen Wert nicht erfüllt wurde (z.B. eine negative ID)
     *   Code 500: Unspezifizierter Fehler (z.B. beim Datenbankzugriff)
     *
     * @param {SchuleStammdaten} data - der Request-Body für die HTTP-Methode
     * @param {string} schema - der Pfad-Parameter schema
     */
    patchSchuleStammdaten(data: Partial<SchuleStammdaten>, schema: string): Promise<void>;
    /**
     * Implementierung der GET-Methode isAlive für den Zugriff auf die URL https://{hostname}/status/alive
     *
     * Eine Test-Methode zum Prüfen, ob der Server erreichbar ist.
     *
     * Mögliche HTTP-Antworten:
     *   Code 200: Der Server ist erreichbar!
     *     - Mime-Type: text/plain
     *     - Rückgabe-Typ: String
     *
     * @returns Der Server ist erreichbar!
     */
    isAlive(): Promise<String>;
}
