@newpeak/barista-cli 0.1.7 → 0.1.9

package/src/core/api/client.ts

@@ -26,6 +26,18 @@ import {
   SupplierQueryParams,
   SupplierApiResponse,
 } from '../../types/supplier.js';
+import {
+  CreateClientContactRequest,
+  UpdateClientContactRequest,
+  ClientContactQueryParams,
+  ClientContactApiResponse,
+} from '../../types/client-contact.js';
+import {
+  CreateSupplierContactRequest,
+  UpdateSupplierContactRequest,
+  SupplierContactQueryParams,
+  SupplierContactApiResponse,
+} from '../../types/supplier-contact.js';
 import { OrgListItem } from '../../types/org.js';
 import { PositionListItem } from '../../types/position.js';
 import {
@@ -55,6 +67,42 @@ import {
   CreateLocationRequest,
   UpdateLocationRequest,
 } from '../../types/location.js';
+import {
+  UpdateDictTypeRequest,
+  DictTypeQueryParams,
+  DictItemQueryParams,
+  DictTypeApiResponse,
+  DictApiResponse,
+  CreateDictItemRequest,
+  UpdateDictItemRequest,
+} from '../../types/dict.js';
+import {
+  OperationQueryParams,
+  OperationApiResponse,
+  OperationCreateRequest,
+  OperationUpdateRequest,
+} from '../../types/operation.js';
+import {
+  MasterStockQueryParams,
+  MasterStockApiResponse,
+  StockJourneyQueryParams,
+  StockJourneyApiResponse,
+  StockJourneySummaryApiResponse,
+} from '../../types/stock.js';
+import {
+  CalendarQueryParams,
+  CalendarApiResponse,
+  CalendarSetRequest,
+} from '../../types/calendar.js';
+import {
+  MouldEntityQueryParams,
+  MouldEntitySetStatusRequest,
+  MouldEntityApiResponse,
+} from '../../types/mould.js';
+import {
+  MouldEntityRegFormRequest,
+  MouldEntityRegFormApiResponse,
+} from '../../types/mould-stock-in.js';
 
 export interface LoginResponse {
   token: string;
@@ -246,6 +294,7 @@ export function createAPIClient(service: Service, environment: Environment, tena
 
 const orgCache = new Map<string, { items: OrgListItem[]; timestamp: number }>();
 const positionCache = new Map<string, { items: PositionListItem[]; timestamp: number }>();
+const dictItemsCache = new Map<string, { items: { dictCode: string; dictName: string }[]; timestamp: number }>();
 const CACHE_TTL_MS = 5 * 60 * 1000;
 
 export const apiClient = {
@@ -517,6 +566,180 @@ export const apiClient = {
     }
   },
 
+  async listDictTypes(
+    environment: Environment,
+    tenant: string,
+    params: DictTypeQueryParams
+  ): Promise<DictTypeApiResponse> {
+    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' as Service, 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<DictTypeApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorDictType(error);
+    }
+  },
+
+  async getDictType(
+    environment: Environment,
+    tenant: string,
+    dictTypeId: string
+  ): Promise<DictTypeApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+const response = await client.getClient().get<DictTypeApiResponse>(
+        `/api/enterprise/dictType/detail?dictTypeId=${dictTypeId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorDictType(error);
+    }
+  },
+
+  async updateDictType(
+    environment: Environment,
+    tenant: string,
+    data: UpdateDictTypeRequest
+  ): Promise<DictTypeApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<DictTypeApiResponse>('/api/enterprise/dictType/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorDictType(error);
+    }
+  },
+
+  async listDictItems(
+    environment: Environment,
+    tenant: string,
+    params: DictItemQueryParams
+  ): Promise<DictApiResponse> {
+    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' as Service, 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<DictApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorDict(error);
+    }
+  },
+
+  async getDictItem(
+    environment: Environment,
+    tenant: string,
+    dictId: string
+  ): Promise<DictApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<DictApiResponse>(
+        `/api/enterprise/dict/detail?dictId=${dictId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorDict(error);
+    }
+  },
+
+  async createDictItem(
+    environment: Environment,
+    tenant: string,
+    data: CreateDictItemRequest
+  ): Promise<DictApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<DictApiResponse>('/api/enterprise/dict/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorDict(error);
+    }
+  },
+
+  async updateDictItem(
+    environment: Environment,
+    tenant: string,
+    data: UpdateDictItemRequest
+  ): Promise<DictApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<DictApiResponse>('/api/enterprise/dict/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorDict(error);
+    }
+  },
+
+  async deleteDictItem(
+    environment: Environment,
+    tenant: string,
+    dictId: string
+  ): Promise<DictApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<DictApiResponse>(
+        '/api/enterprise/dict/delete',
+        { dictId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorDict(error);
+    }
+  },
+
   async listPositions(
     environment: Environment,
     tenant: string
@@ -551,7 +774,48 @@ export const apiClient = {
     } catch (error) {
       return handleApiError(error) as { success: boolean; data?: PositionListItem[]; error?: { code: string; message: string } };
     }
- },
+  },
+
+  async getDictItems(
+    environment: Environment,
+    tenant: string,
+    dictTypeCode: string
+  ): Promise<{ success: boolean; data?: { dictCode: string; dictName: string }[]; error?: { code: string; message: string } }> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<{ success: boolean; data?: { dictCode: string; dictName: string }[]; message?: string }>(
+        `/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 as any, timestamp: Date.now() });
+        return { success: true, data: response.data.data as any };
+      }
+      return response.data as { success: boolean; data?: { dictCode: string; dictName: string }[]; error?: { code: string; message: string } };
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: { dictCode: string; dictName: string }[]; error?: { code: string; message: string } };
+    }
+  },
+
+  async getOperationCode(
+    environment: Environment,
+    tenant: string
+  ): Promise<{ success: boolean; data?: string; error?: { code: string; message: string } }> {
+    return this.getCodeByType(environment, tenant, 'TenantOperationCode');
+  },
 
   async createUser(
     environment: Environment,
@@ -929,6 +1193,123 @@ export const apiClient = {
     }
   },
 
+  async listClientContacts(
+    environment: Environment,
+    tenant: string,
+    params: ClientContactQueryParams
+  ): Promise<ClientContactApiResponse> {
+    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' as Service, 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 as ClientContactApiResponse;
+    } catch (error) {
+      return handleApiErrorClientContact(error);
+    }
+  },
+
+  async getClientContact(
+    environment: Environment,
+    tenant: string,
+    clientContactId: string
+  ): Promise<ClientContactApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<ClientContactApiResponse>(
+        `/api/enterprise/sales/clientContact/detail?clientContactId=${clientContactId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorClientContact(error);
+    }
+  },
+
+  async createClientContact(
+    environment: Environment,
+    tenant: string,
+    data: CreateClientContactRequest
+  ): Promise<ClientContactApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<ClientContactApiResponse>('/api/enterprise/sales/clientContact/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorClientContact(error);
+    }
+  },
+
+  async updateClientContact(
+    environment: Environment,
+    tenant: string,
+    data: UpdateClientContactRequest
+  ): Promise<ClientContactApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<ClientContactApiResponse>('/api/enterprise/sales/clientContact/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorClientContact(error);
+    }
+  },
+
+  async deleteClientContact(
+    environment: Environment,
+    tenant: string,
+    clientContactId: string
+  ): Promise<ClientContactApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<ClientContactApiResponse>(
+        '/api/enterprise/sales/clientContact/delete',
+        { clientContactId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorClientContact(error);
+    }
+  },
+
+
   async listSuppliers(
     environment: Environment,
     tenant: string,
@@ -1149,11 +1530,11 @@ export const apiClient = {
     }
   },
 
-  async createMaterial(
+  async listSupplierContacts(
     environment: Environment,
     tenant: string,
-    data: MaterialRequest
-  ): Promise<MaterialApiResponse> {
+    params: SupplierContactQueryParams
+  ): Promise<SupplierContactApiResponse> {
     try {
       const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
       if (!token) {
@@ -1161,19 +1542,34 @@ export const apiClient = {
       }
       const client = createAPIClient('liberica' as Service, environment, tenant);
       client.setAuthToken(token);
-      const response = await client.getClient().post<MaterialApiResponse>('/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 as SupplierContactApiResponse;
     } catch (error) {
-      return handleApiErrorMaterial(error);
+      return handleApiErrorSupplierContact(error);
     }
   },
 
-  async updateMaterial(
+  async getSupplierContact(
     environment: Environment,
     tenant: string,
-    materialId: string,
-    data: MaterialRequest
-  ): Promise<MaterialApiResponse> {
+    supplierContactId: string
+  ): Promise<SupplierContactApiResponse> {
     try {
       const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
       if (!token) {
@@ -1181,14 +1577,115 @@ export const apiClient = {
       }
       const client = createAPIClient('liberica' as Service, environment, tenant);
       client.setAuthToken(token);
-      const response = await client.getClient().post<MaterialApiResponse>('/api/enterprise/sales/material/edit', { materialId, ...data });
+      const response = await client.getClient().get<SupplierContactApiResponse>(
+        `/api/enterprise/purchases/supplierContact/detail?supplierContactId=${supplierContactId}`
+      );
       return response.data;
     } catch (error) {
-      return handleApiErrorMaterial(error);
+      return handleApiErrorSupplierContact(error);
     }
   },
 
-  async disableMaterial(
+  async createSupplierContact(
+    environment: Environment,
+    tenant: string,
+    data: CreateSupplierContactRequest
+  ): Promise<SupplierContactApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<SupplierContactApiResponse>('/api/enterprise/purchases/supplierContact/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplierContact(error);
+    }
+  },
+
+  async updateSupplierContact(
+    environment: Environment,
+    tenant: string,
+    data: UpdateSupplierContactRequest
+  ): Promise<SupplierContactApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<SupplierContactApiResponse>('/api/enterprise/purchases/supplierContact/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplierContact(error);
+    }
+  },
+
+  async deleteSupplierContact(
+    environment: Environment,
+    tenant: string,
+    supplierContactId: string
+  ): Promise<SupplierContactApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<SupplierContactApiResponse>(
+        '/api/enterprise/purchases/supplierContact/delete',
+        { supplierContactId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplierContact(error);
+    }
+  },
+
+  async createMaterial(
+    environment: Environment,
+    tenant: string,
+    data: MaterialRequest
+  ): Promise<MaterialApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MaterialApiResponse>('/api/enterprise/sales/material/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async updateMaterial(
+    environment: Environment,
+    tenant: string,
+    materialId: string,
+    data: MaterialRequest
+  ): Promise<MaterialApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MaterialApiResponse>('/api/enterprise/sales/material/edit', { materialId, ...data });
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async disableMaterial(
     environment: Environment,
     tenant: string,
     materialId: string
@@ -1232,6 +1729,258 @@ export const apiClient = {
     }
   },
 
+  async listStock(
+    environment: Environment,
+    tenant: string,
+    params: MasterStockQueryParams
+  ): Promise<MasterStockApiResponse> {
+    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' as Service, 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<MasterStockApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error);
+    }
+  },
+
+  async listStockLedger(
+    environment: Environment,
+    tenant: string,
+    params: StockJourneyQueryParams
+  ): Promise<StockJourneyApiResponse> {
+    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' as Service, 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<StockJourneyApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as StockJourneyApiResponse;
+    }
+  },
+
+  async getStockLedgerSummary(
+    environment: Environment,
+    tenant: string,
+    params: StockJourneyQueryParams
+  ): Promise<StockJourneySummaryApiResponse> {
+    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' as Service, 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<StockJourneySummaryApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as StockJourneySummaryApiResponse;
+    }
+  },
+
+  async listCalendar(
+    environment: Environment,
+    tenant: string,
+    params: CalendarQueryParams
+  ): Promise<CalendarApiResponse> {
+    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' as Service, 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<CalendarApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as CalendarApiResponse;
+    }
+  },
+
+  async setCalendar(
+    environment: Environment,
+    tenant: string,
+    request: CalendarSetRequest
+  ): Promise<APIResponse<void>> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<APIResponse<void>>(
+        '/api/enterprise/portal/calendar/edit',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as APIResponse<void>;
+    }
+  },
+
+  async listMouldEntities(
+    environment: Environment,
+    tenant: string,
+    params: MouldEntityQueryParams
+  ): Promise<MouldEntityApiResponse> {
+    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' as Service, 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<MouldEntityApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMould(error);
+    }
+  },
+
+  async getMouldEntity(
+    environment: Environment,
+    tenant: string,
+    id: string
+  ): Promise<MouldEntityApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MouldEntityApiResponse>(
+        '/api/enterprise/manufacture/mouldEntity/detail',
+        { mouldEntityId: id }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMould(error);
+    }
+  },
+
+  async setMouldStatus(
+    environment: Environment,
+    tenant: string,
+    request: MouldEntitySetStatusRequest
+  ): Promise<MouldEntityApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MouldEntityApiResponse>(
+        '/api/enterprise/manufacture/mouldEntity/setMouldStatus',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMould(error);
+    }
+  },
+
+  async createMouldStockIn(
+    environment: Environment,
+    tenant: string,
+    request: MouldEntityRegFormRequest
+  ): Promise<MouldEntityRegFormApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MouldEntityRegFormApiResponse>(
+        '/api/enterprise/manufacture/mouldEntityRegForm/add',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMould(error) as unknown as MouldEntityRegFormApiResponse;
+    }
+  },
+
   async listUoms(
     environment: Environment,
     tenant: string,
@@ -1879,10 +2628,209 @@ export const apiClient = {
     }
   },
 
-};
+  async listOperations(
+    environment: Environment,
+    tenant: string,
+    params: OperationQueryParams
+  ): Promise<OperationApiResponse> {
+    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' as Service, 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<OperationApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
 
-function handleApiError(error: unknown): EmployeeApiResponse {
-  if (axios.isAxiosError(error)) {
+  async getOperationDetail(
+    environment: Environment,
+    tenant: string,
+    idOrCode: string
+  ): Promise<OperationApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const isNumeric = /^\d+$/.test(idOrCode);
+      const paramName = isNumeric ? 'operationId' : 'operationCode';
+      const response = await client.getClient().get<OperationApiResponse>(
+        `/api/enterprise/manufacture/operation/detail?${paramName}=${encodeURIComponent(idOrCode)}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
+
+  async createOperation(
+    environment: Environment,
+    tenant: string,
+    data: OperationCreateRequest
+  ): Promise<OperationApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<OperationApiResponse>('/api/enterprise/manufacture/operation/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
+
+  async updateOperation(
+    environment: Environment,
+    tenant: string,
+    data: OperationUpdateRequest
+  ): Promise<OperationApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<OperationApiResponse>('/api/enterprise/manufacture/operation/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
+
+  async deleteOperation(
+    environment: Environment,
+    tenant: string,
+    operationId: string
+  ): Promise<OperationApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<OperationApiResponse>(
+        '/api/enterprise/manufacture/operation/delete',
+        { operationId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
+
+  async batchDeleteOperations(
+    environment: Environment,
+    tenant: string,
+    operationIds: string[]
+  ): Promise<OperationApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<OperationApiResponse>(
+        '/api/enterprise/manufacture/operation/batchDelete',
+        { operationIdList: operationIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
+
+  async copyOperation(
+    environment: Environment,
+    tenant: string,
+    operationId: string
+  ): Promise<OperationApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<OperationApiResponse>(
+        '/api/enterprise/manufacture/operation/copy',
+        { operationId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
+
+  async batchActiveOperations(
+    environment: Environment,
+    tenant: string,
+    operationIds: string[]
+  ): Promise<OperationApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<OperationApiResponse>(
+        '/api/enterprise/manufacture/operation/batchActive',
+        { operationIdList: operationIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
+
+  async batchDeActiveOperations(
+    environment: Environment,
+    tenant: string,
+    operationIds: string[]
+  ): Promise<OperationApiResponse> {
+    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' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<OperationApiResponse>(
+        '/api/enterprise/manufacture/operation/batchDeActive',
+        { operationIdList: operationIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorOperation(error);
+    }
+  },
+
+};
+
+function handleApiError(error: unknown): EmployeeApiResponse {
+  if (axios.isAxiosError(error)) {
     const axiosError = error as AxiosError<Record<string, unknown>>;
     const responseData = axiosError.response?.data;
     if (responseData) {
@@ -1959,6 +2907,84 @@ function handleApiErrorClient(error: unknown): ClientApiResponse {
   };
 }
 
+function handleApiErrorClientContact(error: unknown): ClientContactApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as ClientContactApiResponse;
+    }
+    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: unknown): SupplierContactApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as SupplierContactApiResponse;
+    }
+    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: unknown): SupplierApiResponse {
   if (axios.isAxiosError(error)) {
     const axiosError = error as AxiosError<Record<string, unknown>>;
@@ -2191,4 +3217,199 @@ function handleApiErrorCurrency(error: unknown): CurrencyApiResponse {
       message: error instanceof Error ? error.message : 'Unknown error occurred',
     },
   };
+}
+
+function handleApiErrorDictType(error: unknown): DictTypeApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as DictTypeApiResponse;
+    }
+    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: unknown): DictApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as DictApiResponse;
+    }
+    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: unknown): OperationApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as OperationApiResponse;
+    }
+    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: unknown): MasterStockApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as MasterStockApiResponse;
+    }
+    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: unknown): MouldEntityApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as MouldEntityApiResponse;
+    }
+    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',
+    },
+  };
 }