ts-api/dist/api/ApiServer.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ApiServer = void 0;
const BaseApi_1 = require("../api/BaseApi");
const Abiturdaten_1 = require("../core/data/gost/Abiturdaten");
const BenutzerListeEintrag_1 = require("../core/data/benutzer/BenutzerListeEintrag");
const BetriebListeEintrag_1 = require("../core/data/betrieb/BetriebListeEintrag");
const BetriebStammdaten_1 = require("../core/data/betrieb/BetriebStammdaten");
const DBSchemaListeEintrag_1 = require("../core/data/db/DBSchemaListeEintrag");
const ENMDaten_1 = require("../core/data/enm/ENMDaten");
const Erzieherart_1 = require("../core/data/erzieher/Erzieherart");
const ErzieherListeEintrag_1 = require("../core/data/erzieher/ErzieherListeEintrag");
const ErzieherStammdaten_1 = require("../core/data/erzieher/ErzieherStammdaten");
const FachDaten_1 = require("../core/data/fach/FachDaten");
const FaecherListeEintrag_1 = require("../core/data/fach/FaecherListeEintrag");
const GEAbschlussFaecher_1 = require("../core/data/abschluss/GEAbschlussFaecher");
const GostBelegpruefungErgebnis_1 = require("../core/abschluss/gost/GostBelegpruefungErgebnis");
const GostBlockungKurs_1 = require("../core/data/gost/GostBlockungKurs");
const GostBlockungListeneintrag_1 = require("../core/data/gost/GostBlockungListeneintrag");
const GostBlockungRegel_1 = require("../core/data/gost/GostBlockungRegel");
const GostBlockungSchiene_1 = require("../core/data/gost/GostBlockungSchiene");
const GostBlockungsdaten_1 = require("../core/data/gost/GostBlockungsdaten");
const GostFach_1 = require("../core/data/gost/GostFach");
const GostJahrgang_1 = require("../core/data/gost/GostJahrgang");
const GostJahrgangsdaten_1 = require("../core/data/gost/GostJahrgangsdaten");
const GostLeistungen_1 = require("../core/data/gost/GostLeistungen");
const GostSchuelerFachwahl_1 = require("../core/data/gost/GostSchuelerFachwahl");
const GostStatistikFachwahl_1 = require("../core/data/gost/GostStatistikFachwahl");
const JahrgangsDaten_1 = require("../core/data/jahrgang/JahrgangsDaten");
const JahrgangsListeEintrag_1 = require("../core/data/jahrgang/JahrgangsListeEintrag");
const KatalogEintrag_1 = require("../core/data/kataloge/KatalogEintrag");
const KatalogEintragStrassen_1 = require("../core/data/kataloge/KatalogEintragStrassen");
const KlassenDaten_1 = require("../core/data/klassen/KlassenDaten");
const KlassenListeEintrag_1 = require("../core/data/klassen/KlassenListeEintrag");
const KursDaten_1 = require("../core/data/kurse/KursDaten");
const KursListeEintrag_1 = require("../core/data/kurse/KursListeEintrag");
const LehrerKatalogAbgangsgrundEintrag_1 = require("../core/data/lehrer/LehrerKatalogAbgangsgrundEintrag");
const LehrerKatalogAnrechnungsgrundEintrag_1 = require("../core/data/lehrer/LehrerKatalogAnrechnungsgrundEintrag");
const LehrerKatalogBeschaeftigungsartEintrag_1 = require("../core/data/lehrer/LehrerKatalogBeschaeftigungsartEintrag");
const LehrerKatalogEinsatzstatusEintrag_1 = require("../core/data/lehrer/LehrerKatalogEinsatzstatusEintrag");
const LehrerKatalogFachrichtungAnerkennungEintrag_1 = require("../core/data/lehrer/LehrerKatalogFachrichtungAnerkennungEintrag");
const LehrerKatalogFachrichtungEintrag_1 = require("../core/data/lehrer/LehrerKatalogFachrichtungEintrag");
const LehrerKatalogLehramtAnerkennungEintrag_1 = require("../core/data/lehrer/LehrerKatalogLehramtAnerkennungEintrag");
const LehrerKatalogLehramtEintrag_1 = require("../core/data/lehrer/LehrerKatalogLehramtEintrag");
const LehrerKatalogLehrbefaehigungAnerkennungEintrag_1 = require("../core/data/lehrer/LehrerKatalogLehrbefaehigungAnerkennungEintrag");
const LehrerKatalogLehrbefaehigungEintrag_1 = require("../core/data/lehrer/LehrerKatalogLehrbefaehigungEintrag");
const LehrerKatalogLeitungsfunktionEintrag_1 = require("../core/data/lehrer/LehrerKatalogLeitungsfunktionEintrag");
const LehrerKatalogMehrleistungsartEintrag_1 = require("../core/data/lehrer/LehrerKatalogMehrleistungsartEintrag");
const LehrerKatalogMinderleistungsartEintrag_1 = require("../core/data/lehrer/LehrerKatalogMinderleistungsartEintrag");
const LehrerKatalogRechtsverhaeltnisEintrag_1 = require("../core/data/lehrer/LehrerKatalogRechtsverhaeltnisEintrag");
const LehrerKatalogZugangsgrundEintrag_1 = require("../core/data/lehrer/LehrerKatalogZugangsgrundEintrag");
const LehrerListeEintrag_1 = require("../core/data/lehrer/LehrerListeEintrag");
const LehrerPersonaldaten_1 = require("../core/data/lehrer/LehrerPersonaldaten");
const LehrerStammdaten_1 = require("../core/data/lehrer/LehrerStammdaten");
const NationalitaetKatalogEintrag_1 = require("../core/data/kataloge/NationalitaetKatalogEintrag");
const OrtKatalogEintrag_1 = require("../core/data/kataloge/OrtKatalogEintrag");
const OrtsteilKatalogEintrag_1 = require("../core/data/kataloge/OrtsteilKatalogEintrag");
const ReligionKatalogEintrag_1 = require("../core/data/kataloge/ReligionKatalogEintrag");
const SchuelerBetriebsdaten_1 = require("../core/data/schueler/SchuelerBetriebsdaten");
const SchuelerLernabschnittListeEintrag_1 = require("../core/data/schueler/SchuelerLernabschnittListeEintrag");
const SchuelerLernabschnittsdaten_1 = require("../core/data/schueler/SchuelerLernabschnittsdaten");
const SchuelerListeEintrag_1 = require("../core/data/schueler/SchuelerListeEintrag");
const SchuelerSchulbesuchsdaten_1 = require("../core/data/schueler/SchuelerSchulbesuchsdaten");
const SchuelerStammdaten_1 = require("../core/data/schueler/SchuelerStammdaten");
const SchuleStammdaten_1 = require("../core/data/schule/SchuleStammdaten");
const Vector_1 = require("../java/util/Vector");
class ApiServer extends BaseApi_1.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, username, password) {
        super(url, username, password);
    }
    /**
     * 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
     */
    async getConfigCertificate() {
        let path = "/config/certificate";
        const text = await super.getText(path);
        return String(text);
    }
    /**
     * 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
     */
    async getConfigCertificateBase64() {
        let path = "/config/certificate_base64";
        const text = await super.getText(path);
        return String(text);
    }
    /**
     * 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
     */
    async getConfigDBSchemata() {
        let path = "/config/db/schemata";
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(DBSchemaListeEintrag_1.DBSchemaListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getConfigPublicKeyBase64() {
        let path = "/config/publickey_base64";
        const text = await super.getText(path);
        return String(text);
    }
    /**
     * 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
     */
    async getBenutzerliste(schema) {
        let path = "/db/{schema}/benutzer/"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(BenutzerListeEintrag_1.BenutzerListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getBetriebe(schema) {
        let path = "/db/{schema}/betriebe/"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(BetriebListeEintrag_1.BetriebListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async patchSchuelerBetriebsdaten(data, schema, id) {
        let path = "/db/{schema}/betriebe/{id : \d+}/betrieb"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = SchuelerBetriebsdaten_1.SchuelerBetriebsdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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.
     */
    async getSchuelerBetriebsdaten(schema, id) {
        let path = "/db/{schema}/betriebe/{id : \d+}/betrieb"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(SchuelerBetriebsdaten_1.SchuelerBetriebsdaten.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getBetriebStammdaten(schema, id) {
        let path = "/db/{schema}/betriebe/{id : \d+}/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return BetriebStammdaten_1.BetriebStammdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchBetriebStammdaten(data, schema, id) {
        let path = "/db/{schema}/betriebe/{id : \d+}/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = BetriebStammdaten_1.BetriebStammdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async setClientConfigGlobalKey(data, schema, app, key) {
        let path = "/db/{schema}/client/config/{app}/global/{key}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{app\s*(:[^}]+)?}/g, app)
            .replace(/{key\s*(:[^}]+)?}/g, key);
        let body = JSON.stringify(data);
        return super.putJSON(path, body);
    }
    /**
     * 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
     */
    async getClientConfigUserKey(schema, app, key) {
        let path = "/db/{schema}/client/config/{app}/user/{key}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{app\s*(:[^}]+)?}/g, app)
            .replace(/{key\s*(:[^}]+)?}/g, key);
        const result = await super.getJSON(path);
        const text = result;
        return JSON.parse(text).toString();
    }
    /**
     * 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
     */
    async setClientConfigUserKey(data, schema, app, key) {
        let path = "/db/{schema}/client/config/{app}/user/{key}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{app\s*(:[^}]+)?}/g, app)
            .replace(/{key\s*(:[^}]+)?}/g, key);
        let body = JSON.stringify(data);
        return super.putJSON(path, body);
    }
    /**
     * 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
     */
    async getLehrerENMDaten(schema, id) {
        let path = "/db/{schema}/enm/lehrer/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return ENMDaten_1.ENMDaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getErzieher(schema) {
        let path = "/db/{schema}/erzieher/"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(ErzieherListeEintrag_1.ErzieherListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getErzieherStammdaten(schema, id) {
        let path = "/db/{schema}/erzieher/{id : \d+}/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return ErzieherStammdaten_1.ErzieherStammdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchErzieherStammdaten(data, schema, id) {
        let path = "/db/{schema}/erzieher/{id : \d+}/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = ErzieherStammdaten_1.ErzieherStammdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getErzieherArten(schema) {
        let path = "/db/{schema}/erzieher/arten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(Erzieherart_1.Erzieherart.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getFaecher(schema) {
        let path = "/db/{schema}/faecher/"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(FaecherListeEintrag_1.FaecherListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getFach(schema, id) {
        let path = "/db/{schema}/faecher/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return FachDaten_1.FachDaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getGesamtschuleSchuelerPrognoseLeistungsdaten(schema, id) {
        let path = "/db/{schema}/gesamtschule/schueler/{id : \d+}/prognose_leistungsdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GEAbschlussFaecher_1.GEAbschlussFaecher.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getGesamtschuleSchuelerPrognosLeistungsdatenFuerAbschnitt(schema, id, abschnittID) {
        let path = "/db/{schema}/gesamtschule/schueler/{id : \d+}/prognose_leistungsdaten/abschnitt/{abschnittID : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString())
            .replace(/{abschnittID\s*(:[^}]+)?}/g, abschnittID.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GEAbschlussFaecher_1.GEAbschlussFaecher.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getGostAbiturBelegpruefungEF1(data, schema) {
        let path = "/db/{schema}/gost/abitur/belegpruefung/EF1"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        let body = Abiturdaten_1.Abiturdaten.transpilerToJSON(data);
        const result = await super.postJSON(path, body);
        const text = result;
        return GostBelegpruefungErgebnis_1.GostBelegpruefungErgebnis.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getGostAbiturBelegpruefungGesamt(data, schema) {
        let path = "/db/{schema}/gost/abitur/belegpruefung/gesamt"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        let body = Abiturdaten_1.Abiturdaten.transpilerToJSON(data);
        const result = await super.postJSON(path, body);
        const text = result;
        return GostBelegpruefungErgebnis_1.GostBelegpruefungErgebnis.transpilerFromJSON(text);
    }
    /**
     * 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.
     */
    async getGostAbiturjahrgaenge(schema) {
        let path = "/db/{schema}/gost/abiturjahrgaenge"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(GostJahrgang_1.GostJahrgang.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getGostAbiturjahrgang(schema, abiturjahr) {
        let path = "/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abiturjahr\s*(:[^}]+)?}/g, abiturjahr.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GostJahrgangsdaten_1.GostJahrgangsdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchGostAbiturjahrgang(data, schema, abiturjahr) {
        let path = "/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abiturjahr\s*(:[^}]+)?}/g, abiturjahr.toString());
        let body = GostJahrgangsdaten_1.GostJahrgangsdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getGostAbiturjahrgangBlockungsliste(schema, abiturjahr, halbjahr) {
        let path = "/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/{halbjahr : \d+}/blockungen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abiturjahr\s*(:[^}]+)?}/g, abiturjahr.toString())
            .replace(/{halbjahr\s*(:[^}]+)?}/g, halbjahr.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(GostBlockungListeneintrag_1.GostBlockungListeneintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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.
     */
    async createGostAbiturjahrgangBlockung(data, schema, abiturjahr, halbjahr, name) {
        let path = "/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/{halbjahr : \d+}/blockungen/new/{name}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abiturjahr\s*(:[^}]+)?}/g, abiturjahr.toString())
            .replace(/{halbjahr\s*(:[^}]+)?}/g, halbjahr.toString())
            .replace(/{name\s*(:[^}]+)?}/g, name);
        let body = JSON.stringify(data);
        const result = await super.postJSON(path, body);
        const text = result;
        return parseFloat(JSON.parse(text));
    }
    /**
     * 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
     */
    async getGostAbiturjahrgangFach(schema, abiturjahr, id) {
        let path = "/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/fach/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abiturjahr\s*(:[^}]+)?}/g, abiturjahr.toString())
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GostFach_1.GostFach.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchGostAbiturjahrgangFach(data, schema, abiturjahr, id) {
        let path = "/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/fach/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abiturjahr\s*(:[^}]+)?}/g, abiturjahr.toString())
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = GostFach_1.GostFach.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getGostAbiturjahrgangFachwahlen(schema, abiturjahr) {
        let path = "/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/fachwahlen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abiturjahr\s*(:[^}]+)?}/g, abiturjahr.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(GostStatistikFachwahl_1.GostStatistikFachwahl.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getGostAbiturjahrgangFaecher(schema, abiturjahr) {
        let path = "/db/{schema}/gost/abiturjahrgang/{abiturjahr : \d+}/faecher"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abiturjahr\s*(:[^}]+)?}/g, abiturjahr.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(GostFach_1.GostFach.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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.
     */
    async createGostAbiturjahrgang(schema, jahrgangid) {
        let path = "/db/{schema}/gost/abiturjahrgang/new/{jahrgangid}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{jahrgangid\s*(:[^}]+)?}/g, jahrgangid.toString());
        const result = await super.postJSON(path, null);
        const text = result;
        return parseInt(JSON.parse(text));
    }
    /**
     * 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
     */
    async deleteGostBlockung(schema, blockungsid) {
        let path = "/db/{schema}/gost/blockungen/{blockungsid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{blockungsid\s*(:[^}]+)?}/g, blockungsid.toString());
        return super.deleteJSON(path);
    }
    /**
     * 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
     */
    async getGostBlockung(schema, blockungsid) {
        let path = "/db/{schema}/gost/blockungen/{blockungsid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{blockungsid\s*(:[^}]+)?}/g, blockungsid.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GostBlockungsdaten_1.GostBlockungsdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchGostBlockung(data, schema, blockungsid) {
        let path = "/db/{schema}/gost/blockungen/{blockungsid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{blockungsid\s*(:[^}]+)?}/g, blockungsid.toString());
        let body = GostBlockungsdaten_1.GostBlockungsdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async rechneGostBlockung(schema, blockungsid, zeit) {
        let path = "/db/{schema}/gost/blockungen/{blockungsid : \d+}/rechne/{zeit : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{blockungsid\s*(:[^}]+)?}/g, blockungsid.toString())
            .replace(/{zeit\s*(:[^}]+)?}/g, zeit.toString());
        const result = await super.postJSON(path, null);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(parseFloat(JSON.parse(text))); });
        return ret;
    }
    /**
     * 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
     */
    async getGostBlockungKurs(schema, kursid) {
        let path = "/db/{schema}/gost/blockungen/kurse/{kursid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{kursid\s*(:[^}]+)?}/g, kursid.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GostBlockungKurs_1.GostBlockungKurs.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchGostBlockungKurs(data, schema, kursid) {
        let path = "/db/{schema}/gost/blockungen/kurse/{kursid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{kursid\s*(:[^}]+)?}/g, kursid.toString());
        let body = GostBlockungKurs_1.GostBlockungKurs.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getGostBlockungRegel(schema, regelid) {
        let path = "/db/{schema}/gost/blockungen/regeln/{regelid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{regelid\s*(:[^}]+)?}/g, regelid.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GostBlockungRegel_1.GostBlockungRegel.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchGostBlockungRegel(data, schema, regelid) {
        let path = "/db/{schema}/gost/blockungen/regeln/{regelid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{regelid\s*(:[^}]+)?}/g, regelid.toString());
        let body = GostBlockungRegel_1.GostBlockungRegel.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getGostBlockungSchiene(schema, schienenid) {
        let path = "/db/{schema}/gost/blockungen/schiene/{schienenid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{schienenid\s*(:[^}]+)?}/g, schienenid.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GostBlockungSchiene_1.GostBlockungSchiene.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchGostBlockungSchiene(data, schema, schienenid) {
        let path = "/db/{schema}/gost/blockungen/schiene/{schienenid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{schienenid\s*(:[^}]+)?}/g, schienenid.toString());
        let body = GostBlockungSchiene_1.GostBlockungSchiene.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getGostFach(schema, id) {
        let path = "/db/{schema}/gost/fach/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GostFach_1.GostFach.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchGostFach(data, schema, id) {
        let path = "/db/{schema}/gost/fach/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = GostFach_1.GostFach.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getGostFaecher(schema) {
        let path = "/db/{schema}/gost/faecher"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(GostFach_1.GostFach.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getGostSchuelerAbiturdaten(schema, id) {
        let path = "/db/{schema}/gost/schueler/{id : \d+}/abiturdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return Abiturdaten_1.Abiturdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getGostSchuelerAbiturdatenAusLeistungsdaten(schema, id) {
        let path = "/db/{schema}/gost/schueler/{id : \d+}/abiturdatenAusLeistungsdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return Abiturdaten_1.Abiturdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getGostSchuelerLaufbahnplanung(schema, id) {
        let path = "/db/{schema}/gost/schueler/{id : \d+}/laufbahnplanung"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return Abiturdaten_1.Abiturdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getGostSchuelerLeistungsdaten(schema, id) {
        let path = "/db/{schema}/gost/schueler/{id : \d+}/leistungsdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return GostLeistungen_1.GostLeistungen.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getGostSchuelerPDFWahlbogen(schema, id) {
        let path = "/db/{schema}/gost/schueler/{id : \d+}/wahlbogen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const data = await super.getPDF(path);
        return data;
    }
    /**
     * 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
     */
    async getGostSchuelerFachwahl(schema, schuelerid, fachid) {
        let path = "/db/{schema}/gost/schueler/{schuelerid : \d+}/fachwahl/{fachid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{schuelerid\s*(:[^}]+)?}/g, schuelerid.toString())
            .replace(/{fachid\s*(:[^}]+)?}/g, fachid.toString());
        const result = await super.getJSON(path);
        const text = result;
        return Abiturdaten_1.Abiturdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchGostSchuelerFachwahl(data, schema, schuelerid, fachid) {
        let path = "/db/{schema}/gost/schueler/{schuelerid : \d+}/fachwahl/{fachid : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{schuelerid\s*(:[^}]+)?}/g, schuelerid.toString())
            .replace(/{fachid\s*(:[^}]+)?}/g, fachid.toString());
        let body = GostSchuelerFachwahl_1.GostSchuelerFachwahl.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getJahrgaenge(schema) {
        let path = "/db/{schema}/jahrgaenge/"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(JahrgangsListeEintrag_1.JahrgangsListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getJahrgang(schema, id) {
        let path = "/db/{schema}/jahrgaenge/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return JahrgangsDaten_1.JahrgangsDaten.transpilerFromJSON(text);
    }
    /**
     * 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.
     */
    async getKatalogBeschaeftigungsart(schema) {
        let path = "/db/{schema}/kataloge/beschaeftigungsart"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintrag_1.KatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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.
     */
    async getKatalogBeschaeftigungsartmitID(schema, id) {
        let path = "/db/{schema}/kataloge/beschaeftigungsart/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintrag_1.KatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async patchBeschaeftigungsart(data, schema, id) {
        let path = "/db/{schema}/kataloge/beschaeftigungsart/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = KatalogEintrag_1.KatalogEintrag.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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.
     */
    async getKatalogBetriebsartmitID(schema, id) {
        let path = "/db/{schema}/kataloge/beschaeftigungsart/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintrag_1.KatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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.
     */
    async getKatalogBetriebsart(schema) {
        let path = "/db/{schema}/kataloge/betriebsart"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintrag_1.KatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async patchBetriebsart(data, schema, id) {
        let path = "/db/{schema}/kataloge/betriebsart/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = KatalogEintrag_1.KatalogEintrag.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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.
     */
    async getKatalogHaltestellen(schema) {
        let path = "/db/{schema}/kataloge/haltestellen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintrag_1.KatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getKatalogNationaelitaeten(schema) {
        let path = "/db/{schema}/kataloge/nationalitaeten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(NationalitaetKatalogEintrag_1.NationalitaetKatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getKatalogOrte(schema) {
        let path = "/db/{schema}/kataloge/orte"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(OrtKatalogEintrag_1.OrtKatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getKatalogOrtsteile(schema) {
        let path = "/db/{schema}/kataloge/ortsteile"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(OrtsteilKatalogEintrag_1.OrtsteilKatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getKatalogReligionen(schema) {
        let path = "/db/{schema}/kataloge/religionen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(ReligionKatalogEintrag_1.ReligionKatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getKatalogStrassen(schema) {
        let path = "/db/{schema}/kataloge/strassen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintragStrassen_1.KatalogEintragStrassen.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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.
     */
    async getKatalogVerkehrssprachen(schema) {
        let path = "/db/{schema}/kataloge/verkehrsprachen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintrag_1.KatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getKlasse(schema, id) {
        let path = "/db/{schema}/klassen/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return KlassenDaten_1.KlassenDaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getKlassenFuerAbschnitt(schema, abschnitt) {
        let path = "/db/{schema}/klassen/abschnitt/{abschnitt : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abschnitt\s*(:[^}]+)?}/g, abschnitt.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KlassenListeEintrag_1.KlassenListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getKurse(schema) {
        let path = "/db/{schema}/kurse/"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KursListeEintrag_1.KursListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getKurs(schema, id) {
        let path = "/db/{schema}/kurse/{id : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return KursDaten_1.KursDaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getKurseFuerAbschnitt(schema, abschnitt) {
        let path = "/db/{schema}/kurse/abschnitt/{abschnitt : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abschnitt\s*(:[^}]+)?}/g, abschnitt.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KursListeEintrag_1.KursListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrer(schema) {
        let path = "/db/{schema}/lehrer/"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerListeEintrag_1.LehrerListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerPersonaldaten(schema, id) {
        let path = "/db/{schema}/lehrer/{id : \d+}/personaldaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return LehrerPersonaldaten_1.LehrerPersonaldaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchLehrerPersonaldaten(data, schema, id) {
        let path = "/db/{schema}/lehrer/{id : \d+}/personaldaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = LehrerPersonaldaten_1.LehrerPersonaldaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getLehrerStammdaten(schema, id) {
        let path = "/db/{schema}/lehrer/{id : \d+}/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return LehrerStammdaten_1.LehrerStammdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchLehrerStammdaten(data, schema, id) {
        let path = "/db/{schema}/lehrer/{id : \d+}/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = LehrerStammdaten_1.LehrerStammdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getLehrerAbgangsgruende(schema) {
        let path = "/db/{schema}/lehrer/abgangsgruende"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogAbgangsgrundEintrag_1.LehrerKatalogAbgangsgrundEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerAnrechnungsgruende(schema) {
        let path = "/db/{schema}/lehrer/anrechnungsgruende"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogAnrechnungsgrundEintrag_1.LehrerKatalogAnrechnungsgrundEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerBeschaeftigungsarten(schema) {
        let path = "/db/{schema}/lehrer/beschaeftigungsarten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogBeschaeftigungsartEintrag_1.LehrerKatalogBeschaeftigungsartEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerEinsatzstatus(schema) {
        let path = "/db/{schema}/lehrer/einsatzstatus"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogEinsatzstatusEintrag_1.LehrerKatalogEinsatzstatusEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerFachrichtungen(schema) {
        let path = "/db/{schema}/lehrer/fachrichtungen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogFachrichtungEintrag_1.LehrerKatalogFachrichtungEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerFachrichtungAnerkennungen(schema) {
        let path = "/db/{schema}/lehrer/fachrichtungen_anerkennungen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogFachrichtungAnerkennungEintrag_1.LehrerKatalogFachrichtungAnerkennungEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerLehraemter(schema) {
        let path = "/db/{schema}/lehrer/lehraemter"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogLehramtEintrag_1.LehrerKatalogLehramtEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerLehramtAnerkennungen(schema) {
        let path = "/db/{schema}/lehrer/lehraemter_anerkennungen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogLehramtAnerkennungEintrag_1.LehrerKatalogLehramtAnerkennungEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerLehrbefaehigungen(schema) {
        let path = "/db/{schema}/lehrer/lehrbefaehigungen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogLehrbefaehigungEintrag_1.LehrerKatalogLehrbefaehigungEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerLehrbefaehigungenAnerkennungen(schema) {
        let path = "/db/{schema}/lehrer/lehrbefaehigungen_anerkennungen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogLehrbefaehigungAnerkennungEintrag_1.LehrerKatalogLehrbefaehigungAnerkennungEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerLeitungsfunktionen(schema) {
        let path = "/db/{schema}/lehrer/leitungsfunktionen"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogLeitungsfunktionEintrag_1.LehrerKatalogLeitungsfunktionEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerMehrleistungsarten(schema) {
        let path = "/db/{schema}/lehrer/mehrleistungsarten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogMehrleistungsartEintrag_1.LehrerKatalogMehrleistungsartEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerMinderleistungsarten(schema) {
        let path = "/db/{schema}/lehrer/minderleistungsarten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogMinderleistungsartEintrag_1.LehrerKatalogMinderleistungsartEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerRechtsverhaeltnisse(schema) {
        let path = "/db/{schema}/lehrer/rechtsverhaeltnisse"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogRechtsverhaeltnisEintrag_1.LehrerKatalogRechtsverhaeltnisEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getLehrerZugangsgruende(schema) {
        let path = "/db/{schema}/lehrer/zugangsgruende"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(LehrerKatalogZugangsgrundEintrag_1.LehrerKatalogZugangsgrundEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchuelerLernabschnittsdaten(schema, id, abschnitt) {
        let path = "/db/{schema}/schueler/{id : \d+}/abschnitt/{abschnitt : \d+}/lernabschnittsdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString())
            .replace(/{abschnitt\s*(:[^}]+)?}/g, abschnitt.toString());
        const result = await super.getJSON(path);
        const text = result;
        return SchuelerLernabschnittsdaten_1.SchuelerLernabschnittsdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async getSchuelerBetriebe(schema, id) {
        let path = "/db/{schema}/schueler/{id : \d+}/betriebe"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(SchuelerBetriebsdaten_1.SchuelerBetriebsdaten.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchuelerBetriebsstammdaten(schema, id) {
        let path = "/db/{schema}/schueler/{id : \d+}/betriebsstammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(BetriebStammdaten_1.BetriebStammdaten.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchuelerErzieher(schema, id) {
        let path = "/db/{schema}/schueler/{id : \d+}/erzieher"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(ErzieherStammdaten_1.ErzieherStammdaten.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchuelerLernabschnittsliste(schema, id) {
        let path = "/db/{schema}/schueler/{id : \d+}/lernabschnitte"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(SchuelerLernabschnittListeEintrag_1.SchuelerLernabschnittListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchuelerSchulbesuch(schema, id) {
        let path = "/db/{schema}/schueler/{id : \d+}/schulbesuch"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return SchuelerSchulbesuchsdaten_1.SchuelerSchulbesuchsdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchSchuelerSchulbesuch(data, schema, id) {
        let path = "/db/{schema}/schueler/{id : \d+}/schulbesuch"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = SchuelerSchulbesuchsdaten_1.SchuelerSchulbesuchsdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getSchuelerStammdaten(schema, id) {
        let path = "/db/{schema}/schueler/{id : \d+}/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        const result = await super.getJSON(path);
        const text = result;
        return SchuelerStammdaten_1.SchuelerStammdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchSchuelerStammdaten(data, schema, id) {
        let path = "/db/{schema}/schueler/{id : \d+}/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{id\s*(:[^}]+)?}/g, id.toString());
        let body = SchuelerStammdaten_1.SchuelerStammdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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
     */
    async getSchuelerFuerAbschnitt(schema, abschnitt) {
        let path = "/db/{schema}/schueler/abschnitt/{abschnitt : \d+}"
            .replace(/{schema\s*(:[^}]+)?}/g, schema)
            .replace(/{abschnitt\s*(:[^}]+)?}/g, abschnitt.toString());
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(SchuelerListeEintrag_1.SchuelerListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchuelerAktuell(schema) {
        let path = "/db/{schema}/schueler/aktuell"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(SchuelerListeEintrag_1.SchuelerListeEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchuelerFahrschuelerarten(schema) {
        let path = "/db/{schema}/schueler/fahrschuelerarten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintrag_1.KatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchuelerFoerderschwerpunkte(schema) {
        let path = "/db/{schema}/schueler/foerderschwerpunkte"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const obj = JSON.parse(result);
        let ret = new Vector_1.Vector();
        obj.forEach((elem) => { let text = JSON.stringify(elem); ret.add(KatalogEintrag_1.KatalogEintrag.transpilerFromJSON(text)); });
        return ret;
    }
    /**
     * 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
     */
    async getSchullogo(schema) {
        let path = "/db/{schema}/schule/logo"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const text = result;
        return JSON.parse(text).toString();
    }
    /**
     * 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
     */
    async putSchullogo(data, schema) {
        let path = "/db/{schema}/schule/logo"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        let body = JSON.stringify(data);
        return super.putJSON(path, body);
    }
    /**
     * 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
     */
    async getSchuleNummer(schema) {
        let path = "/db/{schema}/schule/nummer"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const text = result;
        return parseInt(JSON.parse(text));
    }
    /**
     * 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
     */
    async getSchuleStammdaten(schema) {
        let path = "/db/{schema}/schule/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        const result = await super.getJSON(path);
        const text = result;
        return SchuleStammdaten_1.SchuleStammdaten.transpilerFromJSON(text);
    }
    /**
     * 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
     */
    async patchSchuleStammdaten(data, schema) {
        let path = "/db/{schema}/schule/stammdaten"
            .replace(/{schema\s*(:[^}]+)?}/g, schema);
        let body = SchuleStammdaten_1.SchuleStammdaten.transpilerToJSONPatch(data);
        return super.patchJSON(path, body);
    }
    /**
     * 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!
     */
    async isAlive() {
        let path = "/status/alive";
        const text = await super.getText(path);
        return String(text);
    }
}
exports.ApiServer = ApiServer;
//# sourceMappingURL=ApiServer.js.map