@newpeak/barista-cli 0.1.7 → 0.1.8

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,33 @@ 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';
 
 export interface LoginResponse {
   token: string;
@@ -517,6 +556,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 +764,14 @@ export const apiClient = {
     } catch (error) {
       return handleApiError(error) as { success: boolean; data?: PositionListItem[]; 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 +1149,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 +1486,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 +1498,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,18 +1533,20 @@ 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,
-    materialId: string
-  ): Promise<MaterialApiResponse> {
+    data: CreateSupplierContactRequest
+  ): Promise<SupplierContactApiResponse> {
     try {
       const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
       if (!token) {
@@ -1200,21 +1554,18 @@ 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/batchDeActive',
-        { materialIdList: [materialId] }
-      );
+      const response = await client.getClient().post<SupplierContactApiResponse>('/api/enterprise/purchases/supplierContact/add', data);
       return response.data;
     } catch (error) {
-      return handleApiErrorMaterial(error);
+      return handleApiErrorSupplierContact(error);
     }
   },
 
-  async enableMaterial(
+  async updateSupplierContact(
     environment: Environment,
     tenant: string,
-    materialId: string
-  ): Promise<MaterialApiResponse> {
+    data: UpdateSupplierContactRequest
+  ): Promise<SupplierContactApiResponse> {
     try {
       const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
       if (!token) {
@@ -1222,21 +1573,18 @@ 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/batchActive',
-        { materialIdList: [materialId] }
-      );
+      const response = await client.getClient().post<SupplierContactApiResponse>('/api/enterprise/purchases/supplierContact/edit', data);
       return response.data;
     } catch (error) {
-      return handleApiErrorMaterial(error);
+      return handleApiErrorSupplierContact(error);
     }
   },
 
-  async listUoms(
+  async deleteSupplierContact(
     environment: Environment,
     tenant: string,
-    params: UomQueryParams
-  ): Promise<UomApiResponse> {
+    supplierContactId: string
+  ): Promise<SupplierContactApiResponse> {
     try {
       const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
       if (!token) {
@@ -1244,9 +1592,247 @@ export const apiClient = {
       }
       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());
+      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
+  ): 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/batchDeActive',
+        { materialIdList: [materialId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async enableMaterial(
+    environment: Environment,
+    tenant: string,
+    materialId: string
+  ): 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/batchActive',
+        { materialIdList: [materialId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  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 listUoms(
+    environment: Environment,
+    tenant: string,
+    params: UomQueryParams
+  ): Promise<UomApiResponse> {
+    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.uomCode) queryString.append('uomCode', params.uomCode);
       if (params.uomName) queryString.append('uomName', params.uomName);
@@ -1879,49 +2465,248 @@ 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)) {
-    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',
-            },
-          };
-        }
+  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 } };
       }
-      return responseData as unknown as EmployeeApiResponse;
+      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);
     }
-    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 handleApiErrorClient(error: unknown): ClientApiResponse {
-  if (axios.isAxiosError(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) {
+      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 EmployeeApiResponse;
+    }
+    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 handleApiErrorClient(error: unknown): ClientApiResponse {
+  if (axios.isAxiosError(error)) {
     const axiosError = error as AxiosError<Record<string, unknown>>;
     const responseData = axiosError.response?.data;
     if (responseData) {
@@ -1959,6 +2744,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 +3054,160 @@ 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',
+    },
+  };
 }