keez-invoicing 1.1.5

package/dist/tests/invoices-extended.test.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock = require("nock");
+const keezApi_1 = require("../src/keezApi");
+const paymentType_1 = require("../src/config/paymentType");
+describe('Keez API Invoices Extended', () => {
+    let keezApi;
+    const baseDomain = 'https://staging.keez.ro';
+    const clientEid = 'test-client-eid';
+    beforeAll(() => {
+        keezApi = new keezApi_1.KeezApi({
+            application_id: 'test-app-id',
+            client_eid: clientEid,
+            secret: 'test-secret',
+            live: false,
+        });
+    });
+    beforeEach(() => {
+        // Mock the auth token generation
+        nock(baseDomain)
+            .post('/idp/connect/token')
+            .reply(200, {
+            access_token: 'test-token',
+            expires_in: 3600,
+            token_type: 'Bearer',
+            scope: 'public-api',
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+    });
+    describe('getAllInvoices with filters', () => {
+        it('should fetch invoices with status filter', async () => {
+            const mockInvoices = {
+                first: 0,
+                last: 1,
+                recordsCount: 1,
+                data: [
+                    {
+                        externalId: 'inv-1',
+                        series: 'INV',
+                        number: 1,
+                        documentDate: 20230101,
+                        dueDate: 20230115,
+                        status: 'VALIDATED',
+                        clientName: 'Test Client',
+                        partnerName: 'Test Partner',
+                        currencyCode: 'RON',
+                        referenceCurrencyCode: 'RON',
+                        netAmount: 100,
+                        vatAmount: 19,
+                        grossAmount: 119,
+                    },
+                ],
+            };
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/invoices`)
+                .query({ status: 'VALIDATED' })
+                .reply(200, mockInvoices);
+            const result = await keezApi.getAllInvoices({ status: 'VALIDATED' });
+            expect(result.data).toHaveLength(1);
+            expect(result.data[0].status).toBe('VALIDATED');
+        });
+        it('should fetch invoices with pagination', async () => {
+            const mockInvoices = {
+                first: 10,
+                last: 19,
+                recordsCount: 50,
+                data: [],
+            };
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/invoices`)
+                .query({ offset: '10', count: '10' })
+                .reply(200, mockInvoices);
+            const result = await keezApi.getAllInvoices({ offset: 10, count: 10 });
+            expect(result.first).toBe(10);
+        });
+    });
+    describe('sendInvoice with extended params', () => {
+        it('should send invoice with simple email', async () => {
+            nock(baseDomain)
+                .post('/api/v1.0/public-api/invoices/delivery')
+                .reply(200);
+            const result = await keezApi.sendInvoice('test@example.com', 'inv-123');
+            expect(result).toBe('SENT');
+        });
+        it('should send invoice with CC and BCC', async () => {
+            nock(baseDomain)
+                .post('/api/v1.0/public-api/invoices/delivery')
+                .reply(200);
+            const result = await keezApi.sendInvoice({
+                to: 'main@example.com',
+                cc: ['cc1@example.com', 'cc2@example.com'],
+                bcc: ['bcc@example.com'],
+            }, 'inv-123');
+            expect(result).toBe('SENT');
+        });
+    });
+    describe('updateInvoice', () => {
+        it('should update an existing invoice', async () => {
+            nock(baseDomain)
+                .put(`/api/v1.0/public-api/${clientEid}/invoices/inv-123`)
+                .reply(200);
+            await expect(keezApi.updateInvoice('inv-123', {
+                series: 'INV',
+                documentDate: 20230101,
+                dueDate: 20230115,
+                currencyCode: 'RON',
+                paymentType: paymentType_1.PaymentType.BANK_TRANSFER,
+                partner: {
+                    isLegalPerson: false,
+                    partnerName: 'Updated Partner',
+                    identificationNumber: '123456',
+                    countryCode: 'RO',
+                    countryName: 'Romania',
+                    countyCode: 'B',
+                    countyName: 'Bucuresti',
+                    cityName: 'Bucuresti',
+                    addressDetails: 'Test Address',
+                },
+                items: [
+                    {
+                        itemExternalId: 'item-1',
+                        measureUnitId: 1,
+                        quantity: 2,
+                        unitPrice: 100,
+                    },
+                ],
+            })).resolves.toBeUndefined();
+        });
+    });
+    describe('deleteInvoice', () => {
+        it('should delete an invoice', async () => {
+            nock(baseDomain)
+                .delete(`/api/v1.0/public-api/${clientEid}/invoices`)
+                .reply(200);
+            await expect(keezApi.deleteInvoice('inv-123')).resolves.toBeUndefined();
+        });
+    });
+    describe('submitInvoiceToEfactura', () => {
+        it('should submit invoice to eFactura', async () => {
+            nock(baseDomain)
+                .post(`/api/v1.0/public-api/${clientEid}/invoices/efactura/submitted`)
+                .reply(200, { uploadIndex: 'upload-123' });
+            const result = await keezApi.submitInvoiceToEfactura('inv-123');
+            expect(result).toBe('upload-123');
+        });
+    });
+    describe('cancelInvoice', () => {
+        it('should cancel an invoice', async () => {
+            nock(baseDomain)
+                .post(`/api/v1.0/public-api/${clientEid}/invoices/canceled`)
+                .reply(200);
+            await expect(keezApi.cancelInvoice('inv-123')).resolves.toBeUndefined();
+        });
+    });
+    describe('downloadInvoicePdf', () => {
+        it('should download invoice PDF', async () => {
+            const pdfBuffer = Buffer.from('PDF content');
+            nock(baseDomain)
+                .get('/api/v1.0/public-api/invoices/inv-123/pdf')
+                .reply(200, pdfBuffer);
+            const result = await keezApi.downloadInvoicePdf('inv-123');
+            expect(result).toBeInstanceOf(Buffer);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invoices-extended.test.js","sourceRoot":"","sources":["../../tests/invoices-extended.test.ts"],"names":[],"mappings":"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","sourcesContent":["import nock = require('nock');\nimport { KeezApi } from '@/keezApi';\nimport { PaymentType } from '@/config/paymentType';\n\ndescribe('Keez API Invoices Extended', () => {\n    let keezApi: KeezApi;\n    const baseDomain = 'https://staging.keez.ro';\n    const clientEid = 'test-client-eid';\n\n    beforeAll(() => {\n        keezApi = new KeezApi({\n            application_id: 'test-app-id',\n            client_eid: clientEid,\n            secret: 'test-secret',\n            live: false,\n        });\n    });\n\n    beforeEach(() => {\n        // Mock the auth token generation\n        nock(baseDomain)\n            .post('/idp/connect/token')\n            .reply(200, {\n                access_token: 'test-token',\n                expires_in: 3600,\n                token_type: 'Bearer',\n                scope: 'public-api',\n            });\n    });\n\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    describe('getAllInvoices with filters', () => {\n        it('should fetch invoices with status filter', async () => {\n            const mockInvoices = {\n                first: 0,\n                last: 1,\n                recordsCount: 1,\n                data: [\n                    {\n                        externalId: 'inv-1',\n                        series: 'INV',\n                        number: 1,\n                        documentDate: 20230101,\n                        dueDate: 20230115,\n                        status: 'VALIDATED',\n                        clientName: 'Test Client',\n                        partnerName: 'Test Partner',\n                        currencyCode: 'RON',\n                        referenceCurrencyCode: 'RON',\n                        netAmount: 100,\n                        vatAmount: 19,\n                        grossAmount: 119,\n                    },\n                ],\n            };\n\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/invoices`)\n                .query({ status: 'VALIDATED' })\n                .reply(200, mockInvoices);\n\n            const result = await keezApi.getAllInvoices({ status: 'VALIDATED' });\n            expect(result.data).toHaveLength(1);\n            expect(result.data[0].status).toBe('VALIDATED');\n        });\n\n        it('should fetch invoices with pagination', async () => {\n            const mockInvoices = {\n                first: 10,\n                last: 19,\n                recordsCount: 50,\n                data: [],\n            };\n\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/invoices`)\n                .query({ offset: '10', count: '10' })\n                .reply(200, mockInvoices);\n\n            const result = await keezApi.getAllInvoices({ offset: 10, count: 10 });\n            expect(result.first).toBe(10);\n        });\n    });\n\n    describe('sendInvoice with extended params', () => {\n        it('should send invoice with simple email', async () => {\n            nock(baseDomain)\n                .post('/api/v1.0/public-api/invoices/delivery')\n                .reply(200);\n\n            const result = await keezApi.sendInvoice('test@example.com', 'inv-123');\n            expect(result).toBe('SENT');\n        });\n\n        it('should send invoice with CC and BCC', async () => {\n            nock(baseDomain)\n                .post('/api/v1.0/public-api/invoices/delivery')\n                .reply(200);\n\n            const result = await keezApi.sendInvoice(\n                {\n                    to: 'main@example.com',\n                    cc: ['cc1@example.com', 'cc2@example.com'],\n                    bcc: ['bcc@example.com'],\n                },\n                'inv-123',\n            );\n            expect(result).toBe('SENT');\n        });\n    });\n\n    describe('updateInvoice', () => {\n        it('should update an existing invoice', async () => {\n            nock(baseDomain)\n                .put(`/api/v1.0/public-api/${clientEid}/invoices/inv-123`)\n                .reply(200);\n\n            await expect(keezApi.updateInvoice('inv-123', {\n                series: 'INV',\n                documentDate: 20230101,\n                dueDate: 20230115,\n                currencyCode: 'RON',\n                paymentType: PaymentType.BANK_TRANSFER,\n                partner: {\n                    isLegalPerson: false,\n                    partnerName: 'Updated Partner',\n                    identificationNumber: '123456',\n                    countryCode: 'RO',\n                    countryName: 'Romania',\n                    countyCode: 'B',\n                    countyName: 'Bucuresti',\n                    cityName: 'Bucuresti',\n                    addressDetails: 'Test Address',\n                },\n                items: [\n                    {\n                        itemExternalId: 'item-1',\n                        measureUnitId: 1,\n                        quantity: 2,\n                        unitPrice: 100,\n                    },\n                ],\n            })).resolves.toBeUndefined();\n        });\n    });\n\n    describe('deleteInvoice', () => {\n        it('should delete an invoice', async () => {\n            nock(baseDomain)\n                .delete(`/api/v1.0/public-api/${clientEid}/invoices`)\n                .reply(200);\n\n            await expect(keezApi.deleteInvoice('inv-123')).resolves.toBeUndefined();\n        });\n    });\n\n    describe('submitInvoiceToEfactura', () => {\n        it('should submit invoice to eFactura', async () => {\n            nock(baseDomain)\n                .post(`/api/v1.0/public-api/${clientEid}/invoices/efactura/submitted`)\n                .reply(200, { uploadIndex: 'upload-123' });\n\n            const result = await keezApi.submitInvoiceToEfactura('inv-123');\n            expect(result).toBe('upload-123');\n        });\n    });\n\n    describe('cancelInvoice', () => {\n        it('should cancel an invoice', async () => {\n            nock(baseDomain)\n                .post(`/api/v1.0/public-api/${clientEid}/invoices/canceled`)\n                .reply(200);\n\n            await expect(keezApi.cancelInvoice('inv-123')).resolves.toBeUndefined();\n        });\n    });\n\n    describe('downloadInvoicePdf', () => {\n        it('should download invoice PDF', async () => {\n            const pdfBuffer = Buffer.from('PDF content');\n\n            nock(baseDomain)\n                .get('/api/v1.0/public-api/invoices/inv-123/pdf')\n                .reply(200, pdfBuffer);\n\n            const result = await keezApi.downloadInvoicePdf('inv-123');\n            expect(result).toBeInstanceOf(Buffer);\n        });\n    });\n});\n"]}

package/dist/tests/items.test.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock = require("nock");
+const keezApi_1 = require("../src/keezApi");
+const measureUnit_1 = require("../src/config/measureUnit");
+describe('Keez API Items', () => {
+    let keezApi;
+    const baseDomain = 'https://staging.keez.ro';
+    const clientEid = 'test-client-eid';
+    beforeAll(() => {
+        keezApi = new keezApi_1.KeezApi({
+            application_id: 'test-app-id',
+            client_eid: clientEid,
+            secret: 'test-secret',
+            live: false,
+        });
+    });
+    beforeEach(() => {
+        // Mock the auth token generation
+        nock(baseDomain)
+            .post('/idp/connect/token')
+            .reply(200, {
+            access_token: 'test-token',
+            expires_in: 3600,
+            token_type: 'Bearer',
+            scope: 'public-api',
+        });
+    });
+    afterEach(() => {
+        nock.cleanAll();
+    });
+    describe('getAllItems', () => {
+        it('should fetch all items without filters', async () => {
+            const mockItems = {
+                first: 0,
+                last: 1,
+                recordsCount: 2,
+                data: [
+                    {
+                        externalId: 'item-1',
+                        itemName: 'Test Item 1',
+                        itemCode: 'TI001',
+                        itemDescription: 'Test description',
+                        measureUnitId: 1,
+                        measureUnitName: 'Bucata',
+                        unitPrice: 100,
+                        vatPercent: 19,
+                        vatCategoryCode: 'S',
+                        vatExemptionReason: '',
+                        isActive: true,
+                        createdAt: 1700000000000,
+                        updatedAt: 1700000000000,
+                    },
+                ],
+            };
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/items`)
+                .reply(200, mockItems);
+            const result = await keezApi.getAllItems();
+            expect(result.recordsCount).toBe(2);
+            expect(result.data).toHaveLength(1);
+            expect(result.data[0].itemName).toBe('Test Item 1');
+        });
+        it('should fetch items with pagination', async () => {
+            const mockItems = {
+                first: 10,
+                last: 19,
+                recordsCount: 50,
+                data: [],
+            };
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/items`)
+                .query({ offset: '10', count: '10' })
+                .reply(200, mockItems);
+            const result = await keezApi.getAllItems({ offset: 10, count: 10 });
+            expect(result.first).toBe(10);
+        });
+    });
+    describe('getItemByExternalId', () => {
+        it('should fetch a single item by ID', async () => {
+            const mockItem = {
+                externalId: 'item-123',
+                itemName: 'Test Item',
+                itemCode: 'TI001',
+                itemDescription: 'Test description',
+                measureUnitId: 1,
+                measureUnitName: 'Bucata',
+                unitPrice: 100,
+                vatPercent: 19,
+                vatCategoryCode: 'S',
+                vatExemptionReason: '',
+                isActive: true,
+                createdAt: 1700000000000,
+                updatedAt: 1700000000000,
+            };
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/items/item-123`)
+                .reply(200, mockItem);
+            const result = await keezApi.getItemByExternalId('item-123');
+            expect(result.externalId).toBe('item-123');
+            expect(result.itemName).toBe('Test Item');
+        });
+    });
+    describe('createItem', () => {
+        it('should create a new item', async () => {
+            nock(baseDomain)
+                .post(`/api/v1.0/public-api/${clientEid}/items`)
+                .reply(201, { externalId: 'new-item-id' });
+            const result = await keezApi.createItem({
+                itemName: 'New Item',
+                measureUnitId: measureUnit_1.MeasureUnit.PIECE,
+                unitPrice: 50,
+                vatPercent: 19,
+            });
+            expect(result).toBe('new-item-id');
+        });
+    });
+    describe('updateItem', () => {
+        it('should update an existing item', async () => {
+            nock(baseDomain)
+                .put(`/api/v1.0/public-api/${clientEid}/items/item-123`)
+                .reply(200);
+            await expect(keezApi.updateItem('item-123', {
+                itemName: 'Updated Item',
+                measureUnitId: measureUnit_1.MeasureUnit.PIECE,
+                unitPrice: 75,
+                vatPercent: 19,
+            })).resolves.toBeUndefined();
+        });
+    });
+    describe('patchItem', () => {
+        it('should partially update an item', async () => {
+            nock(baseDomain)
+                .patch(`/api/v1.0/public-api/${clientEid}/items/item-123`)
+                .reply(200);
+            await expect(keezApi.patchItem('item-123', {
+                unitPrice: 80,
+            })).resolves.toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"items.test.js","sourceRoot":"","sources":["../../tests/items.test.ts"],"names":[],"mappings":"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","sourcesContent":["import nock = require('nock');\nimport { KeezApi } from '@/keezApi';\nimport { MeasureUnit } from '@/config/measureUnit';\n\ndescribe('Keez API Items', () => {\n    let keezApi: KeezApi;\n    const baseDomain = 'https://staging.keez.ro';\n    const clientEid = 'test-client-eid';\n\n    beforeAll(() => {\n        keezApi = new KeezApi({\n            application_id: 'test-app-id',\n            client_eid: clientEid,\n            secret: 'test-secret',\n            live: false,\n        });\n    });\n\n    beforeEach(() => {\n        // Mock the auth token generation\n        nock(baseDomain)\n            .post('/idp/connect/token')\n            .reply(200, {\n                access_token: 'test-token',\n                expires_in: 3600,\n                token_type: 'Bearer',\n                scope: 'public-api',\n            });\n    });\n\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    describe('getAllItems', () => {\n        it('should fetch all items without filters', async () => {\n            const mockItems = {\n                first: 0,\n                last: 1,\n                recordsCount: 2,\n                data: [\n                    {\n                        externalId: 'item-1',\n                        itemName: 'Test Item 1',\n                        itemCode: 'TI001',\n                        itemDescription: 'Test description',\n                        measureUnitId: 1,\n                        measureUnitName: 'Bucata',\n                        unitPrice: 100,\n                        vatPercent: 19,\n                        vatCategoryCode: 'S',\n                        vatExemptionReason: '',\n                        isActive: true,\n                        createdAt: 1700000000000,\n                        updatedAt: 1700000000000,\n                    },\n                ],\n            };\n\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/items`)\n                .reply(200, mockItems);\n\n            const result = await keezApi.getAllItems();\n            expect(result.recordsCount).toBe(2);\n            expect(result.data).toHaveLength(1);\n            expect(result.data[0].itemName).toBe('Test Item 1');\n        });\n\n        it('should fetch items with pagination', async () => {\n            const mockItems = {\n                first: 10,\n                last: 19,\n                recordsCount: 50,\n                data: [],\n            };\n\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/items`)\n                .query({ offset: '10', count: '10' })\n                .reply(200, mockItems);\n\n            const result = await keezApi.getAllItems({ offset: 10, count: 10 });\n            expect(result.first).toBe(10);\n        });\n    });\n\n    describe('getItemByExternalId', () => {\n        it('should fetch a single item by ID', async () => {\n            const mockItem = {\n                externalId: 'item-123',\n                itemName: 'Test Item',\n                itemCode: 'TI001',\n                itemDescription: 'Test description',\n                measureUnitId: 1,\n                measureUnitName: 'Bucata',\n                unitPrice: 100,\n                vatPercent: 19,\n                vatCategoryCode: 'S',\n                vatExemptionReason: '',\n                isActive: true,\n                createdAt: 1700000000000,\n                updatedAt: 1700000000000,\n            };\n\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/items/item-123`)\n                .reply(200, mockItem);\n\n            const result = await keezApi.getItemByExternalId('item-123');\n            expect(result.externalId).toBe('item-123');\n            expect(result.itemName).toBe('Test Item');\n        });\n    });\n\n    describe('createItem', () => {\n        it('should create a new item', async () => {\n            nock(baseDomain)\n                .post(`/api/v1.0/public-api/${clientEid}/items`)\n                .reply(201, { externalId: 'new-item-id' });\n\n            const result = await keezApi.createItem({\n                itemName: 'New Item',\n                measureUnitId: MeasureUnit.PIECE,\n                unitPrice: 50,\n                vatPercent: 19,\n            });\n\n            expect(result).toBe('new-item-id');\n        });\n    });\n\n    describe('updateItem', () => {\n        it('should update an existing item', async () => {\n            nock(baseDomain)\n                .put(`/api/v1.0/public-api/${clientEid}/items/item-123`)\n                .reply(200);\n\n            await expect(keezApi.updateItem('item-123', {\n                itemName: 'Updated Item',\n                measureUnitId: MeasureUnit.PIECE,\n                unitPrice: 75,\n                vatPercent: 19,\n            })).resolves.toBeUndefined();\n        });\n    });\n\n    describe('patchItem', () => {\n        it('should partially update an item', async () => {\n            nock(baseDomain)\n                .patch(`/api/v1.0/public-api/${clientEid}/items/item-123`)\n                .reply(200);\n\n            await expect(keezApi.patchItem('item-123', {\n                unitPrice: 80,\n            })).resolves.toBeUndefined();\n        });\n    });\n});\n"]}

package/dist/types/coverage/lcov-report/block-navigation.d.ts

@@ -0,0 +1 @@
+declare function jumpToCode(event: any): void;

package/dist/types/coverage/lcov-report/sorter.d.ts

@@ -0,0 +1 @@
+declare function addSorting(): void;

package/dist/types/eslint.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").FlatConfig.ConfigArray;
+export default _default;

package/dist/types/jest.config.d.cts

@@ -0,0 +1,9 @@
+export let transform: {
+    '^.+\\.(t|j)s$': string;
+};
+export let testRegex: string;
+export let modulePathIgnorePatterns: string[];
+export let moduleFileExtensions: string[];
+export let moduleNameMapper: {
+    '^@/(.*)$': string;
+};

package/dist/types/jest.config.d.ts

@@ -0,0 +1,9 @@
+export let transform: {
+    '^.+\\.(t|j)s$': string;
+};
+export let testRegex: string;
+export let modulePathIgnorePatterns: string[];
+export let moduleFileExtensions: string[];
+export let moduleNameMapper: {
+    '^@/(.*)$': string;
+};

package/dist/types/src/api/__tests__/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/api/authorise.d.ts

@@ -0,0 +1,18 @@
+import { AuthResponse } from '../../../src/dto/authResponse';
+/**
+ * baseDomain - The base domain for the API
+ * appId - The application ID
+ * apiSecret - The API secret
+ */
+interface GenerateTokenParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly apiSecret: string;
+}
+/**
+ * Generate a token for the Keez API
+ * @returns {AuthResponse} - The token response containing the access token and the expiry time
+ * @param params - As defined in the interface
+ */
+export declare function apiGenerateToken(params: GenerateTokenParams): Promise<AuthResponse>;
+export {};

package/dist/types/src/api/invoices/cancel.d.ts

@@ -0,0 +1,9 @@
+interface CancelInvoiceParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly invoiceId: string;
+}
+export declare function apiCancelInvoice(params: CancelInvoiceParams): Promise<void>;
+export {};

package/dist/types/src/api/invoices/create.d.ts

@@ -0,0 +1,22 @@
+import { InvoiceRequest } from '../../../../src/dto/createInvoiceRequest';
+/**
+ * baseDomain - The base domain for the API
+ * appId - The application ID
+ * appClientId - The application client ID
+ * bearerToken - The bearer token obtained at the authentication stage
+ * itemId - The item ID
+ */
+interface CreateInvoiceParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly invoice: InvoiceRequest;
+}
+/**
+ * Create an invoice
+ * @param params as defined in the interface
+ * @returns {Promise<string>} - The external ID of the created invoice
+ */
+export declare function apiCreateInvoice(params: CreateInvoiceParams): Promise<string>;
+export {};

package/dist/types/src/api/invoices/delete.d.ts

@@ -0,0 +1,9 @@
+interface DeleteInvoiceParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly invoiceId: string;
+}
+export declare function apiDeleteInvoice(params: DeleteInvoiceParams): Promise<void>;
+export {};

package/dist/types/src/api/invoices/downloadPdf.d.ts

@@ -0,0 +1,8 @@
+interface DownloadPdfParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly bearerToken: string;
+    readonly invoiceId: string;
+}
+export declare function apiDownloadInvoicePdf(params: DownloadPdfParams): Promise<Buffer>;
+export {};

package/dist/types/src/api/invoices/getAll.d.ts

@@ -0,0 +1,22 @@
+import { AllInvoicesResponse } from '../../../../src/dto/allInvoicesResponse';
+import { InvoiceFilterParams } from '../../../../src/dto/invoices';
+/**
+ * baseDomain - The base domain for the API
+ * appId - The application ID
+ * appClientId - The application client ID
+ * bearerToken - The bearer token obtained at the authentication stage
+ * filterParams - Optional filter parameters
+ */
+interface GetAllInvoicesParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly filterParams?: InvoiceFilterParams;
+}
+/**
+ * Get all invoices
+ * @param params - As defined in the interface
+ */
+export declare function apiGetAllInvoices(params: GetAllInvoicesParams): Promise<AllInvoicesResponse>;
+export {};

package/dist/types/src/api/invoices/sendMail.d.ts

@@ -0,0 +1,24 @@
+import { SendInvoiceEmailParams } from '../../../../src/dto/invoices';
+/**
+ * appId - The application ID
+ * baseDomain - The base domain for the API
+ * bearerToken - The bearer token obtained at the authentication stage
+ * clientMail - The client email (for backward compatibility)
+ * emailParams - Extended email parameters with CC/BCC support
+ * invoiceId - The invoice ID
+ */
+interface SendInvoiceParams {
+    readonly appId: string;
+    readonly baseDomain: string;
+    readonly bearerToken: string;
+    readonly clientMail?: string;
+    readonly emailParams?: SendInvoiceEmailParams;
+    readonly invoiceId: string;
+}
+/**
+ * Send an invoice by external ID
+ * @param params - as defined in the interface
+ * @returns {Promise<string>} - Returns 'SENT' on success
+ */
+export declare function apiSendInvoice(params: SendInvoiceParams): Promise<string>;
+export {};

package/dist/types/src/api/invoices/submitEfactura.d.ts

@@ -0,0 +1,9 @@
+interface SubmitEfacturaParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly invoiceId: string;
+}
+export declare function apiSubmitEfactura(params: SubmitEfacturaParams): Promise<string>;
+export {};

package/dist/types/src/api/invoices/update.d.ts

@@ -0,0 +1,11 @@
+import { InvoiceRequestV2 } from '../../../../src/dto/invoices';
+interface UpdateInvoiceParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly invoiceId: string;
+    readonly invoice: InvoiceRequestV2;
+}
+export declare function apiUpdateInvoice(params: UpdateInvoiceParams): Promise<void>;
+export {};

package/dist/types/src/api/invoices/validate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * appId - The application ID
+ * appClientId - The application client ID
+ * baseDomain - The base domain for the API
+ * bearerToken - The bearer token obtained at the authentication stage
+ * invoiceId - The invoice ID
+ */
+interface ValidateInvoiceParams {
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly baseDomain: string;
+    readonly bearerToken: string;
+    readonly invoiceId: string;
+}
+/**
+ * Validate an invoice by external ID
+ * @param params - as defined in the interface
+ * @returns {Promise<string>} - Returns 'VALIDATED' on success
+ */
+export declare function apiValidateInvoice(params: ValidateInvoiceParams): Promise<string>;
+export {};

package/dist/types/src/api/invoices/view.d.ts

@@ -0,0 +1,22 @@
+import { InvoiceResponse } from '../../../../src/dto/invoiceResponse';
+/**
+ * baseDomain - The base domain for the API
+ * appId - The application ID
+ * appClientId - The application client ID
+ * bearerToken - The bearer token obtained at the authentication stage
+ * invoiceId - The invoice ID
+ */
+interface ViewInvoiceParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly invoiceId: string;
+}
+/**
+ * Get an invoice by external ID
+ * @param params as defined in the interface
+ * @returns {Promise<InvoiceResponse>} - The invoice details
+ */
+export declare function apiGetInvoiceByExternalId(params: ViewInvoiceParams): Promise<InvoiceResponse>;
+export {};

package/dist/types/src/api/items/create.d.ts

@@ -0,0 +1,10 @@
+import { CreateItemRequest } from '../../../../src/dto/items';
+interface CreateItemParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly item: CreateItemRequest;
+}
+export declare function apiCreateItem(params: CreateItemParams): Promise<string>;
+export {};

package/dist/types/src/api/items/getAll.d.ts

@@ -0,0 +1,10 @@
+import { AllItemsResponse, ItemFilterParams } from '../../../../src/dto/items';
+interface GetAllItemsParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly filterParams?: ItemFilterParams;
+}
+export declare function apiGetAllItems(params: GetAllItemsParams): Promise<AllItemsResponse>;
+export {};

package/dist/types/src/api/items/getById.d.ts

@@ -0,0 +1,10 @@
+import { ItemResponse } from '../../../../src/dto/items';
+interface GetItemByIdParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly itemId: string;
+}
+export declare function apiGetItemById(params: GetItemByIdParams): Promise<ItemResponse>;
+export {};

package/dist/types/src/api/items/index.d.ts

@@ -0,0 +1,5 @@
+export { apiGetAllItems } from './getAll';
+export { apiGetItemById } from './getById';
+export { apiCreateItem } from './create';
+export { apiUpdateItem } from './update';
+export { apiPatchItem } from './patch';

package/dist/types/src/api/items/patch.d.ts

@@ -0,0 +1,11 @@
+import { PatchItemRequest } from '../../../../src/dto/items';
+interface PatchItemParams {
+    readonly baseDomain: string;
+    readonly appId: string;
+    readonly appClientId: string;
+    readonly bearerToken: string;
+    readonly itemId: string;
+    readonly item: PatchItemRequest;
+}
+export declare function apiPatchItem(params: PatchItemParams): Promise<void>;
+export {};