keez-invoicing 1.1.5

package/dist/tests/index.test.js

@@ -0,0 +1,493 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock_1 = __importDefault(require("nock"));
+const keezApi_1 = require("../src/keezApi");
+const authorise_1 = require("../src/api/authorise");
+const getAll_1 = require("../src/api/invoices/getAll");
+const view_1 = require("../src/api/invoices/view");
+const create_1 = require("../src/api/invoices/create");
+const sendMail_1 = require("../src/api/invoices/sendMail");
+const validate_1 = require("../src/api/invoices/validate");
+const paymentType_1 = require("../src/config/paymentType");
+const KeezError_1 = require("../src/errors/KeezError");
+const STAGING_DOMAIN = 'https://staging.keez.ro';
+const LIVE_DOMAIN = 'https://app.keez.ro';
+describe('KeezApi class', () => {
+    let keezApi;
+    beforeAll(() => {
+        keezApi = new keezApi_1.KeezApi({
+            application_id: 'test-app-id',
+            client_eid: 'test-client-eid',
+            secret: 'test-secret',
+            live: true,
+        });
+    });
+    afterEach(() => {
+        nock_1.default.cleanAll();
+    });
+    test('should return live domain when live mode is true', () => {
+        keezApi.setLive(true);
+        expect(keezApi.getBaseDomain()).toBe(LIVE_DOMAIN);
+    });
+    test('should return staging domain when live mode is false', () => {
+        keezApi.setLive(false);
+        expect(keezApi.getBaseDomain()).toBe(STAGING_DOMAIN);
+    });
+});
+describe('apiGenerateToken', () => {
+    afterEach(() => {
+        nock_1.default.cleanAll();
+    });
+    test('should generate token successfully', async () => {
+        const mockResponse = {
+            access_token: 'test-access-token',
+            expires_in: 3600,
+            token_type: 'Bearer',
+            scope: 'public-api',
+        };
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/idp/connect/token')
+            .reply(200, mockResponse);
+        const result = await (0, authorise_1.apiGenerateToken)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            apiSecret: 'test-secret',
+        });
+        expect(result.access_token).toBe('test-access-token');
+        expect(result.expires_in).toBe(3600);
+        expect(result.token_type).toBe('Bearer');
+        expect(result.scope).toBe('public-api');
+        expect(result.expires_at).toBeGreaterThan(Date.now());
+    });
+    test('should throw KeezAuthError on authentication failure', async () => {
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/idp/connect/token')
+            .reply(401, { error: 'invalid_client' });
+        await expect((0, authorise_1.apiGenerateToken)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            apiSecret: 'wrong-secret',
+        })).rejects.toThrow(KeezError_1.KeezAuthError);
+    });
+});
+describe('apiGetAllInvoices', () => {
+    afterEach(() => {
+        nock_1.default.cleanAll();
+    });
+    test('should get all invoices successfully', async () => {
+        const mockResponse = {
+            first: 0,
+            last: 1,
+            recordsCount: 2,
+            data: [
+                {
+                    externalId: 'invoice-1',
+                    series: 'PDI',
+                    number: 1,
+                    documentDate: 20230423,
+                    dueDate: 20230430,
+                    status: 'draft',
+                    clientName: 'Test Client',
+                    partnerName: 'Test Partner',
+                    currencyCode: 'RON',
+                    referenceCurrencyCode: 'RON',
+                    netAmount: 100,
+                    vatAmount: 19,
+                    grossAmount: 119,
+                },
+                {
+                    externalId: 'invoice-2',
+                    series: 'PDI',
+                    number: 2,
+                    documentDate: 20230424,
+                    dueDate: 20230501,
+                    status: 'valid',
+                    clientName: 'Test Client 2',
+                    partnerName: 'Test Partner 2',
+                    currencyCode: 'EUR',
+                    referenceCurrencyCode: 'RON',
+                    netAmount: 200,
+                    vatAmount: 38,
+                    grossAmount: 238,
+                },
+            ],
+        };
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .get('/api/v1.0/public-api/test-client-eid/invoices')
+            .reply(200, mockResponse);
+        const result = await (0, getAll_1.apiGetAllInvoices)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+        });
+        expect(result.recordsCount).toBe(2);
+        expect(result.data).toHaveLength(2);
+        expect(result.data[0].externalId).toBe('invoice-1');
+        expect(result.data[1].externalId).toBe('invoice-2');
+    });
+    test('should return empty array when no invoices exist', async () => {
+        const mockResponse = {
+            first: 0,
+            last: 0,
+            recordsCount: 0,
+            data: [],
+        };
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .get('/api/v1.0/public-api/test-client-eid/invoices')
+            .reply(200, mockResponse);
+        const result = await (0, getAll_1.apiGetAllInvoices)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+        });
+        expect(result.recordsCount).toBe(0);
+        expect(result.data).toHaveLength(0);
+    });
+    test('should throw KeezApiError on failure', async () => {
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .get('/api/v1.0/public-api/test-client-eid/invoices')
+            .reply(500, { error: 'Internal Server Error' });
+        await expect((0, getAll_1.apiGetAllInvoices)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+        })).rejects.toThrow(KeezError_1.KeezApiError);
+    });
+});
+describe('apiGetInvoiceByExternalId', () => {
+    afterEach(() => {
+        nock_1.default.cleanAll();
+    });
+    test('should get invoice by external ID successfully', async () => {
+        const mockResponse = {
+            currencyCode: 'RON',
+            discountGrossValue: 0,
+            discountNetValue: 0,
+            discountVatValue: 0,
+            discountValueOnNet: false,
+            exciseAmount: 0,
+            documentDate: 20230423,
+            dueDate: 20230430,
+            exchangeRate: 1,
+            grossAmount: 119,
+            netAmount: 100,
+            number: 1,
+            originalNetAmount: 100,
+            originalVatAmount: 19,
+            partner: {
+                addressDetails: 'Test Address',
+                cityName: 'Bucharest',
+                countryCode: 'RO',
+                countryName: 'Romania',
+                countyCode: 'RO.B',
+                countyName: 'Bucharest',
+                identificationNumber: '12345678',
+                isLegalPerson: false,
+                partnerName: 'Test Partner',
+            },
+            invoiceDetails: [
+                {
+                    discountGrossValue: 0,
+                    discountNetValue: 0,
+                    discountVatValue: 0,
+                    discountValueOnNet: false,
+                    grossAmount: 119,
+                    itemCode: 'ITEM-001',
+                    itemDescription: 'Test Item',
+                    itemExternalId: 'item-ext-1',
+                    itemName: 'Test Item Name',
+                    measureUnitId: 1,
+                    netAmount: 100,
+                    originalNetAmount: 100,
+                    originalVatAmount: 19,
+                    quantity: 1,
+                    unMeasureUnit: 'buc',
+                    unVatCategory: 'S',
+                    unVatExemptionReason: '',
+                    unitPrice: 100,
+                    vatAmount: 19,
+                    vatPercent: 19,
+                    exciseAmount: 0,
+                },
+            ],
+            paymentTypeId: 3,
+            referenceCurrencyCode: 'RON',
+            series: 'PDI',
+            status: 'draft',
+            vatAmount: 19,
+            vatOnCollection: false,
+        };
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .get('/api/v1.0/public-api/test-client-eid/invoices/invoice-ext-1')
+            .reply(200, mockResponse);
+        const result = await (0, view_1.apiGetInvoiceByExternalId)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+            invoiceId: 'invoice-ext-1',
+        });
+        expect(result.grossAmount).toBe(119);
+        expect(result.partner.partnerName).toBe('Test Partner');
+        expect(result.items).toHaveLength(1);
+        expect(result.items[0].itemName).toBe('Test Item Name');
+    });
+    test('should throw KeezApiError when invoice not found', async () => {
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .get('/api/v1.0/public-api/test-client-eid/invoices/non-existent')
+            .reply(404, { error: 'Invoice not found' });
+        await expect((0, view_1.apiGetInvoiceByExternalId)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+            invoiceId: 'non-existent',
+        })).rejects.toThrow(KeezError_1.KeezApiError);
+    });
+});
+describe('apiCreateInvoice', () => {
+    afterEach(() => {
+        nock_1.default.cleanAll();
+    });
+    test('should create invoice successfully', async () => {
+        const mockResponse = {
+            externalId: 'new-invoice-ext-id',
+        };
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/test-client-eid/invoices')
+            .reply(201, mockResponse);
+        const result = await (0, create_1.apiCreateInvoice)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+            invoice: {
+                series: 'PDI',
+                currencyCode: 'RON',
+                amount: 100,
+                paymentType: paymentType_1.PaymentType.BANK_TRANSFER,
+                partner: {
+                    addressDetails: 'Test Address',
+                    cityName: 'Bucharest',
+                    countryCode: 'RO',
+                    countryName: 'Romania',
+                    countyCode: 'RO.B',
+                    countyName: 'Bucharest',
+                    identificationNumber: '12345678',
+                    isLegalPerson: false,
+                    partnerName: 'Test Partner',
+                },
+                itemId: 'item-ext-1',
+            },
+        });
+        expect(result).toBe('new-invoice-ext-id');
+    });
+    test('should create invoice with custom date and quantity', async () => {
+        const mockResponse = {
+            externalId: 'new-invoice-ext-id-2',
+        };
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/test-client-eid/invoices', (body) => body.documentDate === 20240115 && body.invoiceDetails[0].quantity === 5)
+            .reply(201, mockResponse);
+        const result = await (0, create_1.apiCreateInvoice)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+            invoice: {
+                series: 'PDI',
+                currencyCode: 'RON',
+                amount: 500,
+                paymentType: paymentType_1.PaymentType.CARD_ONLINE,
+                partner: {
+                    addressDetails: 'Test Address',
+                    cityName: 'Bucharest',
+                    countryCode: 'RO',
+                    countryName: 'Romania',
+                    countyCode: 'RO.B',
+                    countyName: 'Bucharest',
+                    identificationNumber: '12345678',
+                    isLegalPerson: false,
+                    partnerName: 'Test Partner',
+                },
+                itemId: 'item-ext-1',
+                documentDate: 20240115,
+                dueDate: 20240130,
+                quantity: 5,
+            },
+        });
+        expect(result).toBe('new-invoice-ext-id-2');
+    });
+    test('should throw KeezApiError on validation error', async () => {
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/test-client-eid/invoices')
+            .reply(400, { Message: 'Validation failed' });
+        await expect((0, create_1.apiCreateInvoice)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+            invoice: {
+                series: 'PDI',
+                currencyCode: 'RON',
+                amount: -100,
+                paymentType: paymentType_1.PaymentType.BANK_TRANSFER,
+                partner: {
+                    addressDetails: 'Test Address',
+                    cityName: 'Bucharest',
+                    countryCode: 'RO',
+                    countryName: 'Romania',
+                    countyCode: 'RO.B',
+                    countyName: 'Bucharest',
+                    identificationNumber: '',
+                    isLegalPerson: false,
+                    partnerName: '',
+                },
+                itemId: '',
+            },
+        })).rejects.toThrow(KeezError_1.KeezApiError);
+    });
+});
+describe('apiSendInvoice', () => {
+    afterEach(() => {
+        nock_1.default.cleanAll();
+    });
+    test('should send invoice email successfully', async () => {
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/invoices/delivery')
+            .reply(200);
+        const result = await (0, sendMail_1.apiSendInvoice)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            bearerToken: 'test-token',
+            clientMail: 'test@example.com',
+            invoiceId: 'invoice-ext-1',
+        });
+        expect(result).toBe('SENT');
+    });
+    test('should throw KeezApiError on send failure', async () => {
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/invoices/delivery')
+            .reply(500, { error: 'Email service unavailable' });
+        await expect((0, sendMail_1.apiSendInvoice)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            bearerToken: 'test-token',
+            clientMail: 'test@example.com',
+            invoiceId: 'invoice-ext-1',
+        })).rejects.toThrow(KeezError_1.KeezApiError);
+    });
+});
+describe('apiValidateInvoice', () => {
+    afterEach(() => {
+        nock_1.default.cleanAll();
+    });
+    test('should validate invoice successfully', async () => {
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/test-client-eid/invoices/valid')
+            .reply(200);
+        const result = await (0, validate_1.apiValidateInvoice)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+            invoiceId: 'invoice-ext-1',
+        });
+        expect(result).toBe('VALIDATED');
+    });
+    test('should throw KeezApiError on validation failure', async () => {
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/test-client-eid/invoices/valid')
+            .reply(400, { Message: 'Invoice cannot be validated' });
+        await expect((0, validate_1.apiValidateInvoice)({
+            baseDomain: STAGING_DOMAIN,
+            appId: 'test-app-id',
+            appClientId: 'test-client-eid',
+            bearerToken: 'test-token',
+            invoiceId: 'invalid-invoice',
+        })).rejects.toThrow(KeezError_1.KeezApiError);
+    });
+});
+describe('KeezApi integration tests', () => {
+    let keezApi;
+    beforeEach(() => {
+        keezApi = new keezApi_1.KeezApi({
+            application_id: 'test-app-id',
+            client_eid: 'test-client-eid',
+            secret: 'test-secret',
+            live: false,
+        });
+    });
+    afterEach(() => {
+        nock_1.default.cleanAll();
+    });
+    test('should auto-refresh token when expired', async () => {
+        // Mock token generation
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/idp/connect/token')
+            .reply(200, {
+            access_token: 'fresh-token',
+            expires_in: 3600,
+            token_type: 'Bearer',
+            scope: 'public-api',
+        });
+        // Mock get all invoices
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .get('/api/v1.0/public-api/test-client-eid/invoices')
+            .reply(200, {
+            first: 0,
+            last: 0,
+            recordsCount: 0,
+            data: [],
+        });
+        const result = await keezApi.getAllInvoices();
+        expect(result.recordsCount).toBe(0);
+    });
+    test('should create and validate invoice flow', async () => {
+        // Mock token generation
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/idp/connect/token')
+            .reply(200, {
+            access_token: 'test-token',
+            expires_in: 3600,
+            token_type: 'Bearer',
+            scope: 'public-api',
+        });
+        // Mock create invoice
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/test-client-eid/invoices')
+            .reply(201, { externalId: 'created-invoice-id' });
+        const invoiceId = await keezApi.createInvoice({
+            series: 'PDI',
+            currencyCode: 'RON',
+            amount: 100,
+            paymentType: paymentType_1.PaymentType.MEAL_VOUCHER,
+            partner: {
+                addressDetails: 'Test Address',
+                cityName: 'Bucharest',
+                countryCode: 'RO',
+                countryName: 'Romania',
+                countyCode: 'RO.B',
+                countyName: 'Bucharest',
+                identificationNumber: '12345678',
+                isLegalPerson: false,
+                partnerName: 'Test Partner',
+            },
+            itemId: 'item-ext-1',
+        });
+        expect(invoiceId).toBe('created-invoice-id');
+        // Mock validate invoice (reuse token)
+        (0, nock_1.default)(STAGING_DOMAIN)
+            .post('/api/v1.0/public-api/test-client-eid/invoices/valid')
+            .reply(200);
+        const validateResult = await keezApi.validateInvoice('created-invoice-id');
+        expect(validateResult).toBe('VALIDATED');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.test.js","sourceRoot":"","sources":["../../tests/index.test.ts"],"names":[],"mappings":";;;;;AAAA,gDAAwB;AACxB,uCAAoC;AACpC,+CAAmD;AACnD,kDAA0D;AAC1D,8CAAgE;AAChE,kDAAyD;AACzD,sDAAyD;AACzD,sDAA6D;AAC7D,sDAAmD;AACnD,kDAAiE;AAEjE,MAAM,cAAc,GAAG,yBAAyB,CAAC;AACjD,MAAM,WAAW,GAAG,qBAAqB,CAAC;AAE1C,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC3B,IAAI,OAAgB,CAAC;IAErB,SAAS,CAAC,GAAG,EAAE;QACX,OAAO,GAAG,IAAI,iBAAO,CAAC;YAClB,cAAc,EAAE,aAAa;YAC7B,UAAU,EAAE,iBAAiB;YAC7B,MAAM,EAAE,aAAa;YACrB,IAAI,EAAE,IAAI;SACb,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACX,cAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC1D,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACtB,MAAM,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,sDAAsD,EAAE,GAAG,EAAE;QAC9D,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvB,MAAM,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAC9B,SAAS,CAAC,GAAG,EAAE;QACX,cAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,oCAAoC,EAAE,KAAK,IAAI,EAAE;QAClD,MAAM,YAAY,GAAG;YACjB,YAAY,EAAE,mBAAmB;YACjC,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,QAAQ;YACpB,KAAK,EAAE,YAAY;SACtB,CAAC;QAEF,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,oBAAoB,CAAC;aAC1B,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QAE9B,MAAM,MAAM,GAAG,MAAM,IAAA,4BAAgB,EAAC;YAClC,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,SAAS,EAAE,aAAa;SAC3B,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACtD,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACzC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACxC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,sDAAsD,EAAE,KAAK,IAAI,EAAE;QACpE,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,oBAAoB,CAAC;aAC1B,KAAK,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAE7C,MAAM,MAAM,CAAC,IAAA,4BAAgB,EAAC;YAC1B,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,SAAS,EAAE,cAAc;SAC5B,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,yBAAa,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;IAC/B,SAAS,CAAC,GAAG,EAAE;QACX,cAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,MAAM,YAAY,GAAG;YACjB,KAAK,EAAE,CAAC;YACR,IAAI,EAAE,CAAC;YACP,YAAY,EAAE,CAAC;YACf,IAAI,EAAE;gBACF;oBACI,UAAU,EAAE,WAAW;oBACvB,MAAM,EAAE,KAAK;oBACb,MAAM,EAAE,CAAC;oBACT,YAAY,EAAE,QAAQ;oBACtB,OAAO,EAAE,QAAQ;oBACjB,MAAM,EAAE,OAAO;oBACf,UAAU,EAAE,aAAa;oBACzB,WAAW,EAAE,cAAc;oBAC3B,YAAY,EAAE,KAAK;oBACnB,qBAAqB,EAAE,KAAK;oBAC5B,SAAS,EAAE,GAAG;oBACd,SAAS,EAAE,EAAE;oBACb,WAAW,EAAE,GAAG;iBACnB;gBACD;oBACI,UAAU,EAAE,WAAW;oBACvB,MAAM,EAAE,KAAK;oBACb,MAAM,EAAE,CAAC;oBACT,YAAY,EAAE,QAAQ;oBACtB,OAAO,EAAE,QAAQ;oBACjB,MAAM,EAAE,OAAO;oBACf,UAAU,EAAE,eAAe;oBAC3B,WAAW,EAAE,gBAAgB;oBAC7B,YAAY,EAAE,KAAK;oBACnB,qBAAqB,EAAE,KAAK;oBAC5B,SAAS,EAAE,GAAG;oBACd,SAAS,EAAE,EAAE;oBACb,WAAW,EAAE,GAAG;iBACnB;aACJ;SACJ,CAAC;QAEF,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,GAAG,CAAC,+CAA+C,CAAC;aACpD,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QAE9B,MAAM,MAAM,GAAG,MAAM,IAAA,0BAAiB,EAAC;YACnC,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;SAC5B,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACpC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACpD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACxD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,kDAAkD,EAAE,KAAK,IAAI,EAAE;QAChE,MAAM,YAAY,GAAG;YACjB,KAAK,EAAE,CAAC;YACR,IAAI,EAAE,CAAC;YACP,YAAY,EAAE,CAAC;YACf,IAAI,EAAE,EAAE;SACX,CAAC;QAEF,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,GAAG,CAAC,+CAA+C,CAAC;aACpD,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QAE9B,MAAM,MAAM,GAAG,MAAM,IAAA,0BAAiB,EAAC;YACnC,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;SAC5B,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,GAAG,CAAC,+CAA+C,CAAC;aACpD,KAAK,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAC,CAAC;QAEpD,MAAM,MAAM,CAAC,IAAA,0BAAiB,EAAC;YAC3B,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;SAC5B,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,wBAAY,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,2BAA2B,EAAE,GAAG,EAAE;IACvC,SAAS,CAAC,GAAG,EAAE;QACX,cAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,gDAAgD,EAAE,KAAK,IAAI,EAAE;QAC9D,MAAM,YAAY,GAAG;YACjB,YAAY,EAAE,KAAK;YACnB,kBAAkB,EAAE,CAAC;YACrB,gBAAgB,EAAE,CAAC;YACnB,gBAAgB,EAAE,CAAC;YACnB,kBAAkB,EAAE,KAAK;YACzB,YAAY,EAAE,CAAC;YACf,YAAY,EAAE,QAAQ;YACtB,OAAO,EAAE,QAAQ;YACjB,YAAY,EAAE,CAAC;YACf,WAAW,EAAE,GAAG;YAChB,SAAS,EAAE,GAAG;YACd,MAAM,EAAE,CAAC;YACT,iBAAiB,EAAE,GAAG;YACtB,iBAAiB,EAAE,EAAE;YACrB,OAAO,EAAE;gBACL,cAAc,EAAE,cAAc;gBAC9B,QAAQ,EAAE,WAAW;gBACrB,WAAW,EAAE,IAAI;gBACjB,WAAW,EAAE,SAAS;gBACtB,UAAU,EAAE,MAAM;gBAClB,UAAU,EAAE,WAAW;gBACvB,oBAAoB,EAAE,UAAU;gBAChC,aAAa,EAAE,KAAK;gBACpB,WAAW,EAAE,cAAc;aAC9B;YACD,cAAc,EAAE;gBACZ;oBACI,kBAAkB,EAAE,CAAC;oBACrB,gBAAgB,EAAE,CAAC;oBACnB,gBAAgB,EAAE,CAAC;oBACnB,kBAAkB,EAAE,KAAK;oBACzB,WAAW,EAAE,GAAG;oBAChB,QAAQ,EAAE,UAAU;oBACpB,eAAe,EAAE,WAAW;oBAC5B,cAAc,EAAE,YAAY;oBAC5B,QAAQ,EAAE,gBAAgB;oBAC1B,aAAa,EAAE,CAAC;oBAChB,SAAS,EAAE,GAAG;oBACd,iBAAiB,EAAE,GAAG;oBACtB,iBAAiB,EAAE,EAAE;oBACrB,QAAQ,EAAE,CAAC;oBACX,aAAa,EAAE,KAAK;oBACpB,aAAa,EAAE,GAAG;oBAClB,oBAAoB,EAAE,EAAE;oBACxB,SAAS,EAAE,GAAG;oBACd,SAAS,EAAE,EAAE;oBACb,UAAU,EAAE,EAAE;oBACd,YAAY,EAAE,CAAC;iBAClB;aACJ;YACD,aAAa,EAAE,CAAC;YAChB,qBAAqB,EAAE,KAAK;YAC5B,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,OAAO;YACf,SAAS,EAAE,EAAE;YACb,eAAe,EAAE,KAAK;SACzB,CAAC;QAEF,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,GAAG,CAAC,6DAA6D,CAAC;aAClE,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QAE9B,MAAM,MAAM,GAAG,MAAM,IAAA,gCAAyB,EAAC;YAC3C,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;YACzB,SAAS,EAAE,eAAe;SAC7B,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACxD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,kDAAkD,EAAE,KAAK,IAAI,EAAE;QAChE,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,GAAG,CAAC,4DAA4D,CAAC;aACjE,KAAK,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,CAAC,CAAC;QAEhD,MAAM,MAAM,CAAC,IAAA,gCAAyB,EAAC;YACnC,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;YACzB,SAAS,EAAE,cAAc;SAC5B,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,wBAAY,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAC9B,SAAS,CAAC,GAAG,EAAE;QACX,cAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,oCAAoC,EAAE,KAAK,IAAI,EAAE;QAClD,MAAM,YAAY,GAAG;YACjB,UAAU,EAAE,oBAAoB;SACnC,CAAC;QAEF,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,+CAA+C,CAAC;aACrD,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QAE9B,MAAM,MAAM,GAAG,MAAM,IAAA,yBAAgB,EAAC;YAClC,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;YACzB,OAAO,EAAE;gBACL,MAAM,EAAE,KAAK;gBACb,YAAY,EAAE,KAAK;gBACnB,MAAM,EAAE,GAAG;gBACX,WAAW,EAAE,yBAAW,CAAC,aAAa;gBACtC,OAAO,EAAE;oBACL,cAAc,EAAE,cAAc;oBAC9B,QAAQ,EAAE,WAAW;oBACrB,WAAW,EAAE,IAAI;oBACjB,WAAW,EAAE,SAAS;oBACtB,UAAU,EAAE,MAAM;oBAClB,UAAU,EAAE,WAAW;oBACvB,oBAAoB,EAAE,UAAU;oBAChC,aAAa,EAAE,KAAK;oBACpB,WAAW,EAAE,cAAc;iBAC9B;gBACD,MAAM,EAAE,YAAY;aACvB;SACJ,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,qDAAqD,EAAE,KAAK,IAAI,EAAE;QACnE,MAAM,YAAY,GAAG;YACjB,UAAU,EAAE,sBAAsB;SACrC,CAAC;QAEF,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,+CAA+C,EAAE,CAAC,IAAsE,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,KAAK,QAAQ,IAAI,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC;aAC1M,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QAE9B,MAAM,MAAM,GAAG,MAAM,IAAA,yBAAgB,EAAC;YAClC,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;YACzB,OAAO,EAAE;gBACL,MAAM,EAAE,KAAK;gBACb,YAAY,EAAE,KAAK;gBACnB,MAAM,EAAE,GAAG;gBACX,WAAW,EAAE,yBAAW,CAAC,WAAW;gBACpC,OAAO,EAAE;oBACL,cAAc,EAAE,cAAc;oBAC9B,QAAQ,EAAE,WAAW;oBACrB,WAAW,EAAE,IAAI;oBACjB,WAAW,EAAE,SAAS;oBACtB,UAAU,EAAE,MAAM;oBAClB,UAAU,EAAE,WAAW;oBACvB,oBAAoB,EAAE,UAAU;oBAChC,aAAa,EAAE,KAAK;oBACpB,WAAW,EAAE,cAAc;iBAC9B;gBACD,MAAM,EAAE,YAAY;gBACpB,YAAY,EAAE,QAAQ;gBACtB,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,CAAC;aACd;SACJ,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;QAC7D,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,+CAA+C,CAAC;aACrD,KAAK,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,mBAAmB,EAAE,CAAC,CAAC;QAElD,MAAM,MAAM,CAAC,IAAA,yBAAgB,EAAC;YAC1B,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;YACzB,OAAO,EAAE;gBACL,MAAM,EAAE,KAAK;gBACb,YAAY,EAAE,KAAK;gBACnB,MAAM,EAAE,CAAC,GAAG;gBACZ,WAAW,EAAE,yBAAW,CAAC,aAAa;gBACtC,OAAO,EAAE;oBACL,cAAc,EAAE,cAAc;oBAC9B,QAAQ,EAAE,WAAW;oBACrB,WAAW,EAAE,IAAI;oBACjB,WAAW,EAAE,SAAS;oBACtB,UAAU,EAAE,MAAM;oBAClB,UAAU,EAAE,WAAW;oBACvB,oBAAoB,EAAE,EAAE;oBACxB,aAAa,EAAE,KAAK;oBACpB,WAAW,EAAE,EAAE;iBAClB;gBACD,MAAM,EAAE,EAAE;aACb;SACJ,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,wBAAY,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC5B,SAAS,CAAC,GAAG,EAAE;QACX,cAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,wCAAwC,EAAE,KAAK,IAAI,EAAE;QACtD,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,wCAAwC,CAAC;aAC9C,KAAK,CAAC,GAAG,CAAC,CAAC;QAEhB,MAAM,MAAM,GAAG,MAAM,IAAA,yBAAc,EAAC;YAChC,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,YAAY;YACzB,UAAU,EAAE,kBAAkB;YAC9B,SAAS,EAAE,eAAe;SAC7B,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,2CAA2C,EAAE,KAAK,IAAI,EAAE;QACzD,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,wCAAwC,CAAC;aAC9C,KAAK,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,2BAA2B,EAAE,CAAC,CAAC;QAExD,MAAM,MAAM,CAAC,IAAA,yBAAc,EAAC;YACxB,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,YAAY;YACzB,UAAU,EAAE,kBAAkB;YAC9B,SAAS,EAAE,eAAe;SAC7B,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,wBAAY,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,oBAAoB,EAAE,GAAG,EAAE;IAChC,SAAS,CAAC,GAAG,EAAE;QACX,cAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,sCAAsC,EAAE,KAAK,IAAI,EAAE;QACpD,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,qDAAqD,CAAC;aAC3D,KAAK,CAAC,GAAG,CAAC,CAAC;QAEhB,MAAM,MAAM,GAAG,MAAM,IAAA,6BAAkB,EAAC;YACpC,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;YACzB,SAAS,EAAE,eAAe;SAC7B,CAAC,CAAC;QAEH,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACrC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,iDAAiD,EAAE,KAAK,IAAI,EAAE;QAC/D,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,qDAAqD,CAAC;aAC3D,KAAK,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,6BAA6B,EAAE,CAAC,CAAC;QAE5D,MAAM,MAAM,CAAC,IAAA,6BAAkB,EAAC;YAC5B,UAAU,EAAE,cAAc;YAC1B,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,iBAAiB;YAC9B,WAAW,EAAE,YAAY;YACzB,SAAS,EAAE,iBAAiB;SAC/B,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,wBAAY,CAAC,CAAC;IACtC,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,2BAA2B,EAAE,GAAG,EAAE;IACvC,IAAI,OAAgB,CAAC;IAErB,UAAU,CAAC,GAAG,EAAE;QACZ,OAAO,GAAG,IAAI,iBAAO,CAAC;YAClB,cAAc,EAAE,aAAa;YAC7B,UAAU,EAAE,iBAAiB;YAC7B,MAAM,EAAE,aAAa;YACrB,IAAI,EAAE,KAAK;SACd,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACX,cAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,wCAAwC,EAAE,KAAK,IAAI,EAAE;QACtD,wBAAwB;QACxB,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,oBAAoB,CAAC;aAC1B,KAAK,CAAC,GAAG,EAAE;YACR,YAAY,EAAE,aAAa;YAC3B,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,QAAQ;YACpB,KAAK,EAAE,YAAY;SACtB,CAAC,CAAC;QAEP,wBAAwB;QACxB,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,GAAG,CAAC,+CAA+C,CAAC;aACpD,KAAK,CAAC,GAAG,EAAE;YACR,KAAK,EAAE,CAAC;YACR,IAAI,EAAE,CAAC;YACP,YAAY,EAAE,CAAC;YACf,IAAI,EAAE,EAAE;SACX,CAAC,CAAC;QAEP,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC;QAC9C,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,yCAAyC,EAAE,KAAK,IAAI,EAAE;QACvD,wBAAwB;QACxB,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,oBAAoB,CAAC;aAC1B,KAAK,CAAC,GAAG,EAAE;YACR,YAAY,EAAE,YAAY;YAC1B,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,QAAQ;YACpB,KAAK,EAAE,YAAY;SACtB,CAAC,CAAC;QAEP,sBAAsB;QACtB,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,+CAA+C,CAAC;aACrD,KAAK,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,oBAAoB,EAAE,CAAC,CAAC;QAEtD,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,aAAa,CAAC;YAC1C,MAAM,EAAE,KAAK;YACb,YAAY,EAAE,KAAK;YACnB,MAAM,EAAE,GAAG;YACX,WAAW,EAAE,yBAAW,CAAC,YAAY;YACrC,OAAO,EAAE;gBACL,cAAc,EAAE,cAAc;gBAC9B,QAAQ,EAAE,WAAW;gBACrB,WAAW,EAAE,IAAI;gBACjB,WAAW,EAAE,SAAS;gBACtB,UAAU,EAAE,MAAM;gBAClB,UAAU,EAAE,WAAW;gBACvB,oBAAoB,EAAE,UAAU;gBAChC,aAAa,EAAE,KAAK;gBACpB,WAAW,EAAE,cAAc;aAC9B;YACD,MAAM,EAAE,YAAY;SACvB,CAAC,CAAC;QAEH,MAAM,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAE7C,sCAAsC;QACtC,IAAA,cAAI,EAAC,cAAc,CAAC;aACf,IAAI,CAAC,qDAAqD,CAAC;aAC3D,KAAK,CAAC,GAAG,CAAC,CAAC;QAEhB,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,oBAAoB,CAAC,CAAC;QAC3E,MAAM,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC","sourcesContent":["import nock from 'nock';\nimport { KeezApi } from '@/keezApi';\nimport { apiGenerateToken } from '@/api/authorise';\nimport { apiGetAllInvoices } from '@/api/invoices/getAll';\nimport { apiGetInvoiceByExternalId } from '@/api/invoices/view';\nimport { apiCreateInvoice } from '@/api/invoices/create';\nimport { apiSendInvoice } from '@/api/invoices/sendMail';\nimport { apiValidateInvoice } from '@/api/invoices/validate';\nimport { PaymentType } from '@/config/paymentType';\nimport { KeezAuthError, KeezApiError } from '@/errors/KeezError';\n\nconst STAGING_DOMAIN = 'https://staging.keez.ro';\nconst LIVE_DOMAIN = 'https://app.keez.ro';\n\ndescribe('KeezApi class', () => {\n    let keezApi: KeezApi;\n\n    beforeAll(() => {\n        keezApi = new KeezApi({\n            application_id: 'test-app-id',\n            client_eid: 'test-client-eid',\n            secret: 'test-secret',\n            live: true,\n        });\n    });\n\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    test('should return live domain when live mode is true', () => {\n        keezApi.setLive(true);\n        expect(keezApi.getBaseDomain()).toBe(LIVE_DOMAIN);\n    });\n\n    test('should return staging domain when live mode is false', () => {\n        keezApi.setLive(false);\n        expect(keezApi.getBaseDomain()).toBe(STAGING_DOMAIN);\n    });\n});\n\ndescribe('apiGenerateToken', () => {\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    test('should generate token successfully', async () => {\n        const mockResponse = {\n            access_token: 'test-access-token',\n            expires_in: 3600,\n            token_type: 'Bearer',\n            scope: 'public-api',\n        };\n\n        nock(STAGING_DOMAIN)\n            .post('/idp/connect/token')\n            .reply(200, mockResponse);\n\n        const result = await apiGenerateToken({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            apiSecret: 'test-secret',\n        });\n\n        expect(result.access_token).toBe('test-access-token');\n        expect(result.expires_in).toBe(3600);\n        expect(result.token_type).toBe('Bearer');\n        expect(result.scope).toBe('public-api');\n        expect(result.expires_at).toBeGreaterThan(Date.now());\n    });\n\n    test('should throw KeezAuthError on authentication failure', async () => {\n        nock(STAGING_DOMAIN)\n            .post('/idp/connect/token')\n            .reply(401, { error: 'invalid_client' });\n\n        await expect(apiGenerateToken({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            apiSecret: 'wrong-secret',\n        })).rejects.toThrow(KeezAuthError);\n    });\n});\n\ndescribe('apiGetAllInvoices', () => {\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    test('should get all invoices successfully', async () => {\n        const mockResponse = {\n            first: 0,\n            last: 1,\n            recordsCount: 2,\n            data: [\n                {\n                    externalId: 'invoice-1',\n                    series: 'PDI',\n                    number: 1,\n                    documentDate: 20230423,\n                    dueDate: 20230430,\n                    status: 'draft',\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                    externalId: 'invoice-2',\n                    series: 'PDI',\n                    number: 2,\n                    documentDate: 20230424,\n                    dueDate: 20230501,\n                    status: 'valid',\n                    clientName: 'Test Client 2',\n                    partnerName: 'Test Partner 2',\n                    currencyCode: 'EUR',\n                    referenceCurrencyCode: 'RON',\n                    netAmount: 200,\n                    vatAmount: 38,\n                    grossAmount: 238,\n                },\n            ],\n        };\n\n        nock(STAGING_DOMAIN)\n            .get('/api/v1.0/public-api/test-client-eid/invoices')\n            .reply(200, mockResponse);\n\n        const result = await apiGetAllInvoices({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n        });\n\n        expect(result.recordsCount).toBe(2);\n        expect(result.data).toHaveLength(2);\n        expect(result.data[0].externalId).toBe('invoice-1');\n        expect(result.data[1].externalId).toBe('invoice-2');\n    });\n\n    test('should return empty array when no invoices exist', async () => {\n        const mockResponse = {\n            first: 0,\n            last: 0,\n            recordsCount: 0,\n            data: [],\n        };\n\n        nock(STAGING_DOMAIN)\n            .get('/api/v1.0/public-api/test-client-eid/invoices')\n            .reply(200, mockResponse);\n\n        const result = await apiGetAllInvoices({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n        });\n\n        expect(result.recordsCount).toBe(0);\n        expect(result.data).toHaveLength(0);\n    });\n\n    test('should throw KeezApiError on failure', async () => {\n        nock(STAGING_DOMAIN)\n            .get('/api/v1.0/public-api/test-client-eid/invoices')\n            .reply(500, { error: 'Internal Server Error' });\n\n        await expect(apiGetAllInvoices({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n        })).rejects.toThrow(KeezApiError);\n    });\n});\n\ndescribe('apiGetInvoiceByExternalId', () => {\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    test('should get invoice by external ID successfully', async () => {\n        const mockResponse = {\n            currencyCode: 'RON',\n            discountGrossValue: 0,\n            discountNetValue: 0,\n            discountVatValue: 0,\n            discountValueOnNet: false,\n            exciseAmount: 0,\n            documentDate: 20230423,\n            dueDate: 20230430,\n            exchangeRate: 1,\n            grossAmount: 119,\n            netAmount: 100,\n            number: 1,\n            originalNetAmount: 100,\n            originalVatAmount: 19,\n            partner: {\n                addressDetails: 'Test Address',\n                cityName: 'Bucharest',\n                countryCode: 'RO',\n                countryName: 'Romania',\n                countyCode: 'RO.B',\n                countyName: 'Bucharest',\n                identificationNumber: '12345678',\n                isLegalPerson: false,\n                partnerName: 'Test Partner',\n            },\n            invoiceDetails: [\n                {\n                    discountGrossValue: 0,\n                    discountNetValue: 0,\n                    discountVatValue: 0,\n                    discountValueOnNet: false,\n                    grossAmount: 119,\n                    itemCode: 'ITEM-001',\n                    itemDescription: 'Test Item',\n                    itemExternalId: 'item-ext-1',\n                    itemName: 'Test Item Name',\n                    measureUnitId: 1,\n                    netAmount: 100,\n                    originalNetAmount: 100,\n                    originalVatAmount: 19,\n                    quantity: 1,\n                    unMeasureUnit: 'buc',\n                    unVatCategory: 'S',\n                    unVatExemptionReason: '',\n                    unitPrice: 100,\n                    vatAmount: 19,\n                    vatPercent: 19,\n                    exciseAmount: 0,\n                },\n            ],\n            paymentTypeId: 3,\n            referenceCurrencyCode: 'RON',\n            series: 'PDI',\n            status: 'draft',\n            vatAmount: 19,\n            vatOnCollection: false,\n        };\n\n        nock(STAGING_DOMAIN)\n            .get('/api/v1.0/public-api/test-client-eid/invoices/invoice-ext-1')\n            .reply(200, mockResponse);\n\n        const result = await apiGetInvoiceByExternalId({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n            invoiceId: 'invoice-ext-1',\n        });\n\n        expect(result.grossAmount).toBe(119);\n        expect(result.partner.partnerName).toBe('Test Partner');\n        expect(result.items).toHaveLength(1);\n        expect(result.items[0].itemName).toBe('Test Item Name');\n    });\n\n    test('should throw KeezApiError when invoice not found', async () => {\n        nock(STAGING_DOMAIN)\n            .get('/api/v1.0/public-api/test-client-eid/invoices/non-existent')\n            .reply(404, { error: 'Invoice not found' });\n\n        await expect(apiGetInvoiceByExternalId({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n            invoiceId: 'non-existent',\n        })).rejects.toThrow(KeezApiError);\n    });\n});\n\ndescribe('apiCreateInvoice', () => {\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    test('should create invoice successfully', async () => {\n        const mockResponse = {\n            externalId: 'new-invoice-ext-id',\n        };\n\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/test-client-eid/invoices')\n            .reply(201, mockResponse);\n\n        const result = await apiCreateInvoice({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n            invoice: {\n                series: 'PDI',\n                currencyCode: 'RON',\n                amount: 100,\n                paymentType: PaymentType.BANK_TRANSFER,\n                partner: {\n                    addressDetails: 'Test Address',\n                    cityName: 'Bucharest',\n                    countryCode: 'RO',\n                    countryName: 'Romania',\n                    countyCode: 'RO.B',\n                    countyName: 'Bucharest',\n                    identificationNumber: '12345678',\n                    isLegalPerson: false,\n                    partnerName: 'Test Partner',\n                },\n                itemId: 'item-ext-1',\n            },\n        });\n\n        expect(result).toBe('new-invoice-ext-id');\n    });\n\n    test('should create invoice with custom date and quantity', async () => {\n        const mockResponse = {\n            externalId: 'new-invoice-ext-id-2',\n        };\n\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/test-client-eid/invoices', (body: { documentDate: number; invoiceDetails: { quantity: number }[] }) => body.documentDate === 20240115 && body.invoiceDetails[0].quantity === 5)\n            .reply(201, mockResponse);\n\n        const result = await apiCreateInvoice({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n            invoice: {\n                series: 'PDI',\n                currencyCode: 'RON',\n                amount: 500,\n                paymentType: PaymentType.CARD_ONLINE,\n                partner: {\n                    addressDetails: 'Test Address',\n                    cityName: 'Bucharest',\n                    countryCode: 'RO',\n                    countryName: 'Romania',\n                    countyCode: 'RO.B',\n                    countyName: 'Bucharest',\n                    identificationNumber: '12345678',\n                    isLegalPerson: false,\n                    partnerName: 'Test Partner',\n                },\n                itemId: 'item-ext-1',\n                documentDate: 20240115,\n                dueDate: 20240130,\n                quantity: 5,\n            },\n        });\n\n        expect(result).toBe('new-invoice-ext-id-2');\n    });\n\n    test('should throw KeezApiError on validation error', async () => {\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/test-client-eid/invoices')\n            .reply(400, { Message: 'Validation failed' });\n\n        await expect(apiCreateInvoice({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n            invoice: {\n                series: 'PDI',\n                currencyCode: 'RON',\n                amount: -100,\n                paymentType: PaymentType.BANK_TRANSFER,\n                partner: {\n                    addressDetails: 'Test Address',\n                    cityName: 'Bucharest',\n                    countryCode: 'RO',\n                    countryName: 'Romania',\n                    countyCode: 'RO.B',\n                    countyName: 'Bucharest',\n                    identificationNumber: '',\n                    isLegalPerson: false,\n                    partnerName: '',\n                },\n                itemId: '',\n            },\n        })).rejects.toThrow(KeezApiError);\n    });\n});\n\ndescribe('apiSendInvoice', () => {\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    test('should send invoice email successfully', async () => {\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/invoices/delivery')\n            .reply(200);\n\n        const result = await apiSendInvoice({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            bearerToken: 'test-token',\n            clientMail: 'test@example.com',\n            invoiceId: 'invoice-ext-1',\n        });\n\n        expect(result).toBe('SENT');\n    });\n\n    test('should throw KeezApiError on send failure', async () => {\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/invoices/delivery')\n            .reply(500, { error: 'Email service unavailable' });\n\n        await expect(apiSendInvoice({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            bearerToken: 'test-token',\n            clientMail: 'test@example.com',\n            invoiceId: 'invoice-ext-1',\n        })).rejects.toThrow(KeezApiError);\n    });\n});\n\ndescribe('apiValidateInvoice', () => {\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    test('should validate invoice successfully', async () => {\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/test-client-eid/invoices/valid')\n            .reply(200);\n\n        const result = await apiValidateInvoice({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n            invoiceId: 'invoice-ext-1',\n        });\n\n        expect(result).toBe('VALIDATED');\n    });\n\n    test('should throw KeezApiError on validation failure', async () => {\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/test-client-eid/invoices/valid')\n            .reply(400, { Message: 'Invoice cannot be validated' });\n\n        await expect(apiValidateInvoice({\n            baseDomain: STAGING_DOMAIN,\n            appId: 'test-app-id',\n            appClientId: 'test-client-eid',\n            bearerToken: 'test-token',\n            invoiceId: 'invalid-invoice',\n        })).rejects.toThrow(KeezApiError);\n    });\n});\n\ndescribe('KeezApi integration tests', () => {\n    let keezApi: KeezApi;\n\n    beforeEach(() => {\n        keezApi = new KeezApi({\n            application_id: 'test-app-id',\n            client_eid: 'test-client-eid',\n            secret: 'test-secret',\n            live: false,\n        });\n    });\n\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    test('should auto-refresh token when expired', async () => {\n        // Mock token generation\n        nock(STAGING_DOMAIN)\n            .post('/idp/connect/token')\n            .reply(200, {\n                access_token: 'fresh-token',\n                expires_in: 3600,\n                token_type: 'Bearer',\n                scope: 'public-api',\n            });\n\n        // Mock get all invoices\n        nock(STAGING_DOMAIN)\n            .get('/api/v1.0/public-api/test-client-eid/invoices')\n            .reply(200, {\n                first: 0,\n                last: 0,\n                recordsCount: 0,\n                data: [],\n            });\n\n        const result = await keezApi.getAllInvoices();\n        expect(result.recordsCount).toBe(0);\n    });\n\n    test('should create and validate invoice flow', async () => {\n        // Mock token generation\n        nock(STAGING_DOMAIN)\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        // Mock create invoice\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/test-client-eid/invoices')\n            .reply(201, { externalId: 'created-invoice-id' });\n\n        const invoiceId = await keezApi.createInvoice({\n            series: 'PDI',\n            currencyCode: 'RON',\n            amount: 100,\n            paymentType: PaymentType.MEAL_VOUCHER,\n            partner: {\n                addressDetails: 'Test Address',\n                cityName: 'Bucharest',\n                countryCode: 'RO',\n                countryName: 'Romania',\n                countyCode: 'RO.B',\n                countyName: 'Bucharest',\n                identificationNumber: '12345678',\n                isLegalPerson: false,\n                partnerName: 'Test Partner',\n            },\n            itemId: 'item-ext-1',\n        });\n\n        expect(invoiceId).toBe('created-invoice-id');\n\n        // Mock validate invoice (reuse token)\n        nock(STAGING_DOMAIN)\n            .post('/api/v1.0/public-api/test-client-eid/invoices/valid')\n            .reply(200);\n\n        const validateResult = await keezApi.validateInvoice('created-invoice-id');\n        expect(validateResult).toBe('VALIDATED');\n    });\n});\n"]}