@tagsamurai/fats-api-services 1.0.3-alpha.69 → 1.0.3-alpha.70

package/api-services.es.js

@@ -119,51 +119,51 @@ const getAssetsFile = async (file, type = "excel") => {
   );
   return response;
 };
-const API$M = createAxiosInstance({
+const API$N = createAxiosInstance({
   prefix: "/utility/v2"
 });
 const ChangelogServices = {
   getChangelogList: (params) => {
-    return API$M.get("/change-log", { params });
+    return API$N.get("/change-log", { params });
   },
   getChangelogListOptions: (params) => {
-    return API$M.get("/change-log/options", { params });
+    return API$N.get("/change-log/options", { params });
   },
   getSessionLogList: (params) => {
-    return API$M.get("/session-log", { params });
+    return API$N.get("/session-log", { params });
   },
   getSessionLogListOptions: (params) => {
-    return API$M.get("/session-log/options", {
+    return API$N.get("/session-log/options", {
       params
     });
   },
   getTransactionLog: (params) => {
-    return API$M.get("/transaction-log", { params });
+    return API$N.get("/transaction-log", { params });
   },
   /**
    * Retrieves the transaction log options.
    * @returns {Promise<AxiosResponse>} - A promise that resolves to the response from the API.
    */
   getTransactionLogOption: (params) => {
-    return API$M.get("/transaction-log/options", { params });
+    return API$N.get("/transaction-log/options", { params });
   },
   getUserDetailSystemLogList: (params) => {
-    return API$M.get("/change-log", { params });
+    return API$N.get("/change-log", { params });
   },
   getUserDetailSystemLogOption: (params) => {
-    return API$M.get("/change-log/options", { params });
+    return API$N.get("/change-log/options", { params });
   },
   getUserDetailUserLogBorrowingList: (userId, params) => {
-    return API$M.get(`/borrowing-log/${userId}`, { params });
+    return API$N.get(`/borrowing-log/${userId}`, { params });
   },
   getUserDetailUserLogAssignmentList: (userId, params) => {
-    return API$M.get(`/assignment-log/${userId}`, { params });
+    return API$N.get(`/assignment-log/${userId}`, { params });
   },
   getUserDetailUserLogBorrowingOption: (userId, params) => {
-    return API$M.get(`/borrowing-log/${userId}/options`, { params });
+    return API$N.get(`/borrowing-log/${userId}/options`, { params });
   },
   getUserDetailUserLogAssignmentOption: (userId, params) => {
-    return API$M.get(`/assignment-log/${userId}/options`, { params });
+    return API$N.get(`/assignment-log/${userId}/options`, { params });
   }
 };
 const AssetsAPIs = createAxiosInstance({
@@ -246,38 +246,38 @@ const AssetServices = {
     return AssetsAPIs.delete("/attachment/bulk", { params });
   }
 };
-const API$L = createAxiosInstance({
+const API$M = createAxiosInstance({
   prefix: "/missing-tracking/v2"
 });
 const MissingServices = {
   putFoundAsset: (body) => {
-    return API$L.put("/found", body);
+    return API$M.put("/found", body);
   },
   putReportMissing: (id, body) => {
-    return API$L.put(`/${id}/report-missing`, body);
+    return API$M.put(`/${id}/report-missing`, body);
   },
   getData: (params) => {
-    return API$L.get("/", { params });
+    return API$M.get("/", { params });
   },
   getDataOptions: (params) => {
-    return API$L.get("/options", { params });
+    return API$M.get("/options", { params });
   },
   getDetail: (id) => {
-    return API$L.get(`/${id}`);
+    return API$M.get(`/${id}`);
   }
 };
-const API$K = createAxiosInstance({
+const API$L = createAxiosInstance({
   prefix: "/utility/v2/notification"
 });
 const NotificationServices = {
   getNotifications: (params) => {
-    return API$K.get("/", { params });
+    return API$L.get("/", { params });
   },
   readNotification: (id) => {
-    return API$K.put(`/${id}`);
+    return API$L.put(`/${id}`);
   }
 };
-const API$J = createAxiosInstance({
+const API$K = createAxiosInstance({
   prefix: "/settings-user-role/v2"
 });
 const UserServices = {
@@ -286,19 +286,19 @@ const UserServices = {
    * @returns {Promise<AxiosResponse>} - A promise that resolves to the response from the API.
    */
   getUserDropdown: (params) => {
-    return API$J.get("/users/dropdown", { params });
+    return API$K.get("/users/dropdown", { params });
   },
   getUserOptions: (params) => {
-    return API$J.get("/users/options", { params });
+    return API$K.get("/users/options", { params });
   },
   getUserList: (params) => {
-    return API$J.get("/users", { params });
+    return API$K.get("/users", { params });
   },
   getUserDetail: (id) => {
-    return API$J.get(`/users/${id}`);
+    return API$K.get(`/users/${id}`);
   },
   putSetActiveBulk: (data) => {
-    return API$J.put("/users/set-active-bulk", data);
+    return API$K.put("/users/set-active-bulk", data);
   },
   // User Detail
   /**
@@ -309,96 +309,96 @@ const UserServices = {
    */
   getUserDetailSystemRoles: (id, params, permissionType) => {
     const additionalPath = permissionType ? `/${permissionType}/groups` : "";
-    return API$J.get(`/users/${id}/system-roles${additionalPath}`, {
+    return API$K.get(`/users/${id}/system-roles${additionalPath}`, {
       params
     });
   },
   getUserDetailTransactionRoleList: (id, params) => {
-    return API$J.get(`/users/${id}/transaction-roles`, { params });
+    return API$K.get(`/users/${id}/transaction-roles`, { params });
   },
   postUserDetailAddTransactionRole: (userId, data) => {
-    return API$J.post(`/users/${userId}/add-transaction-role`, data);
+    return API$K.post(`/users/${userId}/add-transaction-role`, data);
   },
   deleteUserDetailTransactionRole: (userId, body) => {
-    return API$J.put(`/users/${userId}/delete-transaction-role`, body);
+    return API$K.put(`/users/${userId}/delete-transaction-role`, body);
   },
   putUserDetailEditTransactionRole: (userId, data) => {
-    return API$J.put(`/users/${userId}/edit-transaction-role`, data);
+    return API$K.put(`/users/${userId}/edit-transaction-role`, data);
   },
   putAssignGroup: (data, permissionType, id) => {
-    return API$J.put(`/users/${id}/system-roles/${permissionType}/groups`, data);
+    return API$K.put(`/users/${id}/system-roles/${permissionType}/groups`, data);
   },
   putRoleSetActive: (body, userId) => {
-    return API$J.put(`/users/${userId}/system-roles/set-active-bulk`, body);
+    return API$K.put(`/users/${userId}/system-roles/set-active-bulk`, body);
   },
   getUserDetailTransactionAdminLogList: (userId, params) => {
-    return API$J.get(`/users/${userId}/transaction-log`, { params });
+    return API$K.get(`/users/${userId}/transaction-log`, { params });
   },
   getUserDetailTransactionAdminLogOption: (userId, params) => {
-    return API$J.get(`/users/${userId}/transaction-log/options`, { params });
+    return API$K.get(`/users/${userId}/transaction-log/options`, { params });
   },
   getUserDetailUserAssetBorrowedList: (userId, params) => {
-    return API$J.get(`/users/${userId}/borrowed-asset`, { params });
+    return API$K.get(`/users/${userId}/borrowed-asset`, { params });
   },
   getUserDetailUserAssetAssignedList: (userId, params) => {
-    return API$J.get(`/users/${userId}/assigned-asset`, { params });
+    return API$K.get(`/users/${userId}/assigned-asset`, { params });
   },
   getUserDetailUserAssetBorrowedOption: (userId, params) => {
-    return API$J.get(`/users/${userId}/borrowed-asset/options`, { params });
+    return API$K.get(`/users/${userId}/borrowed-asset/options`, { params });
   },
   getUserDetailUserAssetAssignedOption: (userId, params) => {
-    return API$J.get(`/users/${userId}/assigned-asset/options`, { params });
+    return API$K.get(`/users/${userId}/assigned-asset/options`, { params });
   }
 };
-const API$I = createAxiosInstance({
+const API$J = createAxiosInstance({
   prefix: "/settings-user-role/v2/users"
 });
 const SubUserServices = {
   // Sub User
   getSubUserList: (userId, params) => {
-    return API$I.get(`/${userId}/sub-users`, { params });
+    return API$J.get(`/${userId}/sub-users`, { params });
   },
   getSubUserOptions: (userId, params) => {
-    return API$I.get(`/${userId}/sub-users/option`, { params });
+    return API$J.get(`/${userId}/sub-users/option`, { params });
   },
   postCreateSubUser: (userId, data) => {
     const headers = { "Content-Type": "multipart/form-data" };
-    return API$I.post(`/${userId}/sub-users`, data, { headers });
+    return API$J.post(`/${userId}/sub-users`, data, { headers });
   },
   putSubUserSetActiveBulk: (userId, data) => {
-    return API$I.put(`/${userId}/sub-users/set-active-bulk`, data);
+    return API$J.put(`/${userId}/sub-users/set-active-bulk`, data);
   },
   deleteSubUser: (userId, subUserIds) => {
-    return API$I.put(`/${userId}/sub-users/bulk`, { subUserIds });
+    return API$J.put(`/${userId}/sub-users/bulk`, { subUserIds });
   },
   putEditSubUser: (userId, subUserId, data) => {
     const headers = { "Content-Type": "multipart/form-data" };
-    return API$I.put(`/${userId}/sub-users/${subUserId}`, data, {
+    return API$J.put(`/${userId}/sub-users/${subUserId}`, data, {
       headers
     });
   },
   getBorrowedAsset: (userId, subUserId, params) => {
-    return API$I.get(`/${userId}/sub-users/${subUserId}/borrowed-asset`, {
+    return API$J.get(`/${userId}/sub-users/${subUserId}/borrowed-asset`, {
       params
     });
   },
   getBorrowedAssetOptions: (userId, subUserId, params) => {
-    return API$I.get(`/${userId}/sub-users/${subUserId}/borrowed-asset/options`, {
+    return API$J.get(`/${userId}/sub-users/${subUserId}/borrowed-asset/options`, {
       params
     });
   },
   getAssignedAsset: (userId, subUserId, params) => {
-    return API$I.get(`/${userId}/sub-users/${subUserId}/assigned-asset`, {
+    return API$J.get(`/${userId}/sub-users/${subUserId}/assigned-asset`, {
       params
     });
   },
   getAssignedAssetOptions: (userId, subUserId, params) => {
-    return API$I.get(`/${userId}/sub-users/${subUserId}/assigned-asset/options`, {
+    return API$J.get(`/${userId}/sub-users/${subUserId}/assigned-asset/options`, {
       params
     });
   }
 };
-const API$H = createAxiosInstance({
+const API$I = createAxiosInstance({
   prefix: "/utility/v2"
 });
 const FileManagerServices = {
@@ -408,7 +408,7 @@ const FileManagerServices = {
    * @returns {Promise<AxiosResponse>} The Axios Response.
    */
   getStorageInformation: () => {
-    return API$H.get("/files/storage");
+    return API$I.get("/files/storage");
   },
   /**
    * Get file manager data.
@@ -418,7 +418,7 @@ const FileManagerServices = {
    * @returns {Promise<AxiosResponse>} The Axios Response.
    */
   getFileManager: (type, params) => {
-    return API$H.get(`/${type}`, { params });
+    return API$I.get(`/${type}`, { params });
   },
   /**
    * Get file manager options.
@@ -428,7 +428,7 @@ const FileManagerServices = {
    * @returns {Promise<AxiosResponse>} The Axios Response.
    */
   getFileManagerOption: (type, params) => {
-    return API$H.get(`/${type}/options`, { params });
+    return API$I.get(`/${type}/options`, { params });
   },
   /**
    * Recover files.
@@ -438,7 +438,7 @@ const FileManagerServices = {
    * @returns {Promise<AxiosResponse>} The Axios Response.
    */
   recoverFiles: (type, body) => {
-    return API$H.put(`/${type}/recover`, body);
+    return API$I.put(`/${type}/recover`, body);
   },
   /**
    * Delete files.
@@ -448,7 +448,7 @@ const FileManagerServices = {
    * @returns {Promise<AxiosResponse>} The Axios Response.
    */
   deleteFiles: (type, params) => {
-    return API$H.delete(`/${type}`, { params });
+    return API$I.delete(`/${type}`, { params });
   },
   /**
    * Delete files permanently.
@@ -458,10 +458,10 @@ const FileManagerServices = {
    * @returns {Promise<AxiosResponse>} The Axios Response.
    */
   deletePermanently: (type, params) => {
-    return API$H.delete(`/${type}/delete-permanent`, { params });
+    return API$I.delete(`/${type}/delete-permanent`, { params });
   }
 };
-const API$G = createAxiosInstance({
+const API$H = createAxiosInstance({
   prefix: "/settings-user-role/v2"
 });
 const RoleServices = {
@@ -472,10 +472,10 @@ const RoleServices = {
    * @returns {Promise<AxiosResponse>} - A promise that resolves to the response from the API.
    */
   getTransactionRole: (groupId, transactionName) => {
-    return API$G.get(`/transaction-roles/${groupId}/${transactionName}`);
+    return API$H.get(`/transaction-roles/${groupId}/${transactionName}`);
   },
   getTransactionRoleTypes: (groupKeys, transactionName) => {
-    return API$G.get(`/transaction-roles/${transactionName}/types`, {
+    return API$H.get(`/transaction-roles/${transactionName}/types`, {
       params: { groupKeys }
     });
   },
@@ -487,7 +487,7 @@ const RoleServices = {
    * @returns {Promise<AxiosResponse>} - A promise that resolves to the response from the API.
    */
   putUpdateUsers: (groupId, transactionName, body) => {
-    return API$G.put(
+    return API$H.put(
       `/transaction-roles/${groupId}/${transactionName}/update-user`,
       body
     );
@@ -500,7 +500,7 @@ const RoleServices = {
    * @returns {Promise<AxiosResponse>} - A promise that resolves to the response from the API.
    */
   putUpdateLevel: (groupId, transactionName, body) => {
-    return API$G.put(
+    return API$H.put(
       `/transaction-roles/${groupId}/${transactionName}/update-approval-level`,
       body
     );
@@ -513,371 +513,371 @@ const RoleServices = {
    * @returns {Promise<AxiosResponse>} - A promise that resolves to the response from the API.
    */
   putUpdateGroupManage: (groupId, transactionName, body) => {
-    return API$G.put(
+    return API$H.put(
       `/transaction-roles/${groupId}/${transactionName}/update-manage-by-parent`,
       body
     );
   },
   getUserAssignedSystemRole: (userId) => {
-    return API$G.get(`/system-roles/user/${userId}`);
+    return API$H.get(`/system-roles/user/${userId}`);
   },
   getAssignedUserAmounts: () => {
-    return API$G.get("/system-roles/amounts");
+    return API$H.get("/system-roles/amounts");
   },
   getPermissionUser: (permissionType, params) => {
     if (["totalControl", "readOnly"].includes(permissionType ?? "")) {
       const type = permissionType === "totalControl" ? "total-control" : "read-only";
-      return API$G.get(`/system-roles/total-control-read-only/${type}`, {
+      return API$H.get(`/system-roles/total-control-read-only/${type}`, {
         params
       });
     }
-    return API$G.get(`/system-roles/permission/${permissionType}`, { params });
+    return API$H.get(`/system-roles/permission/${permissionType}`, { params });
   },
   getPermissionUserOptions: (permissionType, params) => {
     if (["totalControl", "readOnly"].includes(permissionType ?? "")) {
       const type = permissionType === "totalControl" ? "total-control" : "read-only";
-      return API$G.get(`/system-roles/total-control-read-only/${type}/options`, {
+      return API$H.get(`/system-roles/total-control-read-only/${type}/options`, {
         params
       });
     }
-    return API$G.get(`/system-roles/permission/${permissionType}/options`, {
+    return API$H.get(`/system-roles/permission/${permissionType}/options`, {
       params
     });
   },
   getUserGroups: (params, permissionType) => {
-    return API$G.get(`/system-roles/permission/${permissionType}/groups`, {
+    return API$H.get(`/system-roles/permission/${permissionType}/groups`, {
       params
     });
   },
   postAssignUser: (body, permissionType) => {
     if (["totalControl", "readOnly"].includes(permissionType ?? "")) {
       const type = permissionType === "totalControl" ? "total-control" : "read-only";
-      return API$G.post(`/system-roles/total-control-read-only/${type}`, body);
+      return API$H.post(`/system-roles/total-control-read-only/${type}`, body);
     }
-    return API$G.post(`/system-roles/permission/${permissionType}`, body);
+    return API$H.post(`/system-roles/permission/${permissionType}`, body);
   },
   putEditUser: (body, roleId) => {
-    return API$G.put(`/system-roles/${roleId}`, body);
+    return API$H.put(`/system-roles/${roleId}`, body);
   },
   deleteRemoveUser: (body, permissionType) => {
     if (["totalControl", "readOnly"].includes(permissionType ?? "")) {
       const type = permissionType === "totalControl" ? "total-control" : "read-only";
-      return API$G.put(`/system-roles/total-control-read-only/${type}`, body);
+      return API$H.put(`/system-roles/total-control-read-only/${type}`, body);
     }
-    return API$G.put("/system-roles", body);
+    return API$H.put("/system-roles", body);
   }
 };
-const API$F = createAxiosInstance({
+const API$G = createAxiosInstance({
   prefix: "/settings-attribute/v2/open-api"
 });
 const OpenAPIServices = {
   getOpenAPIDocs: (params) => {
-    return API$F.get(`/${params.doc}`);
+    return API$G.get(`/${params.doc}`);
   },
   putGenerateToken: () => {
-    return API$F.put("/generate");
+    return API$G.put("/generate");
   },
   // This is if the dummy was not dummy
   getToken: () => {
-    return API$F.get("");
+    return API$G.get("");
   },
   putRequestOpenAPI: () => {
-    return API$F.put("/request");
+    return API$G.put("/request");
   },
   putCancelRequestOpenAPI: () => {
-    return API$F.put("/cancel-request");
+    return API$G.put("/cancel-request");
   }
 };
-const API$E = createAxiosInstance({
+const API$F = createAxiosInstance({
   prefix: "/import/v2"
 });
 const ImportServices = {
   getImport: (importUrl, params) => {
-    return API$E.get(`/${importUrl}`, { params });
+    return API$F.get(`/${importUrl}`, { params });
   },
   postImportTemporary: (importUrl, data) => {
     const headers = { "Content-Type": "multipart/form-data" };
-    return API$E.post(`/${importUrl}/temporary`, data, { headers });
+    return API$F.post(`/${importUrl}/temporary`, data, { headers });
   },
   deleteImportTemporary: (importUrl, params) => {
-    return API$E.delete(`/${importUrl}/temporary`, { params });
+    return API$F.delete(`/${importUrl}/temporary`, { params });
   },
   postDuplicateImport: (importUrl, body) => {
-    return API$E.post(`/${importUrl}/duplicate`, body);
+    return API$F.post(`/${importUrl}/duplicate`, body);
   },
   putEditImport: (importUrl, body) => {
-    return API$E.put(`/${importUrl}`, body);
+    return API$F.put(`/${importUrl}`, body);
   },
   postImport: (importUrl, controller, body) => {
-    return API$E.post(importUrl, body, { signal: controller.signal });
+    return API$F.post(importUrl, body, { signal: controller.signal });
   },
   putImportCancelProgress: (importUrl) => {
-    return API$E.put(`/${importUrl}/cancel-progress`);
+    return API$F.put(`/${importUrl}/cancel-progress`);
   }
 };
-const API$D = createAxiosInstance({
+const API$E = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/assignment/v2"
 });
 const AssignmentServices$1 = {
   getPreListData: (params) => {
-    return API$D.get("/prelist", { params });
+    return API$E.get("/prelist", { params });
   },
   getPreListOptions: (params) => {
-    return API$D.get("/prelist/options", { params });
+    return API$E.get("/prelist/options", { params });
   },
   getRequestData: (params) => {
-    return API$D.get("/prelist/request", { params });
+    return API$E.get("/prelist/request", { params });
   },
   postAddPrelistData: (body) => {
-    return API$D.post("/prelist", body);
+    return API$E.post("/prelist", body);
   },
   getDetailRequestData: (id, params) => {
-    return API$D.get(`/transaction/${id}/request`, { params });
+    return API$E.get(`/transaction/${id}/request`, { params });
   },
   getDetailRequestOption: (params, id) => {
-    return API$D.get(`/transaction/${id}/request/options`, { params });
+    return API$E.get(`/transaction/${id}/request/options`, { params });
   },
   getTransactionData: (params) => {
-    return API$D.get("/transaction", { params });
+    return API$E.get("/transaction", { params });
   },
   getTransactionOptions: (params) => {
-    return API$D.get("/transaction/options", { params });
+    return API$E.get("/transaction/options", { params });
   },
   getDetailTransactionData: (id) => {
-    return API$D.get(`/transaction/${id}`);
+    return API$E.get(`/transaction/${id}`);
   },
   getTransactionApproval: (params) => {
-    return API$D.get("/approval", { params });
+    return API$E.get("/approval", { params });
   },
   getApprovalData: (transactionId, params) => {
-    return API$D.get(`/approval/transaction/${transactionId}`, { params });
+    return API$E.get(`/approval/transaction/${transactionId}`, { params });
   },
   getTransactionApprovalOptions: (params) => {
-    return API$D.get("/approval/options", { params });
+    return API$E.get("/approval/options", { params });
   },
   getApprovalOptions: (transactionId, params) => {
-    return API$D.get(`/approval/transaction/${transactionId}/options`, {
+    return API$E.get(`/approval/transaction/${transactionId}/options`, {
       params
     });
   },
   getTransactionApprovers: (id) => {
-    return API$D.get(`/approval/transaction/${id}/transaction`);
+    return API$E.get(`/approval/transaction/${id}/transaction`);
   },
   putApproveApproval: (body) => {
-    return API$D.put("/approval/approve", body);
+    return API$E.put("/approval/approve", body);
   },
   getDetailTransactionLog: (id) => {
-    return API$D.get(`/transaction/request/${id}/transaction-log`);
+    return API$E.get(`/transaction/request/${id}/transaction-log`);
   },
   getVerifyAsset: (params, id) => {
-    return API$D.get(`/transaction/${id}/request/scan`, { params });
+    return API$E.get(`/transaction/${id}/request/scan`, { params });
   },
   putEditAssignedUser: (id, body) => {
-    return API$D.put(`/transaction/${id}/user`, body);
+    return API$E.put(`/transaction/${id}/user`, body);
   },
   putEditEmailConfirmation: (id, body) => {
-    return API$D.put(`/transaction/${id}/update-email-or-assigned-user`, body);
+    return API$E.put(`/transaction/${id}/update-email-or-assigned-user`, body);
   },
   postSendConfirmationEmail: (id) => {
-    return API$D.post(`/transaction/${id}/send-confirmation-email`);
+    return API$E.post(`/transaction/${id}/send-confirmation-email`);
   },
   postTransaction: (body) => {
-    return API$D.post("/transaction", body);
+    return API$E.post("/transaction", body);
   },
   putTransactionRequest: (id, body) => {
-    return API$D.put(`/transaction/${id}/request`, body);
+    return API$E.put(`/transaction/${id}/request`, body);
   },
   putCancelTransaction: (body) => {
-    return API$D.put("/transaction/cancel", body);
+    return API$E.put("/transaction/cancel", body);
   },
   putCancelAssignmentRequest: (body) => {
-    return API$D.put("/transaction/request/cancel", body);
+    return API$E.put("/transaction/request/cancel", body);
   },
   putVerifyRequest: (body, id) => {
-    return API$D.put(`/transaction/${id}/verify-requests`, body);
+    return API$E.put(`/transaction/${id}/verify-requests`, body);
   },
   putVerifyToken: (body) => {
-    return API$D.put("/transaction/verify-token", body);
+    return API$E.put("/transaction/verify-token", body);
   },
   putHandoverConfirm: (body) => {
-    return API$D.put("/transaction/handover-confirmation", body);
+    return API$E.put("/transaction/handover-confirmation", body);
   },
   putAssignHandover: (transaction) => {
-    return API$D.put(`/transaction/${transaction}/handover`);
+    return API$E.put(`/transaction/${transaction}/handover`);
   },
   deletePrelistData: (params) => {
-    return API$D.delete("/prelist", { params });
+    return API$E.delete("/prelist", { params });
   },
   deleteRequestPrelistData: (body) => {
-    return API$D.delete("/prelist/request", { data: body });
+    return API$E.delete("/prelist/request", { data: body });
   },
   getAssignedByAsset: (params) => {
-    return API$D.get("/transaction/request/assigned/by-asset", { params });
+    return API$E.get("/transaction/request/assigned/by-asset", { params });
   },
   getAssignedByAssetOptions: (params) => {
-    return API$D.get("/transaction/request/assigned/by-asset/options", {
+    return API$E.get("/transaction/request/assigned/by-asset/options", {
       params
     });
   },
   getAssignedByUser: (params) => {
-    return API$D.get("/transaction/request/assigned/by-user", { params });
+    return API$E.get("/transaction/request/assigned/by-user", { params });
   },
   getAssignedByUserOptions: (params) => {
-    return API$D.get("/transaction/request/assigned/by-user/options", { params });
+    return API$E.get("/transaction/request/assigned/by-user/options", { params });
   },
   postUnassignPrelistAsset: (body) => {
-    return API$D.post("/prelist", body);
+    return API$E.post("/prelist", body);
   },
   postUnassignPrelistUser: (body) => {
-    return API$D.post("/prelist/unassign/by-user", body);
+    return API$E.post("/prelist/unassign/by-user", body);
   },
   putUnassignRequest: (body) => {
-    return API$D.put("/transaction/request/unassign", body);
+    return API$E.put("/transaction/request/unassign", body);
   },
   putReportDone: (id, body) => {
-    return API$D.put(`/transaction/${id}/confirm-report-done`, body);
+    return API$E.put(`/transaction/${id}/confirm-report-done`, body);
   },
   getHistory: (type, params) => {
     const urlType = type.split(" ").join("-").toLowerCase();
-    return API$D.get(`/transaction/history/${urlType}`, { params });
+    return API$E.get(`/transaction/history/${urlType}`, { params });
   },
   getHistoryOptions: (params) => {
-    return API$D.get("/transaction/history/options", { params });
+    return API$E.get("/transaction/history/options", { params });
   },
   getHistoryByTransactionOptions: (params) => {
-    return API$D.get("/transaction/history/by-transaction/options", { params });
+    return API$E.get("/transaction/history/by-transaction/options", { params });
   },
   putCancelReport: (body) => {
-    return API$D.put("/transaction/request/cancel-report", body);
+    return API$E.put("/transaction/request/cancel-report", body);
   },
   getTaskAssignment: async (params) => {
-    return API$D.get("/transaction/my-asset/task", { params });
+    return API$E.get("/transaction/my-asset/task", { params });
   },
   getTaskAssignmentOptions: async (params) => {
-    return API$D.get("/transaction/my-asset/task/options", { params });
+    return API$E.get("/transaction/my-asset/task/options", { params });
   },
   getAssignedAsset: async (params) => {
-    return API$D.get("/transaction/my-asset/assigned-asset", { params });
+    return API$E.get("/transaction/my-asset/assigned-asset", { params });
   },
   getAssignedAssetOptions: async (params) => {
-    return API$D.get("/transaction/my-asset/assigned-asset/options", { params });
+    return API$E.get("/transaction/my-asset/assigned-asset/options", { params });
   },
   putCancelAssignment: async (body) => {
-    return API$D.put("/transaction/cancel", { id: body.id });
+    return API$E.put("/transaction/cancel", { id: body.id });
   },
   putCancelReportById: async (body) => {
-    return API$D.put(`/transaction/request/${body.id}/cancel-report`);
+    return API$E.put(`/transaction/request/${body.id}/cancel-report`);
   }
 };
-const API$C = createAxiosInstance({
+const API$D = createAxiosInstance({
   prefix: "/assignment/v2"
 });
 const AssignmentServices = {
   ...AssignmentServices$1,
   // Temporary inclusion of methods from OldAssignmentServices. Move individual methods here once they are refactored and ready.
   getTransactionData: (params) => {
-    return API$C.get("/transaction", { params });
+    return API$D.get("/transaction", { params });
   },
   getTransactionOptions: (params) => {
-    return API$C.get("/transaction/options", { params });
+    return API$D.get("/transaction/options", { params });
   },
   getDetailTransactionLog: (id) => {
-    return API$C.get(`/transaction/request/${id}/transaction-log`);
+    return API$D.get(`/transaction/request/${id}/transaction-log`);
   },
   postTransaction: (body) => {
-    return API$C.post("/transaction", body);
+    return API$D.post("/transaction", body);
   },
   putTransaction: (body) => {
-    return API$C.put("/transaction", body);
+    return API$D.put("/transaction", body);
   },
   putUnassignTransaction: (body) => {
-    return API$C.put("/transaction/unassign", body);
+    return API$D.put("/transaction/unassign", body);
   },
   putCancelReport: (body) => {
-    return API$C.put("/transaction/request/cancel-report", body);
+    return API$D.put("/transaction/request/cancel-report", body);
   }
 };
-const API$B = createAxiosInstance({
+const API$C = createAxiosInstance({
   prefix: "/license/v2"
 });
 const TotalLicenseServices = {
   getTotalLicense: () => {
-    return API$B.get("/total-license");
+    return API$C.get("/total-license");
   },
   getPurchasedData: (params) => {
-    return API$B.get("/purchase", { params });
+    return API$C.get("/purchase", { params });
   }
 };
 const LicenseConcurrentServices = {
   getConcurrentUserData: () => {
-    return API$B.get("/concurrent-user-data");
+    return API$C.get("/concurrent-user-data");
   },
   getConcurrentUserList: (params) => {
-    return API$B.get("/concurrent-user", { params });
+    return API$C.get("/concurrent-user", { params });
   },
   putLogoutUsers: (body) => {
-    return API$B.put("/concurrent-user", body);
+    return API$C.put("/concurrent-user", body);
   }
 };
 const LicenseAssetServices = {
   getFixedAssetPerGroup: (groupId, params) => {
-    return API$B.get(`/${groupId}/assets`, { params });
+    return API$C.get(`/${groupId}/assets`, { params });
   },
   deleteAssetData: (params) => {
-    return API$B.delete("/assets", { params });
+    return API$C.delete("/assets", { params });
   }
 };
 const LicenseServices = {
   getFilterOptions: (path, params) => {
-    return API$B.get(`/${path}`, { params });
+    return API$C.get(`/${path}`, { params });
   },
   ...TotalLicenseServices,
   ...LicenseConcurrentServices,
   ...LicenseAssetServices
 };
-const API$A = createAxiosInstance({
+const API$B = createAxiosInstance({
   prefix: "/damage-repair-ticketing/v2"
 });
 const DamageServices = {
   getDamageReportList: (params) => {
-    return API$A.get("/", { params });
+    return API$B.get("/", { params });
   },
   getDamageReportListFilterOptions: (params) => {
-    return API$A.get("/options", { params });
+    return API$B.get("/options", { params });
   },
   getDamageReportDetail: (reportId) => {
-    return API$A.get(`/${reportId}`);
+    return API$B.get(`/${reportId}`);
   },
   putReportDamage: (id, body) => {
     const headers = { "Content-Type": "multipart/form-data" };
-    return API$A.put(`/${id}/report-damage`, body, { headers });
+    return API$B.put(`/${id}/report-damage`, body, { headers });
   },
   putMarkAsRepaired: (body) => {
-    return API$A.put("/repair", body);
+    return API$B.put("/repair", body);
   }
 };
-const API$z = createAxiosInstance({
+const API$A = createAxiosInstance({
   prefix: "/assets/v2/my-assets"
 });
 const MyAssetServices = {
   getAssigned: async (params) => {
-    return API$z.get("/assigned", { params });
+    return API$A.get("/assigned", { params });
   },
   getAssignedOptions: async (params) => {
-    return API$z.get("/assigned/options", { params });
+    return API$A.get("/assigned/options", { params });
   },
   getBorrowed: async (params) => {
-    return API$z.get("/borrowed", { params });
+    return API$A.get("/borrowed", { params });
   },
   getBorrowedOptions: async (params) => {
-    return API$z.get("/borrowed/options", { params });
+    return API$A.get("/borrowed/options", { params });
   },
   getHistory: async (params) => {
-    return API$z.get("/history", { params });
+    return API$A.get("/history", { params });
   },
   getHistoryOptions: async (params) => {
-    return API$z.get("/history/options", { params });
+    return API$A.get("/history/options", { params });
   }
 };
 const PREFIX = "/transfer/v2";
@@ -1005,322 +1005,322 @@ const TransferServices = {
     return ApprovalAPI$1.put("/approve", body);
   }
 };
-const API$y = createAxiosInstance({
+const API$z = createAxiosInstance({
   prefix: "/transfer/v2"
 });
 const TransferServicesGo = {
   ...TransferServices,
   getTransactionData: (params) => {
-    return API$y.get("/transaction", { params });
+    return API$z.get("/transaction", { params });
   },
   getTransactionOptions: (params) => {
-    return API$y.get("/transaction/options", { params });
+    return API$z.get("/transaction/options", { params });
   },
   getTransactionLog: (id) => {
-    return API$y.get(`/transaction/request/${id}/transaction-log`);
+    return API$z.get(`/transaction/request/${id}/transaction-log`);
   },
   postCreateTransaction: (body) => {
-    return API$y.post("/transaction", body);
+    return API$z.post("/transaction", body);
   }
 };
-const API$x = createAxiosInstance({
+const API$y = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/borrowing/v2"
 });
 const BorrowServices = {
   getTaskBorrowing: async (params) => {
-    return API$x.get("/transaction/my-asset/task", { params });
+    return API$y.get("/transaction/my-asset/task", { params });
   },
   getTaskBorrowingOptions: async (params) => {
-    return API$x.get("/transaction/my-asset/task/options", { params });
+    return API$y.get("/transaction/my-asset/task/options", { params });
   },
   getBorrowedAsset: async (params) => {
-    return API$x.get("/transaction/my-asset/borrowed-asset", { params });
+    return API$y.get("/transaction/my-asset/borrowed-asset", { params });
   },
   getBorrowedOptions: async (params) => {
-    return API$x.get("/transaction/my-asset/borrowed-asset/options", { params });
+    return API$y.get("/transaction/my-asset/borrowed-asset/options", { params });
   },
   getHistory: async (params) => {
-    return API$x.get("/transaction/my-asset/history", { params });
+    return API$y.get("/transaction/my-asset/history", { params });
   },
   getHistoryOptions: async (params) => {
-    return API$x.get("/transaction/my-asset/history/options", { params });
+    return API$y.get("/transaction/my-asset/history/options", { params });
   },
   postAddPrelistData: (body) => {
-    return API$x.post("/prelist", body);
+    return API$y.post("/prelist", body);
   },
   putCancelBorrowing: async (body) => {
-    return API$x.put("/transaction/cancel", { id: body.id });
+    return API$y.put("/transaction/cancel", { id: body.id });
   },
   putCancelExtensionRequest: async (body) => {
-    return API$x.put(`/transaction/${body.id}/cancel-extension`);
+    return API$y.put(`/transaction/${body.id}/cancel-extension`);
   },
   putCancelRequestReport: async (body) => {
-    return API$x.put(`/transaction/request/${body.id}/cancel-report`);
+    return API$y.put(`/transaction/request/${body.id}/cancel-report`);
   },
   putDeclineExtensionRequest: async (body) => {
-    return API$x.put("transaction/request/decline", body);
+    return API$y.put("transaction/request/decline", body);
   },
   putUpdateRequestExtension: async (body) => {
-    return API$x.put("transaction/request/duration", body);
+    return API$y.put("transaction/request/duration", body);
   },
   // ------------------------------------------------------------------------------------------------------------ //
   getBorrowingPrelist: (params) => {
-    return API$x.get("/prelist", { params });
+    return API$y.get("/prelist", { params });
   },
   getBorrowingPrelistOptions: (params) => {
-    return API$x.get("/prelist/options", { params });
+    return API$y.get("/prelist/options", { params });
   },
   deleteBorrowingPrelist: (id) => {
-    return API$x.delete("/prelist", { data: { id } });
+    return API$y.delete("/prelist", { data: { id } });
   },
   getBorrowingRequest: (params) => {
-    return API$x.get("/prelist/request", { params });
+    return API$y.get("/prelist/request", { params });
   },
   getBorrowingRequestOptions: (params) => {
-    return API$x.get("/prelist/request/options", { params });
+    return API$y.get("/prelist/request/options", { params });
   },
   postBorrowingRequest: (data) => {
-    return API$x.post("/prelist/request", data);
+    return API$y.post("/prelist/request", data);
   },
   putBorrowingRequest: (data) => {
-    return API$x.put("/prelist/request", data);
+    return API$y.put("/prelist/request", data);
   },
   deleteBorrowingRequest: (id) => {
-    return API$x.delete("/prelist/request", { data: { id } });
+    return API$y.delete("/prelist/request", { data: { id } });
   },
   postBorrowingTransaction: (data) => {
-    return API$x.post("/transaction", data, { params: { sourceWeb: true } });
+    return API$y.post("/transaction", data, { params: { sourceWeb: true } });
   },
   getBorrowingTransaction: (params) => {
-    return API$x.get("/transaction", { params });
+    return API$y.get("/transaction", { params });
   },
   getBorrowingTransactionOptions: (params) => {
-    return API$x.get("/transaction/options", { params });
+    return API$y.get("/transaction/options", { params });
   },
   putCancelBorrowingTransaction: (id) => {
-    return API$x.put("/transaction/cancel", { id });
+    return API$y.put("/transaction/cancel", { id });
   },
   putCancelBorrowingRequest: (id) => {
-    return API$x.put("/transaction/request/cancel", { id });
+    return API$y.put("/transaction/request/cancel", { id });
   },
   putCancelExtendBorrowingRequest: (id) => {
-    return API$x.put("/transaction/request/extend/cancel", { id });
+    return API$y.put("/transaction/request/extend/cancel", { id });
   },
   getBorrowingTransactionDetail: (id) => {
-    return API$x.get(`/transaction/${id}`);
+    return API$y.get(`/transaction/${id}`);
   },
   getBorrowingTransactionRequestList: (params) => {
-    return API$x.get("/transaction/request", { params });
+    return API$y.get("/transaction/request", { params });
   },
   getBorrowingTransactionRequest: (id, params) => {
-    return API$x.get(`/transaction/${id}/request`, { params });
+    return API$y.get(`/transaction/${id}/request`, { params });
   },
   getBorrowingTransactionRequestOptions: (id, params) => {
-    return API$x.get(`/transaction/${id}/request/options`, { params });
+    return API$y.get(`/transaction/${id}/request/options`, { params });
   },
   putBorrowingTransactionRequest: (id, data) => {
-    return API$x.put(`/transaction/${id}/request`, data);
+    return API$y.put(`/transaction/${id}/request`, data);
   },
   getApprovalList: (id) => {
-    return API$x.get(`/approval/transaction/${id}/transaction`);
+    return API$y.get(`/approval/transaction/${id}/transaction`);
   },
   putUpdateEmailorBorrower: (id, data) => {
-    return API$x.put(`/transaction/${id}/update-email-or-borrower`, data);
+    return API$y.put(`/transaction/${id}/update-email-or-borrower`, data);
   },
   getTransactionRequestScan: (id, tag) => {
-    return API$x.get(`/transaction/${id}/request/scan`, { params: { tag } });
+    return API$y.get(`/transaction/${id}/request/scan`, { params: { tag } });
   },
   putUpdateBorrower: (id, userId) => {
-    return API$x.put(`/transaction/${id}/user`, { user: userId });
+    return API$y.put(`/transaction/${id}/user`, { user: userId });
   },
   postSendConfirmationEmail: (id) => {
-    return API$x.post(`/transaction/${id}/send-confirmation-email`);
+    return API$y.post(`/transaction/${id}/send-confirmation-email`);
   },
   putVerifyRequests: (id, data) => {
-    return API$x.put(`/transaction/${id}/verify-requests`, data);
+    return API$y.put(`/transaction/${id}/verify-requests`, data);
   },
   getBorrowingTransactionHistoryByTransaction: (params) => {
-    return API$x.get("/transaction/history/by-transaction", { params });
+    return API$y.get("/transaction/history/by-transaction", { params });
   },
   getBorrowingTransactionHistoryByAsset: (params) => {
-    return API$x.get("/transaction/history/by-asset", { params });
+    return API$y.get("/transaction/history/by-asset", { params });
   },
   getBorrowingTransactionHistoryOptions: (params) => {
-    return API$x.get("/transaction/history/options", { params });
+    return API$y.get("/transaction/history/options", { params });
   },
   putBorrowingVerifyToken: (token) => {
-    return API$x.put("/transaction/verify-token", { token });
+    return API$y.put("/transaction/verify-token", { token });
   },
   putBorrowingHandoverConfirmation: (data) => {
-    return API$x.put("/transaction/handover-confirmation", data);
+    return API$y.put("/transaction/handover-confirmation", data);
   },
   putBorrowingHandover: (id) => {
-    return API$x.put(`/transaction/${id}/handover`);
+    return API$y.put(`/transaction/${id}/handover`);
   },
   putBorrowingExtendRequest: (data) => {
-    return API$x.put("/transaction/request/extend", data);
+    return API$y.put("/transaction/request/extend", data);
   },
   putBorrowingExtendApproval: (data) => {
-    return API$x.put("/approval/approve/request-extension", data, {
+    return API$y.put("/approval/approve/request-extension", data, {
       params: { sourceWeb: true }
     });
   },
   putBorrowingDeclineExtendRequest: (id) => {
-    return API$x.put("/transaction/request/decline", { id });
+    return API$y.put("/transaction/request/decline", { id });
   },
   getBorrowingBorrowedAsset: (params) => {
-    return API$x.get("/transaction/request/borrowed/by-asset", { params });
+    return API$y.get("/transaction/request/borrowed/by-asset", { params });
   },
   getBorrowingBorrowedAssetOptions: (params) => {
-    return API$x.get("/transaction/request/borrowed/by-asset/options", {
+    return API$y.get("/transaction/request/borrowed/by-asset/options", {
       params
     });
   },
   getBorrowingBorrowedBorrower: (params) => {
-    return API$x.get("/transaction/request/borrowed/by-user", { params });
+    return API$y.get("/transaction/request/borrowed/by-user", { params });
   },
   putBorrowingReportDamaged: (id, data) => {
-    return API$x.put(`/transaction/request/${id}/damaged`, data);
+    return API$y.put(`/transaction/request/${id}/damaged`, data);
   },
   putBorrowingReportMissing: (id, data) => {
-    return API$x.put(`/transaction/request/${id}/missing`, data);
+    return API$y.put(`/transaction/request/${id}/missing`, data);
   },
   putBorrowingReturn: (id) => {
-    return API$x.put("/transaction/request/return", { id });
+    return API$y.put("/transaction/request/return", { id });
   },
   getBorrowingLog: (id) => {
-    return API$x.get(`/transaction/request/${id}/transaction-log`);
+    return API$y.get(`/transaction/request/${id}/transaction-log`);
   },
   putConfirmReportDone: (id, data) => {
-    return API$x.put(`/transaction/request/${id}/confirm-report-done`, data);
+    return API$y.put(`/transaction/request/${id}/confirm-report-done`, data);
   },
   putCancelReportBulk: (id) => {
-    return API$x.put("/transaction/request/cancel-report", {
+    return API$y.put("/transaction/request/cancel-report", {
       id
     });
   },
   putBorrowingEditExtension: (data) => {
-    return API$x.put("/transaction/request/duration", data);
+    return API$y.put("/transaction/request/duration", data);
   },
   getApproval: (params) => {
-    return API$x.get("/approval", { params });
+    return API$y.get("/approval", { params });
   },
   getApprovalOptions: (params) => {
-    return API$x.get("/approval/options", { params });
+    return API$y.get("/approval/options", { params });
   },
   getApprovalTransactionRequest: (id, params) => {
-    return API$x.get(`/approval/transaction/${id}`, { params });
+    return API$y.get(`/approval/transaction/${id}`, { params });
   },
   getApprovalTransactionRequestOptions: (id, params) => {
-    return API$x.get(`/approval/transaction/${id}/options`, { params });
+    return API$y.get(`/approval/transaction/${id}/options`, { params });
   },
   putApprovalApprove: (data) => {
-    return API$x.put("/approval/approve", data, {
+    return API$y.put("/approval/approve", data, {
       params: { sourceWeb: true }
     });
   }
 };
-const API$w = createAxiosInstance({
+const API$x = createAxiosInstance({
   prefix: "/borrowing/v2"
 });
 const BorrowServicesGo = {
   ...BorrowServices,
   // Temporary inclusion of methods from OldBorrowServices. Move individual methods here once they are refactored and ready.
   getTransactions: async (params) => {
-    return API$w.get("/transaction", { params });
+    return API$x.get("/transaction", { params });
   },
   getTransactionOptions: async (params) => {
-    return API$w.get("/transaction/options", { params });
+    return API$x.get("/transaction/options", { params });
   },
   getTransactionLog: async (id) => {
-    return API$w.get(`/transaction/request/${id}/transaction-log`);
+    return API$x.get(`/transaction/request/${id}/transaction-log`);
   },
   postTransaction: async (body) => {
-    return API$w.post("/transaction", body);
+    return API$x.post("/transaction", body);
   },
   putTransaction: async (body) => {
-    return API$w.put("/transaction", body);
+    return API$x.put("/transaction", body);
   },
   putTransactionReturn: async (requestIds) => {
     const body = { id: requestIds };
-    return API$w.put("/transaction/return", body);
+    return API$x.put("/transaction/return", body);
   },
   putCancelReport: async (requestIds) => {
     const body = { id: requestIds };
-    return API$w.put("/transaction/request/cancel-report", body);
+    return API$x.put("/transaction/request/cancel-report", body);
   }
 };
-const API$v = createAxiosInstance({
+const API$w = createAxiosInstance({
   prefix: "/disposal/v2/"
 });
 const DisposalServices$1 = {
   getReportedDisposal: (params) => {
-    return API$v.get("/report", { params });
+    return API$w.get("/report", { params });
   },
   getReportedDisposalOptions: (params) => {
-    return API$v.get("/report/options", { params });
+    return API$w.get("/report/options", { params });
   },
   postReportDisposal: (body) => {
-    return API$v.post("/report", body);
+    return API$w.post("/report", body);
   },
   deleteCancelReport: (params) => {
     params.isFromDisposal = "false";
-    return API$v.delete("/report/cancel-report", { params });
+    return API$w.delete("/report/cancel-report", { params });
   },
   deleteDeclineReport: (params) => {
     params.isFromDisposal = "true";
-    return API$v.delete("/report/cancel-report", { params });
+    return API$w.delete("/report/cancel-report", { params });
   },
   getDisposalHistory: (params) => {
-    return API$v.get("/transaction", { params });
+    return API$w.get("/transaction", { params });
   },
   getHistoryByAssetOptions: (params) => {
-    return API$v.get("/transaction/options", { params });
+    return API$w.get("/transaction/options", { params });
   },
   getDisposalTransactionLog: (requestId) => {
-    return API$v.get(`/transaction/request/${requestId}/transaction-log`);
+    return API$w.get(`/transaction/request/${requestId}/transaction-log`);
   },
   postCreateTransaction: (body) => {
-    return API$v.post("/transaction", body);
+    return API$w.post("/transaction", body);
   }
 };
-const API$u = createAxiosInstance({
+const API$v = createAxiosInstance({
   prefix: "/report/v2/reports"
 });
 const ReportServices = {
   getReportList: (params) => {
-    return API$u.get("/schedules", { params });
+    return API$v.get("/schedules", { params });
   },
   getReportSchedule: (scheduleId) => {
-    return API$u.get("/schedules/" + scheduleId);
+    return API$v.get("/schedules/" + scheduleId);
   },
   getUniqueScheduleName: (name) => {
-    return API$u.get("/schedules/unique-name", { params: { name } });
+    return API$v.get("/schedules/unique-name", { params: { name } });
   },
   getFilterOptions: (params) => {
-    return API$u.get("/schedules/options", { params });
+    return API$v.get("/schedules/options", { params });
   },
   putSetActive: (body) => {
-    return API$u.put("/schedules/set-active", body);
+    return API$v.put("/schedules/set-active", body);
   },
   putEditSchedule: (id, body) => {
-    return API$u.put(`/schedules/${id}`, body);
+    return API$v.put(`/schedules/${id}`, body);
   },
   deleteReports: (id) => {
-    return API$u.delete("/schedules", { params: { id } });
+    return API$v.delete("/schedules", { params: { id } });
   },
   postCreateSchedule: (data) => {
-    return API$u.post("/schedules", data);
+    return API$v.post("/schedules", data);
   },
   postDownloadReport: (data) => {
-    return API$u.post("/download", data, { responseType: "arraybuffer" });
+    return API$v.post("/download", data, { responseType: "arraybuffer" });
   },
   postGenerateReport: (data) => {
-    return API$u.post("/generate", data);
+    return API$v.post("/generate", data);
   }
 };
-const API$t = createAxiosInstance({
+const API$u = createAxiosInstance({
   prefix: "/settings-attribute/v2"
 });
 const getEndpoint = (type) => {
@@ -1328,111 +1328,111 @@ const getEndpoint = (type) => {
 };
 const GroupCategoryServices = {
   getGroupCategory: (type, params) => {
-    return API$t.get(`/${getEndpoint(type)}/tree`, { params });
+    return API$u.get(`/${getEndpoint(type)}/tree`, { params });
   },
   getCategoryTree: () => {
-    return API$t.get("/category/tree");
+    return API$u.get("/category/tree");
   },
   getGroupTree: (params) => {
-    return API$t.get("/groups/tree", { params });
+    return API$u.get("/groups/tree", { params });
   },
   // Doesn't exist in company plan other than "Basic"
   getGroupCategoryList: (type, groupId, params) => {
-    return API$t.get(`/${getEndpoint(type)}/${groupId}`, { params });
+    return API$u.get(`/${getEndpoint(type)}/${groupId}`, { params });
   },
   getNames: (type) => {
-    return API$t.get(`/${getEndpoint(type)}/names`);
+    return API$u.get(`/${getEndpoint(type)}/names`);
   },
   getCodes: (type) => {
-    return API$t.get(`/${getEndpoint(type)}/codes`);
+    return API$u.get(`/${getEndpoint(type)}/codes`);
   },
   postCreateGroupCategory: (type, body) => {
-    return API$t.post(`/${getEndpoint(type)}`, body);
+    return API$u.post(`/${getEndpoint(type)}`, body);
   },
   putEditGroupCategory: (type, body, objectId) => {
-    return API$t.put(`/${getEndpoint(type)}/${objectId}`, body);
+    return API$u.put(`/${getEndpoint(type)}/${objectId}`, body);
   },
   // Doesn't exist in company plan other than "Enterprise"
   putMoveGroup: (body, objectId) => {
-    return API$t.put(`/groups/${objectId}/move-group`, body);
+    return API$u.put(`/groups/${objectId}/move-group`, body);
   },
   // Doesn't exist in company plan other than "Enterprise"
   putEditBulkGroups: async (body) => {
-    return API$t.put("/groups/bulk", body);
+    return API$u.put("/groups/bulk", body);
   },
   deleteGroupCategory: (type, body, objectId) => {
-    return API$t.delete(`/${getEndpoint(type)}/${objectId}`, { data: body });
+    return API$u.delete(`/${getEndpoint(type)}/${objectId}`, { data: body });
   }
 };
-const API$s = createAxiosInstance({
+const API$t = createAxiosInstance({
   prefix: "/settings-attribute/v2/alias-code"
 });
 const AliasCodeServices = {
   getAliasCode: () => {
-    return API$s.get("/");
+    return API$t.get("/");
   },
   postAliasCode: (data) => {
-    return API$s.post("/", data);
+    return API$t.post("/", data);
   },
   getAliasCodeList: (params) => {
-    return API$s.get(`/${params.object}/code-list`, { params });
+    return API$t.get(`/${params.object}/code-list`, { params });
   }
 };
-const API$r = createAxiosInstance({
+const API$s = createAxiosInstance({
   prefix: "/settings-attribute/v2/general-settings"
 });
 const GeneralSettingsServices = {
   getGeneralSettings: () => {
-    return API$r.get("/");
+    return API$s.get("/");
   },
   putUpdateGeneralSettings: (data) => {
-    return API$r.put("/", data);
+    return API$s.put("/", data);
   }
 };
-const API$q = createAxiosInstance({
+const API$r = createAxiosInstance({
   prefix: "/settings-attribute/v2/custom-field"
 });
 const CustomFieldServices = {
   getCustomField: async (params) => {
-    return API$q.get("/", { params });
+    return API$r.get("/", { params });
   },
   getCustomFieldsByCategory: (category, params) => {
-    return API$q.get(`/${category}`, { params });
+    return API$r.get(`/${category}`, { params });
   },
   getOptions: async (params) => {
-    return API$q.get("/options", { params });
+    return API$r.get("/options", { params });
   },
   postCreateCustomField: async (params, data) => {
-    return API$q.post("/", data, { params });
+    return API$r.post("/", data, { params });
   },
   putEditCustomField: async (params, data, id) => {
-    return API$q.put(`/${id}`, data, { params });
+    return API$r.put(`/${id}`, data, { params });
   },
   putChangeStatus: async (params, data) => {
-    return API$q.put("/bulk", data, { params });
+    return API$r.put("/bulk", data, { params });
   },
   deleteCustomField: async (params) => {
-    return API$q.delete("/bulk", { params });
+    return API$r.delete("/bulk", { params });
   },
   getUsedCustomFields: async () => {
-    return API$q.get("/used-by-assets");
+    return API$r.get("/used-by-assets");
   }
 };
-const API$p = createAxiosInstance({
+const API$q = createAxiosInstance({
   prefix: "/settings-attribute/v2/asset-name-policy"
 });
 const AssetPolicyServices = {
   getList: (params) => {
-    return API$p.get("/", { params });
+    return API$q.get("/", { params });
   },
   getListFilterOptions: (params) => {
-    return API$p.get("/options");
+    return API$q.get("/options");
   },
   putUpdatePolicy: (body) => {
-    return API$p.put("/", body);
+    return API$q.put("/", body);
   }
 };
-const API$o = createAxiosInstance({
+const API$p = createAxiosInstance({
   prefix: "/settings-user-role/v2/auth"
 });
 const onRejected$1 = (error) => {
@@ -1447,10 +1447,10 @@ const onRejected$1 = (error) => {
 };
 const AuthServices$1 = {
   reLogin: (body) => {
-    API$o.interceptors.response.use((response) => {
+    API$p.interceptors.response.use((response) => {
       return response;
     }, onRejected$1);
-    return API$o.post("/login", body);
+    return API$p.post("/login", body);
   }
 };
 const DepreciationMethodAPI = createAxiosInstance({
@@ -1516,31 +1516,31 @@ const AccountingServices = {
     return AccountCodeAPI.put("/account-code/" + id, body);
   }
 };
-const API$n = createAxiosInstance({
+const API$o = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/settings-attribute/v2/asset-name"
 });
 const AssetNameServices = {
   getDropdown: (params) => {
-    return API$n.get("/dropdown", { params });
+    return API$o.get("/dropdown", { params });
   },
   getAssetNameDetail: (id) => {
-    return API$n.get(`/${id}`);
+    return API$o.get(`/${id}`);
   },
   getAssetsByAssetName: (id, params) => {
-    return API$n.get(`/${id}/list-asset`, { params });
+    return API$o.get(`/${id}/list-asset`, { params });
   },
   getAssetNameList: (params) => {
-    return API$n.get("/", { params });
+    return API$o.get("/", { params });
   },
   getUnpairedAssetName: (params) => {
-    return API$n.get("/unpaired", { params });
+    return API$o.get("/unpaired", { params });
   },
   getOptions: (params) => {
-    return API$n.get("/options", { params });
+    return API$o.get("/options", { params });
   }
 };
-const API$m = createAxiosInstance({
+const API$n = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/audit/v2"
 });
@@ -1550,100 +1550,100 @@ const API_IOT = createAxiosInstance({
 });
 const TaskServices = {
   getTaskList: (params) => {
-    return API$m.get("/audit/task", { params });
+    return API$n.get("/audit/task", { params });
   },
   getTaskHistory: (params) => {
-    return API$m.get("/audit/task/history", { params });
+    return API$n.get("/audit/task/history", { params });
   },
   extendAuditDuration: (body, id) => {
-    return API$m.put(`/audit/task/${id}/extend`, body);
+    return API$n.put(`/audit/task/${id}/extend`, body);
   },
   stopAudit: (id, body) => {
-    return API$m.put(`/audit/task/${id}/stop`, body);
+    return API$n.put(`/audit/task/${id}/stop`, body);
   },
   cancelAuditTask: (id) => {
-    return API$m.put(`/audit/task/${id}/cancel`);
+    return API$n.put(`/audit/task/${id}/cancel`);
   },
   getTaskDetail: (id) => {
-    return API$m.get(`/audit/task/${id}`);
+    return API$n.get(`/audit/task/${id}`);
   },
   getInAuditTask: (params) => {
-    return API$m.get("/audit/scheduled-asset/in-audit", { params });
+    return API$n.get("/audit/scheduled-asset/in-audit", { params });
   },
   getTaskDetailAssets: (params, taskId) => {
-    return API$m.get(`/audit/task/${taskId}/view-asset-detail`, { params });
+    return API$n.get(`/audit/task/${taskId}/view-asset-detail`, { params });
   },
   getAuditedTask: (params) => {
-    return API$m.get("/audit/scheduled-asset/audited", { params });
+    return API$n.get("/audit/scheduled-asset/audited", { params });
   },
   getAuditLog: (id) => {
-    return API$m.get(`/audit/scheduled-asset/${id}/log`);
+    return API$n.get(`/audit/scheduled-asset/${id}/log`);
   },
   getTaskEventLog: (params) => {
-    return API$m.get("/audit/task/task-event-log", { params });
+    return API$n.get("/audit/task/task-event-log", { params });
   },
   getTaskTimelineEventLog: (idTask) => {
-    return API$m.get(`/audit/task/${idTask}/event-log`);
+    return API$n.get(`/audit/task/${idTask}/event-log`);
   },
   scanAssetTAG: (body, idTask) => {
-    return API$m.put(`/audit/task/${idTask}/scan`, body);
+    return API$n.put(`/audit/task/${idTask}/scan`, body);
   },
   submitAssetCondition: (body, idAsset) => {
     const headers = body.picture ? { "Content-Type": "multipart/form-data" } : { "Content-Type": "application/json" };
-    return API$m.put(`/audit/scheduled-asset/${idAsset}/update/condition`, body, {
+    return API$n.put(`/audit/scheduled-asset/${idAsset}/update/condition`, body, {
       headers
     });
   },
   submitAuditedAsset: (idTask) => {
-    return API$m.put(`/audit/task/${idTask}/submit`);
+    return API$n.put(`/audit/task/${idTask}/submit`);
   },
   reportTAGMissing: (note, idAsset) => {
-    return API$m.put(`/audit/scheduled-asset/${idAsset}/report-missing`, {
+    return API$n.put(`/audit/scheduled-asset/${idAsset}/report-missing`, {
       note
     });
   },
   reportTAG: (id, body) => {
-    return API$m.put(`/audit/scheduled-asset/${id}/tag-reported`, body);
+    return API$n.put(`/audit/scheduled-asset/${id}/tag-reported`, body);
   },
   getTaskInitialState: (idTask) => {
-    return API$m.get(`/audit/scheduled-asset/${idTask}`);
+    return API$n.get(`/audit/scheduled-asset/${idTask}`);
   },
   cancelTaskReport: (scheduledAssetId) => {
-    return API$m.put(`/audit/scheduled-asset/${scheduledAssetId}/cancel-report`);
+    return API$n.put(`/audit/scheduled-asset/${scheduledAssetId}/cancel-report`);
   }
 };
 const ScheduleServices = {
   getScheduleList: (params) => {
-    return API$m.get("/audit/schedule", { params });
+    return API$n.get("/audit/schedule", { params });
   },
   getScheduleDetail: (id) => {
-    return API$m.get("/audit/schedule/" + id);
+    return API$n.get("/audit/schedule/" + id);
   },
   deleteSchedule: (scheduleId) => {
-    return API$m.put("/audit/schedule/bulk-delete", {
+    return API$n.put("/audit/schedule/bulk-delete", {
       id: scheduleId
     });
   },
   inactivateSchedule: (id) => {
-    return API$m.put("/audit/schedule/bulk-inactive", { id });
+    return API$n.put("/audit/schedule/bulk-inactive", { id });
   },
   activateSchedule: (id) => {
-    return API$m.put("/audit/schedule/bulk-active", { id });
+    return API$n.put("/audit/schedule/bulk-active", { id });
   },
   createNewSchedule: (body) => {
-    return API$m.post("/audit/schedule", body);
+    return API$n.post("/audit/schedule", body);
   },
   editSchedule: (body, id) => {
-    return API$m.put("/audit/schedule/" + id, body);
+    return API$n.put("/audit/schedule/" + id, body);
   },
   getActiveAsset: (id, params) => {
-    return API$m.get(`/audit/asset/schedule/${id}`, { params });
+    return API$n.get(`/audit/asset/schedule/${id}`, { params });
   },
   setAssetActivation: (body) => {
-    return API$m.put("/audit/asset/activation", body);
+    return API$n.put("/audit/asset/activation", body);
   },
   getAuditableAssetAmount: (params) => {
-    return API$m.get("/audit/asset/auditable/total-asset", { params });
+    return API$n.get("/audit/asset/auditable/total-asset", { params });
   }
 };
 const IOTAuditServices = {
@@ -1657,17 +1657,17 @@ const IOTAuditServices = {
     return API_IOT.put(`/iot/audit/${auditId}`, body);
   },
   getReaderTotalAsset: (taskId, params) => {
-    return API$m.get(`/audit/task/${taskId}/reader/total-assets`, {
+    return API$n.get(`/audit/task/${taskId}/reader/total-assets`, {
       params
     });
   },
   getAssetList: (params) => {
-    return API$m.get("/audit/scheduled-asset", { params });
+    return API$n.get("/audit/scheduled-asset", { params });
   }
 };
 const FilterServices = {
   getFilterOptions: (path, params) => {
-    return API$m.get(`/${path}/options`, { params });
+    return API$n.get(`/${path}/options`, { params });
   },
   getIOTFilterOptions: (path, params) => {
     return API_IOT.get(`/${path}/options`, { params });
@@ -1675,50 +1675,50 @@ const FilterServices = {
 };
 const AuditableAssetServices = {
   getAudiableAssetList: (params) => {
-    return API$m.get("/audit/asset/auditable", { params });
+    return API$n.get("/audit/asset/auditable", { params });
   },
   getAuditableAssetDetail: (id) => {
-    return API$m.get("/audit/asset/auditable/" + id);
+    return API$n.get("/audit/asset/auditable/" + id);
   }
 };
 const ApprovalServices = {
   getApprovalList: (idTask, approvalRound) => {
-    return API$m.get(`/audit/approval/task/${idTask}/transaction`, {
+    return API$n.get(`/audit/approval/task/${idTask}/transaction`, {
       params: {
         approvalRound
       }
     });
   },
   getActiveApprovalList: (params) => {
-    return API$m.get("/audit/approval/active", { params });
+    return API$n.get("/audit/approval/active", { params });
   },
   getHisotryApprovalList: (params) => {
-    return API$m.get("/audit/approval/history", { params });
+    return API$n.get("/audit/approval/history", { params });
   },
   getTaskDetail: (id) => {
-    return API$m.get(`/audit/task/${id}`);
+    return API$n.get(`/audit/task/${id}`);
   },
   getApprovalHistoryDetail: (idApproval) => {
-    return API$m.get(`/audit/approval/${idApproval}`);
+    return API$n.get(`/audit/approval/${idApproval}`);
   },
   getApprovalAssetList: (params) => {
-    return API$m.get("/audit/scheduled-asset/audited", { params });
+    return API$n.get("/audit/scheduled-asset/audited", { params });
   },
   submitApprovalAction: (body) => {
-    return API$m.put("/audit/approval/approve", body);
+    return API$n.put("/audit/approval/approve", body);
   }
 };
 const AuditServices = {
   getAudit: (assetId, params) => {
-    return API$m.get(`/audit/schedule/asset-detail/${assetId}`, { params });
+    return API$n.get(`/audit/schedule/asset-detail/${assetId}`, { params });
   },
   getAuditOption: (assetId, params) => {
-    return API$m.get(`/audit/schedule/asset-detail/${assetId}/options`, {
+    return API$n.get(`/audit/schedule/asset-detail/${assetId}/options`, {
       params
     });
   },
   putSetActive: (body) => {
-    return API$m.put("/audit/asset/activation", body);
+    return API$n.put("/audit/asset/activation", body);
   },
   ...TaskServices,
   ...ScheduleServices,
@@ -1727,16 +1727,16 @@ const AuditServices = {
   ...AuditableAssetServices,
   ...ApprovalServices
 };
-const API$l = createAxiosInstance({
+const API$m = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/settings-attribute/v2/brands"
 });
 const BrandServices = {
   getDropdown: (params) => {
-    return API$l.get("/dropdown", { params });
+    return API$m.get("/dropdown", { params });
   }
 };
-const API$k = ({ headers = {}, params = {} } = {}) => {
+const API$l = ({ headers = {}, params = {} } = {}) => {
   const BASE_URL = getBaseURL("APP_COUNTRY_STATE_API");
   const API_KEY = getBaseURL("APP_COUNTRY_STATE_API_KEY");
   const instance = axios.create({
@@ -1752,28 +1752,28 @@ const API$k = ({ headers = {}, params = {} } = {}) => {
 };
 const CountryStateServices = {
   getCountry: () => {
-    return API$k().get("/countries");
+    return API$l().get("/countries");
   },
   getState: (country) => {
-    return API$k().get(`/countries/${country}/states`);
+    return API$l().get(`/countries/${country}/states`);
   },
   getCity: (country, state) => {
-    return API$k().get(`/countries/${country}/states/${state}/cities`);
+    return API$l().get(`/countries/${country}/states/${state}/cities`);
   }
 };
-const API$j = createAxiosInstance({
+const API$k = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/dashboard/v2/dashboard"
 });
 const DashboardServices = {
   getLatestTask: (params) => {
-    return API$j.get("/latest-task", { params });
+    return API$k.get("/latest-task", { params });
   },
   getSummary: (params) => {
-    return API$j.get("/summary", { params });
+    return API$k.get("/summary", { params });
   }
 };
-const API$i = createAxiosInstance({
+const API$j = createAxiosInstance({
   env: "APP_GLOBAL_SETTINGS_API",
   prefix: "/v1/global-settings/auth"
 });
@@ -1790,37 +1790,37 @@ const onRejected = (error) => {
 const AuthServices = {
   login: (form) => {
     const body = { ...form, isMobile: false };
-    return API$i.post("/login", body);
+    return API$j.post("/login", body);
   },
   reLogin: (body) => {
-    API$i.interceptors.response.use((response) => {
+    API$j.interceptors.response.use((response) => {
       return response;
     }, onRejected);
-    return API$i.post("/login", body);
+    return API$j.post("/login", body);
   },
   requestOTP: (email) => {
     const body = { email };
-    return API$i.post("/request-otp", body);
+    return API$j.post("/request-otp", body);
   },
   requestResetPassLink: (email) => {
     const body = { email };
-    return API$i.post("/request-reset-link", body);
+    return API$j.post("/request-reset-link", body);
   },
   setPassword: (body) => {
-    return API$i.post("/set-password", body);
+    return API$j.post("/set-password", body);
   },
   verifyToken: (token) => {
-    return API$i.get(`/verify-token/${token}`);
+    return API$j.get(`/verify-token/${token}`);
   },
   confirmEmailChange: (token) => {
     const body = { token };
-    return API$i.put("/confirm-email-change/confirm", body);
+    return API$j.put("/confirm-email-change/confirm", body);
   },
   postLogout: () => {
-    return API$i.post("/logout");
+    return API$j.post("/logout");
   }
 };
-const API$h = createAxiosInstance({
+const API$i = createAxiosInstance({
   env: "APP_ADMIN_API",
   prefix: "/settings-attribute/languages"
 });
@@ -1831,7 +1831,7 @@ const I18nService = {
    * @returns A promise resolving to a key-value record of messages.
    */
   getMessages: (isoCode) => {
-    return API$h.get(`/${isoCode}/translations`);
+    return API$i.get(`/${isoCode}/translations`);
   },
   /**
    * Fetch all available lang options for LanguageDropdown and LanguageSwitcher
@@ -1839,7 +1839,7 @@ const I18nService = {
    * @returns Promise Array of options
    */
   getLanguageOptions: async () => {
-    const { data } = await API$h.get("/dropdown");
+    const { data } = await API$i.get("/dropdown");
     return data.data;
   },
   /**
@@ -1849,7 +1849,7 @@ const I18nService = {
    * @returns Promise LanguageMeta
    */
   getLanguageOptionMeta: async (isoCode) => {
-    const { data } = await API$h.get(
+    const { data } = await API$i.get(
       "/dropdown/" + isoCode
     );
     return data.data;
@@ -1861,29 +1861,29 @@ const I18nService = {
    * @param locale Target locale code.
    */
   translateText: async (key, locale) => {
-    const { data } = await API$h.post("/translate", {
+    const { data } = await API$i.post("/translate", {
       q: key,
       target: locale
     });
     return data.data.translations[key];
   }
 };
-const API$g = createAxiosInstance({
+const API$h = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/settings-attribute/v2/models"
 });
 const ModelTypeServices = {
   getDropdown: (params) => {
-    return API$g.get("/dropdown", { params });
+    return API$h.get("/dropdown", { params });
   }
 };
-const API$f = createAxiosInstance({
+const API$g = createAxiosInstance({
   prefix: "/v2",
   env: "APP_LOGS_NOTIFICATION_API"
 });
 const NotificationApprovalServices = {
   getTotalApprovals: () => {
-    return API$f.get("/approval/count");
+    return API$g.get("/approval/count");
   }
 };
 const ReaderAPI$1 = createAxiosInstance({
@@ -1963,305 +1963,305 @@ const ReaderServices = {
     return IOTReaderAPI$1.put(`/${id}`, body);
   }
 };
-const API$e = createAxiosInstance({
+const API$f = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/repair/v2"
 });
 const RepairServices = {
   getRepairList: (params) => {
-    return API$e.get("/my-asset/repair", { params });
+    return API$f.get("/my-asset/repair", { params });
   },
   getFilterOptions: (params) => {
-    return API$e.get("/my-asset/repair/options", { params });
+    return API$f.get("/my-asset/repair/options", { params });
   },
   getAssetRepairTicketing: (assetId, params) => {
-    return API$e.get(`/repair/${assetId}/asset-repair-detail`, { params });
+    return API$f.get(`/repair/${assetId}/asset-repair-detail`, { params });
   },
   putConfirmRepair: (repairId) => {
-    return API$e.put(`/repair/${repairId}/confirm-repair`);
+    return API$f.put(`/repair/${repairId}/confirm-repair`);
   }
 };
-const API$d = createAxiosInstance({
+const API$e = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/routine/v2"
 });
 const RoutineServices = {
   getMaintenance: (assetId, params) => {
-    return API$d.get(`/routine-task/${assetId}`, { params });
+    return API$e.get(`/routine-task/${assetId}`, { params });
   },
   getMaintenanceOption: (assetId, params) => {
-    return API$d.get(`/routine-task/${assetId}/options`, { params });
+    return API$e.get(`/routine-task/${assetId}/options`, { params });
   },
   putSetActive: (body) => {
-    return API$d.put("/maintenable-asset/set-active", body);
+    return API$e.put("/maintenable-asset/set-active", body);
   },
   getRoutineTask: (params) => {
-    return API$d.get("/routine-task", { params });
+    return API$e.get("/routine-task", { params });
   },
   getRoutineTaskOptions: (params) => {
-    return API$d.get("/routine-task/options", { params });
+    return API$e.get("/routine-task/options", { params });
   },
   getRoutineSchedule: (params) => {
-    return API$d.get("/routine-schedule", { params });
+    return API$e.get("/routine-schedule", { params });
   },
   getRoutineScheduleOptions: (params) => {
-    return API$d.get("/routine-schedule/options", { params });
+    return API$e.get("/routine-schedule/options", { params });
   },
   getRoutineTaskEventLog: (params) => {
-    return API$d.get("/routine-task/event-log", { params });
+    return API$e.get("/routine-task/event-log", { params });
   },
   getRoutineTaskEventLogOptions: (params) => {
-    return API$d.get("/routine-task/event-log/options", { params });
+    return API$e.get("/routine-task/event-log/options", { params });
   },
   getAssetName: (params) => {
-    return API$d.get("/asset-name", { params });
+    return API$e.get("/asset-name", { params });
   },
   getAssetNameOptions: (params) => {
-    return API$d.get("/asset-name/options", { params });
+    return API$e.get("/asset-name/options", { params });
   },
   postCreateRoutineSchedule: (data) => {
-    return API$d.post("/routine-schedule", data);
+    return API$e.post("/routine-schedule", data);
   },
   postDuplicateRoutineSchedule: (id, data) => {
-    return API$d.post(`/routine-schedule/duplicate/${id}`, data);
+    return API$e.post(`/routine-schedule/duplicate/${id}`, data);
   },
   putEditRoutineSchedule: (id, data) => {
-    return API$d.put(`/routine-schedule/${id}`, data);
+    return API$e.put(`/routine-schedule/${id}`, data);
   },
   getUserStaff: (params) => {
-    return API$d.get("/user-transaction-role/maintenance-role/staff", { params });
+    return API$e.get("/user-transaction-role/maintenance-role/staff", { params });
   },
   getUserStaffOptions: (params) => {
-    return API$d.get("/user-transaction-role/maintenance-role/staff/options", {
+    return API$e.get("/user-transaction-role/maintenance-role/staff/options", {
       params
     });
   },
   getRoutineScheduleDetail: (id) => {
-    return API$d.get(`/routine-schedule/${id}`);
+    return API$e.get(`/routine-schedule/${id}`);
   },
   deleteRoutineSchedule: (id) => {
-    return API$d.delete("/routine-schedule/bulk-delete", {
+    return API$e.delete("/routine-schedule/bulk-delete", {
       params: {
         id: JSON.stringify(id)
       }
     });
   },
   putRoutineTaskCancel: (id) => {
-    return API$d.put("/routine-task/cancel", { id });
+    return API$e.put("/routine-task/cancel", { id });
   },
   getMaintainableAsset: (params) => {
-    return API$d.get("/maintenable-asset", { params });
+    return API$e.get("/maintenable-asset", { params });
   },
   getMaintainableAssetOptions: (params) => {
-    return API$d.get("/maintenable-asset/options", { params });
+    return API$e.get("/maintenable-asset/options", { params });
   },
   getMaintenanceHistory: (params) => {
-    return API$d.get("/routine-task/history", { params });
+    return API$e.get("/routine-task/history", { params });
   },
   getMaintenanceHistoryOptions: (params) => {
-    return API$d.get("/routine-task/history/options", { params });
+    return API$e.get("/routine-task/history/options", { params });
   },
   getActiveAsset: (id) => {
-    return API$d.get(`/routine-schedule/${id}/assets`);
+    return API$e.get(`/routine-schedule/${id}/assets`);
   },
   getActiveAssetOptions: (id, params) => {
-    return API$d.get(`/routine-schedule/${id}/assets/options`, { params });
+    return API$e.get(`/routine-schedule/${id}/assets/options`, { params });
   },
   getRoutineTaskDetail: (id) => {
-    return API$d.get(`/routine-task/${id}/detail`);
+    return API$e.get(`/routine-task/${id}/detail`);
   },
   getApproverList: (id, approvalRound) => {
-    return API$d.get(`/routine-task/${id}/approval-history`, {
+    return API$e.get(`/routine-task/${id}/approval-history`, {
       params: {
         approvalRound
       }
     });
   },
   getReviewerList: (id) => {
-    return API$d.get(`/routine-task/${id}/review-history`);
+    return API$e.get(`/routine-task/${id}/review-history`);
   },
   getMaintainableAssetDetail: (id) => {
-    return API$d.get(`/maintenable-asset/${id}`);
+    return API$e.get(`/maintenable-asset/${id}`);
   },
   putSetActiveTasks: (id, isActive) => {
-    return API$d.put(`/maintenable-asset/${id}/set-tasks-active`, {
+    return API$e.put(`/maintenable-asset/${id}/set-tasks-active`, {
       isActive
     });
   },
   putAssignStaff: (routineId, staffId) => {
-    return API$d.put(`/routine-task/${routineId}/assign-staff`, {
+    return API$e.put(`/routine-task/${routineId}/assign-staff`, {
       id: staffId
     });
   },
   getServiceCenter: () => {
-    return API$d.get("/service-center/dropdown");
+    return API$e.get("/service-center/dropdown");
   },
   putCompleteRoutineTask: (id, data) => {
     const headers = { "Content-Type": "multipart/form-data" };
-    return API$d.put(`/routine-task/${id}/completion`, data, { headers });
+    return API$e.put(`/routine-task/${id}/completion`, data, { headers });
   },
   getApprovalDetail: (id) => {
-    return API$d.get(`/approval/${id}`);
+    return API$e.get(`/approval/${id}`);
   },
   putApprovalApprove: (id, data) => {
-    return API$d.put(`/approval/${id}/approve`, data);
+    return API$e.put(`/approval/${id}/approve`, data);
   },
   putReviewRoutine: (id, data) => {
-    return API$d.put(`/routine-task/${id}/review`, data);
+    return API$e.put(`/routine-task/${id}/review`, data);
   },
   putUpdateRoutineTask: (id, data) => {
-    return API$d.put(`/routine-task/${id}/handle-overdue`, data);
+    return API$e.put(`/routine-task/${id}/handle-overdue`, data);
   },
   getApproval: (params) => {
-    return API$d.get("/approval", { params });
+    return API$e.get("/approval", { params });
   },
   getApprovalOptions: (params) => {
-    return API$d.get("/approval/options", { params });
+    return API$e.get("/approval/options", { params });
   }
 };
-const API$c = createAxiosInstance({
+const API$d = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/routine/v2"
 });
 const ServiceCenterServices = {
   getList: (params) => {
-    return API$c.get("/service-center", { params });
+    return API$d.get("/service-center", { params });
   },
   postList: (body) => {
-    return API$c.post("/service-center", body);
+    return API$d.post("/service-center", body);
   },
   putList: (id, body) => {
-    return API$c.put(`/service-center/${id}`, body);
+    return API$d.put(`/service-center/${id}`, body);
   },
   putActivate: (body) => {
-    return API$c.put("/service-center/bulk", body);
+    return API$d.put("/service-center/bulk", body);
   },
   getDetailList: (id) => {
-    return API$c.get(`/service-center/${id}`);
+    return API$d.get(`/service-center/${id}`);
   },
   getListOptions: (params) => {
-    return API$c.get("/service-center/options", { params });
+    return API$d.get("/service-center/options", { params });
   },
   deleteList: (params) => {
-    return API$c.delete("/service-center", { params });
+    return API$d.delete("/service-center", { params });
   },
   // Activities
   getActivities: (params) => {
-    return API$c.get("/service-activities", { params });
+    return API$d.get("/service-activities", { params });
   },
   getActivityOptions: (params) => {
-    return API$c.get("/service-activities/options", { params });
+    return API$d.get("/service-activities/options", { params });
   },
   getActivityDetail: (id) => {
-    return API$c.get(`/service-activities/${id}`);
+    return API$d.get(`/service-activities/${id}`);
   },
   getActivityLog: (id) => {
-    return API$c.get(`/service-activities/${id}/activity-log`);
+    return API$d.get(`/service-activities/${id}/activity-log`);
   }
 };
-const API$b = createAxiosInstance({
+const API$c = createAxiosInstance({
   prefix: "/v2/session-log",
   env: "APP_LOGS_NOTIFICATION_API"
 });
 const SessionLogServices = {
   postLogout: () => {
-    return API$b.post("/logout");
+    return API$c.post("/logout");
   }
 };
-const API$a = createAxiosInstance({
+const API$b = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/tag/v2"
 });
 const TAGServices = {
   getScanQR: (tag) => {
-    return API$a.get("/qr", { params: { tag } });
+    return API$b.get("/qr", { params: { tag } });
   },
   getScanRFID: (tag) => {
-    return API$a.get("/rfid", { params: { tag } });
+    return API$b.get("/rfid", { params: { tag } });
   },
   getRFIDQRTAG: (params) => {
-    return API$a.get("/rfid-qr/scan", { params });
+    return API$b.get("/rfid-qr/scan", { params });
   },
   getEventLog: (params) => {
-    return API$a.get("/tag-transaction/event-log", { params });
+    return API$b.get("/tag-transaction/event-log", { params });
   },
   // Tab All
   getRfidQrAll: (path, params) => {
-    return API$a.get(`/${path}`, { params });
+    return API$b.get(`/${path}`, { params });
   },
   // Tab Paired
   getRfidQrPaired: (tagType, viewBy, params) => {
-    return API$a.get(`/${tagType}/paired/${viewBy}`, { params });
+    return API$b.get(`/${tagType}/paired/${viewBy}`, { params });
   },
   postAddTAGtoPrelist: (body, destination) => {
-    return API$a.post(`/prelist/${destination}/asset-name`, body);
+    return API$b.post(`/prelist/${destination}/asset-name`, body);
   },
   postAddTAGtoReplacePrelist: (body) => {
-    return API$a.post("/prelist/replace-tag", body);
+    return API$b.post("/prelist/replace-tag", body);
   },
   postAddTAGToPrelistUnpair: (body) => {
-    return API$a.post("/prelist/unpair-tag", body);
+    return API$b.post("/prelist/unpair-tag", body);
   },
   postAddTAGtoPending: (body) => {
-    return API$a.post("/pending-changes", body);
+    return API$b.post("/pending-changes", body);
   },
   // Available Tab
   getRFIDQrAvailable: (tagType, params) => {
-    return API$a.get(`/${tagType}/available`, { params });
+    return API$b.get(`/${tagType}/available`, { params });
   },
   // Damaged TAB
   getRFIDQrDamaged: (tagType, params) => {
-    return API$a.get(`/${tagType}/damaged`, { params });
+    return API$b.get(`/${tagType}/damaged`, { params });
   },
   // RFID and QR Module
   getRFIDandQRList: (params) => {
-    return API$a.get("/rfid-qr", { params });
+    return API$b.get("/rfid-qr", { params });
   },
   deleteUnpairTAG: (body) => {
-    return API$a.delete("/rfid-qr", { data: { data: body } });
+    return API$b.delete("/rfid-qr", { data: { data: body } });
   },
   postPairTAG: (body) => {
-    return API$a.post("/rfid-qr", { body: { data: body } });
+    return API$b.post("/rfid-qr", { body: { data: body } });
   },
   // RFID To Be Returned
   getToBeReturnedTAGList: (params) => {
-    return API$a.get("/rfid/to-be-returned", { params });
+    return API$b.get("/rfid/to-be-returned", { params });
   },
   // Handover TAG
   putHandoverTAG: (body) => {
-    return API$a.put("/rfid/handover", { body: { data: body } });
+    return API$b.put("/rfid/handover", { body: { data: body } });
   },
   // Table Filter
   getFilterOptions: (path, params) => {
-    return API$a.get(`/${path}/options`, { params });
+    return API$b.get(`/${path}/options`, { params });
   },
   getHolderListOptions: (params) => {
-    return API$a.get("/rfid/holder-list/options", { params });
+    return API$b.get("/rfid/holder-list/options", { params });
   },
   getHolderList: (params) => {
-    return API$a.get("/rfid/holder-list", { params });
+    return API$b.get("/rfid/holder-list", { params });
   },
   putAuditTAG: (body, tagType) => {
-    return API$a.put(`/${tagType}/audit`, body);
+    return API$b.put(`/${tagType}/audit`, body);
   },
   postLogAudit: (body) => {
-    return API$a.post("/tag-transaction/log-audit", body);
+    return API$b.post("/tag-transaction/log-audit", body);
   },
   postCreateQr: (amount) => {
     const body = { amount };
-    return API$a.post("/qr", body);
+    return API$b.post("/qr", body);
   },
   putReportTAG: (id, body) => {
-    return API$a.put(`/tag-transaction/report/${id}`, body);
+    return API$b.put(`/tag-transaction/report/${id}`, body);
   },
   putReportTAGBulk: (body) => {
-    return API$a.put("/tag-transaction/report/bulk", body);
+    return API$b.put("/tag-transaction/report/bulk", body);
   },
   putDeclineReport: (body, tagType) => {
-    return API$a.put(`/report/decline-report/${tagType}`, body);
+    return API$b.put(`/report/decline-report/${tagType}`, body);
   }
 };
-const API$9 = createAxiosInstance({
+const API$a = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/tracking/v2/tracking"
 });
@@ -2271,7 +2271,7 @@ const API_APPROVAL = createAxiosInstance({
 });
 const TrackingServices = {
   getTrackingDetail: (trackingId) => {
-    return API$9.get(`/${trackingId}`);
+    return API$a.get(`/${trackingId}`);
   },
   putFoundAsset: (tag, groupId, serialNumber, type) => {
     const params = {
@@ -2280,26 +2280,26 @@ const TrackingServices = {
       serialNumber,
       type: type ?? "Global"
     };
-    return API$9.put("/scan", void 0, { params });
+    return API$a.put("/scan", void 0, { params });
   },
   putReportPermanentlyMissing: (trackingId, body) => {
-    return API$9.put(`/report-permanently-missing/${trackingId}`, body);
+    return API$a.put(`/report-permanently-missing/${trackingId}`, body);
   },
   putUpdateTrackingAsset: (id, body) => {
     const headers = { "Content-type": "multipart/form-data" };
-    return API$9.put(`/update/${id}`, body, { headers });
+    return API$a.put(`/update/${id}`, body, { headers });
   },
   putMoveBack: (body) => {
-    return API$9.put("/tracking/move-back", body);
+    return API$a.put("/tracking/move-back", body);
   },
   getTrackingList: (endpoint, params) => {
-    return API$9.get(endpoint, { params });
+    return API$a.get(endpoint, { params });
   },
   getTrackingDetailByScan: (tag) => {
-    return API$9.get("/scan", { params: { tag } });
+    return API$a.get("/scan", { params: { tag } });
   },
   getFilterOptions: (endPoint, params) => {
-    return API$9.get(endPoint + "/options", { params });
+    return API$a.get(endPoint + "/options", { params });
   },
   getApproverList: (id) => {
     return API_APPROVAL.get(`/${id}/approval-history`);
@@ -2314,182 +2314,182 @@ const TrackingServices = {
     return API_APPROVAL.put("/approval", body);
   }
 };
-const API$8 = createAxiosInstance({
+const API$9 = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/settings-attribute/v2/transaction-settings"
 });
 const TransactionSettingServices = {
   getData: () => {
-    return API$8.get("/");
+    return API$9.get("/");
   },
   putData: (data) => {
-    return API$8.put("/", data);
+    return API$9.put("/", data);
   }
 };
-const API$7 = createAxiosInstance({
+const API$8 = createAxiosInstance({
   prefix: "/settings-attribute/v2/asset-name"
 });
 const SettingAssetNameServiceGo = {
-  getAssetNameList: (params) => API$7.get("", { params }),
+  getAssetNameList: (params) => API$8.get("", { params }),
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/options
   getAssetNameListOptions: (params) => {
-    return API$7.get("/options", { params });
+    return API$8.get("/options", { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/dropdown
   getAssetNameDropdown: (params) => {
-    return API$7.get("/dropdown", { params });
+    return API$8.get("/dropdown", { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/unpaired
   getAssetUnpairedNameList: (params) => {
-    return API$7.get("/unpaired", { params });
+    return API$8.get("/unpaired", { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/unpaired/options
   getAssetUnpairedNameListOptions: (params) => {
-    return API$7.get("/unpaired/options", { params });
+    return API$8.get("/unpaired/options", { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/:id
   getAssetNameDetail: (id) => {
-    return API$7.get(`/${id}`);
+    return API$8.get(`/${id}`);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/:id/list-brand
   getAssetNameBrands: (id, params) => {
-    return API$7.get(`/${id}/list-brand`, { params });
+    return API$8.get(`/${id}/list-brand`, { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/:id/list-asset
   getAssetNameAssets: (id, params) => {
-    return API$7.get(`/${id}/list-asset`, { params });
+    return API$8.get(`/${id}/list-asset`, { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/:id/list-asset/options
   getAssetNameAssetsOptions: (id, params) => {
-    return API$7.get(`/${id}/list-asset/options`, { params });
+    return API$8.get(`/${id}/list-asset/options`, { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/:id/list-brand/options
   getAssetNameBrandsOptions: (id, params) => {
-    return API$7.get(`/${id}/list-brand/options`, { params });
+    return API$8.get(`/${id}/list-brand/options`, { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name
   createAssetName: (body) => {
-    return API$7.post("", body);
+    return API$8.post("", body);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/depreciation-setting
   updateDepreciationSetting: (body) => {
-    return API$7.put("/depreciation-setting", body);
+    return API$8.put("/depreciation-setting", body);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/set-tagtype
   setTagType: (body) => {
-    return API$7.put("/set-tagtype", body);
+    return API$8.put("/set-tagtype", body);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name/:id
   updateAssetName: (body, id) => {
-    return API$7.put(`/${id}`, body);
+    return API$8.put(`/${id}`, body);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/asset-name
   deleteAssetName: (body) => {
-    return API$7.delete("", {
+    return API$8.delete("", {
       data: body
     });
   }
 };
-const API$6 = createAxiosInstance({
+const API$7 = createAxiosInstance({
   prefix: "/settings-attribute/v2/brands"
 });
 const SettingBrandServiceGo = {
   getBrandList: (params) => {
-    return API$6.get("", { params });
+    return API$7.get("", { params });
   },
   getBrandListOptionsFA: (params) => {
-    return API$6.get("/options", { params });
+    return API$7.get("/options", { params });
   },
   getBrandDropdown: (params) => {
-    return API$6.get("/dropdown", { params });
+    return API$7.get("/dropdown", { params });
   },
   getBrandDetail: (id) => {
-    return API$6.get(`/${id}`);
+    return API$7.get(`/${id}`);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/brands/:id/list-category
   getBrandListCategory: (id, params) => {
-    return API$6.get(`/${id}/list-category`, { params });
+    return API$7.get(`/${id}/list-category`, { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/brands/:id/list-category/options
   getBrandListCategoryOptions: (id, params) => {
-    return API$6.get(`/${id}/list-category/options`, { params });
+    return API$7.get(`/${id}/list-category/options`, { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/brands/:id/list-asset
   getBrandListAsset: (id, params) => {
-    return API$6.get(`/${id}/list-asset`, { params });
+    return API$7.get(`/${id}/list-asset`, { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/brands/:id/list-asset/options
   getBrandListAssetOptions: (id, params) => {
-    return API$6.get(`/${id}/list-asset/options`, { params });
+    return API$7.get(`/${id}/list-asset/options`, { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/brands
   createBrand: (body) => {
-    return API$6.post("", body);
+    return API$7.post("", body);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/brands/assign-category
   brandAssignCategory: (body) => {
-    return API$6.put("/assign-category", body);
+    return API$7.put("/assign-category", body);
   },
   brandUnassignCategory: (body) => {
-    return API$6.put("/unassign-category", body);
+    return API$7.put("/unassign-category", body);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/brands/:id
   updateBrand: (body, id) => {
-    return API$6.put(`/${id}`, body);
+    return API$7.put(`/${id}`, body);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/brands
   deleteBrand: (body) => {
-    return API$6.delete("", {
+    return API$7.delete("", {
       data: body
     });
   }
 };
-const API$5 = createAxiosInstance({
+const API$6 = createAxiosInstance({
   prefix: "/settings-attribute/v2/measurement"
 });
 const SettingMeasurementServiceGo = {
   getMeasurementList: (params) => {
-    return API$5.get("", { params });
+    return API$6.get("", { params });
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/measurement/dropdown
   getMeasurementDropdown: () => {
-    return API$5.get("/dropdown");
+    return API$6.get("/dropdown");
   },
   createMeasurement: (body) => {
-    return API$5.post("", body);
+    return API$6.post("", body);
   },
   updateMeasurement: (body, id) => {
-    return API$5.put(`/${id}`, body);
+    return API$6.put(`/${id}`, body);
   },
   //https://dev-api.supply.tagsamurai.com/settings-attribute-go/v2/measurement
   deleteMeasurement: (body) => {
-    return API$5.delete("", {
+    return API$6.delete("", {
       data: body
     });
   }
 };
-const API$4 = createAxiosInstance({
+const API$5 = createAxiosInstance({
   env: "APP_TAGSAMURAI_API",
   prefix: "/iot/v2/iot"
 });
 const IOTServices = {
   getReaderList: () => {
-    return API$4.get("/antenna/available");
+    return API$5.get("/antenna/available");
   },
   getReaderOptions: (params) => {
-    return API$4.get("/reader/options", { params });
+    return API$5.get("/reader/options", { params });
   },
   putSetScanParams: (body) => {
-    return API$4.put("/reader/set-scan-params", body);
+    return API$5.put("/reader/set-scan-params", body);
   },
   putIOTTracking: (body) => {
-    return API$4.put("/tracking", body);
+    return API$5.put("/tracking", body);
   },
   getActivityLogData: (params) => {
-    return API$4.get("/activity-log", { params });
+    return API$5.get("/activity-log", { params });
   },
   getActivityLogOptions: (params) => {
-    return API$4.get("/activity-log/options", { params });
+    return API$5.get("/activity-log/options", { params });
   }
 };
 const ReaderAPI = createAxiosInstance({
@@ -2707,159 +2707,187 @@ const DisposalServices = {
     return ApprovalAPI.put(`/approval-completion/${transactionId}`, body);
   }
 };
-const API$3 = createAxiosInstance({
+const API$4 = createAxiosInstance({
   prefix: "/v2/planning-strategy"
 });
 const RiskRegisterServices = {
   getRisk: (params) => {
-    return API$3.get("", { params });
+    return API$4.get("", { params });
   },
   getRiskLogs: (id) => {
-    return API$3.get(`/risk-log/${id}`);
+    return API$4.get(`/risk-log/${id}`);
   },
   getRiskOptions: (params) => {
-    return API$3.get("/options", { params });
+    return API$4.get("/options", { params });
   },
   getRiskReview: (id) => {
-    return API$3.get(`/risk-review/${id}`);
+    return API$4.get(`/risk-review/${id}`);
   },
   postRisk: (data) => {
-    return API$3.post("", data);
+    return API$4.post("", data);
   },
   editRisk: (id, data) => {
-    return API$3.put(`/${id}`, data);
+    return API$4.put(`/${id}`, data);
   },
   cancelRisk: (id, data) => {
-    return API$3.put(`/${id}/cancel`, data);
+    return API$4.put(`/${id}/cancel`, data);
   },
   verifyRisk: (id, data) => {
-    return API$3.put(`/${id}/verify`, data);
+    return API$4.put(`/${id}/verify`, data);
   },
   reopenRisk: (id, data) => {
-    return API$3.put(`/${id}/reopen`, data);
+    return API$4.put(`/${id}/reopen`, data);
   }
 };
-const API$2 = createAxiosInstance({
+const API$3 = createAxiosInstance({
   prefix: "/v2/documents"
 });
 const DocumentServices = {
   getAllDocuments: (params) => {
-    return API$2.get("", { params });
+    return API$3.get("", { params });
   },
   getDocumentOptions: (params) => {
-    return API$2.get("/options", { params });
+    return API$3.get("/options", { params });
   },
   addDocument: (data) => {
-    return API$2.post("", data);
+    return API$3.post("", data);
   },
   editDocument: (id, data) => {
-    return API$2.put(`/${id}`, data);
+    return API$3.put(`/${id}`, data);
   },
   deleteDocument: (id) => {
-    return API$2.delete("/bulk", { data: { ids: id } });
+    return API$3.delete("/bulk", { data: { ids: id } });
   },
   getDocumentFilterOptions: (params) => {
-    return API$2.get("/filter-options", { params });
+    return API$3.get("/filter-options", { params });
   }
 };
-const API$1 = createAxiosInstance({
+const API$2 = createAxiosInstance({
   prefix: "/opportunity-register/v2"
 });
 const OpportunityRegisterServices = {
   getOpportunityRegisterActiveList: (params) => {
-    return API$1.get("/active", { params: queryParamsStringfy(params) });
+    return API$2.get("/active", { params: queryParamsStringfy(params) });
   },
   getOpportunityRegisterActiveListOptions: (params) => {
-    return API$1.get("/active/options", { params });
+    return API$2.get("/active/options", { params });
   },
   getOpportunityRegisterClosedList: (params) => {
-    return API$1.get("/closed", { params: queryParamsStringfy(params) });
+    return API$2.get("/closed", { params: queryParamsStringfy(params) });
   },
   getOpportunityRegisterClosedListOptions: (params) => {
-    return API$1.get("/closed/options", { params });
+    return API$2.get("/closed/options", { params });
   },
   getOpportunityRegisterActiveDetail: (opportunityId) => {
-    return API$1.get(`/active/${opportunityId}`);
+    return API$2.get(`/active/${opportunityId}`);
   },
   getOpportunityLogData: (opportunityId, params) => {
-    return API$1.get(`/opportunity-log/${opportunityId}`, { params });
+    return API$2.get(`/opportunity-log/${opportunityId}`, { params });
   },
   editActiveOpportunity: (opportunityId, body) => {
-    return API$1.put(`/active/${opportunityId}`, body);
+    return API$2.put(`/active/${opportunityId}`, body);
   },
   addActiveOpportunity: (body) => {
-    return API$1.post("/active", body);
+    return API$2.post("/active", body);
   },
   reviewOpportunityAction: (opportunityId, body) => {
-    return API$1.post(`/active/${opportunityId}/review`, body);
+    return API$2.post(`/active/${opportunityId}/review`, body);
   },
   cancelOpportunity: (opportunityId, body) => {
-    return API$1.put(`/active/${opportunityId}/cancel`, body);
+    return API$2.put(`/active/${opportunityId}/cancel`, body);
   }
 };
-const API = createAxiosInstance({
+const API$1 = createAxiosInstance({
   prefix: "/v2/continuous-improvement"
 });
 const ContinuousImprovementServices = {
   getContiniuousImprovementLogs: (params) => {
-    return API.get("/logs", { params });
+    return API$1.get("/logs", { params });
   },
   getLessonLearned: (params) => {
-    return API.get("/lesson-learned", { params });
+    return API$1.get("/lesson-learned", { params });
   },
   getAuditFindingsCorrectiveActions: (params) => {
-    return API.get("/audit-findings", { params });
+    return API$1.get("/audit-findings", { params });
   },
   getLogOptions: (params) => {
-    return API.get("/logs/options", { params });
+    return API$1.get("/logs/options", { params });
   },
   getLessonLearnedOptions: (params) => {
-    return API.get("/lesson-learned/options", { params });
+    return API$1.get("/lesson-learned/options", { params });
   },
   getAuditFindingOptions: (params) => {
-    return API.get("/audit-findings/options", { params });
+    return API$1.get("/audit-findings/options", { params });
   },
   getLogFilterOptions: (params) => {
-    return API.get("/logs/filter-options", { params });
+    return API$1.get("/logs/filter-options", { params });
   },
   getLessonLearnedFilterOptions: (params) => {
-    return API.get("/lesson-learned/filter-options", { params });
+    return API$1.get("/lesson-learned/filter-options", { params });
   },
   getAuditFindingFilterOptions: (params) => {
-    return API.get("/audit-findings/filter-options", { params });
+    return API$1.get("/audit-findings/filter-options", { params });
   },
   addLog: (data) => {
-    return API.post("/logs", data);
+    return API$1.post("/logs", data);
   },
   editLog: (id, data) => {
-    return API.put(`/logs/${id}`, data);
+    return API$1.put(`/logs/${id}`, data);
   },
   addLessonLearned: (data) => {
-    return API.post("/lesson-learned", data);
+    return API$1.post("/lesson-learned", data);
   },
   editLessonLearned: (id, data) => {
-    return API.put(`/lesson-learned/${id}`, data);
+    return API$1.put(`/lesson-learned/${id}`, data);
   },
   addAuditFinding: (data) => {
-    return API.post("/audit-findings", data);
+    return API$1.post("/audit-findings", data);
   },
   editAuditFinding: (id, data) => {
-    return API.put(`/audit-findings/${id}`, data);
+    return API$1.put(`/audit-findings/${id}`, data);
   },
   cancelImprovement: (id, payload) => {
-    return API.put(`/cancel-improvement/${id}`, payload);
+    return API$1.put(`/cancel-improvement/${id}`, payload);
   },
   reviewImprovement: (id, payload) => {
-    return API.put(`/review-improvement/${id}`, payload);
+    return API$1.put(`/review-improvement/${id}`, payload);
   },
   updateLessonLearnedStatus: (id, payload) => {
-    return API.put(`/lesson-learned/status/${id}`, payload);
+    return API$1.put(`/lesson-learned/status/${id}`, payload);
   },
   reviewAuditFinding: (id, payload) => {
-    return API.put(`/review-audit-finding/${id}`, payload);
+    return API$1.put(`/review-audit-finding/${id}`, payload);
+  }
+};
+const API = createAxiosInstance({ prefix: "/assets/v2/amp" });
+const AmpManagementService = {
+  getAMP(params) {
+    return API.get(`/`, { params });
+  },
+  getDemand(params) {
+    return API.get(`/demand`, { params });
+  },
+  getLifecycle(params) {
+    return API.get(`/lifecycle`, { params });
+  },
+  getResource(params) {
+    return API.get(`/resource`, { params });
+  },
+  getAmpOptions(params) {
+    return API.get(`/options`, { params });
+  },
+  getAMPFilterOptions(params) {
+    return API.get(`/filter-options`, { params });
+  },
+  createAMP(payload) {
+    return API.post(`/`, payload);
+  },
+  editAMP(ampId, payload) {
+    return API.put(`/${ampId}`, payload);
   }
 };
 export {
+  AmpManagementService as AMPManagementService,
   AccountingServices,
   AliasCodeServices,
   AssetNameServices,