keez-invoicing 1.1.5

package/dist/src/api/invoices/downloadPdf.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiDownloadInvoicePdf = apiDownloadInvoicePdf;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+async function apiDownloadInvoicePdf(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/invoices/${params.invoiceId}/pdf`;
+    try {
+        const response = await axios_1.default.get(url, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+            },
+            responseType: 'arraybuffer',
+            timeout: constants_1.DOWNLOAD_REQUEST_TIMEOUT_MS,
+        });
+        return Buffer.from(response.data);
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while downloading invoice PDF (${params.invoiceId}): ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to download invoice PDF: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG93bmxvYWRQZGYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBpL2ludm9pY2VzL2Rvd25sb2FkUGRmLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBY0Esc0RBeUJDO0FBdkNELGtEQUEwQztBQUMxQyw2Q0FBMEM7QUFDMUMsa0RBQWtEO0FBQ2xELGtEQUFpRTtBQUVqRSxNQUFNLFVBQVUsR0FBRyxlQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztBQVMzRSxLQUFLLFVBQVUscUJBQXFCLENBQUMsTUFBeUI7SUFDakUsTUFBTSxHQUFHLEdBQUcsR0FBRyxNQUFNLENBQUMsVUFBVSxpQ0FBaUMsTUFBTSxDQUFDLFNBQVMsTUFBTSxDQUFDO0lBRXhGLElBQUksQ0FBQztRQUNELE1BQU0sUUFBUSxHQUFHLE1BQU0sZUFBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUU7WUFDbEMsT0FBTyxFQUFFO2dCQUNMLGFBQWEsRUFBRSxVQUFVLE1BQU0sQ0FBQyxXQUFXLEVBQUU7YUFDaEQ7WUFDRCxZQUFZLEVBQUUsYUFBYTtZQUMzQixPQUFPLEVBQUUsdUNBQTJCO1NBQ3ZDLENBQUMsQ0FBQztRQUVILE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDdEMsQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDYixNQUFNLFVBQVUsR0FBRyxLQUFtQixDQUFDO1FBQ3ZDLE1BQU0sWUFBWSxHQUFHLFVBQVUsQ0FBQyxRQUFRLEVBQUUsSUFBSSxJQUFJLFVBQVUsQ0FBQyxPQUFPLENBQUM7UUFDckUsVUFBVSxDQUFDLEtBQUssQ0FDWixvREFBb0QsTUFBTSxDQUFDLFNBQVMsTUFBTSxJQUFJLENBQUMsU0FBUyxDQUFDLFlBQVksQ0FBQyxFQUFFLENBQzNHLENBQUM7UUFDRixNQUFNLElBQUksd0JBQVksQ0FDbEIsbUNBQW1DLElBQUksQ0FBQyxTQUFTLENBQUMsWUFBWSxDQUFDLEVBQUUsRUFDakUsVUFBVSxDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQzNCLEtBQUssQ0FDUixDQUFDO0lBQ04sQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgYXhpb3MsIHsgQXhpb3NFcnJvciB9IGZyb20gJ2F4aW9zJztcbmltcG9ydCB7IGxvZ2dlciB9IGZyb20gJ0AvaGVscGVycy9sb2dnZXInO1xuaW1wb3J0IHsgS2VlekFwaUVycm9yIH0gZnJvbSAnQC9lcnJvcnMvS2VlekVycm9yJztcbmltcG9ydCB7IERPV05MT0FEX1JFUVVFU1RfVElNRU9VVF9NUyB9IGZyb20gJ0AvY29uZmlnL2NvbnN0YW50cyc7XG5cbmNvbnN0IGtlZXpMb2dnZXIgPSBsb2dnZXIuY2hpbGQoeyBfbGlicmFyeTogJ0tlZXpXcmFwcGVyJywgX21ldGhvZDogJ0ludm9pY2VzJyB9KTtcblxuaW50ZXJmYWNlIERvd25sb2FkUGRmUGFyYW1zIHtcbiAgICByZWFkb25seSBiYXNlRG9tYWluOiBzdHJpbmc7XG4gICAgcmVhZG9ubHkgYXBwSWQ6IHN0cmluZztcbiAgICByZWFkb25seSBiZWFyZXJUb2tlbjogc3RyaW5nO1xuICAgIHJlYWRvbmx5IGludm9pY2VJZDogc3RyaW5nO1xufVxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gYXBpRG93bmxvYWRJbnZvaWNlUGRmKHBhcmFtczogRG93bmxvYWRQZGZQYXJhbXMpOiBQcm9taXNlPEJ1ZmZlcj4ge1xuICAgIGNvbnN0IHVybCA9IGAke3BhcmFtcy5iYXNlRG9tYWlufS9hcGkvdjEuMC9wdWJsaWMtYXBpL2ludm9pY2VzLyR7cGFyYW1zLmludm9pY2VJZH0vcGRmYDtcblxuICAgIHRyeSB7XG4gICAgICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgYXhpb3MuZ2V0KHVybCwge1xuICAgICAgICAgICAgaGVhZGVyczoge1xuICAgICAgICAgICAgICAgIEF1dGhvcml6YXRpb246IGBCZWFyZXIgJHtwYXJhbXMuYmVhcmVyVG9rZW59YCxcbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgICByZXNwb25zZVR5cGU6ICdhcnJheWJ1ZmZlcicsXG4gICAgICAgICAgICB0aW1lb3V0OiBET1dOTE9BRF9SRVFVRVNUX1RJTUVPVVRfTVMsXG4gICAgICAgIH0pO1xuXG4gICAgICAgIHJldHVybiBCdWZmZXIuZnJvbShyZXNwb25zZS5kYXRhKTtcbiAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgICBjb25zdCBheGlvc0Vycm9yID0gZXJyb3IgYXMgQXhpb3NFcnJvcjtcbiAgICAgICAgY29uc3QgZXJyb3JNZXNzYWdlID0gYXhpb3NFcnJvci5yZXNwb25zZT8uZGF0YSB8fCBheGlvc0Vycm9yLm1lc3NhZ2U7XG4gICAgICAgIGtlZXpMb2dnZXIuZXJyb3IoXG4gICAgICAgICAgICBgRXJyb3IgZW5jb3VudGVyZWQgd2hpbGUgZG93bmxvYWRpbmcgaW52b2ljZSBQREYgKCR7cGFyYW1zLmludm9pY2VJZH0pOiAke0pTT04uc3RyaW5naWZ5KGVycm9yTWVzc2FnZSl9YFxuICAgICAgICApO1xuICAgICAgICB0aHJvdyBuZXcgS2VlekFwaUVycm9yKFxuICAgICAgICAgICAgYEZhaWxlZCB0byBkb3dubG9hZCBpbnZvaWNlIFBERjogJHtKU09OLnN0cmluZ2lmeShlcnJvck1lc3NhZ2UpfWAsXG4gICAgICAgICAgICBheGlvc0Vycm9yLnJlc3BvbnNlPy5zdGF0dXMsXG4gICAgICAgICAgICBlcnJvclxuICAgICAgICApO1xuICAgIH1cbn1cbiJdfQ==

package/dist/src/api/invoices/getAll.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiGetAllInvoices = apiGetAllInvoices;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+/**
+ * Get all invoices
+ * @param params - As defined in the interface
+ */
+async function apiGetAllInvoices(params) {
+    let url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices`;
+    if (params.filterParams) {
+        const queryParams = new URLSearchParams();
+        if (params.filterParams.offset !== undefined) {
+            queryParams.append('offset', params.filterParams.offset.toString());
+        }
+        if (params.filterParams.count !== undefined) {
+            queryParams.append('count', params.filterParams.count.toString());
+        }
+        if (params.filterParams.status) {
+            queryParams.append('status', params.filterParams.status);
+        }
+        if (params.filterParams.fromDate !== undefined) {
+            queryParams.append('fromDate', params.filterParams.fromDate.toString());
+        }
+        if (params.filterParams.toDate !== undefined) {
+            queryParams.append('toDate', params.filterParams.toDate.toString());
+        }
+        if (params.filterParams.series) {
+            queryParams.append('series', params.filterParams.series);
+        }
+        if (params.filterParams.partnerName) {
+            queryParams.append('partnerName', params.filterParams.partnerName);
+        }
+        const queryString = queryParams.toString();
+        if (queryString) {
+            url += `?${queryString}`;
+        }
+    }
+    try {
+        const response = await axios_1.default.get(url, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+        const responseObject = response.data;
+        const allInvoices = responseObject.data.map(shortInvoice => ({
+            externalId: shortInvoice.externalId,
+            series: shortInvoice.series,
+            number: shortInvoice.number,
+            documentDate: shortInvoice.documentDate,
+            dueDate: shortInvoice.dueDate,
+            status: shortInvoice.status,
+            clientName: shortInvoice.clientName,
+            partnerName: shortInvoice.partnerName,
+            currencyCode: shortInvoice.currencyCode,
+            referenceCurrencyCode: shortInvoice.referenceCurrencyCode,
+            netAmount: shortInvoice.netAmount,
+            vatAmount: shortInvoice.vatAmount,
+            grossAmount: shortInvoice.grossAmount,
+        }));
+        const result = {
+            first: responseObject.first,
+            last: responseObject.last,
+            recordsCount: responseObject.recordsCount,
+            data: allInvoices,
+        };
+        return result;
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while getting all invoices: ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to get all invoices: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"getAll.js","sourceRoot":"","sources":["../../../../src/api/invoices/getAll.ts"],"names":[],"mappings":"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","sourcesContent":["import axios, { AxiosError } from 'axios';\nimport { logger } from '@/helpers/logger';\nimport { AllInvoicesResponse, ShortInvoiceResponse } from '@/dto/allInvoicesResponse';\nimport { KeezApiError } from '@/errors/KeezError';\nimport { InvoiceFilterParams } from '@/dto/invoices';\nimport { HTTP_REQUEST_TIMEOUT_MS } from '@/config/constants';\n\nconst keezLogger = logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });\n\n/**\n * baseDomain - The base domain for the API\n * appId - The application ID\n * appClientId - The application client ID\n * bearerToken - The bearer token obtained at the authentication stage\n * filterParams - Optional filter parameters\n */\ninterface GetAllInvoicesParams {\n    readonly baseDomain: string;\n    readonly appId: string;\n    readonly appClientId: string;\n    readonly bearerToken: string;\n    readonly filterParams?: InvoiceFilterParams;\n}\n\ninterface ApiShortInvoice {\n    externalId: string;\n    series: string;\n    number: number;\n    documentDate: number;\n    dueDate: number;\n    status: string;\n    clientName: string;\n    partnerName: string;\n    currencyCode: string;\n    referenceCurrencyCode: string;\n    netAmount: number;\n    vatAmount: number;\n    grossAmount: number;\n}\n\ninterface ApiAllInvoicesResponse {\n    first: number;\n    last: number;\n    recordsCount: number;\n    data: ApiShortInvoice[];\n}\n\n/**\n * Get all invoices\n * @param params - As defined in the interface\n */\nexport async function apiGetAllInvoices(params: GetAllInvoicesParams): Promise<AllInvoicesResponse> {\n    let url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices`;\n\n    if (params.filterParams) {\n        const queryParams = new URLSearchParams();\n        if (params.filterParams.offset !== undefined) {\n            queryParams.append('offset', params.filterParams.offset.toString());\n        }\n        if (params.filterParams.count !== undefined) {\n            queryParams.append('count', params.filterParams.count.toString());\n        }\n        if (params.filterParams.status) {\n            queryParams.append('status', params.filterParams.status);\n        }\n        if (params.filterParams.fromDate !== undefined) {\n            queryParams.append('fromDate', params.filterParams.fromDate.toString());\n        }\n        if (params.filterParams.toDate !== undefined) {\n            queryParams.append('toDate', params.filterParams.toDate.toString());\n        }\n        if (params.filterParams.series) {\n            queryParams.append('series', params.filterParams.series);\n        }\n        if (params.filterParams.partnerName) {\n            queryParams.append('partnerName', params.filterParams.partnerName);\n        }\n        const queryString = queryParams.toString();\n        if (queryString) {\n            url += `?${queryString}`;\n        }\n    }\n\n    try {\n        const response = await axios.get<ApiAllInvoicesResponse>(url, {\n            headers: {\n                Authorization: `Bearer ${params.bearerToken}`,\n            },\n            timeout: HTTP_REQUEST_TIMEOUT_MS,\n        });\n\n        const responseObject = response.data;\n        const allInvoices: ShortInvoiceResponse[] = responseObject.data.map(shortInvoice => ({\n            externalId: shortInvoice.externalId,\n            series: shortInvoice.series,\n            number: shortInvoice.number,\n            documentDate: shortInvoice.documentDate,\n            dueDate: shortInvoice.dueDate,\n            status: shortInvoice.status,\n            clientName: shortInvoice.clientName,\n            partnerName: shortInvoice.partnerName,\n            currencyCode: shortInvoice.currencyCode,\n            referenceCurrencyCode: shortInvoice.referenceCurrencyCode,\n            netAmount: shortInvoice.netAmount,\n            vatAmount: shortInvoice.vatAmount,\n            grossAmount: shortInvoice.grossAmount,\n        }));\n\n        const result: AllInvoicesResponse = {\n            first: responseObject.first,\n            last: responseObject.last,\n            recordsCount: responseObject.recordsCount,\n            data: allInvoices,\n        };\n        return result;\n    } catch (error) {\n        const axiosError = error as AxiosError;\n        const errorMessage = axiosError.response?.data || axiosError.message;\n        keezLogger.error(`Error encountered while getting all invoices: ${JSON.stringify(errorMessage)}`);\n        throw new KeezApiError(\n            `Failed to get all invoices: ${JSON.stringify(errorMessage)}`,\n            axiosError.response?.status,\n            error\n        );\n    }\n}\n"]}

package/dist/src/api/invoices/sendMail.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiSendInvoice = apiSendInvoice;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+/**
+ * Send an invoice by external ID
+ * @param params - as defined in the interface
+ * @returns {Promise<string>} - Returns 'SENT' on success
+ */
+async function apiSendInvoice(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/invoices/delivery`;
+    const recipients = {};
+    if (params.emailParams) {
+        recipients.to = params.emailParams.to;
+        if (params.emailParams.cc && params.emailParams.cc.length > 0) {
+            recipients.cc = params.emailParams.cc.join(',');
+        }
+        if (params.emailParams.bcc && params.emailParams.bcc.length > 0) {
+            recipients.bcc = params.emailParams.bcc.join(',');
+        }
+    }
+    else if (params.clientMail) {
+        recipients.to = params.clientMail;
+    }
+    const body = {
+        invoiceExternalId: params.invoiceId,
+        info: [
+            {
+                deliveryMethod: 'Email',
+                representationType: 'Attachment',
+                recipients,
+            },
+        ],
+    };
+    try {
+        await axios_1.default.post(url, body, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+        return 'SENT';
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while sending e-mail for invoice (id: ${params.invoiceId}): ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to send invoice email: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/api/invoices/submitEfactura.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiSubmitEfactura = apiSubmitEfactura;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+async function apiSubmitEfactura(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices/efactura/submitted`;
+    const body = {
+        externalId: params.invoiceId,
+    };
+    try {
+        const response = await axios_1.default.post(url, body, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+        return response.data.uploadIndex || response.data.externalId || 'SUBMITTED';
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while submitting invoice to eFactura (${params.invoiceId}): ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to submit invoice to eFactura: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/api/invoices/update.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiUpdateInvoice = apiUpdateInvoice;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+async function apiUpdateInvoice(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices/${params.invoiceId}`;
+    const invoiceDetails = params.invoice.items.map(item => ({
+        itemExternalId: item.itemExternalId,
+        measureUnitId: item.measureUnitId,
+        quantity: item.quantity,
+        unitPrice: item.unitPrice,
+        vatPercent: item.vatPercent,
+        discountPercent: item.discountPercent,
+        description: item.description,
+    }));
+    const body = {
+        series: params.invoice.series,
+        documentDate: params.invoice.documentDate,
+        dueDate: params.invoice.dueDate,
+        currencyCode: params.invoice.currencyCode,
+        paymentTypeId: params.invoice.paymentType,
+        vatOnCollection: params.invoice.vatOnCollection ?? false,
+        exchangeRate: params.invoice.exchangeRate,
+        notes: params.invoice.notes,
+        partner: {
+            isLegalPerson: params.invoice.partner.isLegalPerson,
+            partnerName: params.invoice.partner.partnerName,
+            identificationNumber: params.invoice.partner.identificationNumber,
+            countryCode: params.invoice.partner.countryCode,
+            countryName: params.invoice.partner.countryName,
+            countyCode: params.invoice.partner.countyCode,
+            countyName: params.invoice.partner.countyName,
+            cityName: params.invoice.partner.cityName,
+            addressDetails: params.invoice.partner.addressDetails,
+        },
+        invoiceDetails,
+    };
+    try {
+        await axios_1.default.put(url, body, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while updating invoice (${params.invoiceId}): ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to update invoice: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/api/invoices/validate.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiValidateInvoice = apiValidateInvoice;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+/**
+ * Validate an invoice by external ID
+ * @param params - as defined in the interface
+ * @returns {Promise<string>} - Returns 'VALIDATED' on success
+ */
+async function apiValidateInvoice(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices/valid`;
+    const body = {
+        externalId: params.invoiceId,
+    };
+    try {
+        await axios_1.default.post(url, body, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+        return 'VALIDATED';
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data?.Message || axiosError.message;
+        keezLogger.error(`Error encountered while validating invoice (id: ${params.invoiceId}): ${errorMessage}`);
+        throw new KeezError_1.KeezApiError(`Failed to validate invoice: ${errorMessage}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBpL2ludm9pY2VzL3ZhbGlkYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBMkJBLGdEQXNCQztBQWpERCxrREFBMEM7QUFDMUMsNkNBQTBDO0FBQzFDLGtEQUFrRDtBQUNsRCxrREFBNkQ7QUFFN0QsTUFBTSxVQUFVLEdBQUcsZUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLFFBQVEsRUFBRSxhQUFhLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUM7QUFpQmxGOzs7O0dBSUc7QUFDSSxLQUFLLFVBQVUsa0JBQWtCLENBQUMsTUFBNkI7SUFDbEUsTUFBTSxHQUFHLEdBQUcsR0FBRyxNQUFNLENBQUMsVUFBVSx3QkFBd0IsTUFBTSxDQUFDLFdBQVcsaUJBQWlCLENBQUM7SUFDNUYsTUFBTSxJQUFJLEdBQUc7UUFDVCxVQUFVLEVBQUUsTUFBTSxDQUFDLFNBQVM7S0FDL0IsQ0FBQztJQUVGLElBQUksQ0FBQztRQUNELE1BQU0sZUFBSyxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxFQUFFO1lBQ3hCLE9BQU8sRUFBRTtnQkFDTCxhQUFhLEVBQUUsVUFBVSxNQUFNLENBQUMsV0FBVyxFQUFFO2dCQUM3QyxjQUFjLEVBQUUsa0JBQWtCO2FBQ3JDO1lBQ0QsT0FBTyxFQUFFLG1DQUF1QjtTQUNuQyxDQUFDLENBQUM7UUFFSCxPQUFPLFdBQVcsQ0FBQztJQUN2QixDQUFDO0lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztRQUNiLE1BQU0sVUFBVSxHQUFHLEtBQXlDLENBQUM7UUFDN0QsTUFBTSxZQUFZLEdBQUcsVUFBVSxDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsT0FBTyxJQUFJLFVBQVUsQ0FBQyxPQUFPLENBQUM7UUFDOUUsVUFBVSxDQUFDLEtBQUssQ0FBQyxtREFBbUQsTUFBTSxDQUFDLFNBQVMsTUFBTSxZQUFZLEVBQUUsQ0FBQyxDQUFDO1FBQzFHLE1BQU0sSUFBSSx3QkFBWSxDQUFDLCtCQUErQixZQUFZLEVBQUUsRUFBRSxVQUFVLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztJQUM5RyxDQUFDO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBheGlvcywgeyBBeGlvc0Vycm9yIH0gZnJvbSAnYXhpb3MnO1xuaW1wb3J0IHsgbG9nZ2VyIH0gZnJvbSAnQC9oZWxwZXJzL2xvZ2dlcic7XG5pbXBvcnQgeyBLZWV6QXBpRXJyb3IgfSBmcm9tICdAL2Vycm9ycy9LZWV6RXJyb3InO1xuaW1wb3J0IHsgSFRUUF9SRVFVRVNUX1RJTUVPVVRfTVMgfSBmcm9tICdAL2NvbmZpZy9jb25zdGFudHMnO1xuXG5jb25zdCBrZWV6TG9nZ2VyID0gbG9nZ2VyLmNoaWxkKHsgX2xpYnJhcnk6ICdLZWV6V3JhcHBlcicsIF9tZXRob2Q6ICdJbnZvaWNlcycgfSk7XG5cbi8qKlxuICogYXBwSWQgLSBUaGUgYXBwbGljYXRpb24gSURcbiAqIGFwcENsaWVudElkIC0gVGhlIGFwcGxpY2F0aW9uIGNsaWVudCBJRFxuICogYmFzZURvbWFpbiAtIFRoZSBiYXNlIGRvbWFpbiBmb3IgdGhlIEFQSVxuICogYmVhcmVyVG9rZW4gLSBUaGUgYmVhcmVyIHRva2VuIG9idGFpbmVkIGF0IHRoZSBhdXRoZW50aWNhdGlvbiBzdGFnZVxuICogaW52b2ljZUlkIC0gVGhlIGludm9pY2UgSURcbiAqL1xuaW50ZXJmYWNlIFZhbGlkYXRlSW52b2ljZVBhcmFtcyB7XG4gICAgcmVhZG9ubHkgYXBwSWQ6IHN0cmluZztcbiAgICByZWFkb25seSBhcHBDbGllbnRJZDogc3RyaW5nO1xuICAgIHJlYWRvbmx5IGJhc2VEb21haW46IHN0cmluZztcbiAgICByZWFkb25seSBiZWFyZXJUb2tlbjogc3RyaW5nO1xuICAgIHJlYWRvbmx5IGludm9pY2VJZDogc3RyaW5nO1xufVxuXG4vKipcbiAqIFZhbGlkYXRlIGFuIGludm9pY2UgYnkgZXh0ZXJuYWwgSURcbiAqIEBwYXJhbSBwYXJhbXMgLSBhcyBkZWZpbmVkIGluIHRoZSBpbnRlcmZhY2VcbiAqIEByZXR1cm5zIHtQcm9taXNlPHN0cmluZz59IC0gUmV0dXJucyAnVkFMSURBVEVEJyBvbiBzdWNjZXNzXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBhcGlWYWxpZGF0ZUludm9pY2UocGFyYW1zOiBWYWxpZGF0ZUludm9pY2VQYXJhbXMpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIGNvbnN0IHVybCA9IGAke3BhcmFtcy5iYXNlRG9tYWlufS9hcGkvdjEuMC9wdWJsaWMtYXBpLyR7cGFyYW1zLmFwcENsaWVudElkfS9pbnZvaWNlcy92YWxpZGA7XG4gICAgY29uc3QgYm9keSA9IHtcbiAgICAgICAgZXh0ZXJuYWxJZDogcGFyYW1zLmludm9pY2VJZCxcbiAgICB9O1xuXG4gICAgdHJ5IHtcbiAgICAgICAgYXdhaXQgYXhpb3MucG9zdCh1cmwsIGJvZHksIHtcbiAgICAgICAgICAgIGhlYWRlcnM6IHtcbiAgICAgICAgICAgICAgICBBdXRob3JpemF0aW9uOiBgQmVhcmVyICR7cGFyYW1zLmJlYXJlclRva2VufWAsXG4gICAgICAgICAgICAgICAgJ0NvbnRlbnQtVHlwZSc6ICdhcHBsaWNhdGlvbi9qc29uJyxcbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgICB0aW1lb3V0OiBIVFRQX1JFUVVFU1RfVElNRU9VVF9NUyxcbiAgICAgICAgfSk7XG5cbiAgICAgICAgcmV0dXJuICdWQUxJREFURUQnO1xuICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICAgIGNvbnN0IGF4aW9zRXJyb3IgPSBlcnJvciBhcyBBeGlvc0Vycm9yPHsgTWVzc2FnZT86IHN0cmluZyB9PjtcbiAgICAgICAgY29uc3QgZXJyb3JNZXNzYWdlID0gYXhpb3NFcnJvci5yZXNwb25zZT8uZGF0YT8uTWVzc2FnZSB8fCBheGlvc0Vycm9yLm1lc3NhZ2U7XG4gICAgICAgIGtlZXpMb2dnZXIuZXJyb3IoYEVycm9yIGVuY291bnRlcmVkIHdoaWxlIHZhbGlkYXRpbmcgaW52b2ljZSAoaWQ6ICR7cGFyYW1zLmludm9pY2VJZH0pOiAke2Vycm9yTWVzc2FnZX1gKTtcbiAgICAgICAgdGhyb3cgbmV3IEtlZXpBcGlFcnJvcihgRmFpbGVkIHRvIHZhbGlkYXRlIGludm9pY2U6ICR7ZXJyb3JNZXNzYWdlfWAsIGF4aW9zRXJyb3IucmVzcG9uc2U/LnN0YXR1cywgZXJyb3IpO1xuICAgIH1cbn1cbiJdfQ==

package/dist/src/api/invoices/view.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiGetInvoiceByExternalId = apiGetInvoiceByExternalId;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+/**
+ * Get an invoice by external ID
+ * @param params as defined in the interface
+ * @returns {Promise<InvoiceResponse>} - The invoice details
+ */
+async function apiGetInvoiceByExternalId(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices/${params.invoiceId}`;
+    try {
+        const response = await axios_1.default.get(url, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+        const responseObject = response.data;
+        const allItems = responseObject.invoiceDetails.map(item => ({
+            discountGrossValue: item.discountGrossValue,
+            discountNetValue: item.discountNetValue,
+            discountVatValue: item.discountVatValue,
+            discountValueOnNet: item.discountValueOnNet,
+            grossAmount: item.grossAmount,
+            itemCode: item.itemCode,
+            itemDescription: item.itemDescription,
+            itemExternalId: item.itemExternalId,
+            itemName: item.itemName,
+            measureUnitId: item.measureUnitId,
+            netAmount: item.netAmount,
+            originalNetAmount: item.originalNetAmount,
+            originalVatAmount: item.originalVatAmount,
+            quantity: item.quantity,
+            unMeasureUnit: item.unMeasureUnit,
+            unVatCategory: item.unVatCategory,
+            unVatExemptionReason: item.unVatExemptionReason,
+            unitPrice: item.unitPrice,
+            vatAmount: item.vatAmount,
+            vatPercent: item.vatPercent,
+            exciseAmount: item.exciseAmount,
+        }));
+        const result = {
+            currencyCode: responseObject.currencyCode,
+            discountGrossValue: responseObject.discountGrossValue,
+            discountNetValue: responseObject.discountNetValue,
+            discountVatValue: responseObject.discountVatValue,
+            discountValueOnNet: responseObject.discountValueOnNet,
+            exciseAmount: responseObject.exciseAmount,
+            documentDate: responseObject.documentDate,
+            dueDate: responseObject.dueDate,
+            exchangeRate: responseObject.exchangeRate,
+            grossAmount: responseObject.grossAmount,
+            netAmount: responseObject.netAmount,
+            number: responseObject.number,
+            originalNetAmount: responseObject.originalNetAmount,
+            originalVatAmount: responseObject.originalVatAmount,
+            partner: {
+                addressDetails: responseObject.partner.addressDetails,
+                cityName: responseObject.partner.cityName,
+                countryCode: responseObject.partner.countryCode,
+                countryName: responseObject.partner.countryName,
+                countyCode: responseObject.partner.countyCode,
+                countyName: responseObject.partner.countyName,
+                identificationNumber: responseObject.partner.identificationNumber,
+                isLegalPerson: responseObject.partner.isLegalPerson,
+                partnerName: responseObject.partner.partnerName,
+            },
+            items: allItems,
+            paymentTypeId: responseObject.paymentTypeId,
+            referenceCurrencyCode: responseObject.referenceCurrencyCode,
+            series: responseObject.series,
+            status: responseObject.status,
+            vatAmount: responseObject.vatAmount,
+            vatOnCollection: responseObject.vatOnCollection,
+        };
+        return result;
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while getting invoice details (id: ${params.invoiceId}): ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to get invoice details: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../src/api/invoices/view.ts"],"names":[],"mappings":"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","sourcesContent":["import axios, { AxiosError } from 'axios';\nimport { logger } from '@/helpers/logger';\nimport { InvoiceResponse, Item } from '@/dto/invoiceResponse';\nimport { KeezApiError } from '@/errors/KeezError';\nimport { HTTP_REQUEST_TIMEOUT_MS } from '@/config/constants';\n\nconst keezLogger = logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });\n\n/**\n * baseDomain - The base domain for the API\n * appId - The application ID\n * appClientId - The application client ID\n * bearerToken - The bearer token obtained at the authentication stage\n * invoiceId - The invoice ID\n */\ninterface ViewInvoiceParams {\n    readonly baseDomain: string;\n    readonly appId: string;\n    readonly appClientId: string;\n    readonly bearerToken: string;\n    readonly invoiceId: string;\n}\n\ninterface ApiInvoiceItem {\n    discountGrossValue: number;\n    discountNetValue: number;\n    discountVatValue: number;\n    discountValueOnNet: boolean;\n    grossAmount: number;\n    itemCode: string;\n    itemDescription: string;\n    itemExternalId: string;\n    itemName: string;\n    measureUnitId: number;\n    netAmount: number;\n    originalNetAmount: number;\n    originalVatAmount: number;\n    quantity: number;\n    unMeasureUnit: string;\n    unVatCategory: string;\n    unVatExemptionReason: string;\n    unitPrice: number;\n    vatAmount: number;\n    vatPercent: number;\n    exciseAmount: number;\n}\n\ninterface ApiInvoiceResponse {\n    currencyCode: string;\n    discountGrossValue: number;\n    discountNetValue: number;\n    discountVatValue: number;\n    discountValueOnNet: boolean;\n    exciseAmount: number;\n    documentDate: number;\n    dueDate: number;\n    exchangeRate: number;\n    grossAmount: number;\n    netAmount: number;\n    number: number;\n    originalNetAmount: number;\n    originalVatAmount: number;\n    partner: {\n        addressDetails: string;\n        cityName: string;\n        countryCode: string;\n        countryName: string;\n        countyCode: string;\n        countyName: string;\n        identificationNumber: string;\n        isLegalPerson: boolean;\n        partnerName: string;\n    };\n    invoiceDetails: ApiInvoiceItem[];\n    paymentTypeId: number;\n    referenceCurrencyCode: string;\n    series: string;\n    status: string;\n    vatAmount: number;\n    vatOnCollection: boolean;\n}\n\n/**\n * Get an invoice by external ID\n * @param params as defined in the interface\n * @returns {Promise<InvoiceResponse>} - The invoice details\n */\nexport async function apiGetInvoiceByExternalId(params: ViewInvoiceParams): Promise<InvoiceResponse> {\n    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices/${params.invoiceId}`;\n\n    try {\n        const response = await axios.get<ApiInvoiceResponse>(url, {\n            headers: {\n                Authorization: `Bearer ${params.bearerToken}`,\n            },\n            timeout: HTTP_REQUEST_TIMEOUT_MS,\n        });\n\n        const responseObject = response.data;\n        const allItems: Item[] = responseObject.invoiceDetails.map(item => ({\n            discountGrossValue: item.discountGrossValue,\n            discountNetValue: item.discountNetValue,\n            discountVatValue: item.discountVatValue,\n            discountValueOnNet: item.discountValueOnNet,\n            grossAmount: item.grossAmount,\n            itemCode: item.itemCode,\n            itemDescription: item.itemDescription,\n            itemExternalId: item.itemExternalId,\n            itemName: item.itemName,\n            measureUnitId: item.measureUnitId,\n            netAmount: item.netAmount,\n            originalNetAmount: item.originalNetAmount,\n            originalVatAmount: item.originalVatAmount,\n            quantity: item.quantity,\n            unMeasureUnit: item.unMeasureUnit,\n            unVatCategory: item.unVatCategory,\n            unVatExemptionReason: item.unVatExemptionReason,\n            unitPrice: item.unitPrice,\n            vatAmount: item.vatAmount,\n            vatPercent: item.vatPercent,\n            exciseAmount: item.exciseAmount,\n        }));\n\n        const result: InvoiceResponse = {\n            currencyCode: responseObject.currencyCode,\n            discountGrossValue: responseObject.discountGrossValue,\n            discountNetValue: responseObject.discountNetValue,\n            discountVatValue: responseObject.discountVatValue,\n            discountValueOnNet: responseObject.discountValueOnNet,\n            exciseAmount: responseObject.exciseAmount,\n            documentDate: responseObject.documentDate,\n            dueDate: responseObject.dueDate,\n            exchangeRate: responseObject.exchangeRate,\n            grossAmount: responseObject.grossAmount,\n            netAmount: responseObject.netAmount,\n            number: responseObject.number,\n            originalNetAmount: responseObject.originalNetAmount,\n            originalVatAmount: responseObject.originalVatAmount,\n            partner: {\n                addressDetails: responseObject.partner.addressDetails,\n                cityName: responseObject.partner.cityName,\n                countryCode: responseObject.partner.countryCode,\n                countryName: responseObject.partner.countryName,\n                countyCode: responseObject.partner.countyCode,\n                countyName: responseObject.partner.countyName,\n                identificationNumber: responseObject.partner.identificationNumber,\n                isLegalPerson: responseObject.partner.isLegalPerson,\n                partnerName: responseObject.partner.partnerName,\n            },\n            items: allItems,\n            paymentTypeId: responseObject.paymentTypeId,\n            referenceCurrencyCode: responseObject.referenceCurrencyCode,\n            series: responseObject.series,\n            status: responseObject.status,\n            vatAmount: responseObject.vatAmount,\n            vatOnCollection: responseObject.vatOnCollection,\n        };\n        return result;\n    } catch (error) {\n        const axiosError = error as AxiosError;\n        const errorMessage = axiosError.response?.data || axiosError.message;\n        keezLogger.error(\n            `Error encountered while getting invoice details (id: ${params.invoiceId}): ${JSON.stringify(errorMessage)}`\n        );\n        throw new KeezApiError(\n            `Failed to get invoice details: ${JSON.stringify(errorMessage)}`,\n            axiosError.response?.status,\n            error\n        );\n    }\n}\n"]}

package/dist/src/api/items/create.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiCreateItem = apiCreateItem;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Items' });
+async function apiCreateItem(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/items`;
+    const body = {
+        itemName: params.item.itemName,
+        itemCode: params.item.itemCode,
+        itemDescription: params.item.itemDescription,
+        measureUnitId: params.item.measureUnitId,
+        unitPrice: params.item.unitPrice,
+        vatPercent: params.item.vatPercent,
+        vatCategoryCode: params.item.vatCategoryCode,
+        vatExemptionReason: params.item.vatExemptionReason,
+        isActive: params.item.isActive ?? true,
+    };
+    try {
+        const response = await axios_1.default.post(url, body, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+        return response.data.externalId;
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while creating item: ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to create item: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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