@newpeak/barista-cli 0.1.7 → 0.1.9

package/dist/core/api/client.js

@@ -160,6 +160,7 @@ export function createAPIClient(service, environment, tenant) {
 }
 const orgCache = new Map();
 const positionCache = new Map();
+const dictItemsCache = new Map();
 const CACHE_TTL_MS = 5 * 60 * 1000;
 export const apiClient = {
     async login(service, environment, tenant, username, password) {
@@ -359,6 +360,151 @@ export const apiClient = {
             return handleApiError(error);
         }
     },
+    async listDictTypes(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.status)
+                queryString.append('status', params.status.toString());
+            if (params.dictTypeCode)
+                queryString.append('dictTypeCode', params.dictTypeCode);
+            if (params.dictTypeName)
+                queryString.append('dictTypeName', params.dictTypeName);
+            const url = `/api/enterprise/dictType/list${queryString.toString() ? '?' + queryString.toString() : ''}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorDictType(error);
+        }
+    },
+    async getDictType(environment, tenant, dictTypeId) {
+        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/dictType/detail?dictTypeId=${dictTypeId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorDictType(error);
+        }
+    },
+    async updateDictType(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/dictType/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorDictType(error);
+        }
+    },
+    async listDictItems(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();
+            queryString.append('dictTypeCode', params.dictTypeCode);
+            if (params.pageNo !== undefined)
+                queryString.append('pageNo', params.pageNo.toString());
+            if (params.pageSize)
+                queryString.append('pageSize', params.pageSize.toString());
+            if (params.status)
+                queryString.append('status', params.status.toString());
+            if (params.dictCode)
+                queryString.append('dictCode', params.dictCode);
+            if (params.dictName)
+                queryString.append('dictName', params.dictName);
+            const url = `/api/enterprise/master/dict/list?${queryString.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorDict(error);
+        }
+    },
+    async getDictItem(environment, tenant, dictId) {
+        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/dict/detail?dictId=${dictId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorDict(error);
+        }
+    },
+    async createDictItem(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/dict/add', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorDict(error);
+        }
+    },
+    async updateDictItem(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/dict/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorDict(error);
+        }
+    },
+    async deleteDictItem(environment, tenant, dictId) {
+        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/dict/delete', { dictId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorDict(error);
+        }
+    },
     async listPositions(environment, tenant) {
         const cacheKey = `${environment}:${tenant}`;
         const cached = positionCache.get(cacheKey);
@@ -390,6 +536,37 @@ export const apiClient = {
             return handleApiError(error);
         }
     },
+    async getDictItems(environment, tenant, dictTypeCode) {
+        const cacheKey = `${environment}:${tenant}:${dictTypeCode}`;
+        const cached = dictItemsCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+            return { success: true, data: cached.items };
+        }
+        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/master/dict/list?dictTypeCode=${dictTypeCode}`);
+            if (response.data?.success && response.data?.data) {
+                dictItemsCache.set(cacheKey, { items: response.data.data, timestamp: Date.now() });
+                return { success: true, data: response.data.data };
+            }
+            if (response.data?.success && Array.isArray(response.data?.data)) {
+                dictItemsCache.set(cacheKey, { items: response.data.data, timestamp: Date.now() });
+                return { success: true, data: response.data.data };
+            }
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async getOperationCode(environment, tenant) {
+        return this.getCodeByType(environment, tenant, 'TenantOperationCode');
+    },
     async createUser(environment, tenant, data) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
@@ -689,6 +866,97 @@ export const apiClient = {
             return handleApiErrorClient(error);
         }
     },
+    async listClientContacts(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.clientId)
+                queryString.append('clientId', params.clientId);
+            const url = `/api/enterprise/sales/clientContact/list${queryString.toString() ? '?' + queryString.toString() : ''}`;
+            const response = await client.getClient().get(url);
+            const responseData = response.data;
+            if (responseData && responseData.data && Array.isArray(responseData.data)) {
+                return {
+                    success: true,
+                    data: {
+                        rows: responseData.data,
+                        pageNo: 0,
+                        pageSize: responseData.data.length,
+                        totalRows: responseData.data.length,
+                    },
+                };
+            }
+            return responseData;
+        }
+        catch (error) {
+            return handleApiErrorClientContact(error);
+        }
+    },
+    async getClientContact(environment, tenant, clientContactId) {
+        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/sales/clientContact/detail?clientContactId=${clientContactId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorClientContact(error);
+        }
+    },
+    async createClientContact(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/sales/clientContact/add', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorClientContact(error);
+        }
+    },
+    async updateClientContact(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/sales/clientContact/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorClientContact(error);
+        }
+    },
+    async deleteClientContact(environment, tenant, clientContactId) {
+        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/sales/clientContact/delete', { clientContactId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorClientContact(error);
+        }
+    },
     async listSuppliers(environment, tenant, params) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
@@ -863,7 +1131,7 @@ export const apiClient = {
             return handleApiErrorSupplier(error);
         }
     },
-    async createMaterial(environment, tenant, data) {
+    async listSupplierContacts(environment, tenant, params) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -871,14 +1139,30 @@ export const apiClient = {
             }
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client.getClient().post('/api/enterprise/sales/material/add', data);
-            return response.data;
+            const queryString = new URLSearchParams();
+            if (params.supplierId)
+                queryString.append('supplierId', params.supplierId);
+            const url = `/api/enterprise/purchases/supplierContact/list${queryString.toString() ? '?' + queryString.toString() : ''}`;
+            const response = await client.getClient().get(url);
+            const responseData = response.data;
+            if (responseData && responseData.data && Array.isArray(responseData.data)) {
+                return {
+                    success: true,
+                    data: {
+                        rows: responseData.data,
+                        pageNo: 0,
+                        pageSize: responseData.data.length,
+                        totalRows: responseData.data.length,
+                    },
+                };
+            }
+            return responseData;
         }
         catch (error) {
-            return handleApiErrorMaterial(error);
+            return handleApiErrorSupplierContact(error);
         }
     },
-    async updateMaterial(environment, tenant, materialId, data) {
+    async getSupplierContact(environment, tenant, supplierContactId) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -886,14 +1170,14 @@ export const apiClient = {
             }
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client.getClient().post('/api/enterprise/sales/material/edit', { materialId, ...data });
+            const response = await client.getClient().get(`/api/enterprise/purchases/supplierContact/detail?supplierContactId=${supplierContactId}`);
             return response.data;
         }
         catch (error) {
-            return handleApiErrorMaterial(error);
+            return handleApiErrorSupplierContact(error);
         }
     },
-    async disableMaterial(environment, tenant, materialId) {
+    async createSupplierContact(environment, tenant, data) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -901,14 +1185,14 @@ export const apiClient = {
             }
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client.getClient().post('/api/enterprise/sales/material/batchDeActive', { materialIdList: [materialId] });
+            const response = await client.getClient().post('/api/enterprise/purchases/supplierContact/add', data);
             return response.data;
         }
         catch (error) {
-            return handleApiErrorMaterial(error);
+            return handleApiErrorSupplierContact(error);
         }
     },
-    async enableMaterial(environment, tenant, materialId) {
+    async updateSupplierContact(environment, tenant, data) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -916,14 +1200,14 @@ export const apiClient = {
             }
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client.getClient().post('/api/enterprise/sales/material/batchActive', { materialIdList: [materialId] });
+            const response = await client.getClient().post('/api/enterprise/purchases/supplierContact/edit', data);
             return response.data;
         }
         catch (error) {
-            return handleApiErrorMaterial(error);
+            return handleApiErrorSupplierContact(error);
         }
     },
-    async listUoms(environment, tenant, params) {
+    async deleteSupplierContact(environment, tenant, supplierContactId) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -931,26 +1215,14 @@ export const apiClient = {
             }
             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.status)
-                queryString.append('status', params.status.toString());
-            if (params.uomCode)
-                queryString.append('uomCode', params.uomCode);
-            if (params.uomName)
-                queryString.append('uomName', params.uomName);
-            const url = `/api/enterprise/sales/uom/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
-            const response = await client.getClient().get(url);
+            const response = await client.getClient().post('/api/enterprise/purchases/supplierContact/delete', { supplierContactId });
             return response.data;
         }
         catch (error) {
-            return handleApiErrorUom(error);
+            return handleApiErrorSupplierContact(error);
         }
     },
-    async getUom(environment, tenant, uomId) {
+    async createMaterial(environment, tenant, data) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -958,14 +1230,14 @@ export const apiClient = {
             }
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client.getClient().get(`/api/enterprise/sales/uom/detail?uomId=${uomId}`);
+            const response = await client.getClient().post('/api/enterprise/sales/material/add', data);
             return response.data;
         }
         catch (error) {
-            return handleApiErrorUom(error);
+            return handleApiErrorMaterial(error);
         }
     },
-    async createUom(environment, tenant, data) {
+    async updateMaterial(environment, tenant, materialId, data) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -973,14 +1245,14 @@ export const apiClient = {
             }
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client.getClient().post('/api/enterprise/sales/uom/add', data);
+            const response = await client.getClient().post('/api/enterprise/sales/material/edit', { materialId, ...data });
             return response.data;
         }
         catch (error) {
-            return handleApiErrorUom(error);
+            return handleApiErrorMaterial(error);
         }
     },
-    async updateUom(environment, tenant, data) {
+    async disableMaterial(environment, tenant, materialId) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -988,14 +1260,14 @@ export const apiClient = {
             }
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client.getClient().post('/api/enterprise/sales/uom/edit', data);
+            const response = await client.getClient().post('/api/enterprise/sales/material/batchDeActive', { materialIdList: [materialId] });
             return response.data;
         }
         catch (error) {
-            return handleApiErrorUom(error);
+            return handleApiErrorMaterial(error);
         }
     },
-    async deleteUom(environment, tenant, uomId) {
+    async enableMaterial(environment, tenant, materialId) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
             if (!token) {
@@ -1003,11 +1275,305 @@ export const apiClient = {
             }
             const client = createAPIClient('liberica', environment, tenant);
             client.setAuthToken(token);
-            const response = await client.getClient().post('/api/enterprise/sales/uom/delete', { uomId });
+            const response = await client.getClient().post('/api/enterprise/sales/material/batchActive', { materialIdList: [materialId] });
             return response.data;
         }
         catch (error) {
-            return handleApiErrorUom(error);
+            return handleApiErrorMaterial(error);
+        }
+    },
+    async listStock(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/master/stock/page/withWarehouse?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async listStockLedger(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/master/stock/journey/page?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async getStockLedgerSummary(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/master/stock/journey/page/summary?${searchParams.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async listCalendar(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();
+            queryString.append('year', params.year.toString());
+            queryString.append('month', params.month.toString());
+            if (params.months)
+                queryString.append('months', params.months.toString());
+            const url = `/api/enterprise/portal/calendar/page?${queryString.toString()}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async setCalendar(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/portal/calendar/edit', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
+    async listMouldEntities(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);
+            // CLI page 1 → API pageNo 0 (subtract 1)
+            const queryString = new URLSearchParams();
+            if (params.pageNo !== undefined)
+                queryString.append('pageNo', (params.pageNo - 1).toString());
+            if (params.pageSize)
+                queryString.append('pageSize', params.pageSize.toString());
+            if (params.status)
+                queryString.append('status', params.status.toString());
+            if (params.mouldEntityId)
+                queryString.append('mouldEntityId', params.mouldEntityId);
+            if (params.mouldEntityCode)
+                queryString.append('mouldEntityCode', params.mouldEntityCode);
+            if (params.materialCode)
+                queryString.append('materialCode', params.materialCode);
+            if (params.materialNo)
+                queryString.append('materialNo', params.materialNo);
+            if (params.materialName)
+                queryString.append('materialName', params.materialName);
+            if (params.seqNo)
+                queryString.append('seqNo', params.seqNo);
+            if (params.lotNo)
+                queryString.append('lotNo', params.lotNo);
+            if (params.mouldType)
+                queryString.append('mouldType', params.mouldType);
+            if (params.mouldFaceNumber)
+                queryString.append('mouldFaceNumber', params.mouldFaceNumber.toString());
+            if (params.mouldStatus)
+                queryString.append('mouldStatus', params.mouldStatus);
+            if (params.currentWarehouseCode)
+                queryString.append('currentWarehouseCode', params.currentWarehouseCode);
+            const url = `/api/enterprise/manufacture/mouldEntity/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorMould(error);
+        }
+    },
+    async getMouldEntity(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. 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/mouldEntity/detail', { mouldEntityId: id });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorMould(error);
+        }
+    },
+    async setMouldStatus(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/mouldEntity/setMouldStatus', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorMould(error);
+        }
+    },
+    async createMouldStockIn(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 codeResponse = await this.getCodeByType(environment, tenant, 'TenantMouldRegFormCode');
+            if (!codeResponse.success || !codeResponse.data) {
+                return { success: false, error: { code: 'CODE_GENERATION_FAILED', message: codeResponse.error?.message || 'Failed to generate form code' } };
+            }
+            request.mouldEntityRegFormCode = codeResponse.data;
+            for (const item of request.itemList) {
+                if (!item.mouldEntityRegFormItemCode) {
+                    const itemCodeResponse = await this.getCodeByType(environment, tenant, 'TenantMouldRegFormItemCode');
+                    if (!itemCodeResponse.success || !itemCodeResponse.data) {
+                        return { success: false, error: { code: 'CODE_GENERATION_FAILED', message: itemCodeResponse.error?.message || 'Failed to generate item code' } };
+                    }
+                    item.mouldEntityRegFormItemCode = itemCodeResponse.data;
+                }
+            }
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/manufacture/mouldEntityRegForm/add', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorMould(error);
+        }
+    },
+    async listUoms(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.status)
+                queryString.append('status', params.status.toString());
+            if (params.uomCode)
+                queryString.append('uomCode', params.uomCode);
+            if (params.uomName)
+                queryString.append('uomName', params.uomName);
+            const url = `/api/enterprise/sales/uom/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+            const response = await client.getClient().get(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorUom(error);
+        }
+    },
+    async getUom(environment, tenant, uomId) {
+        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/sales/uom/detail?uomId=${uomId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorUom(error);
+        }
+    },
+    async createUom(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/sales/uom/add', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorUom(error);
+        }
+    },
+    async updateUom(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/sales/uom/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorUom(error);
+        }
+    },
+    async deleteUom(environment, tenant, uomId) {
+        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/sales/uom/delete', { uomId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorUom(error);
         }
     },
     async enableUom(environment, tenant, uomId) {
@@ -1397,33 +1963,186 @@ export const apiClient = {
             return handleApiErrorLocation(error);
         }
     },
-};
-function handleApiError(error) {
-    if (axios.isAxiosError(error)) {
-        const axiosError = error;
-        const responseData = axiosError.response?.data;
-        if (responseData) {
-            const success = responseData.success;
-            if (success === false) {
-                const code = responseData.code;
-                const message = responseData.message;
-                const errorObj = responseData.error;
-                if (!errorObj && (code || message)) {
-                    return {
-                        success: false,
-                        error: {
-                            code: code || 'API_ERROR',
-                            message: message || 'API error occurred',
-                        },
-                    };
-                }
+    async listOperations(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 } };
             }
-            return responseData;
+            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.status)
+                queryString.append('status', params.status.toString());
+            if (params.operationCode)
+                queryString.append('operationCode', params.operationCode);
+            if (params.operationName)
+                queryString.append('operationName', params.operationName);
+            if (params.operationType)
+                queryString.append('operationType', params.operationType);
+            if (params.workCenterCode)
+                queryString.append('workCenterCode', params.workCenterCode);
+            const url = `/api/enterprise/manufacture/operation/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+            const response = await client.getClient().get(url);
+            return response.data;
         }
-        return {
-            success: false,
-            error: {
-                code: 'NETWORK_ERROR',
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+    async getOperationDetail(environment, tenant, idOrCode) {
+        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 isNumeric = /^\d+$/.test(idOrCode);
+            const paramName = isNumeric ? 'operationId' : 'operationCode';
+            const response = await client.getClient().get(`/api/enterprise/manufacture/operation/detail?${paramName}=${encodeURIComponent(idOrCode)}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+    async createOperation(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/operation/add', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+    async updateOperation(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/operation/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+    async deleteOperation(environment, tenant, operationId) {
+        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/operation/delete', { operationId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+    async batchDeleteOperations(environment, tenant, operationIds) {
+        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/operation/batchDelete', { operationIdList: operationIds });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+    async copyOperation(environment, tenant, operationId) {
+        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/operation/copy', { operationId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+    async batchActiveOperations(environment, tenant, operationIds) {
+        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/operation/batchActive', { operationIdList: operationIds });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+    async batchDeActiveOperations(environment, tenant, operationIds) {
+        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/operation/batchDeActive', { operationIdList: operationIds });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorOperation(error);
+        }
+    },
+};
+function handleApiError(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
                 message: axiosError.message || 'Network error occurred',
             },
         };
@@ -1474,6 +2193,82 @@ function handleApiErrorClient(error) {
         },
     };
 }
+function handleApiErrorClientContact(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
+                message: axiosError.message || 'Network error occurred',
+            },
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: 'UNKNOWN_ERROR',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+    };
+}
+function handleApiErrorSupplierContact(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
+                message: axiosError.message || 'Network error occurred',
+            },
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: 'UNKNOWN_ERROR',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+    };
+}
 function handleApiErrorSupplier(error) {
     if (axios.isAxiosError(error)) {
         const axiosError = error;
@@ -1702,4 +2497,194 @@ function handleApiErrorCurrency(error) {
         },
     };
 }
+function handleApiErrorDictType(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
+                message: axiosError.message || 'Network error occurred',
+            },
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: 'UNKNOWN_ERROR',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+    };
+}
+function handleApiErrorDict(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
+                message: axiosError.message || 'Network error occurred',
+            },
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: 'UNKNOWN_ERROR',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+    };
+}
+function handleApiErrorOperation(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
+                message: axiosError.message || 'Network error occurred',
+            },
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: 'UNKNOWN_ERROR',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+    };
+}
+function handleApiErrorStock(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
+                message: axiosError.message || 'Network error occurred',
+            },
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: 'UNKNOWN_ERROR',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+    };
+}
+function handleApiErrorMould(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
+                message: axiosError.message || 'Network error occurred',
+            },
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: 'UNKNOWN_ERROR',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+    };
+}
 //# sourceMappingURL=client.js.map