@gandalan/weblibs 1.5.17 → 1.5.19

package/api/business/lieferungApi.js

@@ -0,0 +1,127 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/produktion.js').LieferzusageDTO} LieferzusageDTO
+ * @typedef {import('../dtos/produktion.js').GesamtLieferzusageDTO} GesamtLieferzusageDTO
+ */
+
+/**
+ * Lieferung API - Delivery promises and commitments
+ * @param {FluentApi} fluentApi
+ */
+export function createLieferungApi(fluentApi) {
+    return {
+        // LieferzusageWebRoutinen
+        /**
+         * Get all delivery promises for serie
+         * @param {string} serieGuid
+         * @param {string} [lieferant]
+         * @returns {Promise<LieferzusageDTO[]>}
+         */
+        getAllLieferzusagen: (serieGuid, lieferant = "") =>
+            fluentApi.get(`Lieferzusage/?serieGuid=${serieGuid}&lieferant=${lieferant}`),
+
+        /**
+         * Get delivery promises count
+         * @param {string} serieGuid
+         * @param {string} [lieferant]
+         * @returns {Promise<number>}
+         */
+        getLieferzusagenCount: (serieGuid, lieferant = "") =>
+            fluentApi.get(`Lieferzusage/GetCount/${serieGuid}/${lieferant}`),
+
+        /**
+         * Submit material delivery promise
+         * @param {LieferzusageDTO} lieferzusage
+         * @returns {Promise<string>}
+         */
+        materialZusagen: (lieferzusage) =>
+            fluentApi.post("Lieferzusage", lieferzusage),
+
+        /**
+         * Submit multiple material delivery promises
+         * @param {LieferzusageDTO[]} lieferzusagen
+         * @returns {Promise<string>}
+         */
+        materialZusagenListe: (lieferzusagen) =>
+            fluentApi.post("Lieferzusage/PutLieferzusagenListe", lieferzusagen),
+
+        /**
+         * Reset delivery promise
+         * @param {string} lieferzusageGuid
+         * @returns {Promise<void>}
+         */
+        resetLieferzusage: (lieferzusageGuid) =>
+            fluentApi.delete(`Lieferzusage?zusageGuid=${lieferzusageGuid}`),
+
+        /**
+         * Reset multiple delivery promises
+         * @param {string[]} lieferzusagenGuids
+         * @returns {Promise<string>}
+         */
+        resetLieferzusagen: (lieferzusagenGuids) =>
+            fluentApi.delete("Lieferzusage/DeleteLieferzusagen", lieferzusagenGuids),
+
+        /**
+         * Reset delivery promises by serie
+         * @param {string} serieGuid
+         * @param {string} [lieferant]
+         * @returns {Promise<void>}
+         */
+        resetLieferzusagenBySerie: (serieGuid, lieferant = "") =>
+            fluentApi.delete(`Lieferzusage/DeleteLieferzusagenBySerie/?serieGuid=${serieGuid}&lieferant=${lieferant}`),
+
+        // GesamtLieferzusagenWebRoutinen
+        gesamt: {
+            /**
+             * Get total delivery promises
+             * @param {Date} [stichTag]
+             * @returns {Promise<GesamtLieferzusageDTO[]>}
+             */
+            getAll: (stichTag) =>
+                fluentApi.get(`GesamtLieferzusagen?stichTag=${stichTag?.toISOString() || ""}`),
+
+            /**
+             * Save total delivery promise
+             * @param {GesamtLieferzusageDTO} dto
+             * @returns {Promise<void>}
+             */
+            save: (dto) => fluentApi.put("GesamtLieferzusagen", dto),
+
+            /**
+             * Save multiple total delivery promises
+             * @param {GesamtLieferzusageDTO[]} dtoSet
+             * @returns {Promise<string>}
+             */
+            saveListe: (dtoSet) =>
+                fluentApi.put("GesamtLieferzusagen/PutGesamtLieferzusagenListe", dtoSet),
+
+            /**
+             * Book serie delivery promises
+             * @param {string} serieGuid
+             * @returns {Promise<void>}
+             */
+            serieBuchen: (serieGuid) =>
+                fluentApi.post(`GesamtLieferzusagen/SerieBuchen?serieGuid=${serieGuid}`, null),
+
+            /**
+             * Delete total delivery promise
+             * @param {string} gesamtLieferzusageGuid
+             * @returns {Promise<void>}
+             */
+            delete: (gesamtLieferzusageGuid) =>
+                fluentApi.delete(`GesamtLieferzusage?gesamtLieferzusageGuid=${gesamtLieferzusageGuid}`),
+
+            /**
+             * Delete multiple total delivery promises
+             * @param {string[]} gesamtLieferzusagenGuids
+             * @returns {Promise<string>}
+             */
+            deleteListe: (gesamtLieferzusagenGuids) =>
+                fluentApi.delete("GesamtLieferzusage/DeleteGesamtLieferzusagen", gesamtLieferzusagenGuids),
+        },
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createLieferungApi>} LieferungApi
+ */

package/api/business/mailApi.js

@@ -0,0 +1,41 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/index.js').JobStatusResponseDTO} JobStatusResponseDTO
+ * @typedef {import('../dtos/index.js').JobStatusEntryDTO} JobStatusEntryDTO
+ * @typedef {import('../dtos/index.js').MailJobInfo} MailJobInfo
+ */
+
+/**
+ * Mail API - Email sending and management
+ * @param {FluentApi} fluentApi
+ */
+export function createMailApi(fluentApi) {
+    return {
+        // MailWebRoutinen
+        /**
+         * Send mail
+         * @param {MailJobInfo} job
+         * @param {string[]} [attachments]
+         * @returns {Promise<JobStatusResponseDTO>}
+         */
+        send: (job, attachments) => {
+            const formData = new FormData();
+            formData.append("jobAsString", JSON.stringify(job));
+            if (attachments?.length) {
+                attachments.forEach(file => formData.append("files", file));
+            }
+            return fluentApi.post("Mail", formData);
+        },
+
+        /**
+         * Get mail status
+         * @param {string} guid
+         * @returns {Promise<JobStatusEntryDTO[]>}
+         */
+        getStatus: (guid) => fluentApi.get(`Mail/${guid}`),
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createMailApi>} MailApi
+ */

package/api/business/mandantApi.js

@@ -0,0 +1,137 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/settings.js').MandantDTO} MandantDTO
+ * @typedef {import('../dtos/index.js').BenutzerDTO} BenutzerDTO
+ * @typedef {import('../dtos/index.js').AppActivationStatusDTO} AppActivationStatusDTO
+ */
+
+/**
+ * Mandant API - Mandant/tenant management
+ * @param {FluentApi} fluentApi
+ */
+export function createMandantApi(fluentApi) {
+    return {
+        // MandantenWebRoutinen
+        /**
+         * Sync mandanten list
+         * @param {MandantDTO[]} list
+         * @returns {Promise<void>}
+         */
+        abgleichen: (list) =>
+            Promise.all(list.map(m => fluentApi.put("Mandanten", m))),
+
+        /**
+         * Create mandant
+         * @param {MandantDTO} mandant
+         * @returns {Promise<MandantDTO>}
+         */
+        anlegen: (mandant) => fluentApi.put("Mandanten", mandant),
+
+        /**
+         * Load mandanten with filter
+         * @param {string} filter
+         * @returns {Promise<MandantDTO[]>}
+         */
+        ladenMitFilter: (filter) =>
+            fluentApi.get(`Mandanten?filter=${encodeURIComponent(filter)}`),
+
+        // MandantenAdminWebRoutinen
+        admin: {
+            /**
+             * Load mandanten with filter (admin)
+             * @param {string} filter
+             * @param {boolean} onlyHaendler
+             * @param {boolean} onlyProduzenten
+             * @returns {Promise<MandantDTO[]>}
+             */
+            ladenMitFilter: (filter, onlyHaendler, onlyProduzenten) =>
+                fluentApi.get(`MandantenAdmin?filter=${encodeURIComponent(filter || "")}&onlyHaendler=${onlyHaendler}&onlyProduzenten=${onlyProduzenten}`),
+
+            /**
+             * Load mandant by GUID (admin)
+             * @param {string} guid
+             * @returns {Promise<MandantDTO>}
+             */
+            laden: (guid) => fluentApi.get(`MandantenAdmin?guid=${guid}`),
+
+            /**
+             * Move mandant
+             * @param {string} mandantGuid
+             * @param {string} zielMandantGuid
+             * @returns {Promise<void>}
+             */
+            umziehen: (mandantGuid, zielMandantGuid) =>
+                fluentApi.put("MandantenAdmin", [mandantGuid, zielMandantGuid]),
+
+            /**
+             * Add admin rights
+             * @param {string} email
+             * @returns {Promise<void>}
+             */
+            addAdminRechte: (email) =>
+                fluentApi.post(`MandantenAdmin/SetAdminRechte?email=${encodeURIComponent(email)}`, null),
+        },
+
+        // AppWebRoutinen
+        app: {
+            /**
+             * Get mandant status by customer
+             * @param {string} kundeGuid
+             * @returns {Promise<AppActivationStatusDTO>}
+             */
+            getStatusByKunde: (kundeGuid) => fluentApi.get(`AppMandant/${kundeGuid}`),
+
+            /**
+             * Set mandant status by customer
+             * @param {AppActivationStatusDTO} data
+             * @returns {Promise<AppActivationStatusDTO>}
+             */
+            setStatusByKunde: (data) => fluentApi.put("AppMandant", data),
+
+            /**
+             * Get mandanten
+             * @returns {Promise<MandantDTO[]>}
+             */
+            getAll: () => fluentApi.get("AppMandant/"),
+
+            /**
+             * Get users by customer
+             * @param {string} kundeGuid
+             * @returns {Promise<BenutzerDTO[]>}
+             */
+            getBenutzerByKunde: (kundeGuid) => fluentApi.get(`AppBenutzer/${kundeGuid}`),
+
+            /**
+             * Create or update user by customer
+             * @param {string} kundeGuid
+             * @param {BenutzerDTO} data
+             * @param {boolean} [pwSenden=false]
+             * @param {string} [passwort]
+             * @returns {Promise<BenutzerDTO>}
+             */
+            createOrUpdateBenutzer: (kundeGuid, data, pwSenden = false, passwort = "") =>
+                fluentApi.post(`AppBenutzer/?kundeGuid=${kundeGuid}&pwSenden=${pwSenden}&passwort=${passwort}`, data),
+
+            /**
+             * Delete user by customer
+             * @param {string} kundeGuid
+             * @param {BenutzerDTO} data
+             * @returns {Promise<void>}
+             */
+            deleteBenutzer: (kundeGuid, data) =>
+                fluentApi.delete(`AppBenutzer/?kundeGuid=${kundeGuid}&benutzerGuid=${data.benutzerGuid}`),
+
+            /**
+             * Activate mandant
+             * @param {string} adminEmail
+             * @returns {Promise<void>}
+             */
+            aktiviere: (adminEmail) =>
+                fluentApi.post("ProduzentAktivieren", { adminEmail }),
+        },
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createMandantApi>} MandantApi
+ */

package/api/business/materialApi.js

@@ -0,0 +1,37 @@
+/**
+ * @typedef {Object} MaterialDTO
+ * @property {string} MaterialGuid
+ * @property {string} Bezeichnung
+ * @property {boolean} IstSaegbar
+ * @property {boolean} IstBeschichtbar
+ * @property {boolean} IstFaerbbar
+ * @property {Date} ChangedDate
+ * @property {number} Version
+ * @property {Array<string>} MoeglicheBearbeitungsMethoden
+ */
+
+/** @typedef {import('../fluentApi.js').FluentApi} FluentApi */
+
+/**
+ * @typedef {Object} MaterialApi
+ * @property {() => Promise<MaterialDTO[]>} getAll - Get all materials
+ * @property {(material: MaterialDTO) => Promise<void>} saveMaterial - Save a material
+ */
+
+/**
+ * @param {FluentApi} fluentApi
+ * @returns {MaterialApi}
+ */
+export function createMaterialApi(fluentApi) {
+    const api = fluentApi.withBaseUrl("ModellDaten");
+
+    return {
+        async getAll() {
+            return await api.get("Material");
+        },
+
+        async saveMaterial(material) {
+            return await api.put("Material", material);
+        }
+    };
+}

package/api/business/printApi.js

@@ -0,0 +1,49 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ */
+
+/**
+ * Print API - Document printing and generation
+ * @param {FluentApi} fluentApi
+ */
+export function createPrintApi(fluentApi) {
+    return {
+        // PrintWebRoutinen
+        /**
+         * Generate PDF for beleg
+         * @param {string} belegGuid
+         * @returns {Promise<Uint8Array>}
+         */
+        pdfErzeugen: (belegGuid) =>
+            fluentApi.post(`Print/?bguid=${belegGuid}`, []),
+
+        /**
+         * Generate XPS for beleg
+         * @param {string} belegGuid
+         * @returns {Promise<Uint8Array>}
+         */
+        xpsErzeugen: (belegGuid) =>
+            fluentApi.post(`Print/?bguid=${belegGuid}&fileFormat=XPS`, []),
+
+        // PrintV2WebRoutinen
+        /**
+         * Generate PDF v2
+         * @param {string} belegGuid
+         * @param {string} email
+         * @returns {Promise<Uint8Array>}
+         */
+        pdfV2: (belegGuid, email) =>
+            fluentApi.get(`PrintV2/Pdf?bguid=${belegGuid}&email=${encodeURIComponent(email)}`),
+
+        // BriefbogenWebRoutinen
+        /**
+         * Load letterhead
+         * @returns {Promise<Uint8Array>}
+         */
+        briefbogenLaden: () => fluentApi.get("Briefbogen"),
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createPrintApi>} PrintApi
+ */

package/api/business/produktionApi.js

@@ -0,0 +1,141 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/produktion.js').BearbeitungDTO} BearbeitungDTO
+ * @typedef {import('../dtos/produktion.js').MaterialbedarfDTO} MaterialbedarfDTO
+ * @typedef {import('../dtos/belege.js').VorgangDTO} VorgangDTO
+ * @typedef {import('../dtos/belege.js').BelegartWechselDTO} BelegartWechselDTO
+ * @typedef {import('../dtos/produktion.js').ProduktionsStatusDTO} ProduktionsStatusDTO
+ * @typedef {import('../dtos/produktion.js').ProduktionsStatusHistorieDTO} ProduktionsStatusHistorieDTO
+ * @typedef {import('../dtos/produktion.js').ProduktionsfreigabeItemDTO} ProduktionsfreigabeItemDTO
+ * @typedef {import('../dtos/produktion.js').ProduktionsInfoDTO} ProduktionsInfoDTO
+ */
+
+/**
+ * Produktion API - Production and manufacturing management
+ * @param {FluentApi} fluentApi
+ */
+export function createProduktionApi(fluentApi) {
+    return {
+        // ProduktionWebRoutinen
+        /**
+         * Calculate production for position
+         * @param {string} belegPositionsGuid
+         * @returns {Promise<string>}
+         */
+        produktionBerechnen: (belegPositionsGuid) =>
+            fluentApi.get(`Script/PosBerechnen?pguid=${belegPositionsGuid}`),
+
+        /**
+         * Get production for position
+         * @param {string} belegPositionsGuid
+         * @returns {Promise<BearbeitungDTO[]>}
+         */
+        getProduktion: (belegPositionsGuid) =>
+            fluentApi.get(`Produktion/?posguid=${belegPositionsGuid}`),
+
+        /**
+         * Get material requirements for position
+         * @param {string} belegPositionsGuid
+         * @returns {Promise<MaterialbedarfDTO[]>}
+         */
+        getMaterialBedarf: (belegPositionsGuid) =>
+            fluentApi.get(`MaterialBedarf/?posguid=${belegPositionsGuid}`),
+
+        // ProduktionsfreigabeWebRoutinen
+        /**
+         * Add production release
+         * @param {BelegartWechselDTO} dto
+         * @returns {Promise<VorgangDTO>}
+         */
+        addProduktionsfreigabe: (dto) => fluentApi.put("Produktionsfreigabe", dto),
+
+        /**
+         * Run production release web job
+         * @returns {Promise<void>}
+         */
+        produktionsfreigabeWebJob: () => fluentApi.post("Produktionsfreigabe/WebJob", null),
+
+        // ProduktionsfreigabeListeWebRoutinen
+        /**
+         * Get all production release items
+         * @returns {Promise<ProduktionsfreigabeItemDTO[]>}
+         */
+        getAllProduktionsfreigabeItems: () => fluentApi.get("ProduktionsfreigabeListe"),
+
+        // ProduktionsfreigabeInfoWebRoutinen
+        /**
+         * Get production release info for belege
+         * @param {string[]} belegGuids
+         * @returns {Promise<Record<string, Date>>}
+         */
+        getProduktionsfreigabeInfo: (belegGuids) =>
+            fluentApi.put("ProduktionsfreigabeInfo", belegGuids),
+
+        // ProduktionsStatusWebRoutinen
+        /**
+         * Get all production statuses
+         * @returns {Promise<ProduktionsStatusDTO[]>}
+         */
+        getAllProduktionsStatus: () => fluentApi.get("ProduktionsStatus"),
+
+        /**
+         * Get production status by GUID
+         * @param {string} guid
+         * @returns {Promise<ProduktionsStatusDTO>}
+         */
+        getProduktionsStatus: (guid) => fluentApi.get(`ProduktionsStatus/${guid}`),
+
+        /**
+         * Save production status
+         * @param {ProduktionsStatusDTO} status
+         * @returns {Promise<void>}
+         */
+        saveProduktionsStatus: (status) => fluentApi.put("ProduktionsStatus", status),
+
+        /**
+         * Save production status history
+         * @param {string} avGuid
+         * @param {ProduktionsStatusHistorieDTO} historie
+         * @returns {Promise<void>}
+         */
+        saveProduktionsStatusHistorie: (avGuid, historie) =>
+            fluentApi.put(`ProduktionsStatus/AddHistorie/${avGuid}`, historie),
+
+        // ProduktionsInfoWebRoutinen
+        /**
+         * Get production info for vorgang
+         * @param {string} vorgangGuid
+         * @returns {Promise<ProduktionsInfoDTO>}
+         */
+        getProduktionsInfo: (vorgangGuid) => fluentApi.get(`ProduktionsInfo?vorgangGuid=${vorgangGuid}`),
+
+        // IBOS1Routinen
+        /**
+         * Calculate IBOS1 production
+         * @param {string} belegPositionsGuid
+         * @returns {Promise<string>}
+         */
+        ibos1ProduktionBerechnen: (belegPositionsGuid) =>
+            fluentApi.get(`IBOS1/Print?bguid=${belegPositionsGuid}`),
+
+        /**
+         * Test IBOS1 position
+         * @param {string} belegPositionsGuid
+         * @returns {Promise<string>}
+         */
+        ibos1PositionTesten: (belegPositionsGuid) =>
+            fluentApi.get(`Test?bguid=${belegPositionsGuid}`),
+
+        /**
+         * Get IBOS1 production
+         * @param {string} guid
+         * @returns {Promise<string>}
+         */
+        getIbos1Produktion: (guid) =>
+            fluentApi.get(`Produktion/?posguid=${guid}`),
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createProduktionApi>} ProduktionApi
+ */

package/api/business/rechnungApi.js

@@ -0,0 +1,155 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/faktura.js').BelegeInfoDTO} BelegeInfoDTO
+ * @typedef {import('../dtos/belege.js').BelegartWechselDTO} BelegartWechselDTO
+ * @typedef {import('../dtos/faktura.js').SammelrechnungDTO} SammelrechnungDTO
+ * @typedef {import('../dtos/faktura.js').SammelrechnungListItemDTO} SammelrechnungListItemDTO
+ * @typedef {import('../dtos/faktura.js').CreateSammelrechnungDTO} CreateSammelrechnungDTO
+ */
+
+/**
+ * Rechnung API - Invoice creation and management
+ * Corresponds to RechnungenWebRoutinen and SammelrechnungenWebRoutinen in C#
+ * @param {FluentApi} fluentApi
+ */
+export function createRechnungApi(fluentApi) {
+    return {
+        // RechnungenWebRoutinen
+        /**
+         * Get all deliverable delivery notes
+         * @returns {Promise<BelegeInfoDTO[]>}
+         */
+        getAllAbFakturierbar: () =>
+            fluentApi.get("Rechnungen/GetABFakturierbar"),
+
+        /**
+         * Get all printable invoices
+         * @param {Date} [printedSince]
+         * @returns {Promise<BelegeInfoDTO[]>}
+         */
+        getAllDruckbar: (printedSince) =>
+            fluentApi.get(`Rechnungen/GetNotPrintedRechnungen?printedSince=${printedSince?.toISOString()}`),
+
+        /**
+         * Get all exportable invoices
+         * @param {Date} [exportedSince]
+         * @returns {Promise<BelegeInfoDTO[]>}
+         */
+        getAllExportierbar: (exportedSince) =>
+            fluentApi.get(`Rechnungen/GetNotExportedRechnungen?exportedSince=${exportedSince?.toISOString()}`),
+
+        /**
+         * Set belege as printed
+         * @param {string[]} belegListe
+         * @returns {Promise<void>}
+         */
+        setBelegePrinted: (belegListe) =>
+            fluentApi.post("Rechnungen/SetBelegePrinted", belegListe),
+
+        /**
+         * Set belege as exported
+         * @param {string[]} belegListe
+         * @returns {Promise<void>}
+         */
+        setBelegeExported: (belegListe) =>
+            fluentApi.post("Rechnungen/SetBelegeExported", belegListe),
+
+        /**
+         * Create invoices from delivery notes
+         * @param {BelegartWechselDTO[]} belegeWechsel
+         * @returns {Promise<Record<string, string>>} Map of belegGuid to rechnungGuid
+         */
+        erstelleRechnungen: (belegeWechsel) =>
+            fluentApi.post("Rechnungen/ErstelleRechnungen", belegeWechsel),
+
+        // SammelrechnungenWebRoutinen
+        sammel: {
+            /**
+             * Create collective invoice
+             * @param {CreateSammelrechnungDTO} dto
+             * @returns {Promise<SammelrechnungListItemDTO>}
+             */
+            erstellen: (dto) =>
+                fluentApi.post("Sammelrechnungen/ErstelleSammelrechnungen", dto),
+
+            /**
+             * Get not printed collective invoices
+             * @param {Date} [printedSince]
+             * @returns {Promise<SammelrechnungListItemDTO[]>}
+             */
+            getNotPrinted: (printedSince) =>
+                fluentApi.get(`Sammelrechnungen/GetNotPrintedSammelrechnungen?printedSince=${printedSince?.toISOString()}`),
+
+            /**
+             * Get not exported collective invoices
+             * @param {Date} [exportedSince]
+             * @returns {Promise<SammelrechnungListItemDTO[]>}
+             */
+            getNotExported: (exportedSince) =>
+                fluentApi.get(`Sammelrechnungen/GetNotExportedSammelrechnungen?exportedSince=${exportedSince?.toISOString()}`),
+
+            /**
+             * Get collective invoice by GUID
+             * @param {string} guid
+             * @param {boolean} includeBelegDruckDTO
+             * @returns {Promise<SammelrechnungDTO>}
+             */
+            get: (guid, includeBelegDruckDTO) =>
+                fluentApi.get(`Sammelrechnungen/GetSammelrechnung?guid=${guid}&includeBelegDruckDTO=${includeBelegDruckDTO}`),
+
+            /**
+             * Get possible collective invoice items
+             * @returns {Promise<BelegeInfoDTO[]>}
+             */
+            getPossibleRechnungen: () =>
+                fluentApi.get("Sammelrechnungen/GetPossibleSammelrechnungRechnungen"),
+
+            /**
+             * Update collective invoice
+             * @param {SammelrechnungDTO} dto
+             * @returns {Promise<SammelrechnungDTO>}
+             */
+            update: (dto) =>
+                fluentApi.post("Sammelrechnungen/UpdateSammelrechnung", dto),
+
+            /**
+             * Add invoice to collective invoice
+             * @param {string} belegGuid
+             * @param {string} sammelrechnungGuid
+             * @returns {Promise<SammelrechnungListItemDTO>}
+             */
+            addRechnung: (belegGuid, sammelrechnungGuid) =>
+                fluentApi.post("Sammelrechnungen/AddRechnungToSammelrechnungen", { belegGuid, sammelrechnungGuid }),
+
+            /**
+             * Set invoices as printed
+             * @param {string[]} guidListe
+             * @param {boolean} [setEinzel=false]
+             * @returns {Promise<void>}
+             */
+            setAlsGedruckt: (guidListe, setEinzel = false) =>
+                fluentApi.post(`Sammelrechnungen/SetSammelrechnungPrinted?setEinzel=${setEinzel}`, guidListe),
+
+            /**
+             * Set invoices as exported to accounting
+             * @param {string[]} guidListe
+             * @param {boolean} [setEinzel=false]
+             * @returns {Promise<void>}
+             */
+            setAlsFibuUebergeben: (guidListe, setEinzel = false) =>
+                fluentApi.post(`Sammelrechnungen/SetSammelrechnungExported?setEinzel=${setEinzel}`, guidListe),
+
+            /**
+             * Search collective invoices
+             * @param {string} term
+             * @returns {Promise<SammelrechnungListItemDTO[]>}
+             */
+            search: (term) =>
+                fluentApi.get(`Sammelrechnungen/SearchSammelrechnung?term=${term}`),
+        },
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createRechnungApi>} RechnungApi
+ */