@newpeak/barista-cli 0.1.478 → 0.1.491

package/dist/core/api/client.js

@@ -6170,6 +6170,201 @@ export const apiClient = {
             return handleApiErrorRouting(error);
         }
     },
+    // ===================== Routing Sequence =====================
+    async listRoutingSequences(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const queryString = new URLSearchParams();
+            if (params.pageNo !== undefined)
+                queryString.append('pageNo', params.pageNo.toString());
+            if (params.pageSize)
+                queryString.append('pageSize', params.pageSize.toString());
+            if (params.routingId)
+                queryString.append('routingId', params.routingId);
+            if (params.operationCode)
+                queryString.append('operationCode', params.operationCode);
+            if (params.statusFlag !== undefined)
+                queryString.append('statusFlag', params.statusFlag.toString());
+            const url = `/api/enterprise/manufacture/routing-sequence/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorRouting(error);
+        }
+    },
+    async getRoutingSequence(environment, tenant, routingSequenceId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .get(`/api/enterprise/manufacture/routing-sequence/detail?routingSequenceId=${routingSequenceId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorRouting(error);
+        }
+    },
+    async createRoutingSequence(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/routing-sequence/add', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorRouting(error);
+        }
+    },
+    async updateRoutingSequence(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/routing-sequence/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorRouting(error);
+        }
+    },
+    async deleteRoutingSequence(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/routing-sequence/delete', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorRouting(error);
+        }
+    },
+    async batchDeleteRoutingSequence(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/routing-sequence/batchDelete', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorRouting(error);
+        }
+    },
+    async batchActiveRoutingSequence(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/routing-sequence/batchActive', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorRouting(error);
+        }
+    },
+    async batchDeActiveRoutingSequence(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/routing-sequence/batchDeActive', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorRouting(error);
+        }
+    },
     // ===================== BOM (Bill of Materials) =====================
     async listBoms(environment, tenant, params) {
         try {
@@ -8447,22 +8642,15 @@ export const apiClient = {
             return handleApiError(error);
         }
     },
-    // ============================================
-    // MaterialStockOutOrder API methods (material-issue)
-    // ============================================
-    async listMaterialStockOutOrders(environment, tenant, params) {
+    async listFinanceTaxes(environment, tenant, params) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
-                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in...' } };
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const searchParams = new URLSearchParams();
-            Object.entries(params).forEach(([key, value]) => {
-                if (value !== undefined && value !== null)
-                    searchParams.append(key, String(value));
-            });
-            const url = `/api/enterprise/manufacture/materialStockOutOrder/page?${searchParams.toString()}`;
+            const country = params.country;
+            const url = `/api/enterprise/finance/tax/list/${country}`;
             const response = await client.getClient().get(url);
             return response.data;
         }
@@ -8470,16 +8658,21 @@ export const apiClient = {
             return handleApiError(error);
         }
     },
-    async getMaterialStockOutOrder(environment, tenant, materialStockOutOrderId) {
+    async getFinanceTaxReportQualifiedInvoice(environment, tenant, params) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
-                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in...' } };
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const searchParams = new URLSearchParams();
-            searchParams.append('materialStockOutOrderId', materialStockOutOrderId);
-            const url = `/api/enterprise/manufacture/materialStockOutOrder/detail?${searchParams.toString()}`;
+            const country = params.country;
+            const invoiceId = params.invoiceId;
+            const format = params.format;
+            let url = `/api/enterprise/finance/tax/report/qualified-invoice/${country}/${invoiceId}`;
+            if (format) {
+                const separator = url.includes('?') ? '&' : '?';
+                url += `${separator}format=${format}`;
+            }
             const response = await client.getClient().get(url);
             return response.data;
         }
@@ -8487,109 +8680,338 @@ export const apiClient = {
             return handleApiError(error);
         }
     },
-    async createMaterialStockOutOrder(environment, tenant, request) {
+    // ============================================
+    // Bank Reconciliation API methods
+    // ============================================
+    async createBankReconciliationBankAccount(environment, tenant, data) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
-                return {
-                    success: false,
-                    error: {
-                        code: 'NO_TOKEN',
-                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
-                    },
-                };
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client
-                .getClient()
-                .post('/api/enterprise/manufacture/materialStockOutOrder/add', request);
+            const response = await client.getClient().post('/api/enterprise/finance/reconciliation/bank-account', data);
             return response.data;
         }
         catch (error) {
             return handleApiError(error);
         }
     },
-    async updateMaterialStockOutOrder(environment, tenant, request) {
+    async listBankReconciliationBankAccounts(environment, tenant) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
-                return {
-                    success: false,
-                    error: {
-                        code: 'NO_TOKEN',
-                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
-                    },
-                };
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client
-                .getClient()
-                .post('/api/enterprise/manufacture/materialStockOutOrder/edit', request);
+            const response = await client.getClient().get('/api/enterprise/finance/reconciliation/bank-account/list');
             return response.data;
         }
         catch (error) {
             return handleApiError(error);
         }
     },
-    async batchDeleteMaterialStockOutOrders(environment, tenant, materialStockOutOrderIdList) {
+    async updateBankReconciliationBankAccount(environment, tenant, data) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
-                return {
-                    success: false,
-                    error: {
-                        code: 'NO_TOKEN',
-                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
-                    },
-                };
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client
-                .getClient()
-                .post('/api/enterprise/manufacture/materialStockOutOrder/batchDelete', { materialStockOutOrderIdList });
+            const response = await client.getClient().post('/api/enterprise/finance/reconciliation/bank-account/update', data);
             return response.data;
         }
         catch (error) {
             return handleApiError(error);
         }
     },
-    async batchReviewMaterialStockOutOrders(environment, tenant, materialStockOutOrderIdList) {
+    async deleteBankReconciliationBankAccount(environment, tenant, bankAccountId) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
-                return {
-                    success: false,
-                    error: {
-                        code: 'NO_TOKEN',
-                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
-                    },
-                };
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client
-                .getClient()
-                .post('/api/enterprise/manufacture/materialStockOutOrder/batchReview', { materialStockOutOrderIdList });
+            const response = await client.getClient().post(`/api/enterprise/finance/reconciliation/bank-account/${bankAccountId}/delete`);
             return response.data;
         }
         catch (error) {
             return handleApiError(error);
         }
     },
-    async batchUnreviewMaterialStockOutOrders(environment, tenant, materialStockOutOrderIdList) {
+    async importBankReconciliationStatement(environment, tenant, data) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token)
-                return {
-                    success: false,
-                    error: {
-                        code: 'NO_TOKEN',
-                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
-                    },
-                };
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client
-                .getClient()
+            const response = await client.getClient().post('/api/enterprise/finance/reconciliation/import', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async autoMatchBankReconciliation(environment, tenant, statementId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/reconciliation/${statementId}/auto-match`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async manualMatchBankReconciliation(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/reconciliation/match', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async unmatchBankReconciliation(environment, tenant, lineId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/reconciliation/unmatch/${lineId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async clearBankReconciliation(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/reconciliation/clear', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async listBankReconciliationLines(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null)
+                    searchParams.append(key, String(value));
+            });
+            const url = `/api/enterprise/finance/reconciliation/lines?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getBankReconciliationReport(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null)
+                    searchParams.append(key, String(value));
+            });
+            const url = `/api/enterprise/finance/reconciliation/report?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async exportBankReconciliationReport(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null)
+                    searchParams.append(key, String(value));
+            });
+            const url = `/api/enterprise/finance/reconciliation/report/export?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    // ============================================
+    // MaterialStockOutOrder API methods (material-issue)
+    // ============================================
+    async listMaterialStockOutOrders(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in...' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null)
+                    searchParams.append(key, String(value));
+            });
+            const url = `/api/enterprise/manufacture/materialStockOutOrder/page?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getMaterialStockOutOrder(environment, tenant, materialStockOutOrderId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in...' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            searchParams.append('materialStockOutOrderId', materialStockOutOrderId);
+            const url = `/api/enterprise/manufacture/materialStockOutOrder/detail?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async createMaterialStockOutOrder(environment, tenant, request) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/materialStockOutOrder/add', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async updateMaterialStockOutOrder(environment, tenant, request) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/materialStockOutOrder/edit', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async batchDeleteMaterialStockOutOrders(environment, tenant, materialStockOutOrderIdList) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/materialStockOutOrder/batchDelete', { materialStockOutOrderIdList });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async batchReviewMaterialStockOutOrders(environment, tenant, materialStockOutOrderIdList) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
+                .post('/api/enterprise/manufacture/materialStockOutOrder/batchReview', { materialStockOutOrderIdList });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async batchUnreviewMaterialStockOutOrders(environment, tenant, materialStockOutOrderIdList) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_TOKEN',
+                        message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment,
+                    },
+                };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client
+                .getClient()
                 .post('/api/enterprise/manufacture/materialStockOutOrder/batchUnReview', { materialStockOutOrderIdList });
             return response.data;
         }
@@ -10989,6 +11411,973 @@ export const apiClient = {
             return handleApiErrorEmail(error);
         }
     },
+    async getFinanceConfig(environment, tenant, groupType, groupCode) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const url = `/api/enterprise/portal/interactiveConfig/getInteractiveConfig?groupType=${encodeURIComponent(groupType)}&groupCode=${encodeURIComponent(groupCode)}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async setFinanceConfig(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token) {
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/portal/interactiveConfig/setInteractiveConfig', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    // ---- COA (Chart of Accounts) ----
+    async getCoaTree(environment, tenant, country) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/coa/tree?country=${encodeURIComponent(country)}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async initCoa(environment, tenant, country) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/coa/init?country=${encodeURIComponent(country)}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getCoaDetail(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/coa/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async createCoa(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/coa/create', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async updateCoa(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/coa/update', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async deleteCoa(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/coa/delete/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async toggleCoaStatus(environment, tenant, id, status) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/coa/${id}/status?status=${encodeURIComponent(status)}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    // ---- Account Migration (COA) ----
+    async coaChangeType(environment, tenant, id, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/coa/${id}/change-type`, data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async coaMerge(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/coa/merge', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async coaSplit(environment, tenant, id, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/coa/${id}/split`, data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async coaRenumber(environment, tenant, id, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/coa/${id}/renumber`, data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async coaArchive(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/coa/${id}/archive`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async coaBulkStatus(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/coa/bulk-status', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async coaMigrationHistory(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/coa/${id}/migration-history`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    // ---- Voucher ----
+    async createVoucher(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/voucher/create', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getVoucher(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/voucher/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async listVouchers(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/voucher/list${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async updateVoucher(environment, tenant, id, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/voucher/${id}/edit`, data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async deleteVoucher(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/voucher/${id}/delete`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async postVoucher(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/voucher/${id}/post`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async reverseVoucher(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/voucher/${id}/reverse`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    // ---- Auto-Voucher ----
+    async createAutoVoucherRule(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/auto-voucher/rules', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getAutoVoucherRule(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/auto-voucher/rules/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async listAutoVoucherRules(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/auto-voucher/rules/list${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async enableAutoVoucherRule(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/auto-voucher/rules/${id}/enable`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async disableAutoVoucherRule(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/auto-voucher/rules/${id}/disable`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async listAutoVoucherErrors(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/auto-voucher/errors${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getAutoVoucherError(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/auto-voucher/errors/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async retryAutoVoucherError(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/auto-voucher/errors/${id}/retry`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async generatePeriods(environment, tenant, country, months) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/period/generate', null, {
+                params: { country, months },
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async listPeriods(environment, tenant) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get('/api/enterprise/finance/period/list');
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getCurrentPeriod(environment, tenant) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get('/api/enterprise/finance/period/current');
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async closePeriod(environment, tenant, periodId, type) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/period/close', null, {
+                params: { periodId, type },
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async reopenPeriod(environment, tenant, periodId, reason) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/period/reopen', null, {
+                params: { periodId, reason },
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async carryForward(environment, tenant, year, retainedEarningsAccountId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/period/carry-forward', null, {
+                params: { year, retainedEarningsAccountId },
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async exportCoa(environment, tenant, country) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/coa/export?country=${encodeURIComponent(country)}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getTrialBalance(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/reports/trial-balance${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getBalanceSheet(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/reports/balance-sheet${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getProfitLoss(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/reports/profit-loss${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getIncomeStatement(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/reports/income-statement${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getCashFlow(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/reports/cash-flow${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getGeneralLedger(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/reports/general-ledger${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getSubsidiaryLedger(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/reports/subsidiary-ledger${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    // ---- Exchange Rate ----
+    async getCurrentExchangeRate(environment, tenant, currencyCode) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/exchange-rate/current?currencyCode=${encodeURIComponent(currencyCode)}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async listExchangeRates(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const query = new URLSearchParams();
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== null && v !== '') {
+                    query.append(k, String(v));
+                }
+            }
+            const qs = query.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/exchange-rate/list${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async revalueExchangeRates(environment, tenant, revaluationDate) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/exchange-rate/revalue', null, {
+                params: { revaluationDate },
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    // ============================================
+    // Amortization (Recurring Adjustment) API
+    // ============================================
+    async createRecurringAdjustmentRule(environment, tenant, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/recurring-adjustment', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async listRecurringAdjustmentRules(environment, tenant, params) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const searchParams = new URLSearchParams();
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null)
+                    searchParams.append(key, String(value));
+            });
+            const qs = searchParams.toString();
+            const response = await client.getClient().get(`/api/enterprise/finance/recurring-adjustment/list${qs ? '?' + qs : ''}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getRecurringAdjustmentRule(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/recurring-adjustment/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async updateRecurringAdjustmentRule(environment, tenant, id, data) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/recurring-adjustment/${id}`, data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async pauseRecurringAdjustmentRule(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/recurring-adjustment/${id}/pause`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async resumeRecurringAdjustmentRule(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/recurring-adjustment/${id}/resume`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async deleteRecurringAdjustmentRule(environment, tenant, id) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/recurring-adjustment/${id}/delete`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async generateRecurringAdjustmentNow(environment, tenant, periodId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/recurring-adjustment/generate-now', null, {
+                params: { periodId },
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    // ============================================
+    // Adjustment Checklist API
+    // ============================================
+    async startAdjustmentChecklist(environment, tenant, periodId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/finance/checklist/start', null, {
+                params: { periodId },
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getAdjustmentChecklistExecution(environment, tenant, periodId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/finance/checklist/execution/${periodId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async checkAdjustmentChecklistItem(environment, tenant, itemId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/checklist/item/${itemId}/check`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async markAdjustmentChecklistException(environment, tenant, itemId, reason) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/checklist/item/${itemId}/exception`, null, {
+                params: { reason },
+            });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async resolveAdjustmentChecklistException(environment, tenant, itemId) {
+        try {
+            const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+            if (!token)
+                return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post(`/api/enterprise/finance/checklist/item/${itemId}/resolve`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
 };
 function handleApiErrorEmail(error) {
     return extractApiError(error);