@gandalan/weblibs 1.5.17 → 1.5.19

package/api/business/farbeApi.js

@@ -0,0 +1,129 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/index.js').FarbeDTO} FarbeDTO
+ * @typedef {import('../dtos/index.js').FarbGruppeDTO} FarbGruppeDTO
+ * @typedef {import('../dtos/index.js').OberflaecheDTO} OberflaecheDTO
+ * @typedef {import('../dtos/index.js').FarbKuerzelDTO} FarbKuerzelDTO
+ * @typedef {import('../dtos/index.js').FarbKuerzelGruppeDTO} FarbKuerzelGruppeDTO
+ * @typedef {import('../dtos/index.js').FarbgruppenaufpreiseDTO} FarbgruppenaufpreiseDTO
+ * @typedef {import('../dtos/index.js').ProduzentenFarbGruppeDTO} ProduzentenFarbGruppeDTO
+ */
+
+/**
+ * Farbe API - Color management
+ * @param {FluentApi} fluentApi
+ */
+export function createFarbeApi(fluentApi) {
+    return {
+        // FarbenWebRoutinen
+        /**
+         * Get all colors
+         * @returns {Promise<FarbeDTO[]>}
+         */
+        getAllFarben: () => fluentApi.get("Farben"),
+
+        /**
+         * Save color
+         * @param {FarbeDTO} dto
+         * @returns {Promise<void>}
+         */
+        saveFarbe: (dto) => fluentApi.put(`Farben/${dto.farbItemGuid}`, dto),
+
+        // OberflaechenWebRoutinen
+        /**
+         * Get all surfaces
+         * @returns {Promise<OberflaecheDTO[]>}
+         */
+        getAllOberflaechen: () => fluentApi.get("Oberflaeche"),
+
+        /**
+         * Save surface
+         * @param {OberflaecheDTO} dto
+         * @returns {Promise<void>}
+         */
+        saveOberflaeche: (dto) => fluentApi.put(`Oberflaeche/${dto.oberflaecheGuid}`, dto),
+
+        // FarbGruppenWebRoutinen
+        /**
+         * Get all color groups
+         * @returns {Promise<FarbGruppeDTO[]>}
+         */
+        getAllFarbGruppen: () => fluentApi.get("FarbGruppen"),
+
+        /**
+         * Save color group
+         * @param {FarbGruppeDTO} dto
+         * @returns {Promise<void>}
+         */
+        saveFarbGruppe: (dto) => fluentApi.put(`FarbGruppen/${dto.farbItemGroupGuid}`, dto),
+
+        // FarbKuerzelWebRoutinen
+        /**
+         * Get all color codes
+         * @returns {Promise<FarbKuerzelDTO[]>}
+         */
+        getAllFarbKuerzel: () => fluentApi.get("FarbKuerzel"),
+
+        /**
+         * Save color code
+         * @param {FarbKuerzelDTO} dto
+         * @returns {Promise<void>}
+         */
+        saveFarbKuerzel: (dto) => fluentApi.put(`FarbKuerzel/${dto.farbKuerzelGuid}`, dto),
+
+        // FarbKuerzelGruppenWebRoutinen
+        /**
+         * Get all color code groups
+         * @returns {Promise<FarbKuerzelGruppeDTO[]>}
+         */
+        getAllFarbKuerzelGruppen: () => fluentApi.get("FarbKuerzelGruppe"),
+
+        /**
+         * Save color code group
+         * @param {FarbKuerzelGruppeDTO} dto
+         * @returns {Promise<void>}
+         */
+        saveFarbKuerzelGruppe: (dto) => fluentApi.put("FarbKuerzelGruppe/", dto),
+
+        // FarbgruppenaufpreisWebRoutinen
+        /**
+         * Get color group surcharges
+         * @returns {Promise<FarbgruppenaufpreiseDTO[]>}
+         */
+        getFarbgruppenaufpreise: () => fluentApi.get("Farbgruppenaufpreis"),
+
+        /**
+         * Save color group surcharge
+         * @param {FarbgruppenaufpreiseDTO} dto
+         * @returns {Promise<void>}
+         */
+        saveFarbgruppenaufpreise: (dto) => fluentApi.put("Farbgruppenaufpreis", dto),
+
+        // ProduzentenFarbGruppenWebRoutinen
+        /**
+         * Get all producer color groups
+         * @returns {Promise<ProduzentenFarbGruppeDTO[]>}
+         */
+        getAllProduzentenFarbGruppen: () => fluentApi.get("ProduzentenFarbGruppen"),
+
+        /**
+         * Save producer color group
+         * @param {ProduzentenFarbGruppeDTO} dto
+         * @returns {Promise<void>}
+         */
+        saveProduzentenFarbGruppe: (dto) =>
+            fluentApi.put(`ProduzentenFarbGruppen/${dto.produzentenFarbGruppeGuid}`, dto),
+
+        /**
+         * Delete producer color group
+         * @param {string} produzentenFarbGruppeGuid
+         * @returns {Promise<void>}
+         */
+        deleteProduzentenFarbGruppe: (produzentenFarbGruppeGuid) =>
+            fluentApi.delete(`ProduzentenFarbGruppen/${produzentenFarbGruppeGuid}`),
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createFarbeApi>} FarbeApi
+ */

package/api/business/fileApi.js

@@ -0,0 +1,72 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/index.js').FileInfoDTO} FileInfoDTO
+ */
+
+/**
+ * File API - File management and storage
+ * @param {FluentApi} fluentApi
+ */
+export function createFileApi(fluentApi) {
+    return {
+        // FileWebRoutinen
+        /**
+         * Get file by name
+         * @param {string} name
+         * @returns {Promise<Uint8Array>}
+         */
+        get: (name) => fluentApi.get(`StaticFile/?name=${name}`),
+
+        /**
+         * Get file list
+         * @returns {Promise<FileInfoDTO[]>}
+         */
+        getList: () => fluentApi.get("StaticFile"),
+
+        /**
+         * Get files as zip
+         * @param {string[]} fileNames
+         * @returns {Promise<Uint8Array>}
+         */
+        getZipped: (fileNames) => fluentApi.put("StaticFile", fileNames),
+
+        // DataFileWebRoutinen
+        data: {
+            /**
+             * Get data file
+             * @param {string} filename
+             * @returns {Promise<Uint8Array>}
+             */
+            get: (filename) => fluentApi.get(`DataFile/?filename=${filename}`),
+
+            /**
+             * Get data file list
+             * @param {string} [directory='/']
+             * @returns {Promise<FileInfoDTO[]>}
+             */
+            getList: (directory = "/") =>
+                fluentApi.get(`DataFile/?subdir=${encodeURIComponent(directory)}`),
+
+            /**
+             * Save data file
+             * @param {string} fileName
+             * @param {Uint8Array} data
+             * @returns {Promise<void>}
+             */
+            save: (fileName, data) =>
+                fluentApi.put(`DataFile/?filename=${fileName}`, data),
+
+            /**
+             * Delete data file
+             * @param {string} filename
+             * @returns {Promise<void>}
+             */
+            delete: (filename) =>
+                fluentApi.delete(`DataFile/?filename=${filename}`),
+        },
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createFileApi>} FileApi
+ */

package/api/business/historieApi.js

@@ -0,0 +1,144 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/belege.js').VorgangHistorienDTO} VorgangHistorienDTO
+ * @typedef {import('../dtos/belege.js').BelegHistorienDTO} BelegHistorienDTO
+ * @typedef {import('../dtos/belege.js').BelegPositionHistorienDTO} BelegPositionHistorienDTO
+ * @typedef {import('../dtos/belege.js').VorgangHistorieDTO} VorgangHistorieDTO
+ * @typedef {import('../dtos/belege.js').BelegHistorieDTO} BelegHistorieDTO
+ * @typedef {import('../dtos/belege.js').BelegPositionHistorieDTO} BelegPositionHistorieDTO
+ * @typedef {import('../dtos/index.js').SerieHistorieDTO} SerieHistorieDTO
+ */
+
+/**
+ * Historie API - History tracking and management
+ * @param {FluentApi} fluentApi
+ */
+export function createHistorieApi(fluentApi) {
+    return {
+        // HistorieWebRoutinen
+        /**
+         * Get vorgang history
+         * @param {string} vorgangGuid
+         * @param {boolean} [includeBelege=false]
+         * @param {boolean} [includePositionen=false]
+         * @returns {Promise<VorgangHistorienDTO>}
+         */
+        getVorgangHistorie: (vorgangGuid, includeBelege = false, includePositionen = false) =>
+            fluentApi.get(`HistorieVorgang?vorgangGuid=${vorgangGuid}&includeBelege=${includeBelege}&includePositionen=${includePositionen}`),
+
+        /**
+         * Get beleg history
+         * @param {string} belegGuid
+         * @param {boolean} [includePositionen=false]
+         * @returns {Promise<BelegHistorienDTO>}
+         */
+        getBelegHistorie: (belegGuid, includePositionen = false) =>
+            fluentApi.get(`HistorieBeleg?belegGuid=${belegGuid}&includePositionen=${includePositionen}`),
+
+        /**
+         * Get beleg position history
+         * @param {string} positionGuid
+         * @returns {Promise<BelegPositionHistorienDTO>}
+         */
+        getBelegPositionHistorie: (positionGuid) =>
+            fluentApi.get(`HistorieBelegPosition?positionGuid=${positionGuid}`),
+
+        /**
+         * Get serie history since date
+         * @param {Date} sinceWhen
+         * @returns {Promise<SerieHistorieDTO[]>}
+         */
+        getSerieHistorieSince: (sinceWhen) =>
+            fluentApi.get(`HistorieSerie?createdSince=${sinceWhen.toISOString()}`),
+
+        /**
+         * Get serie history by GUID
+         * @param {string} serieGuid
+         * @returns {Promise<SerieHistorieDTO[]>}
+         */
+        getSerieHistorie: (serieGuid) => fluentApi.get(`HistorieSerie?serieGuid=${serieGuid}`),
+
+        /**
+         * Add vorgang history
+         * @param {string} vorgangGuid
+         * @param {VorgangHistorieDTO} historyDto
+         * @returns {Promise<void>}
+         */
+        addVorgangHistorie: (vorgangGuid, historyDto) =>
+            fluentApi.post(`HistorieVorgang?vorgangGuid=${vorgangGuid}`, historyDto),
+
+        /**
+         * Add beleg history
+         * @param {string} belegGuid
+         * @param {BelegHistorieDTO} historyDto
+         * @returns {Promise<void>}
+         */
+        addBelegHistorie: (belegGuid, historyDto) =>
+            fluentApi.post(`HistorieBeleg?belegGuid=${belegGuid}`, historyDto),
+
+        /**
+         * Add beleg position history
+         * @param {string} positionGuid
+         * @param {BelegPositionHistorieDTO} historyDto
+         * @returns {Promise<void>}
+         */
+        addBelegPositionHistorie: (positionGuid, historyDto) =>
+            fluentApi.post(`HistorieBelegPosition?positionGuid=${positionGuid}`, historyDto),
+
+        /**
+         * Add serie history
+         * @param {SerieHistorieDTO} historyDto
+         * @returns {Promise<void>}
+         */
+        addSerieHistorie: (historyDto) => fluentApi.post("HistorieSerie", historyDto),
+
+        /**
+         * Add vorgang history from function
+         * @param {string} vorgangGuid
+         * @param {VorgangHistorieDTO} historyDto
+         * @param {number} mandantID
+         * @returns {Promise<void>}
+         */
+        addVorgangHistorieFromFunction: (vorgangGuid, historyDto, mandantID) =>
+            fluentApi.post(`AddVorgangHistorieFromFunction?vorgangGuid=${vorgangGuid}&mandantID=${mandantID}`, historyDto),
+
+        /**
+         * Add beleg position history from function
+         * @param {string} positionGuid
+         * @param {BelegPositionHistorieDTO} historyDto
+         * @param {number} mandantID
+         * @returns {Promise<void>}
+         */
+        addBelegPositionHistorieFromFunction: (positionGuid, historyDto, mandantID) =>
+            fluentApi.post(`AddBelegPositionHistorieFromFunction?positionGuid=${positionGuid}&mandantID=${mandantID}`, historyDto),
+
+        /**
+         * Add serie history from function
+         * @param {SerieHistorieDTO} historyDto
+         * @param {number} mandantID
+         * @returns {Promise<void>}
+         */
+        addSerieHistorieFromFunction: (historyDto, mandantID) =>
+            fluentApi.post(`AddBelegPositionHistorieFromFunction?mandantID=${mandantID}`, historyDto),
+
+        /**
+         * Get last editor for beleg
+         * @param {string} belegGuid
+         * @returns {Promise<string>}
+         */
+        getLetzterBearbeiter: (belegGuid) =>
+            fluentApi.get(`HistorieBeleg/LetzterBearbeiter?belegGuid=${belegGuid}`),
+
+        /**
+         * Get last editors for belege
+         * @param {string[]} belegGuids
+         * @returns {Promise<Record<string, string>>}
+         */
+        getLetzteBearbeiter: (belegGuids) =>
+            fluentApi.post("HistorieBeleg/LetzteBearbeiter", belegGuids),
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createHistorieApi>} HistorieApi
+ */

package/api/business/index.js

@@ -0,0 +1,63 @@
+// Business Routines API Exports
+// Auto-generated from C# Gandalan.IDAS.WebApi.Client BusinessRoutinen
+
+export { createVorgangApi } from "./vorgangApi.js";
+export { createKontaktApi } from "./kontaktApi.js";
+export { createBelegPositionenApi } from "./belegPositionenApi.js";
+export { createMaterialApi } from "./materialApi.js";
+export { createSerienApi } from "./serienApi.js";
+export { createBenutzerApi } from "./benutzerApi.js";
+export { createArtikelApi } from "./artikelApi.js";
+export { createBelegApi } from "./belegApi.js";
+export { createProduktionApi } from "./produktionApi.js";
+export { createFakturaApi } from "./fakturaApi.js";
+export { createSettingsApi } from "./settingsApi.js";
+export { createUiApi } from "./uiApi.js";
+export { createUtilityApi } from "./utilityApi.js";
+
+// New API exports
+export { createAblageApi } from "./ablageApi.js";
+export { createAvApi } from "./avApi.js";
+export { createFarbeApi } from "./farbeApi.js";
+export { createLagerApi } from "./lagerApi.js";
+export { createLieferungApi } from "./lieferungApi.js";
+export { createMandantApi } from "./mandantApi.js";
+export { createPrintApi } from "./printApi.js";
+export { createHistorieApi } from "./historieApi.js";
+export { createSystemApi } from "./systemApi.js";
+export { createFileApi } from "./fileApi.js";
+export { createMailApi } from "./mailApi.js";
+export { createAnpassungApi } from "./anpassungApi.js";
+export { createAuthApi } from "./authApi.js";
+export { createRechnungApi } from "./rechnungApi.js";
+
+// Type exports for JSDoc
+/** @typedef {import('./vorgangApi.js').VorgangApi} VorgangApi */
+/** @typedef {import('./kontaktApi.js').KontaktApi} KontaktApi */
+/** @typedef {import('./belegPositionenApi.js').BelegPositionenApi} BelegPositionenApi */
+/** @typedef {import('./materialApi.js').MaterialApi} MaterialApi */
+/** @typedef {import('./serienApi.js').SerienApi} SerienApi */
+/** @typedef {import('./benutzerApi.js').BenutzerApi} BenutzerApi */
+/** @typedef {import('./artikelApi.js').ArtikelApi} ArtikelApi */
+/** @typedef {import('./belegApi.js').BelegApi} BelegApi */
+/** @typedef {import('./produktionApi.js').ProduktionApi} ProduktionApi */
+/** @typedef {import('./fakturaApi.js').FakturaApi} FakturaApi */
+/** @typedef {import('./settingsApi.js').SettingsApi} SettingsApi */
+/** @typedef {import('./uiApi.js').UiApi} UiApi */
+/** @typedef {import('./utilityApi.js').UtilityApi} UtilityApi */
+/** @typedef {import('./ablageApi.js').AblageApi} AblageApi */
+/** @typedef {import('./avApi.js').AvApi} AvApi */
+/** @typedef {import('./farbeApi.js').FarbeApi} FarbeApi */
+/** @typedef {import('./lagerApi.js').LagerApi} LagerApi */
+/** @typedef {import('./lieferungApi.js').LieferungApi} LieferungApi */
+/** @typedef {import('./mandantApi.js').MandantApi} MandantApi */
+/** @typedef {import('./printApi.js').PrintApi} PrintApi */
+/** @typedef {import('./historieApi.js').HistorieApi} HistorieApi */
+/** @typedef {import('./systemApi.js').SystemApi} SystemApi */
+/** @typedef {import('./fileApi.js').FileApi} FileApi */
+/** @typedef {import('./mailApi.js').MailApi} MailApi */
+/** @typedef {import('./anpassungApi.js').AnpassungApi} AnpassungApi */
+/** @typedef {import('./authApi.js').AuthApi} AuthApi */
+/** @typedef {import('./rechnungApi.js').RechnungApi} RechnungApi */
+
+export {};

package/api/business/kontaktApi.js

@@ -0,0 +1,70 @@
+/**
+ * @typedef {import('../dtos/kunden.js').KontaktListItemDTO} KontaktListItemDTO
+ * @typedef {import('../dtos/kunden.js').KontaktDTO} KontaktDTO
+ */
+
+/**
+ * @typedef {Object} KontaktApi
+ * @property {(ohneEndkunden?: boolean, includeASP?: boolean, includeAdditionalProperties?: boolean) => Promise<KontaktListItemDTO[]>} getList - Get list of all contacts
+ * @property {(changedSince?: Date|null, ohneEndkunden?: boolean, includeASP?: boolean, includeAdditionalProperties?: boolean) => Promise<KontaktListItemDTO[]>} getListChangedSince - Get list of contacts changed since a specific date
+ * @property {(kontaktGuid: string) => Promise<KontaktDTO>} getByGuid - Get contact by GUID
+ * @property {(kundenNummer: string) => Promise<KontaktDTO>} getByKundenNummer - Get contact by customer number
+ * @property {(kontakt: KontaktDTO) => Promise<KontaktDTO>} save - Save a contact
+ * @property {(kontakteIds: string[]) => Promise<void>} archive - Archive multiple contacts
+ * @property {(kontakteIds: string[]) => Promise<void>} unarchive - Unarchive multiple contacts
+ * @property {(guidMapping: Record<string, string>) => Promise<void>} setFremdfertigungGuid - Set Fremdfertigung GUID mapping
+ * @property {(kontaktGuid: string, mandantId: number) => Promise<KontaktDTO>} getForFunction - Get contact for function
+ * @property {(changedSince?: Date|null) => Promise<Record<number, string[]>>} getAllForFunction - Get all contacts for function
+ */
+
+/**
+ * @param {import("../fluentApi.js").FluentApi} fluentApi
+ * @returns {KontaktApi}
+ */
+export function createKontaktApi(fluentApi) {
+    return {
+        async getList(ohneEndkunden = false, includeASP = true, includeAdditionalProperties = true) {
+            return await fluentApi.get(`Kontakt?ohneEndkunden=${ohneEndkunden}&includeASP=${includeASP}&includeAdditionalProperties=${includeAdditionalProperties}`);
+        },
+
+        async getListChangedSince(changedSince = null, ohneEndkunden = false, includeASP = true, includeAdditionalProperties = true) {
+            if (changedSince && changedSince > new Date(0)) {
+                return await fluentApi.get(`Kontakt?changedSince=${changedSince.toISOString()}&ohneEndkunden=${ohneEndkunden}&includeASP=${includeASP}&includeAdditionalProperties=${includeAdditionalProperties}`);
+            }
+            return await fluentApi.get(`Kontakt?ohneEndkunden=${ohneEndkunden}&includeASP=${includeASP}&includeAdditionalProperties=${includeAdditionalProperties}`);
+        },
+
+        async getByGuid(kontaktGuid) {
+            return await fluentApi.get(`Kontakt/${kontaktGuid}`);
+        },
+
+        async getByKundenNummer(kundenNummer) {
+            return await fluentApi.get(`Kontakt/GetByKundenNummer?kundennummer=${kundenNummer}`);
+        },
+
+        async save(kontakt) {
+            return await fluentApi.put("Kontakt", kontakt);
+        },
+
+        async archive(kontakteIds) {
+            return await fluentApi.put("kontakt/archivieren", kontakteIds);
+        },
+
+        async unarchive(kontakteIds) {
+            return await fluentApi.put("kontakt/entarchivieren", kontakteIds);
+        },
+
+        async setFremdfertigungGuid(guidMapping) {
+            return await fluentApi.put("Kontakt/SetFremdfertigungGuid", guidMapping);
+        },
+
+        async getForFunction(kontaktGuid, mandantId) {
+            return await fluentApi.get(`GetKontaktForFunction?id=${kontaktGuid}&mandantId=${mandantId}`);
+        },
+
+        async getAllForFunction(changedSince = null) {
+            const isoString = changedSince ? changedSince.toISOString() : "";
+            return await fluentApi.get(`GetAllKontakteForFunction?changedSince=${isoString}`);
+        }
+    };
+}

package/api/business/lagerApi.js

@@ -0,0 +1,162 @@
+/**
+ * @typedef {import('../fluentApi.js').FluentApi} FluentApi
+ * @typedef {import('../dtos/produktion.js').LagerbestandDTO} LagerbestandDTO
+ * @typedef {import('../dtos/produktion.js').LagerbuchungDTO} LagerbuchungDTO
+ * @typedef {import('../dtos/produktion.js').LagerReservierungDTO} LagerReservierungDTO
+ */
+
+/**
+ * Lager API - Warehouse/inventory management
+ * @param {FluentApi} fluentApi
+ */
+export function createLagerApi(fluentApi) {
+    return {
+        // LagerbestandWebRoutinen
+        /**
+         * Get inventory by GUID
+         * @param {string} guid
+         * @returns {Promise<LagerbestandDTO>}
+         */
+        get: (guid) => fluentApi.get(`Lagerbestand/?id=${guid}`),
+
+        /**
+         * Get inventory from GUID list
+         * @param {string[]} guids
+         * @returns {Promise<LagerbestandDTO[]>}
+         */
+        getFromGuidList: (guids) =>
+            fluentApi.post("Lagerbestand/GetFromGuidList", guids),
+
+        /**
+         * Get all inventory
+         * @param {Date} [changedSince]
+         * @returns {Promise<LagerbestandDTO[]>}
+         */
+        getAll: (changedSince) => {
+            if (changedSince) {
+                return fluentApi.get(`Lagerbestand?changedSince=${changedSince.toISOString()}`);
+            }
+            return fluentApi.get("Lagerbestand");
+        },
+
+        /**
+         * Get inventory below minimum stock
+         * @returns {Promise<LagerbestandDTO[]>}
+         */
+        getUnterschreitungEisernerBestand: () =>
+            fluentApi.get("Lagerbestand/UnterschreitungEisernerBestand"),
+
+        /**
+         * Book inventory
+         * @param {LagerbuchungDTO} buchung
+         * @returns {Promise<LagerbestandDTO>}
+         */
+        buchung: (buchung) => fluentApi.put("Lagerbuchung", buchung),
+
+        /**
+         * Book multiple inventory items
+         * @param {LagerbuchungDTO[]} buchungen
+         * @returns {Promise<LagerbestandDTO[]>}
+         */
+        buchungListe: (buchungen) =>
+            fluentApi.put("Lagerbuchung/PutBuchungListe", buchungen),
+
+        /**
+         * Save inventory
+         * @param {LagerbestandDTO} dto
+         * @returns {Promise<void>}
+         */
+        save: (dto) => fluentApi.put("Lagerbestand/", dto),
+
+        /**
+         * Save inventory list
+         * @param {LagerbestandDTO[]} dtos
+         * @returns {Promise<string[]>}
+         */
+        saveListe: (dtos) =>
+            fluentApi.put("Lagerbestand/PutLagerbestandListe", dtos),
+
+        /**
+         * Delete inventory
+         * @param {string} guid
+         * @returns {Promise<void>}
+         */
+        delete: (guid) => fluentApi.delete(`Lagerbestand/?id=${guid}`),
+
+        /**
+         * Get inventory history
+         * @param {Date} vonDatum
+         * @param {Date} bisDatum
+         * @param {boolean} [mitLagerbuchungen=true]
+         * @param {boolean} [mitReservierungen=true]
+         * @param {string} [katalogArtikelGuid]
+         * @returns {Promise<LagerbuchungDTO[]>}
+         */
+        getHistorie: (vonDatum, bisDatum, mitLagerbuchungen = true, mitReservierungen = true, katalogArtikelGuid) => {
+            const url = `Lagerbuchung/?vonDatum=${vonDatum.toISOString()}&bisDatum=${bisDatum.toISOString()}&mitLagerbuchungen=${mitLagerbuchungen}&mitReservierungen=${mitReservierungen}&katalogArtikelGuid=${katalogArtikelGuid || ""}`;
+            return fluentApi.get(url);
+        },
+
+        // LagerReservierungen
+        reservierung: {
+            /**
+             * Get reservation by GUID
+             * @param {string} guid
+             * @returns {Promise<LagerReservierungDTO>}
+             */
+            get: (guid) => fluentApi.get(`LagerReservierungen/?id=${guid}`),
+
+            /**
+             * Get all reservations
+             * @param {string} [artikelnummer]
+             * @param {string} [farbkuerzel]
+             * @param {string} [farbcode]
+             * @param {string} [bezug]
+             * @param {string} [oberflaeche]
+             * @param {Date} [changedSince]
+             * @returns {Promise<LagerReservierungDTO[]>}
+             */
+            getAll: (artikelnummer = "", farbkuerzel = "", farbcode = "", bezug = "", oberflaeche = "", changedSince) => {
+                let url = `LagerReservierungen?artikelnummer=${artikelnummer}&farbkuerzel=${farbkuerzel}&farbcode=${farbcode}&bezug=${bezug}&oberflaeche=${oberflaeche}`;
+                if (changedSince) {
+                    url += `&changedSince=${changedSince.toISOString()}`;
+                }
+                return fluentApi.get(url);
+            },
+
+            /**
+             * Save reservations
+             * @param {LagerReservierungDTO[]} dtos
+             * @returns {Promise<void>}
+             */
+            save: (dtos) => fluentApi.put("LagerReservierungen/", dtos),
+
+            /**
+             * Delete reservations
+             * @param {string[]} guids
+             * @returns {Promise<void>}
+             */
+            delete: (guids) => fluentApi.delete("LagerReservierungen", guids),
+        },
+
+        // Functions
+        /**
+         * Get producer mandant IDs
+         * @returns {Promise<number[]>}
+         */
+        getProduzentenMandantIds: () =>
+            fluentApi.get("Lagerbestand/GetProduzentIdListe"),
+
+        /**
+         * Initialize inventory for articles
+         * @param {number} mandantID
+         * @returns {Promise<number[]>}
+         */
+        initializeBestand: (mandantID) =>
+            fluentApi.get(`Lagerbestand/InitializeBestandForArtikel?mandantId=${mandantID}`),
+    };
+}
+
+/**
+ * @typedef {ReturnType<typeof createLagerApi>} LagerApi
+ */