@newpeak/barista-cli 0.1.9 → 0.1.10

package/src/core/api/client.ts

@@ -103,6 +103,44 @@ 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;
@@ -1815,7 +1853,6 @@ const response = await client.getClient().get<DictTypeApiResponse>(
       return handleApiErrorStock(error) as unknown as StockJourneySummaryApiResponse;
     }
   },
-
   async listCalendar(
     environment: Environment,
     tenant: string,
@@ -2827,210 +2864,1045 @@ 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;
-        if (!errorObj && (code || message)) {
-          return {
-            success: false,
-            error: {
-              code: code || 'API_ERROR',
-              message: message || 'API error occurred',
-            },
-          };
-        }
+  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 } };
       }
-      return responseData as unknown as SupplierContactApiResponse;
+      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);
     }
-    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',
-            },
-          };
-        }
+  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 } };
       }
-      return responseData as unknown as SupplierApiResponse;
+      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);
     }
-    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) {
+  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,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as SupplierContactApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
+}
+
+function handleApiErrorSupplier(error: unknown): SupplierApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    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;
@@ -3412,4 +4284,160 @@ function handleApiErrorMould(error: unknown): MouldEntityApiResponse {
       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',
+    },
+  };
 }