@dizmo/dcs-client-library 4.0.1

package/dist/modules/needs.d.ts

@@ -0,0 +1,12 @@
+import { CreateNeed, Need, UpdateNeed, UpdateResult } from "../types/types";
+declare function createNeed(need: CreateNeed): Promise<UpdateResult>;
+declare function deleteNeed(needId: string): Promise<void>;
+declare function updateNeed(needId: string, needUpdate: UpdateNeed): Promise<void>;
+declare function getNeeds(type: string): Promise<Need[]>;
+export declare const needs: {
+    createNeed: typeof createNeed;
+    deleteNeed: typeof deleteNeed;
+    updateNeed: typeof updateNeed;
+    getNeeds: typeof getNeeds;
+};
+export {};

package/dist/modules/needs.js

@@ -0,0 +1,35 @@
+import { getData, getRequestOptions } from "../helper/httpHelper";
+import { getToken } from "../helper/token";
+import { validateObject, validateString } from "../helper/validate";
+async function createNeed(need) {
+    validateObject(need, "Function: createNeed, Value: need");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, need);
+    return (await getData(`/needs/need/`, requestOptions));
+}
+async function deleteNeed(needId) {
+    validateString(needId, "Function: deleteNeed, Value: needId");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("DELETE", token);
+    await getData(`/needs/need/${needId}`, requestOptions);
+}
+async function updateNeed(needId, needUpdate) {
+    validateString(needId, "Function: updateNeed, Value: needId");
+    validateObject(needUpdate, "Function: updateNeed, Value: needUpdate");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("PUT", token, needUpdate);
+    await getData(`/needs/need/${needId}`, requestOptions);
+}
+async function getNeeds(type) {
+    validateString(type, "Function: getNeeds, Value: type");
+    const token = await getToken();
+    const body = { type };
+    const requestOptions = getRequestOptions("POST", token, body);
+    return (await getData(`/needs/getneeds`, requestOptions));
+}
+export const needs = {
+    createNeed,
+    deleteNeed,
+    updateNeed,
+    getNeeds
+};

package/dist/modules/packages.d.ts

@@ -0,0 +1,16 @@
+import { BulkOperationResult, CreatePackage, PackageFilter, PackageResult, PackagesResult, UpdatePackage, UpdateResult } from "../types/types.js";
+declare function getPackage(packageId: string): Promise<PackageResult>;
+declare function getPackages(packageFilter: PackageFilter): Promise<PackagesResult[]>;
+declare function updatePackage(packageId: string, packageInfo: UpdatePackage): Promise<UpdateResult>;
+declare function deletePackage(packageId: string): Promise<UpdateResult>;
+declare function createPackage(packageInfo: CreatePackage): Promise<PackageResult>;
+declare function instantiatePackage(packageId: string, rootItemId: string, startTimestamp: number, allocName?: boolean): Promise<BulkOperationResult>;
+export declare const packages: {
+    getPackage: typeof getPackage;
+    getPackages: typeof getPackages;
+    updatePackage: typeof updatePackage;
+    deletePackage: typeof deletePackage;
+    createPackage: typeof createPackage;
+    instantiatePackage: typeof instantiatePackage;
+};
+export {};

package/dist/modules/packages.js

@@ -0,0 +1,71 @@
+import { getToken } from "../helper/token.js";
+import { getRequestOptions, getData } from "../helper/httpHelper.js";
+import { validateString, validateObject, validateNumber, } from "../helper/validate.js";
+import { bulkOperation } from "./allocations.js";
+async function getPackage(packageId) {
+    validateString(packageId, "Function: getPackage, Value: packageId");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("GET", token);
+    return (await getData(`/packages/package/${packageId}`, requestOptions));
+}
+async function getPackages(packageFilter) {
+    validateObject(packageFilter, "Function: getPackages, Value: packageFilter");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("GET", token);
+    const queryParams = new URLSearchParams(packageFilter).toString();
+    const url = `/packages/packages${queryParams ? `?${queryParams}` : ""}`;
+    return (await getData(url, requestOptions));
+}
+async function updatePackage(packageId, packageInfo) {
+    validateString(packageId, "Function: updatePackage, Value: packageId");
+    validateObject(packageInfo, "Function: updatePackage, Value: packageInfo");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("PUT", token, packageInfo);
+    return (await getData(`/packages/package/${packageId}`, requestOptions));
+}
+async function deletePackage(packageId) {
+    validateString(packageId, "Function: deletePackage, Value: packageId");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("DELETE", token);
+    return (await getData(`/packages/package/${packageId}`, requestOptions));
+}
+async function createPackage(packageInfo) {
+    validateObject(packageInfo, "Function: createPackage, Value: packageInfo");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, packageInfo);
+    return (await getData(`/packages/package`, requestOptions));
+}
+async function instantiatePackage(packageId, rootItemId, startTimestamp, allocName = true) {
+    validateString(packageId, "Function: instantiatePackage, Value: packageId");
+    validateString(rootItemId, "Function: instantiatePackage, Value: rootItemId");
+    validateNumber(startTimestamp, "Function: instantiatePackage, Value: startTimestamp");
+    const packageInfo = await getPackage(packageId);
+    const createAllocs = packageInfo.packageAllocations
+        .filter((alloc) => alloc.leafData !== undefined)
+        .map((alloc) => ({
+        item1Id: rootItemId,
+        item2Id: alloc.leafId,
+        from: startTimestamp + alloc.startOffset,
+        to: startTimestamp + alloc.startOffset + alloc.duration,
+        name: allocName ? packageInfo.name : "",
+    }));
+    return await bulkOperation({ create: createAllocs }, {
+        type: "package",
+        skipUndefined: true,
+        retryArguments: {
+            packageId,
+            rootItemId,
+            startTimestamp,
+            allocName,
+        },
+        conflicting_allocations: [],
+    });
+}
+export const packages = {
+    getPackage,
+    getPackages,
+    updatePackage,
+    deletePackage,
+    createPackage,
+    instantiatePackage,
+};

package/dist/modules/templates.d.ts

@@ -0,0 +1,19 @@
+import { DeleteResult, RawTemplate, TemplateFilter, TemplateInput, TemplateResult } from "../types/types.js";
+declare function getTemplateById(templateId: string): Promise<TemplateResult>;
+declare function getAllTemplates(): Promise<TemplateResult[]>;
+declare function updateTemplate(templateId: string, templateInfo: TemplateInput): Promise<TemplateResult>;
+declare function deleteTemplate(templateId: string): Promise<DeleteResult>;
+declare function createTemplate(templateProperties: TemplateInput): Promise<TemplateResult>;
+/**
+ * DEPRECATED: use getTemplateById or getAllTemplates
+ */
+declare function getTemplates(filter?: TemplateFilter): Promise<RawTemplate[]>;
+export declare const templates: {
+    getTemplateById: typeof getTemplateById;
+    getAllTemplates: typeof getAllTemplates;
+    updateTemplate: typeof updateTemplate;
+    deleteTemplate: typeof deleteTemplate;
+    createTemplate: typeof createTemplate;
+    getTemplates: typeof getTemplates;
+};
+export {};

package/dist/modules/templates.js

@@ -0,0 +1,64 @@
+import { getToken } from "../helper/token.js";
+import { getRequestOptions, getData } from "../helper/httpHelper.js";
+import { validateString, validateObject } from "../helper/validate.js";
+import parse from "../helper/parse.js";
+async function getTemplateById(templateId) {
+    validateString(templateId, "Function: getTemplateById, Value: templateId");
+    const token = await getToken();
+    const bodyObj = {
+        filter: {
+            name: templateId,
+        },
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    const result = (await getData("/templates/template", requestOptions));
+    return parse.template(result);
+}
+async function getAllTemplates() {
+    const token = await getToken();
+    const bodyObj = {
+        filter: {},
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    const result = (await getData("/templates/template", requestOptions));
+    return parse.templates(result);
+}
+async function updateTemplate(templateId, templateInfo) {
+    validateString(templateId, "Function: updateTemplate, Value: templateId");
+    validateObject(templateInfo, "Function: updateTemplate, Value: templateInfo");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, templateInfo);
+    return (await getData(`/templates/template/${templateId}`, requestOptions));
+}
+async function deleteTemplate(templateId) {
+    validateString(templateId, "Function: deleteTemplate, Value: templateId");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("DELETE", token);
+    return (await getData(`/templates/template/${templateId}`, requestOptions));
+}
+async function createTemplate(templateProperties) {
+    validateObject(templateProperties, "Function: createTemplate, Value: templateProperties");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, templateProperties);
+    return (await getData(`/templates/create`, requestOptions));
+}
+/**
+ * DEPRECATED: use getTemplateById or getAllTemplates
+ */
+async function getTemplates(filter = {}) {
+    validateObject(filter, "Function: getTemplates, Value: filter");
+    const token = await getToken();
+    const bodyObj = {
+        filter: filter,
+    };
+    const requestOptions = getRequestOptions("POST", token, bodyObj);
+    return (await getData("/templates/template", requestOptions));
+}
+export const templates = {
+    getTemplateById,
+    getAllTemplates,
+    updateTemplate,
+    deleteTemplate,
+    createTemplate,
+    getTemplates,
+};

package/dist/modules/translations.d.ts

@@ -0,0 +1,6 @@
+import { DeepLInput, ProcessedDeepLResponse } from "../types/types";
+declare function translate(input: DeepLInput): Promise<ProcessedDeepLResponse | ProcessedDeepLResponse[]>;
+export declare const translations: {
+    translate: typeof translate;
+};
+export {};

package/dist/modules/translations.js

@@ -0,0 +1,17 @@
+import { getData, getRequestOptions } from "../helper/httpHelper";
+import { getToken } from "../helper/token";
+import { validateObject } from "../helper/validate";
+async function translate(input) {
+    validateObject(input, "Function: translate, Value: input");
+    const token = await getToken();
+    const requestOptions = getRequestOptions("POST", token, input);
+    const response = (await getData(`/translations/translate/`, requestOptions));
+    return Array.isArray(response)
+        ? response.map((elem) => {
+            return { text: elem.text, detectedSourceLang: elem.detectedSourceLang };
+        })
+        : { text: response.text, detectedSourceLang: response.detectedSourceLang };
+}
+export const translations = {
+    translate,
+};