@newpeak/barista-cli 0.1.8 → 0.1.10

package/dist/core/api/client.js

@@ -160,6 +160,7 @@ export function createAPIClient(service, environment, tenant) {
 }
 const orgCache = new Map();
 const positionCache = new Map();
+const dictItemsCache = new Map();
 const CACHE_TTL_MS = 5 * 60 * 1000;
 export const apiClient = {
     async login(service, environment, tenant, username, password) {
@@ -535,6 +536,34 @@ export const apiClient = {
             return handleApiError(error);
         }
     },
+    async getDictItems(environment, tenant, dictTypeCode) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/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, timestamp: Date.now() });
+                return { success: true, data: response.data.data };
+            }
+            return response.data;
+        }
+        catch (error) {
+            return handleApiError(error);
+        }
+    },
     async getOperationCode(environment, tenant) {
         return this.getCodeByType(environment, tenant, 'TenantOperationCode');
     },
@@ -1355,6 +1384,111 @@ export const apiClient = {
             return handleApiError(error);
         }
     },
+    async listMouldEntities(environment, tenant, params) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorMould(error);
+        }
+    },
+    async getMouldEntity(environment, tenant, id) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/manufacture/mouldEntity/detail', { mouldEntityId: id });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorMould(error);
+        }
+    },
+    async setMouldStatus(environment, tenant, request) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/manufacture/mouldEntity/setMouldStatus', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorMould(error);
+        }
+    },
+    async createMouldStockIn(environment, tenant, request) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/manufacture/mouldEntityRegForm/add', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorMould(error);
+        }
+    },
     async listUoms(environment, tenant, params) {
         try {
             const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
@@ -1982,150 +2116,796 @@ export const apiClient = {
             return handleApiErrorOperation(error);
         }
     },
-};
-function handleApiError(error) {
-    if (axios.isAxiosError(error)) {
-        const axiosError = error;
-        const responseData = axiosError.response?.data;
-        if (responseData) {
-            const success = responseData.success;
-            if (success === false) {
-                const code = responseData.code;
-                const message = responseData.message;
-                const errorObj = responseData.error;
-                if (!errorObj && (code || message)) {
-                    return {
-                        success: false,
-                        error: {
-                            code: code || 'API_ERROR',
-                            message: message || 'API error occurred',
-                        },
-                    };
-                }
+    async listTeamIssues(environment, tenant, params) {
+        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;
+            const client = createAPIClient('liberica', 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(url);
+            return response.data;
         }
-        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) {
-    if (axios.isAxiosError(error)) {
-        const axiosError = error;
-        const responseData = axiosError.response?.data;
-        if (responseData) {
-            const success = responseData.success;
-            if (success === false) {
-                const code = responseData.code;
-                const message = responseData.message;
-                const errorObj = responseData.error;
-                if (!errorObj && (code || message)) {
-                    return {
-                        success: false,
-                        error: {
-                            code: code || 'API_ERROR',
-                            message: message || 'API error occurred',
-                        },
-                    };
-                }
+        catch (error) {
+            return handleApiErrorTeamIssue(error);
+        }
+    },
+    async getTeamIssue(environment, tenant, teamIssueId) {
+        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;
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/team/issue/detail?teamIssueId=${teamIssueId}`);
+            return response.data;
         }
-        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) {
-    if (axios.isAxiosError(error)) {
-        const axiosError = error;
-        const responseData = axiosError.response?.data;
-        if (responseData) {
-            const success = responseData.success;
-            if (success === false) {
-                const code = responseData.code;
-                const message = responseData.message;
-                const errorObj = responseData.error;
-                if (!errorObj && (code || message)) {
-                    return {
-                        success: false,
-                        error: {
-                            code: code || 'API_ERROR',
-                            message: message || 'API error occurred',
-                        },
-                    };
-                }
+        catch (error) {
+            return handleApiErrorTeamIssue(error);
+        }
+    },
+    async createTeamIssue(environment, tenant, data) {
+        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;
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/issue/add', data);
+            return response.data;
         }
-        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) {
-    if (axios.isAxiosError(error)) {
-        const axiosError = error;
-        const responseData = axiosError.response?.data;
-        if (responseData) {
-            const success = responseData.success;
-            if (success === false) {
-                const code = responseData.code;
-                const message = responseData.message;
-                const errorObj = responseData.error;
-                if (!errorObj && (code || message)) {
-                    return {
-                        success: false,
-                        error: {
-                            code: code || 'API_ERROR',
-                            message: message || 'API error occurred',
-                        },
-                    };
-                }
+        catch (error) {
+            return handleApiErrorTeamIssue(error);
+        }
+    },
+    async updateTeamIssue(environment, tenant, data) {
+        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;
+            const client = createAPIClient('liberica', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/issue/edit', data);
+            return response.data;
         }
-        return {
-            success: false,
-            error: {
-                code: 'NETWORK_ERROR',
-                message: axiosError.message || 'Network error occurred',
-            },
-        };
+        catch (error) {
+            return handleApiErrorTeamIssue(error);
+        }
+    },
+    async deleteTeamIssue(environment, tenant, teamIssueId) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/issue/delete', { teamIssueId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamIssue(error);
+        }
+    },
+    async listTeamTasks(environment, tenant, params) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamTask(error);
+        }
+    },
+    async getTeamTask(environment, tenant, teamTaskId) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/team/task/detail?teamTaskId=${teamTaskId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamTask(error);
+        }
+    },
+    async createTeamTask(environment, tenant, data) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/task/add', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamTask(error);
+        }
+    },
+    async updateTeamTask(environment, tenant, data) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/task/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamTask(error);
+        }
+    },
+    async deleteTeamTask(environment, tenant, teamTaskId) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/task/delete', { teamTaskId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamTask(error);
+        }
+    },
+    async listTeamWorkLogs(environment, tenant, params) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamWorkLog(error);
+        }
+    },
+    async getTeamWorkLog(environment, tenant, teamWorkLogId) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/team/work-log/detail?teamWorkLogId=${teamWorkLogId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamWorkLog(error);
+        }
+    },
+    async createTeamWorkLog(environment, tenant, data) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/work-log/add', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamWorkLog(error);
+        }
+    },
+    async updateTeamWorkLog(environment, tenant, data) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/work-log/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamWorkLog(error);
+        }
+    },
+    async deleteTeamWorkLog(environment, tenant, teamWorkLogId) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/work-log/delete', { teamWorkLogId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamWorkLog(error);
+        }
+    },
+    async listTeamProjects(environment, tenant, params) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamProject(error);
+        }
+    },
+    async getTeamProject(environment, tenant, teamProjectId) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().get(`/api/enterprise/team/project/detail?teamProjectId=${teamProjectId}`);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamProject(error);
+        }
+    },
+    async createTeamProject(environment, tenant, data) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/project/add', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamProject(error);
+        }
+    },
+    async updateTeamProject(environment, tenant, data) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/project/edit', data);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamProject(error);
+        }
+    },
+    async deleteTeamProject(environment, tenant, teamProjectId) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/team/project/delete', { teamProjectId });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorTeamProject(error);
+        }
+    },
+    // ============================================
+    // TransferInForm API methods
+    // ============================================
+    async listTransferInForms(environment, tenant, params) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async getTransferInForm(environment, tenant, transferInFormId) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async createTransferInForm(environment, tenant, request) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferIn/add', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async updateTransferInForm(environment, tenant, request) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferIn/edit', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async batchDeleteTransferInForms(environment, tenant, transferInFormIdList) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferIn/batchDelete', { transferInFormIdList });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async batchReviewTransferInForms(environment, tenant, transferInFormIdList) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferIn/batchReview', { transferInFormIdList });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async batchUnreviewTransferInForms(environment, tenant, transferInFormIdList) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferIn/batchUnReview', { transferInFormIdList });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async getTransferInFormSummary(environment, tenant, params) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    // ============================================
+    // TransferOutForm API methods
+    // ============================================
+    async listTransferOutForms(environment, tenant, params) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async getTransferOutForm(environment, tenant, transferOutFormId) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async createTransferOutForm(environment, tenant, request) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferOut/add', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async updateTransferOutForm(environment, tenant, request) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferOut/edit', request);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async batchDeleteTransferOutForms(environment, tenant, transferOutFormIdList) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferOut/batchDelete', { transferOutFormIdList });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async batchReviewTransferOutForms(environment, tenant, transferOutFormIdList) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferOut/batchReview', { transferOutFormIdList });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async batchUnreviewTransferOutForms(environment, tenant, transferOutFormIdList) {
+        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', environment, tenant);
+            client.setAuthToken(token);
+            const response = await client.getClient().post('/api/enterprise/stock/transferOut/batchUnReview', { transferOutFormIdList });
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+    async getTransferOutFormSummary(environment, tenant, params) {
+        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', 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(url);
+            return response.data;
+        }
+        catch (error) {
+            return handleApiErrorStock(error);
+        }
+    },
+};
+function handleApiError(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        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) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        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) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        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) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        return {
+            success: false,
+            error: {
+                code: 'NETWORK_ERROR',
+                message: axiosError.message || 'Network error occurred',
+            },
+        };
     }
     return {
         success: false,
@@ -2515,4 +3295,194 @@ function handleApiErrorStock(error) {
         },
     };
 }
+function handleApiErrorMould(error) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        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) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        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) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        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) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        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) {
+    if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+            const success = responseData.success;
+            if (success === false) {
+                const code = responseData.code;
+                const message = responseData.message;
+                const errorObj = responseData.error;
+                if (!errorObj && (code || message)) {
+                    return {
+                        success: false,
+                        error: {
+                            code: code || 'API_ERROR',
+                            message: message || 'API error occurred',
+                        },
+                    };
+                }
+            }
+            return responseData;
+        }
+        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',
+        },
+    };
+}
 //# sourceMappingURL=client.js.map