@cemiar/cemiarlink-sdk 1.0.22 → 1.0.24

package/dist/services/Mail.js

@@ -0,0 +1,318 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const nodemailer_1 = __importDefault(require("nodemailer"));
+const AxiosClient_1 = require("../utils/AxiosClient");
+/**
+ * MailService provides email-related features such as sending emails, managing folders, retrieving messages, and handling attachments.
+ * It uses Nodemailer and Axios for communication with Gmail and the Cemiar mail API.
+ */
+class MailService {
+    constructor(mailUrl, headers, user, password) {
+        this.axiosInstance = new AxiosClient_1.AxiosClient(mailUrl, headers).getInstance();
+        this.transporter = nodemailer_1.default.createTransport({
+            service: 'gmail',
+            auth: {
+                user: user,
+                pass: password,
+            },
+        });
+    }
+    async getEmailFolders() {
+        const folders = await this.axiosInstance.get('gmail/folders');
+        return folders.data.labels;
+    }
+    async getEmailMessageIds(filter) {
+        // get messages id from gmail
+        const queryString = this.buildQueryString(filter);
+        const url = `gmail?${queryString}`;
+        const res = await this.axiosInstance.get(url);
+        if (res.data.resultSizeEstimate == 0) {
+            return [];
+        }
+        return res.data.messages.map((message) => message.id);
+    }
+    async updateEmailMetadata(mailId, payload) {
+        // set mail as read
+        await this.axiosInstance.put('gmail/' + mailId, payload);
+    }
+    async getEmailContent(mailId) {
+        const { data } = await this.axiosInstance.get(`gmail/${mailId}?format=FULL`);
+        return data;
+    }
+    findAttachment(parts, attachmentTypes) {
+        if (!parts)
+            return null;
+        let attachment = null;
+        for (const part of parts) {
+            if (part.mimeType === 'multipart/mixed') {
+                for (const subPart of part.parts) {
+                    if (attachmentTypes.some((type) => subPart.filename.includes(`.${type}`))) {
+                        attachment = subPart;
+                        break;
+                    }
+                }
+            }
+            else {
+                if (attachmentTypes.some((type) => part.filename.includes(`.${type}`))) {
+                    attachment = part;
+                    break;
+                }
+            }
+        }
+        return attachment;
+    }
+    async findData(parts) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        let data = '';
+        if (parts) {
+            if ((_b = (_a = parts[0]) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.data) {
+                data = parts[0].body.data;
+            }
+            if ((_c = parts[0]) === null || _c === void 0 ? void 0 : _c.parts) {
+                if ((_f = (_e = (_d = parts[0]) === null || _d === void 0 ? void 0 : _d.parts[0]) === null || _e === void 0 ? void 0 : _e.body) === null || _f === void 0 ? void 0 : _f.data) {
+                    data = parts[0].parts[0].body.data;
+                }
+                if ((_h = (_g = parts[0]) === null || _g === void 0 ? void 0 : _g.parts[0]) === null || _h === void 0 ? void 0 : _h.parts) {
+                    if ((_m = (_l = (_k = (_j = parts[0]) === null || _j === void 0 ? void 0 : _j.parts[0]) === null || _k === void 0 ? void 0 : _k.parts[0]) === null || _l === void 0 ? void 0 : _l.body) === null || _m === void 0 ? void 0 : _m.data) {
+                        data = parts[0].parts[0].parts[0].body.data;
+                    }
+                }
+            }
+        }
+        return data;
+    }
+    async fetchAttachment(mailId, attachmentId) {
+        const { data } = await this.axiosInstance.get(`gmail/attachment/${mailId}/${attachmentId}`);
+        return data;
+    }
+    extractSubject(headers) {
+        return headers.find((header) => header.name === 'Subject')['value'].toLowerCase();
+    }
+    extractTextContent(parts) {
+        const textPart = parts ? parts.find((p) => p.mimeType === 'text/plain') : undefined;
+        return textPart ? Buffer.from(textPart.body.data, 'base64').toString('binary') : '';
+    }
+    extractRecipientEmail(headers) {
+        const toHeader = headers.find((header) => header.name === 'To');
+        if (!toHeader || typeof toHeader.value !== 'string') {
+            return null;
+        }
+        const from = toHeader.value;
+        const emailPattern = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/;
+        const match = from.match(emailPattern);
+        return match ? match[0] : null;
+    }
+    extractReturnAddress(headers) {
+        const from = headers.find((header) => header.name === 'From')['value'].toLowerCase();
+        try {
+            return from.match(/<(.*)>/)[1];
+        }
+        catch (_a) {
+            return from;
+        }
+    }
+    async extractTransactionWatchData(data, returnAddress) {
+        let transactionWatch = {
+            financement: '',
+            transfert: false,
+            itemNumbers: [],
+            clientCode: '',
+            from: returnAddress,
+        };
+        let buffer = Buffer.from(data, 'base64');
+        let rows = buffer
+            .toString()
+            .split('[')[0]
+            .replace(/[\r ()*]+/g, '')
+            .toLowerCase()
+            .split('\n');
+        for (let row of rows) {
+            if (row.indexOf('codeclient:') !== -1) {
+                transactionWatch.clientCode = row.split(':')[1];
+            }
+            if (row.indexOf('transfertdecrédits') !== -1) {
+                transactionWatch.transfert = true;
+            }
+            if (row.indexOf('financement:') !== -1) {
+                transactionWatch.financement = row.split(':')[1];
+            }
+            if (row.indexOf('numérostransactions:') !== -1) {
+                transactionWatch.itemNumbers = row.split(':')[1].split(',');
+            }
+        }
+        return transactionWatch;
+    }
+    buildQueryString(queryParams) {
+        return Object.entries(queryParams)
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+            .join('&');
+    }
+    /**
+     * Asynchronously retrieves an email report based on the provided mail object and attachment type.
+     *
+     * @param to - email recipient
+     * @param subjectType
+     * @param {GetEmailReportOptions | undefined} options - The options for fetching email report.
+     * @returns {object | undefined} - The data of the retrieved report or undefined if not found or an error occurs.
+     * @throws {Error} - If an error occurs during the process.
+     */
+    async getEmailReport(to, subjectType, options) {
+        const date = new Date();
+        date.setDate(date.getDate());
+        const today = date.toISOString().split('T')[0];
+        date.setDate(date.getDate() + 1);
+        const tomorrow = date.toISOString().split('T')[0];
+        const filter = Object.assign({ q: `to: ${to} after:${today} before:${tomorrow}` }, ((options === null || options === void 0 ? void 0 : options.includeRead) ? {} : { labelIds: 'UNREAD' }));
+        const mails = await this.getEmailMessageIds(filter);
+        for (const mail of mails) {
+            const emailContent = await this.getEmailContent(mail);
+            const subject = this.extractSubject(emailContent.payload.headers);
+            if (subject.indexOf(subjectType) === -1) {
+                continue;
+            }
+            const { payload: { parts }, } = emailContent;
+            const attachment = this.findAttachment(parts, ['xlsx']);
+            if (!attachment || attachment.body.size === 0) {
+                throw new Error(`Could not find the attachment ending in 'xlsx' in the email: ${mail}.`);
+            }
+            const attachmentData = await this.fetchAttachment(mail, attachment.body.attachmentId);
+            let fileType = attachment.filename.split('.')[1];
+            fileType = '.' + fileType;
+            const buffer = Buffer.from(attachmentData.data, 'base64');
+            if (!fs_1.default.existsSync('./temp/')) {
+                fs_1.default.mkdirSync('./temp/');
+            }
+            fs_1.default.writeFileSync(`./temp/Rapport ${subjectType} du ${today}${fileType}`, buffer);
+            if (!(options === null || options === void 0 ? void 0 : options.skipRead))
+                await this.updateEmailMetadata(mail, {
+                    removeLabelIds: ['UNREAD'],
+                });
+        }
+    }
+    /**
+     * Asynchronously retrieves all emails' reports based on a date.
+     *
+     * @param {Date} date - The date of email reports to fetch.
+     * @param {GetEmailReportOptions | undefined} options - The options for fetching email report.
+     * @returns {EmailReport[]} - The list of reports.
+     * @throws {Error} - If an error occurs during the process.
+     */
+    async getEmailReports(date, options) {
+        const today = date.toISOString().split('T')[0];
+        date.setDate(date.getDate() + 1);
+        const tomorrow = date.toISOString().split('T')[0];
+        let q = `after:${today} before:${tomorrow} in:inbox`;
+        if (!(options === null || options === void 0 ? void 0 : options.includeRead))
+            q += ' ' + 'in:unread';
+        let emailIds = await this.getEmailMessageIds({
+            q,
+        });
+        if (options === null || options === void 0 ? void 0 : options.subfolders) {
+            const gMailFolders = await this.getEmailFolders();
+            const folders = gMailFolders.filter((f) => { var _a; return (_a = options === null || options === void 0 ? void 0 : options.subfolders) === null || _a === void 0 ? void 0 : _a.includes(f.name); }).map((f) => f.id);
+            if (folders) {
+                let qu = `after:${today} before:${tomorrow}`;
+                if (!(options === null || options === void 0 ? void 0 : options.includeRead)) {
+                    qu += ' ' + 'in:unread';
+                }
+                const folderEmails = await this.getEmailMessageIds({
+                    q: qu,
+                    labelIds: folders.join(','),
+                });
+                emailIds.push(...folderEmails);
+            }
+        }
+        const emailReports = [];
+        for (const emailId of emailIds) {
+            const emailContent = await this.getEmailContent(emailId);
+            const subject = this.extractSubject(emailContent.payload.headers);
+            const recipient = this.extractRecipientEmail(emailContent.payload.headers);
+            const date = new Date(parseInt(emailContent.internalDate)).toISOString().split('T')[0];
+            const { payload: { parts }, } = emailContent;
+            const textContent = this.extractTextContent(parts);
+            const attachment = this.findAttachment(parts, ['xlsx', 'csv', 'pdf']);
+            if (!recipient)
+                continue;
+            if (!attachment || attachment.body.size === 0) {
+                emailReports.push({
+                    emailId,
+                    recipient: recipient,
+                    subject: subject,
+                    date: date,
+                    textContent: textContent,
+                    extension: undefined,
+                    buffer: undefined,
+                    from: this.extractReturnAddress(emailContent.payload.headers),
+                });
+            }
+            else {
+                const attachmentData = await this.fetchAttachment(emailId, attachment.body.attachmentId);
+                const buffer = Buffer.from(attachmentData.data, 'base64');
+                emailReports.push({
+                    emailId,
+                    recipient,
+                    subject,
+                    buffer,
+                    date,
+                    extension: attachment.filename.split('.').pop(),
+                    textContent,
+                    from: this.extractReturnAddress(emailContent.payload.headers),
+                });
+            }
+            if (!(options === null || options === void 0 ? void 0 : options.skipRead))
+                await this.updateEmailMetadata(emailId, {
+                    removeLabelIds: ['UNREAD'],
+                });
+        }
+        return emailReports.filter((item, index, self) => index ===
+            self.findIndex((t) => t.recipient === item.recipient && t.subject === item.subject && t.date === item.date));
+    }
+    async getTransactionWatchList(to, subjectType) {
+        const date = new Date();
+        date.setDate(date.getDate());
+        const today = date.toISOString().split('T')[0];
+        date.setDate(date.getDate() + 1);
+        const tomorrow = date.toISOString().split('T')[0];
+        const mails = await this.getEmailMessageIds({
+            labelIds: 'UNREAD',
+            q: `to: ${to} OR cc:${to} after:${today} before:${tomorrow}`,
+        });
+        let transactionWatchList = [];
+        for (const mail of mails) {
+            const emailContent = await this.getEmailContent(mail);
+            const subject = this.extractSubject(emailContent.payload.headers);
+            if (subject.indexOf(subjectType) === -1) {
+                continue;
+            }
+            const returnAddress = this.extractReturnAddress(emailContent.payload.headers);
+            const { payload: { parts }, } = emailContent;
+            const data = await this.findData(parts);
+            transactionWatchList.push(await this.extractTransactionWatchData(data, returnAddress));
+            await this.updateEmailMetadata(mail, {
+                removeLabelIds: ['UNREAD'],
+            });
+        }
+        return transactionWatchList;
+    }
+    async deleteEmail(id) {
+        await this.axiosInstance.delete(`gmail/${id}`);
+    }
+    async sendMail(subject, text, html, to, attachments, cc) {
+        const mailOptions = {
+            from: this.user,
+            to,
+            subject,
+            text,
+            html,
+            cc,
+            attachments,
+        };
+        await this.transporter.sendMail(mailOptions);
+    }
+}
+exports.MailService = MailService;

package/dist/services/MultiCarrierScheduleEpicService.d.ts

@@ -0,0 +1,12 @@
+import { BaseEpicService } from "./BaseEpicService";
+import { MultiCarrierScheduleModel } from "../models/epic/MultiCarrierSchedule";
+/**
+ * MultiCarrierScheduleEpicService provides methods to manage multi-carrier schedules via the Epic API.
+ * It extends BaseEpicService for common API functionality.
+ */
+export declare class MultiCarrierScheduleEpicService extends BaseEpicService {
+    readonly baseUrl = "multiCarrierSchedule";
+    getMultiCarrierSchedules(req: MultiCarrierScheduleModel.GetRequest): Promise<MultiCarrierScheduleModel.MultiCarrierSchedule[]>;
+    createMultiCarrierSchedule(req: MultiCarrierScheduleModel.CreateRequest): Promise<string>;
+    updateMultiCarrierSchedule(multiCarrierScheduleID: number, payload: MultiCarrierScheduleModel.UpdateRequest): Promise<string>;
+}

package/dist/services/MultiCarrierScheduleEpicService.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiCarrierScheduleEpicService = void 0;
+const BaseEpicService_1 = require("./BaseEpicService");
+/**
+ * MultiCarrierScheduleEpicService provides methods to manage multi-carrier schedules via the Epic API.
+ * It extends BaseEpicService for common API functionality.
+ */
+class MultiCarrierScheduleEpicService extends BaseEpicService_1.BaseEpicService {
+    constructor() {
+        super(...arguments);
+        this.baseUrl = 'multiCarrierSchedule';
+    }
+    async getMultiCarrierSchedules(req) {
+        return this.get(this.baseUrl, req);
+    }
+    async createMultiCarrierSchedule(req) {
+        return this.post(this.baseUrl, req);
+    }
+    async updateMultiCarrierSchedule(multiCarrierScheduleID, payload) {
+        return this.put(`${this.baseUrl}/${multiCarrierScheduleID}`, payload);
+    }
+}
+exports.MultiCarrierScheduleEpicService = MultiCarrierScheduleEpicService;

package/dist/services/SharepointService.d.ts

@@ -0,0 +1,13 @@
+import { AxiosInstance } from 'axios';
+import { SharepointConnection, SharepointDownloadResult, SharepointFileInfo, SharepointSearchRequest } from '../models/sharepoint/Sharepoint';
+/**
+ * SharepointService provides methods to interact with the SharePoint API for file search, download, and retrieval operations.
+ * It wraps Axios and offers methods to find files, download files by ID, and perform combined find-and-download requests.
+ */
+export declare class SharepointService {
+    axiosInstance: AxiosInstance;
+    constructor(sharepointUrl: string | undefined, headers: any);
+    findFile(input: SharepointSearchRequest): Promise<SharepointFileInfo | null>;
+    downloadFileById(id: string, connection: SharepointConnection): Promise<Buffer>;
+    findAndDownload(input: SharepointSearchRequest): Promise<SharepointDownloadResult | null>;
+}

package/dist/services/SharepointService.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharepointService = void 0;
+const AxiosClient_1 = require("../utils/AxiosClient");
+/**
+ * SharepointService provides methods to interact with the SharePoint API for file search, download, and retrieval operations.
+ * It wraps Axios and offers methods to find files, download files by ID, and perform combined find-and-download requests.
+ */
+class SharepointService {
+    constructor(sharepointUrl, headers) {
+        this.axiosInstance = new AxiosClient_1.AxiosClient(sharepointUrl, headers).getInstance();
+    }
+    async findFile(input) {
+        var _a;
+        const { data } = await this.axiosInstance.post('sharepoint/files/search', input);
+        return (_a = data === null || data === void 0 ? void 0 : data.file) !== null && _a !== void 0 ? _a : null;
+    }
+    async downloadFileById(id, connection) {
+        const res = await this.axiosInstance.post(`sharepoint/files/download/${encodeURIComponent(id)}`, connection, { responseType: 'arraybuffer' });
+        return Buffer.from(res.data);
+    }
+    async findAndDownload(input) {
+        const res = await this.axiosInstance.post('sharepoint/files/find-and-download', input, {
+            responseType: 'arraybuffer',
+            validateStatus: (status) => status === 200 || status === 404,
+        });
+        if (res.status === 404)
+            return null;
+        const getHeader = (name) => {
+            var _a;
+            const value = res.headers[name];
+            if (Array.isArray(value))
+                return (_a = value[0]) !== null && _a !== void 0 ? _a : '';
+            return typeof value === 'string' ? value : String(value !== null && value !== void 0 ? value : '');
+        };
+        return {
+            buffer: Buffer.from(res.data),
+            fileName: decodeURIComponent(getHeader('x-sharepoint-file-name')),
+            fileId: getHeader('x-sharepoint-file-id'),
+            webUrl: getHeader('x-sharepoint-file-weburl'),
+        };
+    }
+}
+exports.SharepointService = SharepointService;

package/dist/utils/AxiosClient.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from 'axios';
+export declare class AxiosClient {
+    axiosInstance: AxiosInstance;
+    constructor(baseURL: string | undefined, headers: any);
+    getInstance(): AxiosInstance;
+}

package/dist/utils/AxiosClient.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class AxiosClient {
+    constructor(baseURL, headers) {
+        this.axiosInstance = axios_1.default.create({
+            baseURL: baseURL,
+            headers: headers,
+        });
+        this.axiosInstance.interceptors.response.use((res) => {
+            return res;
+        }, async (err) => {
+            var _a, _b;
+            const originalConfig = err.config;
+            originalConfig._retry = originalConfig._retry || 0;
+            if ((((_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.status) === 524 || ((_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.status) === 504) && originalConfig._retry < 3) {
+                await sleep(originalConfig._retry * 10000);
+                originalConfig._retry += 1;
+                return await this.axiosInstance(originalConfig);
+            }
+            return Promise.reject(err);
+        });
+    }
+    getInstance() {
+        return this.axiosInstance;
+    }
+}
+exports.AxiosClient = AxiosClient;
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/utils/DeepPartial.d.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};

package/dist/utils/DeepPartial.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/Excel.d.ts

@@ -0,0 +1,8 @@
+import ExcelSheet from "../models/admin/ExcelSheet";
+export default class readXlsx {
+    static getFromXLSX<T>(path: string, sheetNumber: number): Promise<T[]>;
+    static getFromCSV<T>(path: string): Promise<T[]>;
+    static appendFile(array: Array<string>, fileName: string): Promise<void>;
+    static createFile(data: string[][], header: string[], fileName: string): void;
+    static createFileFromSheets(sheets: ExcelSheet[], fileName: string): void;
+}

package/dist/utils/Excel.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const xlsx_1 = __importDefault(require("xlsx"));
+class readXlsx {
+    static async getFromXLSX(path, sheetNumber) {
+        var _a, _b;
+        const file = xlsx_1.default.readFile(path);
+        const worksheet = file.Sheets[file.SheetNames[sheetNumber]];
+        if (!worksheet) {
+            return [];
+        }
+        (_a = worksheet['!rows']) === null || _a === void 0 ? void 0 : _a.shift();
+        const range = xlsx_1.default.utils.decode_range((_b = worksheet['!ref']) !== null && _b !== void 0 ? _b : '');
+        range.s.r = 1;
+        worksheet['!ref'] = xlsx_1.default.utils.encode_range(range);
+        return xlsx_1.default.utils.sheet_to_json(file.Sheets[file.SheetNames[sheetNumber]], {
+            raw: false,
+            defval: '',
+            range: range,
+        });
+    }
+    static async getFromCSV(path) {
+        const data = await CSVToJSON(path);
+        const Info = [];
+        for (let i = 1; i < data.length; i++) {
+            const temp = data[i];
+            Info.push(temp);
+        }
+        return Info;
+    }
+    static async appendFile(array, fileName) {
+        let csv = ''; // Construct a CSV row
+        for (const el of array) {
+            if (array.indexOf(el) === array.length - 1) {
+                csv += el + '\n'; // Add new line
+                break;
+            }
+            else {
+                csv += el + ',';
+            }
+        }
+        if (!fs_1.default.existsSync('./result/')) {
+            fs_1.default.mkdirSync('./result/');
+        }
+        fs_1.default.appendFileSync('./result/' + fileName, csv); // Append the CSV row to the file
+    }
+    static createFile(data, header, fileName) {
+        const workbook = xlsx_1.default.utils.book_new();
+        const sheetName = 'Rapport';
+        const filePath = './result/' + fileName;
+        if (!fs_1.default.existsSync('./result/')) {
+            fs_1.default.mkdirSync('./result/');
+        }
+        // Création de la feuille avec les données
+        const worksheet = xlsx_1.default.utils.aoa_to_sheet([header, ...data]);
+        // Ajout de la feuille de calcul au classeur
+        xlsx_1.default.utils.book_append_sheet(workbook, worksheet, sheetName);
+        // Création du fichier Excel
+        xlsx_1.default.writeFile(workbook, filePath);
+    }
+    static createFileFromSheets(sheets, fileName) {
+        const filePath = './result/' + fileName;
+        if (!fs_1.default.existsSync('./result/')) {
+            fs_1.default.mkdirSync('./result/');
+        }
+        const workbook = xlsx_1.default.utils.book_new();
+        for (const sheet of sheets) {
+            // Création de la feuille avec les données
+            const worksheet = xlsx_1.default.utils.aoa_to_sheet([sheet.header, ...sheet.data]);
+            // Ajout de la feuille de calcul au classeur
+            xlsx_1.default.utils.book_append_sheet(workbook, worksheet, sheet.name);
+        }
+        // Création du fichier Excel
+        xlsx_1.default.writeFile(workbook, filePath);
+    }
+}
+exports.default = readXlsx;
+async function CSVToJSON(csv) {
+    let file = fs_1.default.readFileSync(csv, 'utf8');
+    file = file.replace('\r', '');
+    const rows = file.split('\n');
+    const titles = rows[0].split(',');
+    const data = [];
+    for (let i = 1; i < rows.length; i++) {
+        if (rows[i] === '')
+            continue;
+        const elements = rows[i].split(',');
+        const temp = {};
+        for (let j = 0; j < elements.length; j++) {
+            temp[titles[j]] = elements[j];
+        }
+        data.push(temp);
+    }
+    return data;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cemiar/cemiarlink-sdk",
-    "version": "1.0.22",
+    "version": "1.0.24",
     "description": "CemiarLink SDK to access CemiarLink API services",
     "engines": {
         "npm": ">=9.5.1",