@dizmo/dcs-client-library 4.0.1

package/dist/index.js

@@ -0,0 +1,15 @@
+import * as languageHelper from "./helper/language.js";
+(async () => {
+    languageHelper.initializeErrorLanguage();
+})();
+export { config } from "./modules/configurator";
+export { templates } from "./modules/templates";
+export { items } from "./modules/items";
+export { allocations } from "./modules/allocations.js";
+export { dcs } from "./modules/dcs";
+export { analytics } from "./modules/analytics.js";
+export { language } from "./modules/language";
+export { events } from "./modules/events";
+export { needs } from "./modules/needs";
+export { packages } from "./modules/packages";
+export { translations } from "./modules/translations";

package/dist/modules/allocations.d.ts

@@ -0,0 +1,29 @@
+import { AllocFilter, AllocOptions, AllocSort, AllocationResult, AllocationResult3, BulkCommand, BulkOperationOptions, BulkOperationResult, CreateAlloc, CreateResult, DeleteResult, EditOrDeletionType, RepetitionCreateResult, RepetitionInfo, SpreadAllocationResult, SpreadAllocationResult3, UpdateAlloc } from "../types/types.js";
+declare function getAllocations2(filter?: AllocFilter, paging?: AllocOptions, sort?: AllocSort): Promise<AllocationResult[] | SpreadAllocationResult[]>;
+declare function getAllocations3(filter?: AllocFilter, paging?: AllocOptions, sort?: AllocSort): Promise<AllocationResult3[] | SpreadAllocationResult3[]>;
+export declare function bulkOperation(operations: BulkCommand, options?: BulkOperationOptions): Promise<BulkOperationResult>;
+declare function createAllocation(itemId1: string, itemId2: string, allocationInfo: CreateAlloc): Promise<CreateResult>;
+declare function updateAllocation(allocationId?: string, allocationInfo?: UpdateAlloc): Promise<CreateResult>;
+declare function deleteAllocation(allocationId?: string): Promise<BulkOperationResult>;
+/**
+ * DEPRECATED: use getAllocations2
+ */
+declare function getAllocations(filter?: {}, paging?: {}): Promise<AllocationResult[]>;
+declare function updateAllocations(file: File, keepData?: boolean): Promise<DeleteResult>;
+declare function createRepeatedAllocations(itemId1: string, itemId2: string, allocationInfo: CreateAlloc, repetitionInfo: RepetitionInfo): Promise<RepetitionCreateResult>;
+declare function deleteRepeatedAllocations(repetitionId: string, deletionType: EditOrDeletionType, timestamp: number): Promise<DeleteResult>;
+declare function updateRepeatedAllocations(repetitionId: string, editType: EditOrDeletionType, timestamp: number, allocationInfo: UpdateAlloc): Promise<RepetitionCreateResult>;
+export declare const allocations: {
+    getAllocations2: typeof getAllocations2;
+    getAllocations3: typeof getAllocations3;
+    bulkOperation: typeof bulkOperation;
+    createAllocation: typeof createAllocation;
+    getAllocations: typeof getAllocations;
+    deleteAllocation: typeof deleteAllocation;
+    updateAllocation: typeof updateAllocation;
+    updateAllocations: typeof updateAllocations;
+    createRepeatedAllocations: typeof createRepeatedAllocations;
+    deleteRepeatedAllocations: typeof deleteRepeatedAllocations;
+    updateRepeatedAllocations: typeof updateRepeatedAllocations;
+};
+export {};

package/dist/modules/allocations.js

@@ -0,0 +1,148 @@
+import { getToken } from "../helper/token.js";
+import { getRequestOptions, getData, getFileUploadRequestOptions, } from "../helper/httpHelper.js";
+import { validateString, validateObject, validateNumber, } from "../helper/validate.js";
+import { generateError } from "../helper/language.js";
+import { transformToSpreadAllocations, transformToSpreadAllocations3 } from "../helper/transform.js";
+// the new getAllocations function that allows advanced filtering
+// will replace the existing call once all clients have updated their
+// code to this function
+async function getAllocations2(filter = {}, paging = {}, sort = {}) {
+    validateObject(filter, "Function: getAllocations2, Value: filter");
+    validateObject(paging, "Function: getAllocations2, Value: paging");
+    validateObject(sort, "Function: getAllocations2, Value: sort");
+    const token = await getToken();
+    const bodyObj = {
+        filter,
+        paging,
+        sort,
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    // specify v2 in call
+    const result = (await getData(`/allocations/allocation`, requestOptions, "v2"));
+    if (paging.spreadAllocations) {
+        return transformToSpreadAllocations(result);
+    }
+    return result;
+}
+// v3 getAllocations - same as v2 but without automatic _datatype: "item" filter
+// allows querying allocations for non-item types (e.g. packages, needs)
+async function getAllocations3(filter = {}, paging = {}, sort = {}) {
+    validateObject(filter, "Function: getAllocations3, Value: filter");
+    validateObject(paging, "Function: getAllocations3, Value: paging");
+    validateObject(sort, "Function: getAllocations3, Value: sort");
+    const token = await getToken();
+    const bodyObj = {
+        filter,
+        paging,
+        sort,
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    const result = (await getData(`/allocations/allocation`, requestOptions, "v3"));
+    if (paging.spreadAllocations) {
+        return transformToSpreadAllocations3(result);
+    }
+    return result;
+}
+export async function bulkOperation(operations, options = {}) {
+    // options can be "type": "package", "bulk"
+    validateObject(operations, "Function: bulkOperation, Value: operations");
+    validateObject(options, "Function: bulkOperation, Value: options");
+    const token = await getToken();
+    const bodyObj = operations;
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    return (await getData(`/allocations/bulk${options.skipUndefined ? "?skipundefined=true" : ""}`, requestOptions, "v1", options.type === "package", options));
+}
+async function createAllocation(itemId1, itemId2, allocationInfo) {
+    validateString(itemId1, "Function: createAllocation, Value: itemId1");
+    validateString(itemId2, "Function: createAllocation, Value: itemId2");
+    validateObject(allocationInfo, "Function: createAllocation, Value: allocationInfo");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, allocationInfo);
+    return (await getData(`/allocations/allocation/${encodeURIComponent(itemId1)}/${encodeURIComponent(itemId2)}`, requestOptions));
+}
+async function updateAllocation(allocationId = "", allocationInfo = {}) {
+    validateString(allocationId, "Function: updateAllocation, Value: allocationId");
+    validateObject(allocationInfo, "Function: updateAllocation, Value: allocationInfo");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, allocationInfo);
+    return (await getData(`/allocations/allocation/${encodeURIComponent(allocationId)}`, requestOptions));
+}
+async function deleteAllocation(allocationId = "") {
+    validateString(allocationId, "Function: deleteAllocation, Value: allocationId");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("DELETE", token);
+    return (await getData(`/allocations/allocation/${encodeURIComponent(allocationId)}`, requestOptions));
+}
+/**
+ * DEPRECATED: use getAllocations2
+ */
+async function getAllocations(filter = {}, paging = {}) {
+    validateObject(filter, "getItems: filter");
+    validateObject(paging, "getItems: paging");
+    const token = await getToken();
+    const bodyObj = {
+        filter: filter,
+        paging: paging,
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    return (await getData(`/allocations/allocation`, requestOptions));
+}
+async function updateAllocations(file, keepData = false) {
+    if (typeof file === "undefined") {
+        throw generateError("fileNotSupplied");
+    }
+    const token = await getToken();
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const requestOptions = getFileUploadRequestOptions(token, file, { timezone });
+    return (await getData(`/allocations/csv${keepData ? "?keep=true" : ""}`, requestOptions));
+}
+async function createRepeatedAllocations(itemId1, itemId2, allocationInfo, repetitionInfo) {
+    validateString(itemId1, "Function: createRepeatedAllocations, Value: itemId1");
+    validateString(itemId2, "Function: createRepeatedAllocations, Value: itemId2");
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    allocationInfo.timezone = timezone;
+    const params = {
+        type: "repetition",
+        repetition_info: {
+            ...repetitionInfo,
+            ...allocationInfo,
+            timezone,
+        },
+        itemId1,
+        itemId2,
+    };
+    //validate repetitionInfo
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, allocationInfo);
+    return (await getData(`/allocations/allocations/${encodeURIComponent(itemId1)}/${encodeURIComponent(itemId2)}/${encodeURIComponent(repetitionInfo.pattern)}/${encodeURIComponent(repetitionInfo.durationType)}/${encodeURIComponent(String(repetitionInfo.durationValue))}/${encodeURIComponent(repetitionInfo.originalId ?? "")}/`, requestOptions, "v1", true, params));
+}
+async function deleteRepeatedAllocations(repetitionId, deletionType, timestamp) {
+    validateString(repetitionId, "Function: deleteRepeatedAllocations, Value: repetitionId");
+    validateString(deletionType, "Function: deleteRepeatedAllocations, Value: deletionType");
+    validateNumber(timestamp, "Function: deleteRepeatedAllocations, Value: timestamp");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("DELETE", token);
+    return (await getData(`/allocations/allocations/${encodeURIComponent(repetitionId)}/${encodeURIComponent(deletionType)}/${encodeURIComponent(String(timestamp))}`, requestOptions));
+}
+async function updateRepeatedAllocations(repetitionId, editType, timestamp, allocationInfo) {
+    validateString(repetitionId, "Function: updateRepeatedAllocations, Value: repetitionId");
+    validateString(editType, "Function: updateRepeatedAllocations, Value: editType");
+    validateNumber(timestamp, "Function: updateRepeatedAllocations, Value: timestamp");
+    validateObject(allocationInfo, "Function: updateRepeatedAllocations, Value: allocationInfo");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, allocationInfo);
+    return (await getData(`/allocations/allocations/${encodeURIComponent(repetitionId)}/${encodeURIComponent(editType)}/${encodeURIComponent(String(timestamp))}`, requestOptions));
+}
+export const allocations = {
+    getAllocations2,
+    getAllocations3,
+    bulkOperation,
+    createAllocation,
+    getAllocations,
+    deleteAllocation,
+    updateAllocation,
+    updateAllocations,
+    createRepeatedAllocations,
+    deleteRepeatedAllocations,
+    updateRepeatedAllocations,
+};

package/dist/modules/analytics.d.ts

@@ -0,0 +1,7 @@
+declare function jqQuery2(paging?: {}, jqQuery?: string, filter?: {}): Promise<unknown>;
+declare function jqQuery(itemIds?: string[], jqQuery?: string, options?: {}): Promise<unknown>;
+export declare const analytics: {
+    jqQuery: typeof jqQuery;
+    jqQuery2: typeof jqQuery2;
+};
+export {};

package/dist/modules/analytics.js

@@ -0,0 +1,33 @@
+import { getToken } from "../helper/token.js";
+import { getRequestOptions, getData } from "../helper/httpHelper.js";
+import { validateString, validateObject, validateArray, } from "../helper/validate.js";
+async function jqQuery2(paging = {}, jqQuery = "", filter = {}) {
+    validateObject(paging, "jqQuery: paging");
+    validateString(jqQuery, "jqQuery: jqQuery");
+    validateObject(filter, "jqQuery: filter");
+    const token = await getToken();
+    const bodyObj = {
+        paging: paging,
+        jqQuery: jqQuery,
+        filter: filter,
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    return await getData("/analytics/jq", requestOptions, "v2");
+}
+async function jqQuery(itemIds = [], jqQuery = "", options = {}) {
+    validateArray(itemIds, "jqQuery: itemIds");
+    validateString(jqQuery, "jqQuery: jqQuery");
+    validateObject(options, "jqQuery: options");
+    const token = await getToken();
+    const bodyObj = {
+        itemIds: itemIds,
+        jqQuery: jqQuery,
+        paging: options,
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    return await getData("/analytics/jq", requestOptions);
+}
+export const analytics = {
+    jqQuery,
+    jqQuery2,
+};

package/dist/modules/configurator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * DEPRECATED
+ */
+declare function setDcsApiEndpoint(url: string): void;
+export declare const config: {
+    setDcsApiEndpoint: typeof setDcsApiEndpoint;
+};
+export {};

package/dist/modules/configurator.js

@@ -0,0 +1,10 @@
+import { setCustomAPIURL } from "../helper/api.js";
+/**
+ * DEPRECATED
+ */
+function setDcsApiEndpoint(url) {
+    setCustomAPIURL(url);
+}
+export const config = {
+    setDcsApiEndpoint,
+};

package/dist/modules/dcs.d.ts

@@ -0,0 +1,32 @@
+import { CalendarInfo, CalendarResult, CompanySettingsInput, CompanySettingsResult, ExportAllocConfig, ExportItemsConfig, FileInfoResult, GetCalendarOptions, RestoreResult, UpdateCalendarInfo, UpdateResult, UserInfo } from "../types/types.js";
+declare function getCompanySettings(): Promise<CompanySettingsResult[]>;
+declare function setCompanySettings(companySettings: CompanySettingsInput): Promise<CompanySettingsResult>;
+declare function deleteCompanySettings(): Promise<unknown>;
+declare function backupDatabase(download?: boolean): Promise<void>;
+declare function restoreDatabase(file: File): Promise<RestoreResult>;
+declare function exportDatabase(itemSettings?: ExportItemsConfig, allocationSettings?: ExportAllocConfig, xlsx?: string, download?: boolean): Promise<void>;
+declare function detectLanguage(supportedLanguages: string[], defaultLanguage: string): string;
+declare function getUserInfo(): Promise<UserInfo>;
+declare function getFileInfo(url: string): Promise<FileInfoResult>;
+declare function createCalendarInfo(data: CalendarInfo): Promise<CalendarResult>;
+declare function bulkCreateCalendarInfo(data: CalendarInfo[], overwrite?: boolean): Promise<CalendarResult[]>;
+declare function getCalendarInfo(options?: GetCalendarOptions): Promise<CalendarResult[]>;
+declare function updateCalendarInfo(id: string, data: UpdateCalendarInfo): Promise<UpdateResult>;
+declare function deleteCalendarInfo(id: string): Promise<UpdateResult>;
+export declare const dcs: {
+    getCompanySettings: typeof getCompanySettings;
+    setCompanySettings: typeof setCompanySettings;
+    deleteCompanySettings: typeof deleteCompanySettings;
+    backupDatabase: typeof backupDatabase;
+    restoreDatabase: typeof restoreDatabase;
+    exportDatabase: typeof exportDatabase;
+    detectLanguage: typeof detectLanguage;
+    getUserInfo: typeof getUserInfo;
+    getFileInfo: typeof getFileInfo;
+    createCalendarInfo: typeof createCalendarInfo;
+    bulkCreateCalendarInfo: typeof bulkCreateCalendarInfo;
+    getCalendarInfo: typeof getCalendarInfo;
+    updateCalendarInfo: typeof updateCalendarInfo;
+    deleteCalendarInfo: typeof deleteCalendarInfo;
+};
+export {};

package/dist/modules/dcs.js

@@ -0,0 +1,130 @@
+import { getToken } from "../helper/token.js";
+import { getRequestOptions, getData, getZip, getFileUploadRequestOptions, getFile, } from "../helper/httpHelper.js";
+import { validateObject, validateArray, validateString, } from "../helper/validate.js";
+import { getMostSuitedLanguage } from "../helper/language.js";
+import { generateError } from "../helper/language.js";
+async function getCompanySettings() {
+    const token = await getToken();
+    const requestOptions = getRequestOptions("GET", token);
+    return (await getData(`/dcs/companysettings`, requestOptions));
+}
+async function setCompanySettings(companySettings) {
+    validateObject(companySettings, "Function: updateCompanySettings, Value: companySettings");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, companySettings);
+    return (await getData(`/dcs/companySettings`, requestOptions));
+}
+async function deleteCompanySettings() {
+    const token = await getToken();
+    const requestOptions = getRequestOptions("DELETE", token);
+    return await getData(`/dcs/companySettings`, requestOptions);
+}
+async function backupDatabase(download = true) {
+    const token = await getToken();
+    const requestOptions = getRequestOptions("GET", token, undefined, "zip");
+    if (download === true) {
+        const backupName = `planisyBackup_${new Date().toISOString()}`;
+        await getZip(`/dcs/backup?file=true`, requestOptions, backupName);
+    }
+    else {
+        console.log("DB backup without download has not been implemented. ");
+    }
+}
+async function restoreDatabase(file) {
+    if (typeof file === "undefined") {
+        throw generateError("fileNotSupplied");
+    }
+    const token = await getToken();
+    const requestOptions = getFileUploadRequestOptions(token, file);
+    return (await getData(`/dcs/restore`, requestOptions));
+}
+async function exportDatabase(itemSettings = "none", allocationSettings = "none", xlsx = "false", download = true) {
+    const requestSettings = {};
+    requestSettings.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (!(typeof itemSettings === "string")) {
+        validateArray(itemSettings, "exportDatabase: itemSettings");
+        requestSettings.items = itemSettings;
+    }
+    if (!(allocationSettings === "none")) {
+        validateObject(allocationSettings, "exportDatabase: allocationSettings");
+        requestSettings.allocations = allocationSettings;
+    }
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, requestSettings, "json");
+    if (download === true) {
+        const exportName = `planisyExport_${new Date().toISOString()}`;
+        await getZip(`/dcs/export${xlsx ? "?xlsx=true" : ""}`, requestOptions, exportName);
+    }
+    else {
+        console.log("Exporting without downloading has not yet been implemented.");
+    }
+}
+function detectLanguage(supportedLanguages, defaultLanguage) {
+    return getMostSuitedLanguage(supportedLanguages, defaultLanguage);
+}
+async function getUserInfo() {
+    const token = await getToken();
+    const requestOptions = getRequestOptions("GET", token);
+    return (await getData(`/dcs/userinfo`, requestOptions));
+}
+async function getFileInfo(url) {
+    const token = await getToken();
+    const requestOptions = getRequestOptions("GET", token);
+    return await getFile(url, requestOptions);
+}
+async function createCalendarInfo(data) {
+    validateObject(data, "Function: createCalendarInfo, Value: calendarInfo");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, data);
+    return (await getData(`/dcs/calendarinfo`, requestOptions));
+}
+async function bulkCreateCalendarInfo(data, overwrite = false) {
+    validateArray(data, "Function: bulkCreateCalendarInfo, Value: data");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, data);
+    return (await getData(`/dcs/calendarinfo/bulk${overwrite ? "?overwrite=true" : ""}`, requestOptions));
+}
+async function getCalendarInfo(options = {}) {
+    validateObject(options, "Function: getCalendarInfo, Value: options");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("GET", token);
+    const params = new URLSearchParams();
+    if (options.id)
+        params.set("id", options.id);
+    if (options.start)
+        params.set("start", String(options.start));
+    if (options.end)
+        params.set("end", String(options.end));
+    const queryString = params.toString();
+    const url = queryString ? `?${queryString}` : "";
+    return (await getData(`/dcs/calendarinfo${url}`, requestOptions));
+}
+async function updateCalendarInfo(id, data) {
+    validateString(id, "Function: updateCalendarInfo, Value: id");
+    validateObject(data, "Function: updateCalendarInfo, Value: data");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("PUT", token, data);
+    return (await getData(`/dcs/calendarinfo/${id}`, requestOptions));
+}
+async function deleteCalendarInfo(id) {
+    validateString(id, "Function: deleteCalendarInfo, Value: id");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("DELETE", token);
+    return (await getData(`/dcs/calendarinfo/${id}`, requestOptions));
+}
+export const dcs = {
+    getCompanySettings,
+    setCompanySettings,
+    deleteCompanySettings,
+    backupDatabase,
+    restoreDatabase,
+    exportDatabase,
+    detectLanguage,
+    getUserInfo,
+    getFileInfo,
+    createCalendarInfo,
+    bulkCreateCalendarInfo,
+    getCalendarInfo,
+    updateCalendarInfo,
+    deleteCalendarInfo,
+};

package/dist/modules/events.d.ts

@@ -0,0 +1,5 @@
+declare function getLastChange(): Promise<string>;
+export declare const events: {
+    getLastChange: typeof getLastChange;
+};
+export {};

package/dist/modules/events.js

@@ -0,0 +1,10 @@
+import { getToken } from "../helper/token.js";
+import { getRequestOptions, getData } from "../helper/httpHelper.js";
+async function getLastChange() {
+    const token = await getToken();
+    const requestOptions = getRequestOptions("GET", token);
+    return (await getData(`/events/lastchange`, requestOptions));
+}
+export const events = {
+    getLastChange,
+};

package/dist/modules/items.d.ts

@@ -0,0 +1,21 @@
+import { CsvImportResult, Filter, Input, CreateResult, ItemOptions, ItemResult } from "../types/types.js";
+declare function createItem(templateName: string, itemProperties: Input): Promise<CreateResult>;
+declare function updateItem(itemId: string, itemProperties: Input): Promise<ItemResult[]>;
+/**
+ * DEPRECATED, use getItems2
+ */
+declare function getItems(filter?: {}, paging?: {}): Promise<ItemResult[]>;
+declare function getItems2(filter?: Filter | {}, paging?: ItemOptions): Promise<ItemResult[]>;
+declare function deleteItem(itemId: string): Promise<{}>;
+declare function updateItems(file: File, templateName: string, primaryKey: string, keepData?: boolean): Promise<CsvImportResult>;
+declare function attachFile(itemId: string | undefined, attributeId: string | undefined, file: File): Promise<string>;
+export declare const items: {
+    createItem: typeof createItem;
+    updateItem: typeof updateItem;
+    getItems: typeof getItems;
+    getItems2: typeof getItems2;
+    updateItems: typeof updateItems;
+    attachFile: typeof attachFile;
+    deleteItem: typeof deleteItem;
+};
+export {};

package/dist/modules/items.js

@@ -0,0 +1,70 @@
+import { getToken } from "../helper/token.js";
+import { getData, getFileUploadRequestOptions, getRequestOptions, } from "../helper/httpHelper.js";
+import { validateObject, validateString } from "../helper/validate.js";
+async function createItem(templateName, itemProperties) {
+    validateString(templateName, "Function: createItem, Value: templateName");
+    validateObject(itemProperties, "Function: createItem, Value: itemProperties");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, itemProperties);
+    return (await getData(`/items/template/${encodeURIComponent(templateName)}`, requestOptions));
+}
+async function updateItem(itemId, itemProperties) {
+    validateString(itemId, "Function: updateItem, Value: itemId");
+    validateObject(itemProperties, "Function: updateItem, Value: itemProperties");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, itemProperties);
+    return (await getData(`/items/item/${encodeURIComponent(itemId)}`, requestOptions));
+}
+/**
+ * DEPRECATED, use getItems2
+ */
+async function getItems(filter = {}, paging = {}) {
+    const token = await getToken();
+    const bodyObj = {
+        filter: filter,
+        paging: paging,
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    return (await getData("/items/item", requestOptions));
+}
+async function getItems2(filter = {}, paging = {}) {
+    validateObject(filter, "Function: getItems2, Value: filter");
+    validateObject(paging, "Function: getItems2, Value: options");
+    const token = await getToken();
+    const bodyObj = {
+        ...(Object.keys(filter ?? {}).length ? { filter } : {}),
+        paging: paging,
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    return (await getData("/items/item", requestOptions, "v2"));
+}
+async function deleteItem(itemId) {
+    validateString(itemId, "Function: deleteItem, Value: itemId");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("DELETE", token);
+    return (await getData(`/items/item/${encodeURIComponent(itemId)}`, requestOptions));
+}
+async function updateItems(file, templateName, primaryKey, keepData = false) {
+    validateString(templateName, "Function: updateItems, Value: templateName");
+    validateString(primaryKey, "Function: updateItems, Value: primaryKey");
+    const token = await getToken();
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const requestOptions = getFileUploadRequestOptions(token, file, { timezone });
+    return (await getData(`/items/csv/${encodeURIComponent(templateName)}/${encodeURIComponent(primaryKey)}${keepData ? "?keep=true" : ""}`, requestOptions));
+}
+async function attachFile(itemId = "", attributeId = "", file) {
+    validateString(itemId, "Function: attachFile, Value: itemId");
+    validateString(attributeId, "Function: attachFile, Value: attributeId");
+    const token = await getToken();
+    const requestOptions = getFileUploadRequestOptions(token, file, {}, "PUT", attributeId);
+    return (await getData(`/items/item/${encodeURIComponent(itemId)}/fileattribute`, requestOptions));
+}
+export const items = {
+    createItem,
+    updateItem,
+    getItems,
+    getItems2,
+    updateItems,
+    attachFile,
+    deleteItem
+};

package/dist/modules/language.d.ts

@@ -0,0 +1,18 @@
+import { LanguageObj, StringParams } from "../types/types.js";
+declare function loadLanguageFile(languages?: string[]): Promise<void>;
+declare function detectCompanyLanguage(): Promise<void>;
+declare function getTranslatedLabel(languageObject: LanguageObj): string;
+declare function translateHTML(): void;
+declare function translateString(key: string, params?: StringParams): string;
+declare function getCompanyLanguage(): string;
+declare function getUILanguage(): string;
+export declare const language: {
+    loadLanguageFile: typeof loadLanguageFile;
+    detectCompanyLanguage: typeof detectCompanyLanguage;
+    getTranslatedLabel: typeof getTranslatedLabel;
+    translateHTML: typeof translateHTML;
+    translateString: typeof translateString;
+    getCompanyLanguage: typeof getCompanyLanguage;
+    getUILanguage: typeof getUILanguage;
+};
+export {};

package/dist/modules/language.js

@@ -0,0 +1,106 @@
+import { getMostSuitedLanguage, getProgramLanguage, } from "../helper/language.js";
+import { dcs } from "./dcs.js";
+let languageData = {};
+let defaultCompanyLanguage;
+let uiLanguage;
+// this version of the function is used when the language files are hosted on the server
+async function loadLanguageFile(languages = []) {
+    try {
+        languageData = await getProgramLanguage();
+        // this is to set the ui language locally
+        const finalLanguages = languages.length
+            ? languages
+            : ["en", "de", "it", "fr", "es"];
+        // "en" is the currently hardcoded fallback language, in the future it will come from the company settings.
+        uiLanguage = getMostSuitedLanguage(finalLanguages, "en");
+    }
+    catch (e) {
+        console.log(e);
+        console.warn(`Using fallback language files for ${bundle?.identifier}. Please make sure that this dizmo exists on the translation service and the most recent language files are deployed.`);
+        await fallbackLoadLanguageFile(languages);
+    }
+}
+// Loads the correct language data json from assets folder and stores it in languageData
+// This is the language used for UI elements.
+async function fallbackLoadLanguageFile(languages = []) {
+    try {
+        // This array has to be set manually according to the available files in assets/locales
+        const finalLanguages = languages.length
+            ? languages
+            : ["en", "de", "it", "fr", "es"];
+        // "en" is the currently hardcoded fallback language, in the future it will come from the company settings.
+        uiLanguage = getMostSuitedLanguage(finalLanguages, "en");
+        const languageFileResponse = await fetch(`assets/locales/translation.${uiLanguage}.json`);
+        if (!languageFileResponse.ok) {
+            throw new Error(`Failed to load language file: ${languageFileResponse.status} ${languageFileResponse.statusText}`);
+        }
+        // sets the global language file
+        languageData = await languageFileResponse.json();
+    }
+    catch (e) {
+        console.error("Error loading fallback language file:", e);
+    }
+}
+async function detectCompanyLanguage() {
+    // based on the available languages in the companySettings
+    // this is the language that is used to display the correct labels for the templates
+    // "en" is the currently hardcoded fallback language, in the future it will come from the company settings.
+    try {
+        const companySettings = await dcs.getCompanySettings();
+        defaultCompanyLanguage =
+            companySettings[0]?.properties?.default_language ?? "en";
+    }
+    catch {
+        defaultCompanyLanguage = "en";
+    }
+}
+function getTranslatedLabel(languageObject) {
+    // accepts a label object like:
+    /*
+      {
+        "en": "Car",
+        "de": "Auto"
+      }
+    */
+    // from a template and returns the label in the correct language
+    const supportedLanguages = Object.keys(languageObject).filter((language) => languageObject[language]);
+    const languageToUse = getMostSuitedLanguage(supportedLanguages, defaultCompanyLanguage);
+    return languageObject[languageToUse];
+}
+function translateHTML() {
+    // replaces all hardcoded strings in HTML with data from the languageData object,
+    // the json keys must match with the HTML ids
+    // except the ones that start with 'js_'
+    Object.keys(languageData).forEach((id) => {
+        if (!id.startsWith("js_")) {
+            const elem = document.getElementById(id);
+            if (elem)
+                elem.textContent = languageData[id];
+        }
+    });
+}
+function translateString(key, params = {}) {
+    // translates a single string from the languageData file, based on its key
+    // used when for example a HTML element is generated in JS and its textContent is set dynamically
+    // accepts parameters that will be placed in the translated strings.
+    let finalString = languageData[key];
+    Object.keys(params).forEach((paramName) => {
+        finalString = finalString.replace(`{${paramName}}`, params[paramName].toString());
+    });
+    return finalString;
+}
+function getCompanyLanguage() {
+    return defaultCompanyLanguage;
+}
+function getUILanguage() {
+    return uiLanguage;
+}
+export const language = {
+    loadLanguageFile,
+    detectCompanyLanguage,
+    getTranslatedLabel,
+    translateHTML,
+    translateString,
+    getCompanyLanguage,
+    getUILanguage,
+};