@dizmo/dcs-client-library 4.0.1

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2026 dizmo AG, Switzerland. All rights reserved.
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# DCS Client Library
+
+## Installation
+Add the following dependency to the dizmo's package.json file.
+```json
+"@dizmo/dcs-client-library": "^4.0.0"
+```
+Or install with
+```
+npm i @dizmo/dcs-client-library
+```
+## Usage
+The modules for the different data types are separated and can be individually imported
+```js
+import { templates, items, allocations, dcs, config, events, analytics, language, needs, packages, translations } from '@dizmo/dcs-client-library'
+
+// Most functions throw errors, so they can be caught when they are called
+try {
+    const allItems = await items.getItems2()
+} catch (e) {
+    console.error(e)
+}
+```
+## API Documentation
+The modules all have separate documentation files to keep this main README short and concise.
+
+### Templates Module
+Contains all template-related functions of the DCS.
+Documentation can be found [here](./documentation/templates/templates.md).
+### Items Module
+Contains all item-related functions of the DCS.
+Documentation can be found [here](./documentation/items/items.md).
+### Allocations Module
+Contains all allocation-related functions of the DCS.
+Documentation can be found [here](./documentation/allocations/allocations.md).
+### DCS Module
+Contains all company and system-related functions of the DCS.
+Documentation can be found [here](./documentation/dcs/dcs.md).
+### Analytics Module
+Contains the analytics functionality to process database data.
+Documentation can be found [here](./documentation/analytics/analytics.md).
+### Config Module
+Contains library configuration functions.
+Documentation can be found [here](./documentation/config/config.md).
+### Language Module
+Contains all language and translation related functions.
+Documentation can be found [here](./documentation/language/language.md).
+
+### Events Module
+Contains the function that informs the client on database updates.
+Documentation can be found [here](./documentation/events/events.md).
+
+### Needs Module
+Contains functions for creating and managing needs (requirements/demands).
+Documentation can be found [here](./documentation/needs/needs.md).
+
+### Packages Module
+Contains functions for creating and managing allocation packages (reusable allocation templates).
+Documentation can be found [here](./documentation/packages/packages.md).
+
+### Translations Module
+Contains DeepL translation API integration for translating text content.
+Documentation can be found [here](./documentation/translations/translations.md).
+
+### Data Structures
+Common data structures used across modules.
+Documentation can be found [here](./documentation/datastructures/datastructures.md).

package/dist/data/errorTypes/errorTypes.de.d.ts

@@ -0,0 +1,3 @@
+import { UserErrorCollection } from "../../types/types";
+declare const messages: UserErrorCollection;
+export default messages;

package/dist/data/errorTypes/errorTypes.de.js

@@ -0,0 +1,20 @@
+const messages = {
+    fileNotSupplied: "Datei muss bereitgestellt werden",
+    invalidApiURL: "Keine gültige URL, um als API-Endpunkt festgelegt zu werden",
+    noProgramSpecified: "Der Programmname muss angegeben werden, wenn die Sprache für eine Nicht-Dizmo-Anwendung abgerufen wird.",
+    updateItemsInvalidArguments: "Datei, Vorlagenname und Primärschlüssel müssen bereitgestellt werden",
+    stringError: "{param1} muss ein nicht leerer String sein.",
+    objectError: "{param1} muss ein Objekt sein.",
+    numberError: "{param1} muss eine positive Zahl sein.",
+    arrayError: "{param1} muss ein Array sein.",
+    dzaccessTokenNotFound: "dzaccess-Token nicht gefunden",
+    loginBundleNotFound: "Das Login-Dizmo-Bundle konnte nicht gefunden werden. Ist es in Ihrer Sitzung installiert?",
+    tokenGetError: "Fehler beim Abrufen des Tokens aus dem Login-Dizmo-Bundle.",
+    notLoggedIn: "Das aus dem Login-Dizmo-Bundle abgerufene Token existiert nicht. Sind Sie im Login-Dizmo angemeldet?",
+    invalidToken: "Kann keine Anfrage an die API mit dem Token durchführen: {param1}",
+    bodyParseError: "Kann den bereitgestellten Anfragekörper nicht verarbeiten.",
+    fileError: "Kann die bereitgestellte Datei nicht verarbeiten.",
+    apiUnreachable: "Kann den API-Server nicht erreichen.",
+    itemIdNotExists: "Die Ressource die Sie zuweisen möchten wurde noch nicht gespeichert. Bitte speichern Sie Ihre Änderungen in der Ressource bevor Sie die Zuweisung erstellen.",
+};
+export default messages;

package/dist/data/errorTypes/errorTypes.en.d.ts

@@ -0,0 +1,3 @@
+import { UserErrorCollection } from "../../types/types";
+declare const messages: UserErrorCollection;
+export default messages;

package/dist/data/errorTypes/errorTypes.en.js

@@ -0,0 +1,20 @@
+const messages = {
+    fileNotSupplied: "File must be supplied",
+    invalidApiURL: "Not a valid URL to be set as API Endpoint",
+    noProgramSpecified: "The program name must be specified when getting the language for a non-dizmo application.",
+    updateItemsInvalidArguments: "File, templateName and PrimaryKey must be supplied",
+    stringError: "{param1} must be a non-empty string.",
+    objectError: "{param1} must be an object.",
+    numberError: "{param1} must be a positive number.",
+    arrayError: "{param1} must be an array.",
+    dzaccessTokenNotFound: "dzaccess token not found",
+    loginBundleNotFound: "Login dizmo bundle could not be found. Is it installed in your session?",
+    tokenGetError: "Error getting token from login dizmo bundle.",
+    notLoggedIn: "Token retrieved from login dizmo bundle does not exist. Are you logged in on the login dizmo?",
+    invalidToken: "Cannot make a request to the API with the token: {param1}",
+    bodyParseError: "Cannot process the supplied request body.",
+    fileError: "Cannot process the supplied file.",
+    apiUnreachable: "Cannot reach the API server.",
+    itemIdNotExists: "The Resource you tried to allocate has not yet been saved. Please save your changes in the resource before creating an allocation",
+};
+export default messages;

package/dist/data/errorTypes/errorTypes.es.d.ts

@@ -0,0 +1,3 @@
+import { UserErrorCollection } from "../../types/types";
+declare const messages: UserErrorCollection;
+export default messages;

package/dist/data/errorTypes/errorTypes.es.js

@@ -0,0 +1,4 @@
+const messages = {
+    itemIdNotExists: "El recurso que intentaste asignar aún no existe. Por favor, guarda tus cambios en el recurso antes de crear una asignación",
+};
+export default messages;

package/dist/data/errorTypes/errorTypes.fr.d.ts

@@ -0,0 +1,3 @@
+import { UserErrorCollection } from "../../types/types";
+declare const messages: UserErrorCollection;
+export default messages;

package/dist/data/errorTypes/errorTypes.fr.js

@@ -0,0 +1,4 @@
+const messages = {
+    itemIdNotExists: "La ressource que vous avez essayé d'allouer n'existe pas encore. Veuillez enregistrer vos modifications dans la ressource avant de créer une allocation",
+};
+export default messages;

package/dist/data/errorTypes/errorTypes.it.d.ts

@@ -0,0 +1,3 @@
+import { UserErrorCollection } from "../../types/types";
+declare const messages: UserErrorCollection;
+export default messages;

package/dist/data/errorTypes/errorTypes.it.js

@@ -0,0 +1,4 @@
+const messages = {
+    itemIdNotExists: "La risorsa che si è cercato di allocare non esiste ancora. Si prega di salvare le modifiche apportate alla risorsa prima di creare un'allocazione",
+};
+export default messages;

package/dist/data/errorTypes.dev.d.ts

@@ -0,0 +1,3 @@
+import { DevErrorCollection } from "../types/types";
+declare const messages: DevErrorCollection;
+export default messages;

package/dist/data/errorTypes.dev.js

@@ -0,0 +1,71 @@
+const messages = {
+    fileNotSupplied: {
+        message: "File must be supplied",
+        number: 100,
+    },
+    invalidApiURL: {
+        message: "Not a valid URL to be set as API Endpoint",
+        number: 101,
+    },
+    noProgramSpecified: {
+        message: "The program name must be specified when getting the language for a non-dizmo application.",
+        number: 102,
+    },
+    updateItemsInvalidArguments: {
+        message: "File, templateName and PrimaryKey must be supplied",
+        number: 103,
+    },
+    stringError: {
+        message: "{param1} must be a non-empty string.",
+        number: 104,
+    },
+    objectError: {
+        message: "{param1} must be an object.",
+        number: 105,
+    },
+    numberError: {
+        message: "{param1} must be a positive number.",
+        number: 106,
+    },
+    arrayError: {
+        message: "{param1} must be an array.",
+        number: 107,
+    },
+    dzaccessTokenNotFound: {
+        message: "dzaccess token not found",
+        number: 108,
+    },
+    loginBundleNotFound: {
+        message: "Login dizmo bundle could not be found. Is it installed in your session?",
+        number: 109,
+    },
+    tokenGetError: {
+        message: "Error getting token from login dizmo bundle.",
+        number: 110,
+    },
+    notLoggedIn: {
+        message: "Token retrieved from login dizmo bundle does not exist. Are you logged in on the login dizmo?",
+        number: 111,
+    },
+    invalidToken: {
+        message: "Cannot make a request to the API with the token: {param1}",
+        number: 112,
+    },
+    bodyParseError: {
+        message: "Cannot process the supplied request body.",
+        number: 113,
+    },
+    fileError: {
+        message: "Cannot process the supplied file.",
+        number: 114,
+    },
+    apiUnreachable: {
+        message: "Cannot reach the API server.",
+        number: 115,
+    },
+    itemIdNotExists: {
+        message: "The Resource you tried to allocate does not yet exist. Please save your changes before creating an allocation",
+        number: 116,
+    },
+};
+export default messages;

package/dist/helper/api.d.ts

@@ -0,0 +1,2 @@
+export declare function baseUrl(apiVersion?: string): string;
+export declare function setCustomAPIURL(url: string): void;

package/dist/helper/api.js

@@ -0,0 +1,25 @@
+import { generateError } from "./language";
+const APIURL = "/dcsapi";
+let customAPIURL = "";
+export function baseUrl(apiVersion = "v1") {
+    if (!customAPIURL) {
+        return `${APIURL}/${apiVersion}`;
+    }
+    else {
+        return `${customAPIURL}/${apiVersion}`;
+    }
+}
+export function setCustomAPIURL(url) {
+    if (url.startsWith("/")) {
+        // relative url
+        customAPIURL = url;
+        return;
+    }
+    try {
+        const parsedURL = new URL(url);
+        customAPIURL = parsedURL.href;
+    }
+    catch (error) {
+        throw generateError("invalidApiURL");
+    }
+}

package/dist/helper/httpHelper.d.ts

@@ -0,0 +1,32 @@
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+export declare function getRequestOptions(type: HttpMethod, token: string, body?: unknown, contentType?: string): RequestInit;
+export declare function getFileUploadRequestOptions(token: string, file: File, body?: {
+    [key: string]: string;
+}, method?: HttpMethod, filename?: string): {
+    method: HttpMethod;
+    cache: "no-cache";
+    headers: {
+        Authorization?: string | undefined;
+    };
+    body: FormData;
+};
+export declare function getData(url: string, options: RequestInit, apiVersion?: string, throwFullError?: boolean, addlErrorData?: Record<string, unknown>): Promise<unknown>;
+export declare function getZip(url: string, options: RequestInit, filename?: string): Promise<void>;
+export declare function getFile(url: string, options: RequestInit): Promise<{
+    successOnAPI: boolean;
+    isDCSFile: boolean;
+    fileCategory: undefined;
+    fileType: undefined;
+    originalURL: string;
+    blobURL: undefined;
+    previewURL: string;
+} | {
+    successOnAPI: boolean;
+    isDCSFile: boolean;
+    fileCategory: string | undefined;
+    fileType: string | null;
+    originalURL: string;
+    blobURL: string;
+    previewURL: string;
+}>;
+export {};

package/dist/helper/httpHelper.js

@@ -0,0 +1,145 @@
+import * as api from "./api.js";
+import { generateError } from "./language.js";
+function handleNetworkError(_error) {
+    throw generateError("apiUnreachable");
+}
+async function parseResponseBody(response) {
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+export function getRequestOptions(type, token, body, contentType = "json") {
+    let requestOptions = {
+        method: type,
+        cache: "no-cache",
+        headers: {
+            "Content-Type": `application/${contentType}`,
+            ...(token.trim() && { Authorization: `Bearer ${token}` }),
+        },
+    };
+    if (body) {
+        try {
+            requestOptions.body = JSON.stringify(body);
+        }
+        catch (e) {
+            throw generateError("bodyParseError");
+        }
+    }
+    return requestOptions;
+}
+export function getFileUploadRequestOptions(token, file, body = {}, method = "POST", filename = "") {
+    let formdata;
+    try {
+        formdata = new FormData();
+        formdata.append(filename ?? "", file, file.name ?? "undefined");
+        Object.keys(body).forEach((param) => {
+            formdata.append(param, body[param]);
+        });
+    }
+    catch (e) {
+        throw generateError("fileError");
+    }
+    const requestOptions = {
+        method: method,
+        cache: "no-cache",
+        headers: {
+            ...(token.trim() && { Authorization: `Bearer ${token}` }),
+        },
+        body: formdata,
+    };
+    return requestOptions;
+}
+export async function getData(url, options, apiVersion = "v1", throwFullError = false, addlErrorData = {}) {
+    let response;
+    try {
+        response = await fetch(api.baseUrl(apiVersion) + url, options);
+    }
+    catch (error) {
+        handleNetworkError(error);
+    }
+    if (!response.ok) {
+        const body = await parseResponseBody(response);
+        if (typeof body === "object" && body !== null) {
+            const errorObj = body;
+            if (throwFullError) {
+                if (errorObj.data) {
+                    const throwThing = errorObj;
+                    throwThing.clientErrorData = addlErrorData;
+                    throwThing.clientErrorData.conflicting_allocations = errorObj.data;
+                    throw throwThing;
+                }
+            }
+            throw errorObj.userMessage ?? body;
+        }
+        throw body;
+    }
+    return await parseResponseBody(response);
+}
+export async function getZip(url, options, filename = "backup") {
+    let response;
+    try {
+        response = await fetch(api.baseUrl() + url, options);
+    }
+    catch (error) {
+        handleNetworkError(error);
+    }
+    if (!response.ok) {
+        const body = await parseResponseBody(response);
+        if (typeof body === "object" && body !== null) {
+            throw body.userMessage ?? body;
+        }
+        throw body;
+    }
+    const file = await response.blob();
+    const elm = document.createElement("a");
+    elm.href = URL.createObjectURL(file);
+    elm.setAttribute("download", `${filename}.zip`);
+    elm.click();
+}
+export async function getFile(url, options) {
+    if (!url.startsWith(window.location.origin)) {
+        return {
+            successOnAPI: false,
+            isDCSFile: false,
+            fileCategory: undefined,
+            fileType: undefined,
+            originalURL: url,
+            blobURL: undefined,
+            previewURL: url,
+        };
+    }
+    let response;
+    try {
+        response = await fetch(url, options);
+    }
+    catch (error) {
+        handleNetworkError(error);
+    }
+    if (!response.ok) {
+        return {
+            successOnAPI: false,
+            isDCSFile: true,
+            fileCategory: undefined,
+            fileType: undefined,
+            originalURL: url,
+            blobURL: undefined,
+            previewURL: url,
+        };
+    }
+    const contentType = response.headers.get("content-type");
+    const blob = await response.blob();
+    const fileURL = URL.createObjectURL(blob);
+    return {
+        successOnAPI: true,
+        isDCSFile: true,
+        fileCategory: contentType?.split("/")[0] ?? undefined,
+        fileType: contentType,
+        originalURL: url,
+        blobURL: fileURL,
+        previewURL: fileURL,
+    };
+}

package/dist/helper/language.d.ts

@@ -0,0 +1,5 @@
+import { ErrorParams, LanguageObj } from "../types/types.js";
+export declare function initializeErrorLanguage(): void;
+export declare function getMostSuitedLanguage(supportedLanguages: string[], defaultLanguage: string): string;
+export declare function generateError(type: string, params?: ErrorParams): string;
+export declare function getProgramLanguage(programName?: string): Promise<LanguageObj>;

package/dist/helper/language.js

@@ -0,0 +1,69 @@
+import devMessages from "../data/errorTypes.dev.js";
+import enMessages from "../data/errorTypes/errorTypes.en.js";
+import deMessages from "../data/errorTypes/errorTypes.de.js";
+import frMessages from "../data/errorTypes/errorTypes.fr.js";
+import itMessages from "../data/errorTypes/errorTypes.it.js";
+import esMessages from "../data/errorTypes/errorTypes.es.js";
+import { getData, getRequestOptions } from "./httpHelper.js";
+let rawErrorData = {
+    en: enMessages,
+    de: deMessages,
+    fr: frMessages,
+    it: itMessages,
+    es: esMessages,
+};
+const errorData = {};
+export function initializeErrorLanguage() {
+    try {
+        const languages = ["en", "de", "fr", "es", "it"];
+        const language = getMostSuitedLanguage(languages, "en");
+        for (const errorType of Object.keys(devMessages)) {
+            if (!devMessages[errorType]) {
+                console.warn(`Missing dcs client library devMessages for errorType: ${errorType}`);
+                continue;
+            }
+            errorData[errorType] = {
+                ...errorData[errorType], // Retain any existing data in errorData[errorType]
+                errorName: errorType,
+                userMessage: rawErrorData[language]?.[errorType] || devMessages[errorType].message,
+                devMessage: devMessages[errorType].message,
+                errorNumber: devMessages[errorType].number,
+            };
+        }
+    }
+    catch {
+        //throw e // Re-throw to allow higher-level handling if necessary
+    }
+}
+export function getMostSuitedLanguage(supportedLanguages, defaultLanguage) {
+    const supportedBrowserLanguages = navigator.languages || [];
+    for (const browserLanguage of supportedBrowserLanguages) {
+        for (const supportedLanguage of supportedLanguages) {
+            if (browserLanguage.startsWith(supportedLanguage.toLowerCase())) {
+                return supportedLanguage.toLowerCase();
+            }
+        }
+    }
+    return defaultLanguage.toLowerCase();
+}
+export function generateError(type, params = {}) {
+    const errorType = { ...errorData[type] };
+    Object.keys(params).forEach((paramName) => {
+        errorType.userMessage = errorType.userMessage.replace(`{${paramName}}`, String(params[paramName]));
+        errorType.devMessage = errorType.devMessage.replace(`{${paramName}}`, String(params[paramName]));
+    });
+    // TODO: change this to the full object once dizmos can handle error object.
+    return errorType.userMessage;
+}
+export async function getProgramLanguage(programName = "") {
+    const requestOptions = getRequestOptions("GET", "token");
+    let programVersion = "";
+    if (programName === "") {
+        if (typeof bundle === 'undefined') {
+            throw generateError("noProgramSpecified");
+        }
+        programName = bundle.identifier;
+        programVersion = bundle.getAttribute("version");
+    }
+    return (await getData(`/languages/translation/${programName}/${programVersion}`, requestOptions));
+}

package/dist/helper/parse.d.ts

@@ -0,0 +1,8 @@
+import { RawTemplate, TemplateResult } from "../types/types.js";
+declare function templates(templateResponseArray: RawTemplate[]): TemplateResult[];
+declare function template(templateResponseArray: RawTemplate[]): TemplateResult;
+declare const _default: {
+    templates: typeof templates;
+    template: typeof template;
+};
+export default _default;

package/dist/helper/parse.js

@@ -0,0 +1,28 @@
+import { generateError } from "./language.js";
+function parseTemplateData(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        throw generateError("parseTemplateError");
+    }
+}
+function templates(templateResponseArray) {
+    if (!Array.isArray(templateResponseArray)) {
+        throw generateError("parseTemplateError");
+    }
+    return templateResponseArray.map((template) => parseTemplateData(template.properties.data));
+}
+function template(templateResponseArray) {
+    if (Array.isArray(templateResponseArray) &&
+        templateResponseArray.length === 1) {
+        return parseTemplateData(templateResponseArray[0].properties.data);
+    }
+    else {
+        throw generateError("parseTemplateError");
+    }
+}
+export default {
+    templates,
+    template
+};

package/dist/helper/token.d.ts

@@ -0,0 +1 @@
+export declare function getToken(): Promise<string>;

package/dist/helper/token.js

@@ -0,0 +1,28 @@
+import { generateError } from "./language.js";
+export async function getToken() {
+    // check if in viewer, else read cookie from browser
+    if (typeof viewer === 'undefined') {
+        // in webapp. no cookie required.
+        return "";
+    }
+    let token = "";
+    let loginBundle;
+    try {
+        loginBundle = viewer.getBundleById("com.dizmo.dcs.login");
+    }
+    catch (e) {
+        throw generateError("loginBundleNotFound");
+    }
+    try {
+        const cacheId = await loginBundle.cacheProperty("token", { public: true });
+        token = loginBundle.getProperty("token", { public: true });
+        loginBundle.uncacheProperty(cacheId, { public: true });
+    }
+    catch (e) {
+        throw generateError("tokenGetError");
+    }
+    if (!Boolean(token)) {
+        throw generateError("notLoggedIn");
+    }
+    return token;
+}

package/dist/helper/transform.d.ts

@@ -0,0 +1,3 @@
+import { AllocationResult, AllocationResult3, SpreadAllocationResult, SpreadAllocationResult3 } from "../types/types";
+export declare function transformToSpreadAllocations(allocations: AllocationResult[]): SpreadAllocationResult[];
+export declare function transformToSpreadAllocations3(allocations: AllocationResult3[]): SpreadAllocationResult3[];

package/dist/helper/transform.js

@@ -0,0 +1,18 @@
+export function transformToSpreadAllocations(allocations) {
+    return allocations.map(({ root, relationships }) => ({
+        root,
+        relationships: relationships.flatMap(({ allocations, leaf, }) => allocations.map((allocation) => ({
+            leaf,
+            allocation,
+        }))),
+    }));
+}
+export function transformToSpreadAllocations3(allocations) {
+    return allocations.map(({ root, relationships }) => ({
+        root,
+        relationships: relationships.flatMap(({ allocations, leaf, }) => allocations.map((allocation) => ({
+            leaf,
+            allocation,
+        }))),
+    }));
+}

package/dist/helper/validate.d.ts

@@ -0,0 +1,4 @@
+export declare function validateString(input: string, data: string): void;
+export declare function validateObject(object: unknown, data: string): void;
+export declare function validateNumber(input: number, data: string): void;
+export declare function validateArray(array: unknown, data: string): void;

package/dist/helper/validate.js

@@ -0,0 +1,21 @@
+import { generateError } from "./language.js";
+export function validateString(input, data) {
+    if (!(typeof input === "string" && input.trim() !== "")) {
+        throw generateError("stringError", { param1: data ?? "unknown" });
+    }
+}
+export function validateObject(object, data) {
+    if (!(typeof object === "object" && object !== null && !Array.isArray(object))) {
+        throw generateError("objectError", { param1: data ?? "unknown" });
+    }
+}
+export function validateNumber(input, data) {
+    if (!(typeof input === "number" && input > 0)) {
+        throw generateError("numberError", { param1: data ?? "unknown" });
+    }
+}
+export function validateArray(array, data) {
+    if (!Array.isArray(array)) {
+        throw generateError("arrayError", { param1: data ?? "unknown" });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+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";