@newpeak/barista-cli 0.1.8 → 0.1.10

package/src/core/api/client.ts

@@ -94,6 +94,53 @@ import {
   CalendarApiResponse,
   CalendarSetRequest,
 } from '../../types/calendar.js';
+import {
+  MouldEntityQueryParams,
+  MouldEntitySetStatusRequest,
+  MouldEntityApiResponse,
+} from '../../types/mould.js';
+import {
+  MouldEntityRegFormRequest,
+  MouldEntityRegFormApiResponse,
+} from '../../types/mould-stock-in.js';
+import {
+  TeamIssueQueryParams,
+  TeamIssueApiResponse,
+  CreateTeamIssueRequest,
+  UpdateTeamIssueRequest,
+} from '../../types/team-issue.js';
+import {
+  TeamWorkLogQueryParams,
+  TeamWorkLogApiResponse,
+  CreateTeamWorkLogRequest,
+  UpdateTeamWorkLogRequest,
+} from '../../types/team-work-log.js';
+import {
+  TeamProjectQueryParams,
+  TeamProjectApiResponse,
+  CreateTeamProjectRequest,
+  UpdateTeamProjectRequest,
+} from '../../types/team-project.js';
+import {
+  TeamTaskQueryParams,
+  TeamTaskApiResponse,
+  CreateTeamTaskRequest,
+  UpdateTeamTaskRequest,
+} from '../../types/team-task.js';
+import {
+  CreateTransferInFormRequest,
+  UpdateTransferInFormRequest,
+  TransferInFormQueryParams,
+  TransferInFormApiResponse,
+} from '../../types/transfer-in-form.js';
+import {
+  CreateTransferOutFormRequest,
+  UpdateTransferOutFormRequest,
+  TransferOutFormQueryParams,
+  TransferOutFormApiResponse,
+  TransferOutFormListApiResponse,
+  TransferOutFormSummary,
+} from '../../types/transfer-out-form.js';
 
 export interface LoginResponse {
   token: string;
@@ -285,6 +332,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 = {
@@ -766,6 +814,40 @@ const response = await client.getClient().get<DictTypeApiResponse>(
     }
   },
 
+  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
@@ -1771,7 +1853,6 @@ const response = await client.getClient().get<DictTypeApiResponse>(
       return handleApiErrorStock(error) as unknown as StockJourneySummaryApiResponse;
     }
   },
-
   async listCalendar(
     environment: Environment,
     tenant: string,
@@ -1818,6 +1899,125 @@ const response = await client.getClient().get<DictTypeApiResponse>(
     }
   },
 
+  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,
@@ -2664,135 +2864,970 @@ const response = await client.getClient().get<DictTypeApiResponse>(
     }
   },
 
-};
-
-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 listTeamIssues(
+    environment: Environment,
+    tenant: string,
+    params: TeamIssueQueryParams
+  ): Promise<TeamIssueApiResponse> {
+    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 queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', params.pageNo.toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.teamIssueStatus) queryString.append('teamIssueStatus', params.teamIssueStatus);
+      if (params.issueType) queryString.append('issueType', params.issueType);
+      if (params.priority) queryString.append('priority', params.priority);
+      if (params.projectId) queryString.append('projectId', params.projectId);
+      if (params.issueTitle) queryString.append('issueTitle', params.issueTitle);
+      const url = `/api/enterprise/team/issue/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<TeamIssueApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamIssue(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 getTeamIssue(
+    environment: Environment,
+    tenant: string,
+    teamIssueId: string
+  ): Promise<TeamIssueApiResponse> {
+    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<TeamIssueApiResponse>(
+        `/api/enterprise/team/issue/detail?teamIssueId=${teamIssueId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamIssue(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 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',
-            },
-          };
-        }
+  async createTeamIssue(
+    environment: Environment,
+    tenant: string,
+    data: CreateTeamIssueRequest
+  ): Promise<TeamIssueApiResponse> {
+    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 ClientContactApiResponse;
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<TeamIssueApiResponse>('/api/enterprise/team/issue/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamIssue(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 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;
+  async updateTeamIssue(
+    environment: Environment,
+    tenant: string,
+    data: UpdateTeamIssueRequest
+  ): Promise<TeamIssueApiResponse> {
+    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<TeamIssueApiResponse>('/api/enterprise/team/issue/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamIssue(error);
+    }
+  },
+
+  async deleteTeamIssue(
+    environment: Environment,
+    tenant: string,
+    teamIssueId: string
+  ): Promise<TeamIssueApiResponse> {
+    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<TeamIssueApiResponse>(
+        '/api/enterprise/team/issue/delete',
+        { teamIssueId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamIssue(error);
+    }
+  },
+
+  async listTeamTasks(
+    environment: Environment,
+    tenant: string,
+    params: TeamTaskQueryParams
+  ): Promise<TeamTaskApiResponse> {
+    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.teamTaskStatus) queryString.append('teamTaskStatus', params.teamTaskStatus);
+      if (params.taskType) queryString.append('taskType', params.taskType);
+      if (params.priority) queryString.append('priority', params.priority);
+      if (params.projectId) queryString.append('projectId', params.projectId);
+      if (params.taskTitle) queryString.append('taskTitle', params.taskTitle);
+      const url = `/api/enterprise/team/task/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<TeamTaskApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamTask(error);
+    }
+  },
+
+  async getTeamTask(
+    environment: Environment,
+    tenant: string,
+    teamTaskId: string
+  ): Promise<TeamTaskApiResponse> {
+    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<TeamTaskApiResponse>(
+        `/api/enterprise/team/task/detail?teamTaskId=${teamTaskId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamTask(error);
+    }
+  },
+
+  async createTeamTask(
+    environment: Environment,
+    tenant: string,
+    data: CreateTeamTaskRequest
+  ): Promise<TeamTaskApiResponse> {
+    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<TeamTaskApiResponse>('/api/enterprise/team/task/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamTask(error);
+    }
+  },
+
+  async updateTeamTask(
+    environment: Environment,
+    tenant: string,
+    data: UpdateTeamTaskRequest
+  ): Promise<TeamTaskApiResponse> {
+    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<TeamTaskApiResponse>('/api/enterprise/team/task/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamTask(error);
+    }
+  },
+
+  async deleteTeamTask(
+    environment: Environment,
+    tenant: string,
+    teamTaskId: string
+  ): Promise<TeamTaskApiResponse> {
+    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<TeamTaskApiResponse>(
+        '/api/enterprise/team/task/delete',
+        { teamTaskId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamTask(error);
+    }
+  },
+
+  async listTeamWorkLogs(
+    environment: Environment,
+    tenant: string,
+    params: TeamWorkLogQueryParams
+  ): Promise<TeamWorkLogApiResponse> {
+    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.workLogStatus) queryString.append('workLogStatus', params.workLogStatus);
+      if (params.workLogType) queryString.append('workLogType', params.workLogType);
+      if (params.projectId) queryString.append('projectId', params.projectId);
+      if (params.workLogTitle) queryString.append('workLogTitle', params.workLogTitle);
+      const url = `/api/enterprise/team/work-log/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<TeamWorkLogApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamWorkLog(error);
+    }
+  },
+
+  async getTeamWorkLog(
+    environment: Environment,
+    tenant: string,
+    teamWorkLogId: string
+  ): Promise<TeamWorkLogApiResponse> {
+    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<TeamWorkLogApiResponse>(
+        `/api/enterprise/team/work-log/detail?teamWorkLogId=${teamWorkLogId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamWorkLog(error);
+    }
+  },
+
+  async createTeamWorkLog(
+    environment: Environment,
+    tenant: string,
+    data: CreateTeamWorkLogRequest
+  ): Promise<TeamWorkLogApiResponse> {
+    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<TeamWorkLogApiResponse>('/api/enterprise/team/work-log/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamWorkLog(error);
+    }
+  },
+
+  async updateTeamWorkLog(
+    environment: Environment,
+    tenant: string,
+    data: UpdateTeamWorkLogRequest
+  ): Promise<TeamWorkLogApiResponse> {
+    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<TeamWorkLogApiResponse>('/api/enterprise/team/work-log/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamWorkLog(error);
+    }
+  },
+
+  async deleteTeamWorkLog(
+    environment: Environment,
+    tenant: string,
+    teamWorkLogId: string
+  ): Promise<TeamWorkLogApiResponse> {
+    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<TeamWorkLogApiResponse>(
+        '/api/enterprise/team/work-log/delete',
+        { teamWorkLogId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamWorkLog(error);
+    }
+  },
+
+  async listTeamProjects(
+    environment: Environment,
+    tenant: string,
+    params: TeamProjectQueryParams
+  ): Promise<TeamProjectApiResponse> {
+    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.projectStatus) queryString.append('projectStatus', params.projectStatus);
+      if (params.priority) queryString.append('priority', params.priority);
+      if (params.teamId) queryString.append('teamId', params.teamId);
+      if (params.projectId) queryString.append('projectId', params.projectId);
+      if (params.projectCode) queryString.append('projectCode', params.projectCode);
+      if (params.projectName) queryString.append('projectName', params.projectName);
+      if (params.managerId) queryString.append('managerId', params.managerId);
+      const url = `/api/enterprise/team/project/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<TeamProjectApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamProject(error);
+    }
+  },
+
+  async getTeamProject(
+    environment: Environment,
+    tenant: string,
+    teamProjectId: string
+  ): Promise<TeamProjectApiResponse> {
+    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<TeamProjectApiResponse>(
+        `/api/enterprise/team/project/detail?teamProjectId=${teamProjectId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamProject(error);
+    }
+  },
+
+  async createTeamProject(
+    environment: Environment,
+    tenant: string,
+    data: CreateTeamProjectRequest
+  ): Promise<TeamProjectApiResponse> {
+    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<TeamProjectApiResponse>('/api/enterprise/team/project/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamProject(error);
+    }
+  },
+
+  async updateTeamProject(
+    environment: Environment,
+    tenant: string,
+    data: UpdateTeamProjectRequest
+  ): Promise<TeamProjectApiResponse> {
+    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<TeamProjectApiResponse>('/api/enterprise/team/project/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamProject(error);
+    }
+  },
+
+  async deleteTeamProject(
+    environment: Environment,
+    tenant: string,
+    teamProjectId: string
+  ): Promise<TeamProjectApiResponse> {
+    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<TeamProjectApiResponse>(
+        '/api/enterprise/team/project/delete',
+        { teamProjectId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorTeamProject(error);
+    }
+  },
+
+  // ============================================
+  // TransferInForm API methods
+  // ============================================
+
+  async listTransferInForms(
+    environment: Environment,
+    tenant: string,
+    params: TransferInFormQueryParams
+  ): Promise<TransferInFormApiResponse> {
+    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/stock/transferIn/page?${searchParams.toString()}`;
+      const response = await client.getClient().get<TransferInFormApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferInFormApiResponse;
+    }
+  },
+
+  async getTransferInForm(
+    environment: Environment,
+    tenant: string,
+    transferInFormId: string
+  ): Promise<TransferInFormApiResponse> {
+    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();
+      searchParams.append('transferInFormId', transferInFormId);
+
+      const url = `/api/enterprise/stock/transferIn/detail?${searchParams.toString()}`;
+      const response = await client.getClient().get<TransferInFormApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferInFormApiResponse;
+    }
+  },
+
+  async createTransferInForm(
+    environment: Environment,
+    tenant: string,
+    request: CreateTransferInFormRequest
+  ): Promise<TransferInFormApiResponse> {
+    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<TransferInFormApiResponse>(
+        '/api/enterprise/stock/transferIn/add',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferInFormApiResponse;
+    }
+  },
+
+  async updateTransferInForm(
+    environment: Environment,
+    tenant: string,
+    request: UpdateTransferInFormRequest
+  ): Promise<TransferInFormApiResponse> {
+    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<TransferInFormApiResponse>(
+        '/api/enterprise/stock/transferIn/edit',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferInFormApiResponse;
+    }
+  },
+
+  async batchDeleteTransferInForms(
+    environment: Environment,
+    tenant: string,
+    transferInFormIdList: string[]
+  ): Promise<TransferInFormApiResponse> {
+    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<TransferInFormApiResponse>(
+        '/api/enterprise/stock/transferIn/batchDelete',
+        { transferInFormIdList }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferInFormApiResponse;
+    }
+  },
+
+  async batchReviewTransferInForms(
+    environment: Environment,
+    tenant: string,
+    transferInFormIdList: string[]
+  ): Promise<TransferInFormApiResponse> {
+    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<TransferInFormApiResponse>(
+        '/api/enterprise/stock/transferIn/batchReview',
+        { transferInFormIdList }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferInFormApiResponse;
+    }
+  },
+
+  async batchUnreviewTransferInForms(
+    environment: Environment,
+    tenant: string,
+    transferInFormIdList: string[]
+  ): Promise<TransferInFormApiResponse> {
+    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<TransferInFormApiResponse>(
+        '/api/enterprise/stock/transferIn/batchUnReview',
+        { transferInFormIdList }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferInFormApiResponse;
+    }
+  },
+
+  async getTransferInFormSummary(
+    environment: Environment,
+    tenant: string,
+    params: TransferInFormQueryParams
+  ): Promise<TransferInFormApiResponse> {
+    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/stock/transferIn/summary?${searchParams.toString()}`;
+      const response = await client.getClient().get<TransferInFormApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferInFormApiResponse;
+    }
+  },
+
+  // ============================================
+  // TransferOutForm API methods
+  // ============================================
+
+  async listTransferOutForms(
+    environment: Environment,
+    tenant: string,
+    params: TransferOutFormQueryParams
+  ): Promise<TransferOutFormListApiResponse> {
+    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/stock/transferOut/page?${searchParams.toString()}`;
+      const response = await client.getClient().get<TransferOutFormListApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferOutFormListApiResponse;
+    }
+  },
+
+  async getTransferOutForm(
+    environment: Environment,
+    tenant: string,
+    transferOutFormId: string
+  ): Promise<TransferOutFormApiResponse> {
+    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();
+      searchParams.append('transferOutFormId', transferOutFormId);
+
+      const url = `/api/enterprise/stock/transferOut/detail?${searchParams.toString()}`;
+      const response = await client.getClient().get<TransferOutFormApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferOutFormApiResponse;
+    }
+  },
+
+  async createTransferOutForm(
+    environment: Environment,
+    tenant: string,
+    request: CreateTransferOutFormRequest
+  ): Promise<TransferOutFormApiResponse> {
+    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().post<TransferOutFormApiResponse>(
+        '/api/enterprise/stock/transferOut/add',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferOutFormApiResponse;
+    }
+  },
+
+  async updateTransferOutForm(
+    environment: Environment,
+    tenant: string,
+    request: UpdateTransferOutFormRequest
+  ): Promise<TransferOutFormApiResponse> {
+    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().post<TransferOutFormApiResponse>(
+        '/api/enterprise/stock/transferOut/edit',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferOutFormApiResponse;
+    }
+  },
+
+  async batchDeleteTransferOutForms(
+    environment: Environment,
+    tenant: string,
+    transferOutFormIdList: string[]
+  ): Promise<TransferOutFormApiResponse> {
+    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().post<TransferOutFormApiResponse>(
+        '/api/enterprise/stock/transferOut/batchDelete',
+        { transferOutFormIdList }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferOutFormApiResponse;
+    }
+  },
+
+  async batchReviewTransferOutForms(
+    environment: Environment,
+    tenant: string,
+    transferOutFormIdList: string[]
+  ): Promise<TransferOutFormApiResponse> {
+    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().post<TransferOutFormApiResponse>(
+        '/api/enterprise/stock/transferOut/batchReview',
+        { transferOutFormIdList }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferOutFormApiResponse;
+    }
+  },
+
+  async batchUnreviewTransferOutForms(
+    environment: Environment,
+    tenant: string,
+    transferOutFormIdList: string[]
+  ): Promise<TransferOutFormApiResponse> {
+    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().post<TransferOutFormApiResponse>(
+        '/api/enterprise/stock/transferOut/batchUnReview',
+        { transferOutFormIdList }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferOutFormApiResponse;
+    }
+  },
+
+  async getTransferOutFormSummary(
+    environment: Environment,
+    tenant: string,
+    params: TransferOutFormQueryParams
+  ): Promise<TransferOutFormApiResponse<TransferOutFormSummary>> {
+    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/stock/transferOut/summary?${searchParams.toString()}`;
+      const response = await client.getClient().get<TransferOutFormApiResponse<TransferOutFormSummary>>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorStock(error) as unknown as TransferOutFormApiResponse<TransferOutFormSummary>;
+    }
+  },
+
+};
+
+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 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,
@@ -3210,4 +4245,199 @@ function handleApiErrorStock(error: unknown): MasterStockApiResponse {
       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',
+    },
+  };
+}
+
+function handleApiErrorTeamIssue(error: unknown): TeamIssueApiResponse {
+  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 TeamIssueApiResponse;
+    }
+    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 handleApiErrorTeamWorkLog(error: unknown): TeamWorkLogApiResponse {
+  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 TeamWorkLogApiResponse;
+    }
+    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 handleApiErrorTeamProject(error: unknown): TeamProjectApiResponse {
+  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 TeamProjectApiResponse;
+    }
+    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 handleApiErrorTeamTask(error: unknown): TeamTaskApiResponse {
+  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 TeamTaskApiResponse;
+    }
+    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',
+    },
+  };
 }