@newpeak/barista-cli 0.1.4 → 0.1.6

package/src/core/api/client.ts

@@ -20,8 +20,29 @@ import {
   ClientQueryParams,
   ClientApiResponse,
 } from '../../types/client.js';
+import {
+  CreateSupplierRequest,
+  UpdateSupplierRequest,
+  SupplierQueryParams,
+  SupplierApiResponse,
+} from '../../types/supplier.js';
 import { OrgListItem } from '../../types/org.js';
 import { PositionListItem } from '../../types/position.js';
+import {
+  CreateUomRequest,
+  UpdateUomRequest,
+  UomQueryParams,
+  UomApiResponse,
+} from '../../types/uom.js';
+import {
+  CreateCurrencyRequest,
+  UpdateCurrencyRequest,
+  CurrencyQueryParams,
+  CurrencyApiResponse,
+  CurrencyDefaultResponse,
+} from '../../types/currency.js';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { ApiResponse, Material, MaterialApiResponse, MaterialQueryParams, MaterialRequest } from '../../types/material.js';
 
 export interface LoginResponse {
   token: string;
@@ -896,68 +917,868 @@ export const apiClient = {
     }
   },
 
-};
+  async listSuppliers(
+    environment: Environment,
+    tenant: string,
+    params: SupplierQueryParams
+  ): Promise<SupplierApiResponse> {
+    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.supplierCode) queryString.append('supplierCode', params.supplierCode);
+      if (params.supplierName) queryString.append('supplierName', params.supplierName);
+      const url = `/api/enterprise/purchases/supplier/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<SupplierApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(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 getSupplier(
+    environment: Environment,
+    tenant: string,
+    supplierId: string
+  ): Promise<SupplierApiResponse> {
+    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 response = await client.getClient().get<SupplierApiResponse>(
+        `/api/enterprise/purchases/supplier/detail?supplierId=${supplierId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(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)) {
-    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 getMaterial(
+    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 } };
       }
-      return responseData as unknown as ClientApiResponse;
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<MaterialApiResponse>(
+        `/api/enterprise/sales/material/detail?materialId=${materialId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async listMaterials(
+    environment: Environment,
+    tenant: string,
+    params: MaterialQueryParams
+  ): 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 queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', params.pageNo.toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.statusFlag) queryString.append('statusFlag', params.statusFlag.toString());
+      if (params.materialClass) queryString.append('materialClass', params.materialClass);
+      if (params.keyword) queryString.append('keyword', params.keyword);
+      const url = `/api/enterprise/sales/material/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<MaterialApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error);
+    }
+  },
+
+  async deleteMaterial(
+    environment: Environment,
+    tenant: string,
+    materialId: string
+  ): 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/sales/material/delete',
+        { materialId: materialId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMaterial(error) as unknown as ApiResponse<void>;
+    }
+  },
+
+  async createSupplier(
+    environment: Environment,
+    tenant: string,
+    data: CreateSupplierRequest
+  ): Promise<SupplierApiResponse> {
+    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<SupplierApiResponse>('/api/enterprise/purchases/supplier/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async updateSupplier(
+    environment: Environment,
+    tenant: string,
+    data: UpdateSupplierRequest
+  ): Promise<SupplierApiResponse> {
+    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<SupplierApiResponse>('/api/enterprise/purchases/supplier/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async deleteSupplier(
+    environment: Environment,
+    tenant: string,
+    supplierId: string
+  ): Promise<SupplierApiResponse> {
+    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<SupplierApiResponse>(
+        '/api/enterprise/purchases/supplier/delete',
+        { supplierId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async enableSupplier(
+    environment: Environment,
+    tenant: string,
+    supplierId: string
+  ): Promise<SupplierApiResponse> {
+    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<SupplierApiResponse>(
+        '/api/enterprise/purchases/supplier/batchActive',
+        { supplierIdList: [supplierId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(error);
+    }
+  },
+
+  async disableSupplier(
+    environment: Environment,
+    tenant: string,
+    supplierId: string
+  ): Promise<SupplierApiResponse> {
+    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<SupplierApiResponse>(
+        '/api/enterprise/purchases/supplier/batchDeActive',
+        { supplierIdList: [supplierId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorSupplier(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 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);
+      const url = `/api/enterprise/sales/uom/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<UomApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async getUom(
+    environment: Environment,
+    tenant: string,
+    uomId: string
+  ): 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 response = await client.getClient().get<UomApiResponse>(
+        `/api/enterprise/sales/uom/detail?uomId=${uomId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async createUom(
+    environment: Environment,
+    tenant: string,
+    data: CreateUomRequest
+  ): 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 response = await client.getClient().post<UomApiResponse>('/api/enterprise/sales/uom/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async updateUom(
+    environment: Environment,
+    tenant: string,
+    data: UpdateUomRequest
+  ): 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 response = await client.getClient().post<UomApiResponse>('/api/enterprise/sales/uom/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async deleteUom(
+    environment: Environment,
+    tenant: string,
+    uomId: string
+  ): 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 response = await client.getClient().post<UomApiResponse>(
+        '/api/enterprise/sales/uom/delete',
+        { uomId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async enableUom(
+    environment: Environment,
+    tenant: string,
+    uomId: string
+  ): 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 response = await client.getClient().post<UomApiResponse>(
+        '/api/enterprise/sales/uom/batchActive',
+        { uomIdList: [uomId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async disableUom(
+    environment: Environment,
+    tenant: string,
+    uomId: string
+  ): 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 response = await client.getClient().post<UomApiResponse>(
+        '/api/enterprise/sales/uom/batchDeActive',
+        { uomIdList: [uomId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorUom(error);
+    }
+  },
+
+  async listCurrencies(
+    environment: Environment,
+    tenant: string,
+    params: CurrencyQueryParams
+  ): Promise<CurrencyApiResponse> {
+    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.currencyCode) queryString.append('currencyCode', params.currencyCode);
+      if (params.currencyName) queryString.append('currencyName', params.currencyName);
+      const url = `/api/enterprise/sales/currency/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<CurrencyApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async getCurrency(
+    environment: Environment,
+    tenant: string,
+    currencyId: string
+  ): Promise<CurrencyApiResponse> {
+    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<CurrencyApiResponse>(
+        `/api/enterprise/sales/currency/detail?currencyId=${currencyId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async getAvailableCurrencies(
+    environment: Environment,
+    tenant: string
+  ): Promise<CurrencyApiResponse> {
+    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<CurrencyApiResponse>('/api/enterprise/master/currency/available/list');
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async getCurrencyDefault(
+    environment: Environment,
+    tenant: string,
+    currencyCode: string
+  ): Promise<CurrencyDefaultResponse> {
+    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<CurrencyDefaultResponse>(
+        `/api/enterprise/master/currency/currency/default?currencyCode=${currencyCode}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error) as CurrencyDefaultResponse;
+    }
+  },
+
+  async createCurrency(
+    environment: Environment,
+    tenant: string,
+    data: CreateCurrencyRequest
+  ): Promise<CurrencyApiResponse> {
+    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<CurrencyApiResponse>('/api/enterprise/sales/currency/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async updateCurrency(
+    environment: Environment,
+    tenant: string,
+    data: UpdateCurrencyRequest
+  ): Promise<CurrencyApiResponse> {
+    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<CurrencyApiResponse>('/api/enterprise/sales/currency/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async deleteCurrency(
+    environment: Environment,
+    tenant: string,
+    currencyId: string
+  ): Promise<CurrencyApiResponse> {
+    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<CurrencyApiResponse>(
+        '/api/enterprise/sales/currency/delete',
+        { currencyId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async enableCurrencies(
+    environment: Environment,
+    tenant: string,
+    currencyIds: string[]
+  ): Promise<CurrencyApiResponse> {
+    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<CurrencyApiResponse>(
+        '/api/enterprise/sales/currency/batchActive',
+        { currencyIdList: currencyIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(error);
+    }
+  },
+
+  async disableCurrencies(
+    environment: Environment,
+    tenant: string,
+    currencyIds: string[]
+  ): Promise<CurrencyApiResponse> {
+    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<CurrencyApiResponse>(
+        '/api/enterprise/sales/currency/batchDeActive',
+        { currencyIdList: currencyIds }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorCurrency(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) {
+      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 ClientApiResponse;
+    }
+    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>>;
+    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 SupplierApiResponse;
+    }
+    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 handleApiErrorMaterial(error: unknown): MaterialApiResponse {
+  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 MaterialApiResponse;
+    }
+    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 handleApiErrorUom(error: unknown): UomApiResponse {
+  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 UomApiResponse;
+    }
+    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 handleApiErrorCurrency(error: unknown): CurrencyApiResponse {
+  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 CurrencyApiResponse;
     }
     return {
       success: false,