@fctc/interface-logic 1.10.7 → 1.10.9

package/dist/provider.mjs

@@ -648,10 +648,10 @@ var MainProvider = ({ children }) => {
 };
 
 // src/provider/version-gate-provider.tsx
-import { useEffect as useEffect2, useState as useState3 } from "react";
+import { useEffect as useEffect2, useState as useState2 } from "react";
 import { useQueryClient } from "@tanstack/react-query";
 
-// src/services/view-service/backup.ts
+// src/services/action-service/index.ts
 import { useCallback } from "react";
 
 // src/constants/api/uri-constant.ts
@@ -684,6 +684,9 @@ var UriConstants = /* @__PURE__ */ ((UriConstants2) => {
   return UriConstants2;
 })(UriConstants || {});
 
+// src/utils/format.ts
+import moment from "moment";
+
 // src/constants/widget/widget-avatar-constant.ts
 var WIDGETAVATAR = /* @__PURE__ */ ((WIDGETAVATAR2) => {
   WIDGETAVATAR2["many2one_avatar_user"] = "many2one_avatar_user";
@@ -691,265 +694,6 @@ var WIDGETAVATAR = /* @__PURE__ */ ((WIDGETAVATAR2) => {
   return WIDGETAVATAR2;
 })(WIDGETAVATAR || {});
 
-// src/services/view-service/backup.ts
-function useViewService() {
-  const { env: env2 } = useEnv();
-  const getView = useCallback(
-    async ({ model, views, context = {}, options = {}, aid }) => {
-      const defaultOptions = {
-        load_filters: true,
-        toolbar: true,
-        action_id: aid
-      };
-      const jsonDataView = {
-        model,
-        method: "get_fields_view_v2" /* GET_FIELD_VIEW */,
-        kwargs: {
-          views,
-          options: { ...options, ...defaultOptions }
-        },
-        with_context: context
-      };
-      return env2?.requests?.post("/call" /* CALL_PATH */, jsonDataView, {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    },
-    [env2]
-  );
-  const getMenu = useCallback(
-    async (context) => {
-      const jsonData = {
-        model: "ir.ui.menu" /* MENU */,
-        method: "web_search_read" /* WEB_SEARCH_READ */,
-        ids: [],
-        with_context: context,
-        kwargs: {
-          specification: {
-            active: {},
-            name: {},
-            is_display: {},
-            sequence: {},
-            complete_name: {},
-            action: {
-              fields: {
-                display_name: {},
-                type: {},
-                binding_view_types: {}
-              }
-            },
-            url_icon: {},
-            web_icon: {},
-            web_icon_data: {},
-            groups_id: {
-              fields: {
-                full_name: {}
-              },
-              limit: 40,
-              order: ""
-            },
-            display_name: {},
-            child_id: {
-              fields: {
-                active: {},
-                name: {},
-                is_display: {},
-                sequence: {},
-                complete_name: {},
-                action: {
-                  fields: {
-                    display_name: {},
-                    type: {},
-                    binding_view_types: {}
-                  }
-                },
-                url_icon: {},
-                web_icon: {},
-                web_icon_data: {},
-                groups_id: {
-                  fields: {
-                    full_name: {}
-                  },
-                  limit: 40,
-                  order: ""
-                },
-                display_name: {},
-                child_id: {
-                  fields: {
-                    active: {},
-                    name: {},
-                    is_display: {},
-                    sequence: {},
-                    complete_name: {},
-                    action: {
-                      fields: {
-                        display_name: {},
-                        type: {},
-                        binding_view_types: {}
-                      }
-                    },
-                    url_icon: {},
-                    web_icon: {},
-                    web_icon_data: {},
-                    groups_id: {
-                      fields: {
-                        full_name: {}
-                      },
-                      limit: 40,
-                      order: ""
-                    },
-                    display_name: {},
-                    child_id: {
-                      fields: {},
-                      limit: 40,
-                      order: ""
-                    }
-                  },
-                  limit: 40,
-                  order: ""
-                }
-              },
-              limit: 40,
-              order: ""
-            }
-          },
-          domain: [
-            "&",
-            ["is_display", "=", true],
-            "&",
-            ["active", "=", true],
-            ["parent_id", "=", false]
-          ]
-        }
-      };
-      return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    },
-    [env2]
-  );
-  const getActionDetail = useCallback(
-    async (aid, context) => {
-      const jsonData = {
-        model: "ir.actions.act_window" /* WINDOW_ACTION */,
-        method: "web_read" /* WEB_READ */,
-        ids: [aid],
-        with_context: context,
-        kwargs: {
-          specification: {
-            id: {},
-            name: {},
-            res_model: {},
-            views: {},
-            view_mode: {},
-            mobile_view_mode: {},
-            domain: {},
-            context: {},
-            groups_id: {},
-            search_view_id: {}
-          }
-        }
-      };
-      return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    },
-    [env2]
-  );
-  const getResequence = useCallback(
-    async ({ model, ids, context, offset }) => {
-      const jsonData = {
-        model,
-        with_context: context,
-        ids,
-        field: "sequence",
-        ...offset > 0 ? { offset } : {}
-      };
-      return env2?.requests.post("/web/dataset/resequence", jsonData, {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    },
-    [env2]
-  );
-  const getSelectionItem = useCallback(
-    async ({ data }) => {
-      const jsonData = {
-        model: data.model,
-        ids: [],
-        method: "get_data_select",
-        with_context: data.context,
-        kwargs: {
-          count_limit: 10001,
-          domain: data.domain ? data.domain : [],
-          offset: 0,
-          order: "",
-          specification: data?.specification ?? {
-            id: {},
-            name: {},
-            display_name: {}
-          }
-        }
-      };
-      return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    },
-    [env2]
-  );
-  const loadMessages = useCallback(
-    async () => {
-      return env2.requests.post(
-        "/load_message_failures" /* LOAD_MESSAGE */,
-        {},
-        {
-          headers: {
-            "Content-Type": "application/json"
-          }
-        }
-      );
-    },
-    [env2]
-  );
-  const getVersion = useCallback(
-    async () => {
-      console.log("env?.requests", env2, env2?.requests);
-      return env2?.requests?.get("", {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    },
-    [env2]
-  );
-  return {
-    getView,
-    getMenu,
-    getActionDetail,
-    getResequence,
-    getSelectionItem,
-    loadMessages,
-    getVersion
-  };
-}
-
-// src/hooks/auth/use-forgot-password.ts
-import { useMutation } from "@tanstack/react-query";
-
-// src/configs/axios-client.ts
-import axios from "axios";
-
-// src/utils/format.ts
-import moment from "moment";
-
 // src/utils/domain/py_tokenizer.ts
 var TokenizerError = class extends Error {
 };
@@ -3058,6 +2802,11 @@ function matchDomain(record, domain) {
 
 // src/utils/function.ts
 import { useEffect, useState } from "react";
+var toQueryString = (params) => {
+  return Object.keys(params).map(
+    (key) => encodeURIComponent(key) + "=" + encodeURIComponent(params[key].toString())
+  ).join("&");
+};
 var isBase64File = (str) => {
   try {
     const dataUriPattern = /^data:([a-zA-Z]+\/[a-zA-Z0-9-.+]+)?;base64,/;
@@ -3093,1506 +2842,1875 @@ var updateTokenParamInOriginalRequest = (originalRequest, newAccessToken) => {
   return originalRequest.data;
 };
 
-// src/utils/storage/local-storage.ts
-var localStorageUtils = () => {
-  const setToken = async (access_token) => {
-    localStorage.setItem("accessToken", access_token);
-  };
-  const setRefreshToken = async (refresh_token) => {
-    localStorage.setItem("refreshToken", refresh_token);
-  };
-  const getAccessToken = async () => {
-    return localStorage.getItem("accessToken");
-  };
-  const getRefreshToken = async () => {
-    return localStorage.getItem("refreshToken");
-  };
-  const clearToken = async () => {
-    localStorage.removeItem("accessToken");
-    localStorage.removeItem("refreshToken");
-  };
-  return {
-    setToken,
-    setRefreshToken,
-    getAccessToken,
-    getRefreshToken,
-    clearToken
-  };
-};
-
-// src/utils/storage/session-storage.ts
-var sessionStorageUtils = () => {
-  const getBrowserSession = async () => {
-    return sessionStorage.getItem("browserSession");
-  };
+// src/services/action-service/index.ts
+function useActionService() {
+  const { env } = useEnv();
+  const loadAction = useCallback(
+    async ({
+      idAction,
+      context
+    }) => {
+      const jsonData = {
+        action_id: idAction,
+        with_context: { ...context }
+      };
+      return env.requests.post("/load_action" /* LOAD_ACTION */, jsonData, {
+        headers: { "Content-Type": "application/json" }
+      });
+    },
+    [env]
+  );
+  const callButton = useCallback(
+    async ({
+      model,
+      ids = [],
+      context,
+      method
+    }) => {
+      try {
+        const jsonData = {
+          model,
+          method,
+          ids,
+          with_context: context
+        };
+        return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        console.error("Error when calling button action:", error);
+        throw error;
+      }
+    },
+    [env]
+  );
+  const removeRows = useCallback(
+    async ({
+      model,
+      ids,
+      context
+    }) => {
+      const jsonData = {
+        model,
+        method: "unlink",
+        ids,
+        with_context: context
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: { "Content-Type": "application/json" }
+      });
+    },
+    [env]
+  );
+  const duplicateRecord = useCallback(
+    async ({
+      model,
+      id,
+      context
+    }) => {
+      const jsonData = {
+        model,
+        method: "copy",
+        ids: id,
+        with_context: context
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: { "Content-Type": "application/json" }
+      });
+    },
+    [env]
+  );
+  const getPrintReportName = useCallback(
+    async ({ id }) => {
+      const jsonData = {
+        model: "ir.actions.report",
+        method: "web_read",
+        id,
+        kwargs: {
+          specification: {
+            report_name: {}
+          }
+        }
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: { "Content-Type": "application/json" }
+      });
+    },
+    [env]
+  );
+  const print = useCallback(
+    async ({ id, report, db }) => {
+      const jsonData = {
+        report,
+        id,
+        type: "pdf",
+        file_response: true,
+        db
+      };
+      const queryString = toQueryString(jsonData);
+      const urlWithParams = `${"/report" /* REPORT_PATH */}?${queryString}`;
+      return env.requests.get(urlWithParams, {
+        headers: { "Content-Type": "application/json" },
+        responseType: "arraybuffer"
+      });
+    },
+    [env]
+  );
+  const runAction = useCallback(
+    async ({
+      idAction,
+      context
+    }) => {
+      const jsonData = {
+        action_id: idAction,
+        with_context: { ...context }
+      };
+      return env.requests.post("/run_action" /* RUN_ACTION_PATH */, jsonData, {
+        headers: { "Content-Type": "application/json" }
+      });
+    },
+    [env]
+  );
   return {
-    getBrowserSession
+    loadAction,
+    callButton,
+    removeRows,
+    duplicateRecord,
+    getPrintReportName,
+    print,
+    runAction
   };
-};
+}
 
-// src/configs/axios-client.ts
-var axiosClient = {
-  init(config) {
-    const localStorage2 = config?.localStorageUtils ?? localStorageUtils();
-    const sessionStorage2 = config?.sessionStorageUtils ?? sessionStorageUtils();
-    const db = config?.db;
-    let isRefreshing = false;
-    let failedQueue = [];
-    const processQueue = (error, token = null) => {
-      failedQueue?.forEach((prom) => {
-        if (error) {
-          prom.reject(error);
-        } else {
-          prom.resolve(token);
+// src/services/auth-service/index.ts
+import { useCallback as useCallback2 } from "react";
+function useAuthService() {
+  const { env } = useEnv();
+  const login = useCallback2(
+    async (body) => {
+      const payload = Object.fromEntries(
+        Object.entries({
+          username: body.email,
+          password: body.password,
+          grant_type: env?.config?.grantType || "",
+          client_id: env?.config?.clientId || "",
+          client_secret: env?.config?.clientSecret || ""
+        }).filter(([_, value]) => !!value)
+      );
+      const encodedData = new URLSearchParams(payload).toString();
+      return env?.requests?.post(body.path, encodedData, {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
         }
       });
-      failedQueue = [];
-    };
-    const instance = axios.create({
-      adapter: axios.defaults.adapter,
-      baseURL: config.baseUrl,
-      timeout: 5e4,
-      paramsSerializer: (params) => new URLSearchParams(params).toString()
-    });
-    instance.interceptors.request.use(async (config2) => {
-      const { useRefreshToken, useActionToken, actionToken } = config2;
-      if (useActionToken && actionToken) {
-        config2.headers["Action-Token"] = actionToken;
-      }
-      const getToken = useRefreshToken ? localStorage2.getRefreshToken : localStorage2.getAccessToken;
-      const token = await getToken?.();
-      if (token) config2.headers["Authorization"] = `Bearer ${token}`;
-      return config2;
-    }, Promise.reject);
-    instance.interceptors.response.use(
-      (response) => {
-        return handleResponse(response);
-      },
-      async (error) => {
-        const handleError3 = async (error2) => {
-          if (!error2.response) {
-            return error2;
-          }
-          const { data } = error2.response;
-          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
-            await clearAuthToken();
-          }
-          return data;
-        };
-        const originalRequest = error.config;
-        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
-          error.response.data.code
-        )) {
-          if (isRefreshing) {
-            return new Promise(function(resolve, reject) {
-              failedQueue.push({ resolve, reject });
-            }).then((token) => {
-              originalRequest.headers["Authorization"] = "Bearer " + token;
-              originalRequest.data = updateTokenParamInOriginalRequest(
-                originalRequest,
-                token
-              );
-              return instance.request(originalRequest);
-            }).catch(async (err) => {
-              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
-                await clearAuthToken();
-              }
-            });
-          }
-          const browserSession = await sessionStorage2.getBrowserSession();
-          const refreshToken = await localStorage2.getRefreshToken();
-          const accessTokenExp = await localStorage2.getAccessToken();
-          isRefreshing = true;
-          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
-            await clearAuthToken();
-          } else {
-            const payload = Object.fromEntries(
-              Object.entries({
-                refresh_token: refreshToken,
-                grant_type: "refresh_token",
-                client_id: config.config.clientId,
-                client_secret: config.config.clientSecret
-              }).filter(([_, value]) => !!value)
-            );
-            return new Promise(function(resolve) {
-              axios.post(
-                `${config.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
-                payload,
-                {
-                  headers: {
-                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
-                    Authorization: `Bearer ${accessTokenExp}`
-                  }
-                }
-              ).then(async (res) => {
-                const data = res.data;
-                await localStorage2.setToken(data.access_token);
-                await localStorage2.setRefreshToken(data.refresh_token);
-                axios.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
-                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
-                originalRequest.data = updateTokenParamInOriginalRequest(
-                  originalRequest,
-                  data.access_token
-                );
-                processQueue(null, data.access_token);
-                resolve(instance.request(originalRequest));
-              }).catch(async (err) => {
-                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_BAD_REQUEST") || err?.error_code === "ERR_2FA_006") {
-                  await clearAuthToken();
-                }
-                if (err && err.response) {
-                  const { error_code } = err.response?.data || {};
-                  if (error_code === "AUTHEN_FAIL") {
-                    await clearAuthToken();
-                  }
-                }
-                processQueue(err, null);
-              }).finally(() => {
-                isRefreshing = false;
-              });
-            });
+    },
+    [env]
+  );
+  const forgotPassword = useCallback2(
+    async (email) => {
+      const bodyData = {
+        login: email,
+        url: `${window.location.origin}/reset-password`
+      };
+      return env?.requests?.post("/reset_password" /* RESET_PASSWORD_PATH */, bodyData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const forgotPasswordSSO = useCallback2(
+    async ({
+      email,
+      with_context,
+      method
+    }) => {
+      const body = {
+        method,
+        kwargs: {
+          vals: {
+            email
           }
+        },
+        with_context
+      };
+      return env?.requests?.post("/call" /* CALL_PATH */, body, {
+        headers: {
+          "Content-Type": "application/json"
         }
-        return Promise.reject(await handleError3(error));
-      }
-    );
-    const handleResponse = (res) => {
-      if (res && res.data) {
-        return res.data;
-      }
-      return res;
-    };
-    const handleError2 = (error) => {
-      if (error.isAxiosError && error.code === "ECONNABORTED") {
-        console.error("Request Timeout Error:", error);
-        return "Request Timeout Error";
-      } else if (error.isAxiosError && !error.response) {
-        console.error("Network Error:", error);
-        return "Network Error";
-      } else {
-        console.error("Other Error:", error?.response);
-        const errorMessage = error?.response?.data?.message || "An error occurred";
-        return { message: errorMessage, status: error?.response?.status };
-      }
-    };
-    const clearAuthToken = async () => {
-      await localStorage2.clearToken();
-      if (typeof window !== "undefined") {
-        window.location.href = `/login`;
-      }
-    };
-    function formatUrl(url, db2) {
-      return url + (db2 ? "?db=" + db2 : "");
-    }
-    const responseBody = (response) => response;
-    const requests = {
-      get: (url, headers) => instance.get(formatUrl(url, db), headers).then(responseBody),
-      post: (url, body, headers) => instance.post(formatUrl(url, db), body, headers).then(responseBody),
-      post_excel: (url, body, headers) => instance.post(formatUrl(url, db), body, {
-        responseType: "arraybuffer",
+      });
+    },
+    [env]
+  );
+  const resetPassword = useCallback2(
+    async (data, token) => {
+      const bodyData = {
+        token,
+        password: data.password,
+        new_password: data.confirmPassword
+      };
+      return env?.requests?.post("/change_password" /* CHANGE_PASSWORD_PATH */, bodyData, {
         headers: {
-          "Content-Type": typeof window !== "undefined" ? "application/json" : "application/javascript",
-          Accept: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+          "Content-Type": "application/json"
         }
-      }).then(responseBody),
-      put: (url, body, headers) => instance.put(formatUrl(url, db), body, headers).then(responseBody),
-      patch: (url, body) => instance.patch(formatUrl(url, db), body).then(responseBody),
-      delete: (url, body) => instance.delete(formatUrl(url, db), body).then(responseBody)
-    };
-    return requests;
-  }
-};
-
-// src/environment/EnvStore.ts
-var EventEmitter = class {
-  listeners = {};
-  on(event, callback) {
-    if (!this.listeners[event]) {
-      this.listeners[event] = [];
-    }
-    this.listeners[event].push(callback);
-  }
-  emit(event, data) {
-    if (this.listeners[event]) {
-      this.listeners[event].forEach((callback) => callback(data));
-    }
-  }
-};
-var EnvStore = class {
-  state;
-  emitter;
-  localStorageUtil;
-  sessionStorageUtil;
-  constructor(localStorageUtil = localStorageUtils(), sessionStorageUtil = sessionStorageUtils()) {
-    this.state = {
-      baseUrl: "",
-      requests: null,
-      companies: [],
-      user: {},
-      config: null,
-      envFile: null,
-      defaultCompany: {
-        id: null,
-        logo: "",
-        secondary_color: "",
-        primary_color: ""
-      },
-      context: {
-        uid: null,
-        allowed_company_ids: [],
-        lang: "vi_VN",
-        tz: "Asia/Saigon"
-      },
-      localStorageUtils: localStorageUtil,
-      sessionStorageUtils: sessionStorageUtil
-    };
-    this.emitter = new EventEmitter();
-    this.localStorageUtil = localStorageUtil;
-    this.sessionStorageUtil = sessionStorageUtil;
-  }
-  getEnv() {
-    return { ...this.state };
-  }
-  onUpdate(callback) {
-    this.emitter.on("update", callback);
-  }
-  setupEnv(envConfig) {
-    this.state = {
-      ...this.state,
-      ...envConfig,
-      localStorageUtils: this.localStorageUtil,
-      sessionStorageUtils: this.sessionStorageUtil
-    };
-    this.state.requests = axiosClient.init(this.state);
-    this.emitter.emit("update", this.getEnv());
-    return this.getEnv();
-  }
-  setUid(uid) {
-    this.state = {
-      ...this.state,
-      context: { ...this.state.context, uid }
-    };
-    this.emitter.emit("update", this.getEnv());
-  }
-  setLang(lang) {
-    this.state = {
-      ...this.state,
-      context: { ...this.state.context, lang }
-    };
-    this.emitter.emit("update", this.getEnv());
-  }
-  setAllowCompanies(allowed_company_ids) {
-    this.state = {
-      ...this.state,
-      context: { ...this.state.context, allowed_company_ids }
-    };
-    this.emitter.emit("update", this.getEnv());
-  }
-  setCompanies(companies) {
-    this.state = { ...this.state, companies };
-    this.emitter.emit("update", this.getEnv());
-  }
-  setDefaultCompany(defaultCompany) {
-    this.state = { ...this.state, defaultCompany };
-    this.emitter.emit("update", this.getEnv());
-  }
-  setUserInfo(user) {
-    this.state = { ...this.state, user };
-    this.emitter.emit("update", this.getEnv());
-  }
-  setConfig(config) {
-    this.state = { ...this.state, config };
-    this.emitter.emit("update", this.getEnv());
-  }
-  setEnvFile(envFile) {
-    this.state = { ...this.state, envFile };
-    this.emitter.emit("update", this.getEnv());
-  }
-};
-var env = null;
-function initEnv({
-  localStorageUtils: localStorageUtil = localStorageUtils(),
-  sessionStorageUtils: sessionStorageUtil = sessionStorageUtils()
-}) {
-  if (!env) {
-    env = new EnvStore(localStorageUtil, sessionStorageUtil);
-  }
-  return env;
-}
-function getEnv() {
-  if (!env) {
-    env = initEnv({});
-  }
-  return env?.getEnv();
+      });
+    },
+    [env]
+  );
+  const resetPasswordSSO = useCallback2(
+    async ({
+      method,
+      password,
+      with_context
+    }) => {
+      const bodyData = {
+        method,
+        kwargs: {
+          vals: {
+            password
+          }
+        },
+        with_context
+      };
+      return env?.requests?.post("/call" /* CALL_PATH */, bodyData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const updatePassword = useCallback2(
+    async (data, token) => {
+      const bodyData = {
+        token,
+        old_password: data.oldPassword,
+        new_password: data.newPassword
+      };
+      return env?.requests?.post("/change_password_parent" /* UPDATE_PASSWORD_PATH */, bodyData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const isValidToken = useCallback2(
+    async (token) => {
+      const bodyData = {
+        token
+      };
+      return env?.requests?.post("/check_token" /* TOKEN */, bodyData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const isValidActionToken = useCallback2(
+    async (actionToken, path) => {
+      return env?.requests?.post(
+        path,
+        {},
+        {
+          headers: {
+            "Content-Type": "application/json"
+          },
+          useActionToken: true,
+          actionToken
+        }
+      );
+    },
+    [env]
+  );
+  const loginSocial = useCallback2(
+    async ({
+      db,
+      state,
+      access_token
+    }) => {
+      return env?.requests?.post(
+        "/token/generate" /* GENTOKEN_SOCIAL */,
+        { state, access_token },
+        {
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+    },
+    [env]
+  );
+  const getProviders = useCallback2(
+    async (db) => {
+      return env?.requests?.get("/oauth/providers", { params: { db } });
+    },
+    [env]
+  );
+  const getAccessByCode = useCallback2(
+    async (code) => {
+      const data = new URLSearchParams();
+      data.append("code", code);
+      data.append("grant_type", "authorization_code");
+      data.append("client_id", env?.config?.clientId || "");
+      data.append("redirect_uri", env?.config?.redirectUri || "");
+      return env?.requests?.post(
+        `${env?.baseUrl?.replace("/mms/", "/id/")}/${"/token" /* TOKEN_BY_CODE */}`,
+        data,
+        {
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded"
+          }
+        }
+      );
+    },
+    [env]
+  );
+  const logout = useCallback2(
+    async (data) => {
+      console.log(data);
+      return env?.requests?.post(
+        "/logout" /* LOGOUT */,
+        {},
+        {
+          headers: {
+            "Content-Type": "application/json"
+          },
+          withCredentials: true,
+          useRefreshToken: true
+        }
+      );
+    },
+    [env]
+  );
+  return {
+    login,
+    forgotPassword,
+    forgotPasswordSSO,
+    resetPassword,
+    resetPasswordSSO,
+    updatePassword,
+    isValidToken,
+    isValidActionToken,
+    loginSocial,
+    getProviders,
+    getAccessByCode,
+    logout
+  };
 }
 
-// src/services/auth-service/index.ts
-var AuthService = {
-  async login(body) {
-    const env2 = getEnv();
-    const payload = Object.fromEntries(
-      Object.entries({
-        username: body.email,
-        password: body.password,
-        grant_type: env2?.config?.grantType || "",
-        client_id: env2?.config?.clientId || "",
-        client_secret: env2?.config?.clientSecret || ""
-      }).filter(([_, value]) => !!value)
-    );
-    const encodedData = new URLSearchParams(payload).toString();
-    return env2?.requests?.post(body.path, encodedData, {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      }
-    });
-  },
-  async forgotPassword(email) {
-    const env2 = getEnv();
-    const bodyData = {
-      login: email,
-      url: `${window.location.origin}/reset-password`
-    };
-    return env2?.requests?.post("/reset_password" /* RESET_PASSWORD_PATH */, bodyData, {
+// src/services/company-service/index.ts
+import { useCallback as useCallback3 } from "react";
+function useCompanyService() {
+  const { env } = useEnv();
+  const getCurrentCompany = useCallback3(async () => {
+    return await env.requests.get("/company" /* COMPANY_PATH */, {
       headers: {
         "Content-Type": "application/json"
       }
     });
-  },
-  async forgotPasswordSSO({
-    email,
-    with_context,
-    method
-  }) {
-    const env2 = getEnv();
-    const body = {
-      method,
-      kwargs: {
-        vals: {
-          email
+  }, [env]);
+  const getInfoCompany = useCallback3(
+    async (id) => {
+      const jsonData = {
+        ids: [id],
+        model: "res.company" /* COMPANY */,
+        method: "web_read" /* WEB_READ */,
+        kwargs: {
+          specification: {
+            primary_color: {},
+            secondary_color: {},
+            logo: {},
+            display_name: {},
+            secondary_logo: {}
+          }
         }
-      },
-      with_context
-    };
-    return env2?.requests?.post("/call" /* CALL_PATH */, body, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async resetPassword(data, token) {
-    const env2 = getEnv();
-    const bodyData = {
-      token,
-      password: data.password,
-      new_password: data.confirmPassword
-    };
-    return env2?.requests?.post("/change_password" /* CHANGE_PASSWORD_PATH */, bodyData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async resetPasswordSSO({
-    method,
-    password,
-    with_context
-  }) {
-    const env2 = getEnv();
-    const bodyData = {
-      method,
-      kwargs: {
-        vals: {
-          password
+      };
+      return await env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
         }
-      },
-      with_context
-    };
-    return env2?.requests?.post("/call" /* CALL_PATH */, bodyData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async updatePassword(data, token) {
-    const env2 = getEnv();
-    const bodyData = {
-      token,
-      old_password: data.oldPassword,
-      new_password: data.newPassword
-    };
-    return env2?.requests?.post("/change_password_parent" /* UPDATE_PASSWORD_PATH */, bodyData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async isValidToken(token) {
-    const env2 = getEnv();
-    const bodyData = {
-      token
-    };
-    return env2?.requests?.post("/check_token" /* TOKEN */, bodyData, {
-      headers: {
-        "Content-Type": "application/json"
+      });
+    },
+    [env]
+  );
+  return {
+    getCurrentCompany,
+    getInfoCompany
+  };
+}
+
+// src/services/excel-service/index.ts
+import { useCallback as useCallback4 } from "react";
+function useExcelService() {
+  const { env } = useEnv();
+  const uploadFile = useCallback4(
+    async ({ formData }) => {
+      return env.requests.post("/upload/file" /* UPLOAD_FILE_PATH */, formData, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    },
+    [env]
+  );
+  const uploadIdFile = useCallback4(
+    async ({ formData }) => {
+      return env.requests.post("/upload/file" /* UPLOAD_FILE_PATH */, formData, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    },
+    [env]
+  );
+  const parsePreview = useCallback4(
+    async ({
+      id,
+      selectedSheet,
+      isHeader,
+      context
+    }) => {
+      const jsonData = {
+        model: "base_import.import" /* BASE_IMPORT */,
+        method: "parse_preview",
+        ids: [id],
+        kwargs: {
+          options: {
+            import_skip_records: [],
+            import_set_empty_fields: [],
+            fallback_values: {},
+            name_create_enabled_fields: {},
+            encoding: "",
+            separator: "",
+            quoting: '"',
+            date_format: "",
+            datetime_format: "",
+            float_thousand_separator: ",",
+            float_decimal_separator: ".",
+            advanced: true,
+            has_headers: isHeader,
+            keep_matches: false,
+            limit: 2e3,
+            sheets: [],
+            sheet: selectedSheet,
+            skip: 0,
+            tracking_disable: true
+          }
+        },
+        with_context: context
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    },
+    [env]
+  );
+  const executeImport = useCallback4(
+    async ({
+      columns,
+      fields,
+      idFile,
+      options,
+      dryrun,
+      context
+    }) => {
+      const jsonData = {
+        model: "base_import.import" /* BASE_IMPORT */,
+        method: "execute_import",
+        ids: [idFile],
+        kwargs: {
+          fields,
+          columns,
+          options,
+          dryrun
+        },
+        with_context: context
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    },
+    [env]
+  );
+  const getFileExcel = useCallback4(
+    async ({ model }) => {
+      const jsonData = {
+        model,
+        method: "get_import_templates" /* GET_IMPORT */,
+        args: []
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData);
+    },
+    [env]
+  );
+  const getFieldExport = useCallback4(
+    async ({
+      ids,
+      model,
+      isShow,
+      parentField,
+      fieldType,
+      parentName,
+      prefix,
+      name,
+      context,
+      importCompat
+    }) => {
+      const jsonData = {
+        model,
+        import_compat: importCompat,
+        domain: [["id", "in", ids]],
+        with_context: context
+      };
+      if (isShow) {
+        jsonData.parent_field = parentField;
+        jsonData.parent_field_type = fieldType;
+        jsonData.parent_name = parentName;
+        jsonData.name = name;
+        jsonData.prefix = prefix;
+        jsonData.exclude = [null];
       }
-    });
-  },
-  async isValidActionToken(actionToken, path) {
-    const env2 = getEnv();
-    return env2?.requests?.post(
-      path,
-      {},
-      {
+      return env.requests.post("/export/get_fields", jsonData);
+    },
+    [env]
+  );
+  const exportExcel = useCallback4(
+    async ({
+      model,
+      domain,
+      ids,
+      fields,
+      type,
+      importCompat,
+      context,
+      groupby
+    }) => {
+      const jsonData = {
+        model,
+        domain,
+        ids,
+        import_compat: importCompat,
+        fields,
+        with_context: context,
+        groupby: groupby ?? []
+      };
+      return env.requests.post_excel(`/export/${type}`, jsonData);
+    },
+    [env]
+  );
+  return {
+    uploadFile,
+    uploadIdFile,
+    parsePreview,
+    executeImport,
+    getFileExcel,
+    getFieldExport,
+    exportExcel
+  };
+}
+
+// src/services/form-service/index.ts
+import { useCallback as useCallback5 } from "react";
+function useFormService() {
+  const { env } = useEnv();
+  const getComment = useCallback5(
+    async ({ data }) => {
+      const jsonData = {
+        thread_id: data.thread_id,
+        thread_model: data.thread_model,
+        limit: 100,
+        with_context: {
+          lang: data.lang
+        }
+      };
+      return env.requests.post("/chatter/thread/messages" /* GET_MESSAGE */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const sentComment = useCallback5(
+    async ({ data }) => {
+      const jsonData = {
+        context: {
+          tz: "Asia/Saigon",
+          uid: 2,
+          allowed_company_ids: [1],
+          mail_post_autofollow: false,
+          temporary_id: 142183.01
+        },
+        post_data: {
+          body: data.message,
+          message_type: "comment",
+          attachment_ids: data.attachment_ids,
+          attachment_tokens: [],
+          subtype_xmlid: data.subtype
+        },
+        thread_id: Number(data.thread_id),
+        thread_model: data.thread_model
+      };
+      return env.requests.post("/chatter/message/post" /* SENT_MESSAGE */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const deleteComment = useCallback5(
+    async ({ data }) => {
+      const jsonData = {
+        attachment_ids: [],
+        attachment_tokens: [],
+        body: "",
+        message_id: data.message_id
+      };
+      return env.requests.post("/chatter/message/update_content" /* DELETE_MESSAGE */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const getImage = useCallback5(
+    async ({ data }) => {
+      return env.requests.get(
+        `${"/web/image" /* IMAGE_PATH */}?filename=${data.filename}&unique=${data.checksum}&width=1920&height=300`,
+        {
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+    },
+    [env]
+  );
+  const uploadImage = useCallback5(
+    async ({ data }) => {
+      return env.requests.post("/mail/attachment/upload" /* UPLOAD_IMAGE */, data, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    },
+    [env]
+  );
+  const getFormView = useCallback5(
+    async ({ data }) => {
+      const jsonData = {
+        model: data.model,
+        method: "get_formview_action",
+        ids: data.id ? [data.id] : [],
+        with_context: data.context
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const changeStatus = useCallback5(
+    async ({ data }) => {
+      const vals = {
+        [data.name]: data.stage_id
+      };
+      const jsonData = {
+        model: data.model,
+        method: "web_save",
+        with_context: {
+          lang: data.lang,
+          allowed_company_ids: [1],
+          uid: 2,
+          search_default_my_ticket: true,
+          search_default_is_open: true
+        },
+        ids: [data.id],
+        kwargs: {
+          vals,
+          specification: {}
+        }
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  return {
+    getComment,
+    sentComment,
+    deleteComment,
+    getImage,
+    uploadImage,
+    getFormView,
+    changeStatus
+  };
+}
+
+// src/services/kanban-service/index.ts
+import { useCallback as useCallback6 } from "react";
+function useKanbanService() {
+  const { env } = useEnv();
+  const getGroups = useCallback6(
+    async ({ model, width_context }) => {
+      const jsonData = {
+        model,
+        method: "web_read_group",
+        kwargs: {
+          domain: [["stage_id.fold", "=", false]],
+          fields: ["color:sum"],
+          groupby: ["stage_id"]
+        },
+        width_context
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const getProgressBar = useCallback6(
+    async ({ field, color, model, width_context }) => {
+      const jsonData = {
+        model,
+        method: "read_progress_bar",
+        kwargs: {
+          domain: [],
+          group_by: "stage_id",
+          progress_bar: {
+            colors: color,
+            field
+          }
         },
-        useActionToken: true,
-        actionToken
-      }
-    );
-  },
-  async loginSocial({
-    db,
-    state,
-    access_token
-  }) {
-    const env2 = getEnv();
-    return env2?.requests?.post(
-      "/token/generate" /* GENTOKEN_SOCIAL */,
-      { state, access_token },
-      {
+        width_context
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
-      }
-    );
-  },
-  async getProviders(db) {
-    const env2 = getEnv();
-    return env2?.requests?.get("/oauth/providers", { params: { db } });
-  },
-  async getAccessByCode(code) {
-    const env2 = getEnv();
-    const data = new URLSearchParams();
-    data.append("code", code);
-    data.append("grant_type", "authorization_code");
-    data.append("client_id", env2?.config?.clientId || "");
-    data.append("redirect_uri", env2?.config?.redirectUri || "");
-    return env2?.requests?.post(
-      `${env2?.baseUrl?.replace("/mms/", "/id/")}/${"/token" /* TOKEN_BY_CODE */}`,
-      data,
-      {
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
+      });
+    },
+    [env]
+  );
+  return {
+    getGroups,
+    getProgressBar
+  };
+}
+
+// src/services/model-service/index.ts
+import { useCallback as useCallback7 } from "react";
+var OBJECT_POSITION = 2;
+function useModelService() {
+  const { env } = useEnv();
+  const getListMyBankAccount = useCallback7(
+    async ({
+      domain,
+      spectification,
+      model
+    }) => {
+      const jsonData = {
+        model,
+        method: "web_search_read",
+        kwargs: {
+          specification: spectification,
+          domain,
+          limit: 100,
+          offset: 0
         }
-      }
-    );
-  },
-  async logout(data) {
-    const env2 = getEnv();
-    console.log(data);
-    return env2?.requests?.post(
-      "/logout" /* LOGOUT */,
-      {},
-      {
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
-        },
-        withCredentials: true,
-        useRefreshToken: true
-      }
-    );
-  }
-};
-var auth_service_default = AuthService;
-
-// src/services/company-service/index.ts
-var CompanyService = {
-  async getCurrentCompany() {
-    const env2 = getEnv();
-    return await env2.requests.get("/company" /* COMPANY_PATH */, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async getInfoCompany(id) {
-    const env2 = getEnv();
+        }
+      });
+    },
+    [env]
+  );
+  const getCurrency = useCallback7(async () => {
     const jsonData = {
-      ids: [id],
-      model: "res.company" /* COMPANY */,
-      method: "web_read" /* WEB_READ */,
+      model: "res.currency",
+      method: "web_search_read",
       kwargs: {
         specification: {
-          primary_color: {},
-          secondary_color: {},
-          logo: {},
-          display_name: {},
-          secondary_logo: {}
-        }
+          icon_url: {},
+          name: {}
+        },
+        domain: [["active", "=", true]],
+        limit: 100,
+        offset: 0
       }
     };
-    return await env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+    return env.requests.post("/call" /* CALL_PATH */, jsonData, {
       headers: {
         "Content-Type": "application/json"
       }
     });
-  }
-};
-var company_service_default = CompanyService;
-
-// src/services/excel-service/index.ts
-var ExcelService = {
-  async uploadFile({ formData }) {
-    const env2 = getEnv();
-    return env2.requests.post(`${"/upload/file" /* UPLOAD_FILE_PATH */}`, formData, {
-      headers: {
-        "Content-Type": "multipart/form-data"
-      }
-    });
-  },
-  async uploadIdFile({ formData }) {
-    const env2 = getEnv();
-    return env2.requests.post(`${"/upload/file" /* UPLOAD_FILE_PATH */}`, formData, {
-      headers: {
-        "Content-Type": "multipart/form-data"
-      }
-    });
-  },
-  async parsePreview({
-    id,
-    selectedSheet,
-    isHeader,
-    context
-  }) {
-    const env2 = getEnv();
+  }, [env]);
+  const getConversionRate = useCallback7(async () => {
     const jsonData = {
-      model: "base_import.import" /* BASE_IMPORT */,
-      method: "parse_preview",
-      ids: [id],
+      model: "res.currency",
+      method: "web_search_read",
       kwargs: {
-        options: {
-          import_skip_records: [],
-          import_set_empty_fields: [],
-          fallback_values: {},
-          name_create_enabled_fields: {},
-          encoding: "",
-          separator: "",
-          quoting: '"',
-          date_format: "",
-          datetime_format: "",
-          float_thousand_separator: ",",
-          float_decimal_separator: ".",
-          advanced: true,
-          has_headers: isHeader,
-          keep_matches: false,
-          limit: 2e3,
-          sheets: [],
-          sheet: selectedSheet,
-          skip: 0,
-          tracking_disable: true
-        }
-      },
-      with_context: context
-    };
-    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "multipart/form-data"
+        specification: {
+          name: {},
+          icon_url: {},
+          rate_ids: {
+            fields: {
+              company_rate: {},
+              sell: {}
+            }
+          }
+        },
+        domain: [["active", "=", true]],
+        limit: 100,
+        offset: 0
       }
-    });
-  },
-  async executeImport({
-    columns,
-    fields,
-    idFile,
-    options,
-    dryrun,
-    context
-  }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model: "base_import.import" /* BASE_IMPORT */,
-      method: "execute_import",
-      ids: [idFile],
-      kwargs: {
-        fields,
-        columns,
-        options,
-        dryrun
-      },
-      with_context: context
     };
-    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+    return env.requests.post("/call" /* CALL_PATH */, jsonData, {
       headers: {
-        "Content-Type": "multipart/form-data"
+        "Content-Type": "application/json"
       }
     });
-  },
-  async getFileExcel({ model }) {
-    const env2 = getEnv();
-    const jsonData = {
+  }, [env]);
+  const getAll = useCallback7(
+    async ({ data }) => {
+      const jsonReadGroup = data.type == "calendar" ? { fields: data?.fields } : data.fields && data.fields.length > 0 && data.groupby && data.groupby.length > 0 && data.groupby[0] ? {
+        fields: data.fields,
+        groupby: data.groupby
+      } : {
+        count_limit: 10001,
+        order: data.sort,
+        specification: data.specification
+      };
+      const jsonData = {
+        model: String(data.model),
+        method: data.type == "calendar" ? "search_read" : jsonReadGroup.fields && jsonReadGroup.groupby ? "web_read_group" : "web_search_read",
+        ids: data.ids,
+        with_context: data.context,
+        kwargs: {
+          domain: data.domain,
+          limit: data.limit,
+          offset: data.offset,
+          ...jsonReadGroup
+        }
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const getListCalendar = useCallback7(
+    async ({ data }) => {
+      const jsonReadGroup = data.type == "calendar" ? data?.fields : data.fields && data.fields.length > 0 && data.groupby && data.groupby.length > 0 && data.groupby[0] ? {
+        fields: data.fields,
+        groupby: data.groupby
+      } : {
+        count_limit: 10001,
+        order: data.sort,
+        specification: data.specification
+      };
+      const jsonData = {
+        model: String(data.model),
+        method: data.type == "calendar" ? "search_read" : jsonReadGroup.fields && jsonReadGroup.groupby ? "web_read_group" : "web_search_read",
+        ids: data.ids,
+        with_context: data.context,
+        kwargs: {
+          domain: data.domain,
+          limit: data.limit,
+          offset: data.offset,
+          fields: data.fields,
+          ...jsonReadGroup
+        }
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const getList = useCallback7(
+    async ({
       model,
-      method: "get_import_templates" /* GET_IMPORT */,
-      args: []
-    };
-    return env2.requests.post("/call" /* CALL_PATH */, jsonData);
-  },
-  async getFieldExport({
-    ids,
-    model,
-    isShow,
-    parentField,
-    fieldType,
-    parentName,
-    prefix,
-    name,
-    context,
-    importCompat
-  }) {
-    const env2 = getEnv();
-    const jsonData = {
+      ids = [],
+      specification = {},
+      domain = [],
+      offset,
+      order,
+      context = {},
+      limit = 10
+    }) => {
+      const jsonData = {
+        model,
+        method: "web_search_read" /* WEB_SEARCH_READ */,
+        ids,
+        with_context: context,
+        kwargs: {
+          specification,
+          domain,
+          limit,
+          offset,
+          order
+        }
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const getDetail = useCallback7(
+    async ({ ids = [], model, specification, context }) => {
+      const jsonData = {
+        model,
+        method: "web_read" /* WEB_READ */,
+        ids,
+        with_context: context,
+        kwargs: {
+          specification
+        }
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const save = useCallback7(
+    async ({
       model,
-      import_compat: importCompat,
-      domain: [["id", "in", ids]],
-      with_context: context
-    };
-    if (isShow) {
-      jsonData.parent_field = parentField;
-      jsonData.parent_field_type = fieldType;
-      jsonData.parent_name = parentName;
-      jsonData.name = name;
-      jsonData.prefix = prefix;
-      jsonData.exclude = [null];
-    }
-    return env2.requests.post("/export/get_fields", jsonData);
-  },
-  async exportExcel({
-    model,
-    domain,
-    ids,
-    fields,
-    type,
-    importCompat,
-    context,
-    groupby
-  }) {
-    const env2 = getEnv();
-    const jsonData = {
+      ids = [],
+      data = {},
+      specification = {},
+      context = {},
+      path
+    }) => {
+      const jsonData = {
+        model,
+        method: "web_save" /* WEB_SAVE */,
+        with_context: context,
+        ids,
+        kwargs: {
+          vals: data,
+          specification
+        }
+      };
+      return env.requests.post(path ?? "/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const deleteApi = useCallback7(
+    async ({ ids = [], model }) => {
+      const jsonData = {
+        model,
+        method: "unlink" /* UNLINK */,
+        ids
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const onChange = useCallback7(
+    async ({
+      ids = [],
       model,
-      domain,
-      ids,
-      import_compat: importCompat,
-      fields,
-      with_context: context,
-      groupby: groupby ?? []
-    };
-    return env2.requests.post_excel(`/export/${type}`, jsonData);
-  }
-};
-var excel_service_default = ExcelService;
+      object,
+      specification,
+      context,
+      fieldChange
+    }) => {
+      const jsonData = {
+        model,
+        method: "onchange" /* ONCHANGE */,
+        ids,
+        with_context: context,
+        args: [
+          object ? object : {},
+          fieldChange ? fieldChange : [],
+          specification
+        ]
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const getListFieldsOnchange = useCallback7(
+    async ({ model }) => {
+      const jsonData = {
+        model,
+        method: "get_fields_onchange" /* GET_ONCHANGE_FIELDS */
+      };
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const parseORMOdoo = useCallback7((data) => {
+    for (const key in data) {
+      if (key === "display_name") {
+        delete data[key];
+      }
+      if (!data[key] && data[key] !== 0) {
+        data[key] = false;
+      } else if (data[key] === "Draft") {
+        data[key] = "/";
+      }
+    }
+    return { ...data };
+  }, []);
+  const toDataJS = useCallback7(
+    (data, viewData, model) => {
+      for (const key in data) {
+        if (data[key] === false) {
+          if (viewData && model) {
+            if (viewData?.models?.[model]?.[key]?.type !== "boolean" /* BOOLEAN */) {
+              data[key] = null;
+            }
+          } else {
+            data[key] = null;
+          }
+        } else if (data[key] === "/") {
+          data[key] = "Draft";
+        } else if (data[key] !== false) {
+          if (model !== void 0) {
+            if (viewData?.models?.[model]?.[key]?.type === "one2many" /* ONE2MANY */ || viewData?.models?.[model]?.[key]?.type === "many2many" /* MANY2MANY */) {
+              data[key] = (data[key] ??= [])?.map((item) => {
+                const relation = viewData?.models?.[model]?.[key]?.relation;
+                if (relation !== void 0) {
+                  if (viewData?.models?.[relation]) {
+                    if (item?.length >= 3) {
+                      return toDataJS(item[OBJECT_POSITION], viewData, relation);
+                    } else {
+                      return toDataJS(item, viewData, relation);
+                    }
+                  } else {
+                    if (item?.length >= 3) {
+                      return item[OBJECT_POSITION];
+                    } else {
+                      return item;
+                    }
+                  }
+                }
+              });
+            }
+          }
+        }
+      }
+      return { ...data };
+    },
+    []
+  );
+  return {
+    getListMyBankAccount,
+    getCurrency,
+    getConversionRate,
+    getAll,
+    getListCalendar,
+    getList,
+    getDetail,
+    save,
+    deleteApi,
+    onChange,
+    getListFieldsOnchange,
+    parseORMOdoo,
+    toDataJS
+  };
+}
 
-// src/services/form-service/index.ts
-var FormService = {
-  async getComment({ data }) {
-    try {
-      const env2 = getEnv();
+// src/services/user-service/index.ts
+import { useCallback as useCallback8 } from "react";
+function useUserService() {
+  const { env } = useEnv();
+  const getProfile = useCallback8(
+    async (path) => {
+      return env?.requests?.get(path ?? "/userinfo" /* PROFILE_PATH */, {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+    },
+    [env]
+  );
+  const getUser = useCallback8(
+    async ({ context, id }) => {
       const jsonData = {
-        thread_id: data.thread_id,
-        thread_model: data.thread_model,
-        limit: 100,
-        with_context: {
-          lang: data.lang
+        model: "res.users",
+        method: "web_read",
+        ids: [id],
+        with_context: context,
+        kwargs: {
+          specification: {
+            display_name: {},
+            image_1920: {},
+            name: {},
+            login: {},
+            email: {},
+            password: {},
+            visible_group_id: {
+              fields: {
+                id: {},
+                display_name: {}
+              }
+            },
+            company_id: {
+              fields: {
+                id: {},
+                display_name: {}
+              }
+            }
+          }
         }
       };
-      return env2.requests.post("/chatter/thread/messages" /* GET_MESSAGE */, jsonData, {
+      return env.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
-    } catch (error) {
-      console.error("Error when sending message:", error);
-      throw error;
-    }
-  },
-  async sentComment({ data }) {
-    try {
-      const env2 = getEnv();
+    },
+    [env]
+  );
+  const switchUserLocale = useCallback8(
+    async ({ id, values }) => {
       const jsonData = {
-        context: {
-          tz: "Asia/Saigon",
-          uid: 2,
-          allowed_company_ids: [1],
-          mail_post_autofollow: false,
-          temporary_id: 142183.01
-        },
-        post_data: {
-          body: data.message,
-          message_type: "comment",
-          attachment_ids: data.attachment_ids,
-          attachment_tokens: [],
-          subtype_xmlid: data.subtype
+        model: "res.users",
+        domain: [["id", "=", id]],
+        values
+      };
+      return env?.requests.post(UriConstants?.CREATE_UPDATE_PATH, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  return {
+    getProfile,
+    getUser,
+    switchUserLocale
+  };
+}
+
+// src/services/view-service/index.ts
+import { useCallback as useCallback9 } from "react";
+function useViewService() {
+  const { env } = useEnv();
+  const getView = useCallback9(
+    async ({
+      model,
+      views,
+      context = {},
+      options = {},
+      aid
+    }) => {
+      const defaultOptions = {
+        load_filters: true,
+        toolbar: true,
+        action_id: aid
+      };
+      const jsonDataView = {
+        model,
+        method: "get_fields_view_v2" /* GET_FIELD_VIEW */,
+        kwargs: {
+          views,
+          options: { ...options, ...defaultOptions }
         },
-        thread_id: Number(data.thread_id),
-        thread_model: data.thread_model
+        with_context: context
       };
-      return env2.requests.post("/chatter/message/post" /* SENT_MESSAGE */, jsonData, {
+      return env?.requests?.post("/call" /* CALL_PATH */, jsonDataView, {
         headers: {
           "Content-Type": "application/json"
         }
       });
-    } catch (error) {
-      console.error("Error when sent message:", error);
-      throw error;
-    }
-  },
-  async deleteComment({ data }) {
-    try {
-      const env2 = getEnv();
+    },
+    [env]
+  );
+  const getMenu = useCallback9(
+    async (context) => {
       const jsonData = {
-        attachment_ids: [],
-        attachment_tokens: [],
-        body: "",
-        message_id: data.message_id
+        model: "ir.ui.menu" /* MENU */,
+        method: "web_search_read" /* WEB_SEARCH_READ */,
+        ids: [],
+        with_context: context,
+        kwargs: {
+          specification: {
+            active: {},
+            name: {},
+            is_display: {},
+            sequence: {},
+            complete_name: {},
+            action: {
+              fields: {
+                display_name: {},
+                type: {},
+                binding_view_types: {}
+              }
+            },
+            url_icon: {},
+            web_icon: {},
+            web_icon_data: {},
+            groups_id: {
+              fields: {
+                full_name: {}
+              },
+              limit: 40,
+              order: ""
+            },
+            display_name: {},
+            child_id: {
+              fields: {
+                active: {},
+                name: {},
+                is_display: {},
+                sequence: {},
+                complete_name: {},
+                action: {
+                  fields: {
+                    display_name: {},
+                    type: {},
+                    binding_view_types: {}
+                  }
+                },
+                url_icon: {},
+                web_icon: {},
+                web_icon_data: {},
+                groups_id: {
+                  fields: {
+                    full_name: {}
+                  },
+                  limit: 40,
+                  order: ""
+                },
+                display_name: {},
+                child_id: {
+                  fields: {
+                    active: {},
+                    name: {},
+                    is_display: {},
+                    sequence: {},
+                    complete_name: {},
+                    action: {
+                      fields: {
+                        display_name: {},
+                        type: {},
+                        binding_view_types: {}
+                      }
+                    },
+                    url_icon: {},
+                    web_icon: {},
+                    web_icon_data: {},
+                    groups_id: {
+                      fields: {
+                        full_name: {}
+                      },
+                      limit: 40,
+                      order: ""
+                    },
+                    display_name: {},
+                    child_id: {
+                      fields: {},
+                      limit: 40,
+                      order: ""
+                    }
+                  },
+                  limit: 40,
+                  order: ""
+                }
+              },
+              limit: 40,
+              order: ""
+            }
+          },
+          domain: [
+            "&",
+            ["is_display", "=", true],
+            "&",
+            ["active", "=", true],
+            ["parent_id", "=", false]
+          ]
+        }
       };
-      return env2.requests.post("/chatter/message/update_content" /* DELETE_MESSAGE */, jsonData, {
+      return env?.requests?.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
-    } catch (error) {
-      console.error("Error when sent message:", error);
-      throw error;
-    }
-  },
-  async getImage({ data }) {
-    try {
-      const env2 = getEnv();
-      return env2.requests.get(
-        `${"/web/image" /* IMAGE_PATH */}?filename=${data.filename}&unique=${data.checksum}&width=1920&height=300`,
-        {
-          headers: {
-            "Content-Type": "application/json"
+    },
+    [env]
+  );
+  const getActionDetail = useCallback9(
+    async (aid, context) => {
+      const jsonData = {
+        model: "ir.actions.act_window" /* WINDOW_ACTION */,
+        method: "web_read" /* WEB_READ */,
+        ids: [aid],
+        with_context: context,
+        kwargs: {
+          specification: {
+            id: {},
+            name: {},
+            res_model: {},
+            views: {},
+            view_mode: {},
+            mobile_view_mode: {},
+            domain: {},
+            context: {},
+            groups_id: {},
+            search_view_id: {}
           }
         }
-      );
-    } catch (error) {
-      console.error("Error when sent message:", error);
-      throw error;
-    }
-  },
-  async uploadImage({ data }) {
-    try {
-      const env2 = getEnv();
-      return env2.requests.post("/mail/attachment/upload" /* UPLOAD_IMAGE */, data, {
+      };
+      return env?.requests?.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    },
+    [env]
+  );
+  const getResequence = useCallback9(
+    async ({
+      model,
+      ids,
+      context,
+      offset
+    }) => {
+      const jsonData = {
+        model,
+        with_context: context,
+        ids,
+        field: "sequence",
+        ...offset > 0 ? { offset } : {}
+      };
+      return env?.requests.post("/web/dataset/resequence", jsonData, {
         headers: {
-          "Content-Type": "multipart/form-data"
+          "Content-Type": "application/json"
         }
       });
-    } catch (error) {
-      console.error("Error when sent message:", error);
-      throw error;
-    }
-  },
-  async getFormView({ data }) {
-    try {
-      const env2 = getEnv();
+    },
+    [env]
+  );
+  const getSelectionItem = useCallback9(
+    async ({ data }) => {
       const jsonData = {
         model: data.model,
-        method: "get_formview_action",
-        ids: data.id ? [data.id] : [],
-        with_context: data.context
+        ids: [],
+        method: "get_data_select",
+        with_context: data.context,
+        kwargs: {
+          count_limit: 10001,
+          domain: data.domain ? data.domain : [],
+          offset: 0,
+          order: "",
+          specification: data?.specification ?? {
+            id: {},
+            name: {},
+            display_name: {}
+          }
+        }
       };
-      return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      return env?.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
-    } catch (error) {
-      console.error("Error when fetching form view:", error);
-      throw error;
-    }
-  },
-  async changeStatus({ data }) {
-    const env2 = getEnv();
-    const vals = {
-      [data.name]: data.stage_id
-    };
-    const jsonData = {
-      model: data.model,
-      method: "web_save",
-      with_context: {
-        lang: data.lang,
-        allowed_company_ids: [1],
-        uid: 2,
-        search_default_my_ticket: true,
-        search_default_is_open: true
-      },
-      ids: [data.id],
-      kwargs: {
-        vals,
-        specification: {}
-      }
-    };
-    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  }
-};
-var form_service_default = FormService;
-
-// src/services/model-service/index.ts
-var OBJECT_POSITION = 2;
-var ModelService = {
-  async getListMyBankAccount({
-    domain,
-    spectification,
-    model
-  }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model,
-      method: "web_search_read",
-      kwargs: {
-        specification: spectification,
-        domain,
-        limit: 100,
-        offset: 0
-      }
-    };
-    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async getCurrency() {
-    const env2 = getEnv();
-    const jsonData = {
-      model: "res.currency",
-      method: "web_search_read",
-      kwargs: {
-        specification: {
-          icon_url: {},
-          name: {}
-        },
-        domain: [["active", "=", true]],
-        limit: 100,
-        offset: 0
-      }
-    };
-    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async getConversionRate() {
-    const env2 = getEnv();
-    const jsonData = {
-      model: "res.currency",
-      method: "web_search_read",
-      kwargs: {
-        specification: {
-          name: {},
-          icon_url: {},
-          rate_ids: {
-            fields: {
-              company_rate: {},
-              sell: {}
-            }
-          }
-        },
-        domain: [["active", "=", true]],
-        limit: 100,
-        offset: 0
-      }
-    };
-    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async getAll({ data }) {
-    const env2 = getEnv();
-    const jsonReadGroup = data.type == "calendar" ? { fields: data?.fields } : data.fields && data.fields.length > 0 && data.groupby && data.groupby.length > 0 && data.groupby[0] ? {
-      fields: data.fields,
-      groupby: data.groupby
-    } : {
-      count_limit: 10001,
-      order: data.sort,
-      specification: data.specification
-    };
-    const jsonData = {
-      model: String(data.model),
-      method: data.type == "calendar" ? "search_read" : jsonReadGroup.fields && jsonReadGroup.groupby ? "web_read_group" : "web_search_read",
-      ids: data.ids,
-      with_context: data.context,
-      kwargs: {
-        domain: data.domain,
-        limit: data.limit,
-        offset: data.offset,
-        ...jsonReadGroup
-      }
-    };
-    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async getListCalendar({ data }) {
-    const env2 = getEnv();
-    const jsonReadGroup = data.type == "calendar" ? data?.fields : data.fields && data.fields.length > 0 && data.groupby && data.groupby.length > 0 && data.groupby[0] ? {
-      fields: data.fields,
-      groupby: data.groupby
-    } : {
-      count_limit: 10001,
-      order: data.sort,
-      specification: data.specification
-    };
-    const jsonData = {
-      model: String(data.model),
-      method: data.type == "calendar" ? "search_read" : jsonReadGroup.fields && jsonReadGroup.groupby ? "web_read_group" : "web_search_read",
-      ids: data.ids,
-      with_context: data.context,
-      kwargs: {
-        domain: data.domain,
-        limit: data.limit,
-        offset: data.offset,
-        fields: data.fields,
-        ...jsonReadGroup
-      }
-    };
-    return env2?.requests.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async getList({
-    model,
-    ids = [],
-    specification = {},
-    domain = [],
-    offset,
-    order,
-    context = {},
-    limit = 10
-  }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model,
-      method: "web_search_read" /* WEB_SEARCH_READ */,
-      ids,
-      with_context: context,
-      kwargs: {
-        specification,
-        domain,
-        limit,
-        offset,
-        order
-      }
-    };
-    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async getDetail({
-    ids = [],
-    model,
-    specification,
-    context
-  }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model,
-      method: "web_read" /* WEB_READ */,
-      ids,
-      with_context: context,
-      kwargs: {
-        specification
-      }
-    };
-    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async save({
-    model,
-    ids = [],
-    data = {},
-    specification = {},
-    context = {},
-    path
-  }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model,
-      method: "web_save" /* WEB_SAVE */,
-      with_context: context,
-      ids,
-      kwargs: {
-        vals: data,
-        specification
-      }
-    };
-    return env2?.requests?.post(path ?? "/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async delete({ ids = [], model }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model,
-      method: "unlink" /* UNLINK */,
-      ids
-    };
-    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async onChange({
-    ids = [],
-    model,
-    object,
-    specification,
-    context,
-    fieldChange
-  }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model,
-      method: "onchange" /* ONCHANGE */,
-      ids,
-      with_context: context,
-      args: [
-        object ? object : {},
-        fieldChange ? fieldChange : [],
-        specification
-      ]
-    };
-    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  async getListFieldsOnchange({ model }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model,
-      method: "get_fields_onchange" /* GET_ONCHANGE_FIELDS */
-    };
-    return env2?.requests?.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  parseORMOdoo(data) {
-    for (const key in data) {
-      if (key === "display_name") {
-        delete data[key];
-      }
-      if (!data[key] && data[key] !== 0) {
-        data[key] = false;
-      } else if (data[key] === "Draft") {
-        data[key] = "/";
-      }
-    }
-    return { ...data };
-  },
-  toDataJS(data, viewData, model) {
-    for (const key in data) {
-      if (data[key] === false) {
-        if (viewData && model) {
-          if (viewData?.models?.[model]?.[key]?.type !== "boolean" /* BOOLEAN */) {
-            data[key] = null;
-          }
-        } else {
-          data[key] = null;
-        }
-      } else if (data[key] === "/") {
-        data[key] = "Draft";
-      } else if (data[key] !== false) {
-        if (model !== void 0) {
-          if (viewData?.models?.[model]?.[key]?.type === "one2many" /* ONE2MANY */ || viewData?.models?.[model]?.[key]?.type === "many2many" /* MANY2MANY */) {
-            data[key] = (data[key] ??= [])?.map((item) => {
-              const relation = viewData?.models?.[model]?.[key]?.relation;
-              if (relation !== void 0) {
-                if (viewData?.models?.[relation]) {
-                  if (item?.length >= 3) {
-                    return ModelService.toDataJS(
-                      item[OBJECT_POSITION],
-                      viewData,
-                      relation
-                    );
-                  } else {
-                    return ModelService.toDataJS(item, viewData, relation);
-                  }
-                } else {
-                  if (item?.length >= 3) {
-                    return item[OBJECT_POSITION];
-                  } else {
-                    return item;
-                  }
-                }
-              }
-            });
-          }
-        }
-      }
-    }
-    return { ...data };
-  }
-};
-var model_service_default = ModelService;
-
-// src/services/user-service/index.ts
-var UserService = {
-  async getProfile(path) {
-    const env2 = getEnv();
-    return env2?.requests?.get(path ?? "/userinfo" /* PROFILE_PATH */, {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      }
-    });
-  },
-  async getUser({ context, id }) {
-    const env2 = getEnv();
-    const jsonData = {
-      model: "res.users",
-      method: "web_read",
-      ids: [id],
-      with_context: context,
-      kwargs: {
-        specification: {
-          display_name: {},
-          image_1920: {},
-          name: {},
-          login: {},
-          email: {},
-          password: {},
-          visible_group_id: {
-            fields: {
-              id: {},
-              display_name: {}
-            }
-          },
-          company_id: {
-            fields: {
-              id: {},
-              display_name: {}
-            }
-          }
-        }
-      }
-    };
-    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-  },
-  switchUserLocale: async ({ id, values }) => {
-    const env2 = getEnv();
-    const jsonData = {
-      model: "res.users",
-      domain: [["id", "=", id]],
-      values
-    };
-    return env2?.requests.post(UriConstants?.CREATE_UPDATE_PATH, jsonData, {
+    },
+    [env]
+  );
+  const loadMessages = useCallback9(async () => {
+    return env.requests.post(
+      "/load_message_failures" /* LOAD_MESSAGE */,
+      {},
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+  }, [env]);
+  const getVersion = useCallback9(async () => {
+    return env?.requests?.get("", {
       headers: {
         "Content-Type": "application/json"
       }
     });
-  }
-};
-var user_service_default = UserService;
-
-// src/hooks/auth/use-forgot-password.ts
-var useForgotPassword = () => {
-  return useMutation({
-    mutationFn: (email) => {
-      return auth_service_default.forgotPassword(email);
-    }
-  });
-};
-var use_forgot_password_default = useForgotPassword;
-
-// src/hooks/auth/use-forgotpassword-sso.ts
-import { useMutation as useMutation2 } from "@tanstack/react-query";
-var useForgotPasswordSSO = () => {
-  return useMutation2({
-    mutationFn: ({
-      email,
-      with_context,
-      method
+  }, [env]);
+  const grantAccess = useCallback9(
+    async ({
+      redirect_uri,
+      state,
+      client_id,
+      scopes
     }) => {
-      return auth_service_default.forgotPasswordSSO({ email, with_context, method });
-    }
-  });
-};
-var use_forgotpassword_sso_default = useForgotPasswordSSO;
-
-// src/hooks/auth/use-get-provider.ts
-import { useMutation as useMutation3 } from "@tanstack/react-query";
-var useGetProvider = () => {
-  return useMutation3({
-    mutationFn: (data) => {
-      return auth_service_default.getProviders(data?.db);
-    }
-  });
-};
-var use_get_provider_default = useGetProvider;
-
-// src/hooks/auth/use-isvalid-token.ts
-import { useMutation as useMutation4 } from "@tanstack/react-query";
-var useIsValidToken = () => {
-  return useMutation4({
-    mutationFn: (token) => {
-      return auth_service_default.isValidToken(token);
-    }
-  });
-};
-var use_isvalid_token_default = useIsValidToken;
-
-// src/hooks/auth/use-login-credential.tsx
-import { useMutation as useMutation5 } from "@tanstack/react-query";
-
-// src/services/auth-service/backup.ts
-import { useCallback as useCallback2 } from "react";
-function useAuthService() {
-  const { env: env2 } = useEnv();
-  const login = useCallback2(
-    async (body) => {
-      const payload = Object.fromEntries(
-        Object.entries({
-          username: body.email,
-          password: body.password,
-          grant_type: env2?.config?.grantType || "",
-          client_id: env2?.config?.clientId || "",
-          client_secret: env2?.config?.clientSecret || ""
-        }).filter(([_, value]) => !!value)
-      );
-      const encodedData = new URLSearchParams(payload).toString();
-      return env2?.requests?.post(body.path, encodedData, {
+      const jsonData = {
+        redirect_uri,
+        state,
+        client_id,
+        scopes
+      };
+      return env?.requests.post("/grant-access" /* GRANT_ACCESS */, jsonData, {
         headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
+          "Content-Type": "application/json"
+        },
+        withCredentials: true
+      });
+    },
+    [env]
+  );
+  const removeTotpSetUp = useCallback9(
+    async ({ method, token }) => {
+      const jsonData = {
+        method,
+        with_context: {
+          token
+        }
+      };
+      return env?.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
         }
       });
     },
-    [env2]
+    [env]
   );
-  const forgotPassword = useCallback2(
-    async (email) => {
-      const bodyData = {
-        login: email,
-        url: `${window.location.origin}/reset-password`
+  const requestSetupTotp = useCallback9(
+    async ({ method, token }) => {
+      const jsonData = {
+        method,
+        with_context: { token }
       };
-      return env2?.requests?.post("/reset_password" /* RESET_PASSWORD_PATH */, bodyData, {
+      return env?.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env2]
+    [env]
   );
-  const forgotPasswordSSO = useCallback2(
+  const settingsWebRead2fa = useCallback9(
     async ({
-      email,
-      with_context,
-      method
+      method,
+      model,
+      kwargs,
+      token
     }) => {
-      const body = {
+      const jsonData = {
         method,
-        kwargs: {
-          vals: {
-            email
-          }
-        },
-        with_context
+        model,
+        kwargs,
+        with_context: {
+          token
+        }
       };
-      return env2?.requests?.post("/call" /* CALL_PATH */, body, {
+      return env?.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env2]
+    [env]
   );
-  const resetPassword = useCallback2(
-    async (data, token) => {
-      const bodyData = {
-        token,
-        password: data.password,
-        new_password: data.confirmPassword
+  const signInSSO = useCallback9(
+    async ({
+      redirect_uri,
+      state,
+      client_id,
+      response_type
+    }) => {
+      const jsonData = {
+        redirect_uri,
+        state,
+        client_id,
+        response_type
       };
-      return env2?.requests?.post("/change_password" /* CHANGE_PASSWORD_PATH */, bodyData, {
+      return env?.requests.get("/signin-sso/oauth" /* SIGNIN_SSO */, jsonData, {
         headers: {
-          "Content-Type": "application/json"
+          credentials: "include"
         }
       });
     },
-    [env2]
+    [env]
   );
-  const resetPasswordSSO = useCallback2(
-    async ({
+  const verify2FA = useCallback9(
+    ({
       method,
-      password,
-      with_context
+      with_context,
+      code,
+      device,
+      location
     }) => {
-      const bodyData = {
+      const jsonData = {
         method,
         kwargs: {
           vals: {
-            password
+            code,
+            device,
+            location
           }
         },
         with_context
       };
-      return env2?.requests?.post("/call" /* CALL_PATH */, bodyData, {
+      return env?.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
-        }
+        },
+        withCredentials: true
       });
     },
-    [env2]
+    [env]
   );
-  const updatePassword = useCallback2(
-    async (data, token) => {
-      const bodyData = {
-        token,
-        old_password: data.oldPassword,
-        new_password: data.newPassword
+  const get2FAMethods = useCallback9(
+    ({ method, with_context }) => {
+      const jsonData = {
+        method,
+        with_context
       };
-      return env2?.requests?.post("/change_password_parent" /* UPDATE_PASSWORD_PATH */, bodyData, {
+      return env?.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env2]
+    [env]
   );
-  const isValidToken = useCallback2(
-    async (token) => {
-      const bodyData = {
-        token
+  const verifyTotp = useCallback9(
+    ({
+      method,
+      action_token,
+      code
+    }) => {
+      const jsonData = {
+        method,
+        kwargs: {
+          vals: {
+            code
+          }
+        },
+        with_context: {
+          action_token
+        }
       };
-      return env2?.requests?.post("/check_token" /* TOKEN */, bodyData, {
+      return env?.requests.post("/call" /* CALL_PATH */, jsonData, {
         headers: {
           "Content-Type": "application/json"
         }
       });
     },
-    [env2]
+    [env]
   );
-  const isValidActionToken = useCallback2(
-    async (actionToken, path) => {
-      return env2?.requests?.post(
-        path,
-        {},
-        {
-          headers: {
-            "Content-Type": "application/json"
-          },
-          useActionToken: true,
-          actionToken
+  return {
+    getView,
+    getMenu,
+    getActionDetail,
+    getResequence,
+    getSelectionItem,
+    loadMessages,
+    getVersion,
+    grantAccess,
+    removeTotpSetUp,
+    requestSetupTotp,
+    settingsWebRead2fa,
+    signInSSO,
+    verify2FA,
+    get2FAMethods,
+    verifyTotp
+  };
+}
+
+// src/provider/version-gate-provider.tsx
+import { Fragment, jsx as jsx4 } from "react/jsx-runtime";
+var VersionGate = ({ children }) => {
+  const queryClient = useQueryClient();
+  const [ready, setReady] = useState2(false);
+  const { getVersion } = useViewService();
+  useEffect2(() => {
+    const clearVersion = () => {
+      queryClient.clear();
+      localStorage.removeItem("__api_version__");
+    };
+    const validateVersion = async () => {
+      const serverVersion = await getVersion();
+      const cached = localStorage.getItem("__api_version__");
+      if (cached !== serverVersion?.api_version) {
+        clearVersion();
+        localStorage.setItem("__api_version__", serverVersion?.api_version);
+      } else {
+        console.log("Api version:", serverVersion?.api_version);
+      }
+      setReady(true);
+    };
+    validateVersion();
+    if (typeof window !== "undefined") {
+      const onKey = (e) => {
+        const key = e.key.toLowerCase();
+        const isHardRefresh = (key === "f5" || key === "r") && e.ctrlKey && (key !== "r" || e.shiftKey) || key === "r" && e.metaKey && e.shiftKey || key === "r" && e.metaKey && e.altKey;
+        if (isHardRefresh) clearVersion();
+      };
+      window.addEventListener("keydown", onKey);
+      return () => window.removeEventListener("keydown", onKey);
+    }
+  }, [queryClient]);
+  return ready ? /* @__PURE__ */ jsx4(Fragment, { children }) : null;
+};
+
+// src/provider/env-provider.tsx
+import { createContext, useContext, useState as useState3, useCallback as useCallback10 } from "react";
+
+// src/configs/axios-client.ts
+import axios from "axios";
+
+// src/utils/storage/local-storage.ts
+var localStorageUtils = () => {
+  const setToken = async (access_token) => {
+    localStorage.setItem("accessToken", access_token);
+  };
+  const setRefreshToken = async (refresh_token) => {
+    localStorage.setItem("refreshToken", refresh_token);
+  };
+  const getAccessToken = async () => {
+    return localStorage.getItem("accessToken");
+  };
+  const getRefreshToken = async () => {
+    return localStorage.getItem("refreshToken");
+  };
+  const clearToken = async () => {
+    localStorage.removeItem("accessToken");
+    localStorage.removeItem("refreshToken");
+  };
+  return {
+    setToken,
+    setRefreshToken,
+    getAccessToken,
+    getRefreshToken,
+    clearToken
+  };
+};
+
+// src/utils/storage/session-storage.ts
+var sessionStorageUtils = () => {
+  const getBrowserSession = async () => {
+    return sessionStorage.getItem("browserSession");
+  };
+  return {
+    getBrowserSession
+  };
+};
+
+// src/configs/axios-client.ts
+var axiosClient = {
+  init(config) {
+    const localStorage2 = config?.localStorageUtils ?? localStorageUtils();
+    const sessionStorage2 = config?.sessionStorageUtils ?? sessionStorageUtils();
+    const db = config?.db;
+    let isRefreshing = false;
+    let failedQueue = [];
+    const processQueue = (error, token = null) => {
+      failedQueue?.forEach((prom) => {
+        if (error) {
+          prom.reject(error);
+        } else {
+          prom.resolve(token);
         }
-      );
-    },
-    [env2]
-  );
-  const loginSocial = useCallback2(
-    async ({
-      db,
-      state,
-      access_token
-    }) => {
-      return env2?.requests?.post(
-        "/token/generate" /* GENTOKEN_SOCIAL */,
-        { state, access_token },
-        {
-          headers: {
-            "Content-Type": "application/json"
+      });
+      failedQueue = [];
+    };
+    const instance = axios.create({
+      adapter: axios.defaults.adapter,
+      baseURL: config.baseUrl,
+      timeout: 5e4,
+      paramsSerializer: (params) => new URLSearchParams(params).toString()
+    });
+    instance.interceptors.request.use(async (config2) => {
+      const { useRefreshToken, useActionToken, actionToken } = config2;
+      if (useActionToken && actionToken) {
+        config2.headers["Action-Token"] = actionToken;
+      }
+      const getToken = useRefreshToken ? localStorage2.getRefreshToken : localStorage2.getAccessToken;
+      const token = await getToken?.();
+      if (token) config2.headers["Authorization"] = `Bearer ${token}`;
+      return config2;
+    }, Promise.reject);
+    instance.interceptors.response.use(
+      (response) => {
+        return handleResponse(response);
+      },
+      async (error) => {
+        const handleError3 = async (error2) => {
+          if (!error2.response) {
+            return error2;
           }
-        }
-      );
-    },
-    [env2]
-  );
-  const getProviders = useCallback2(
-    async (db) => {
-      return env2?.requests?.get("/oauth/providers", { params: { db } });
-    },
-    [env2]
-  );
-  const getAccessByCode = useCallback2(
-    async (code) => {
-      const data = new URLSearchParams();
-      data.append("code", code);
-      data.append("grant_type", "authorization_code");
-      data.append("client_id", env2?.config?.clientId || "");
-      data.append("redirect_uri", env2?.config?.redirectUri || "");
-      return env2?.requests?.post(
-        `${env2?.baseUrl?.replace("/mms/", "/id/")}/${"/token" /* TOKEN_BY_CODE */}`,
-        data,
-        {
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded"
+          const { data } = error2.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((token) => {
+              originalRequest.headers["Authorization"] = "Bearer " + token;
+              originalRequest.data = updateTokenParamInOriginalRequest(
+                originalRequest,
+                token
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage2.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, value]) => !!value)
+            );
+            return new Promise(function(resolve) {
+              axios.post(
+                `${config.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
+                }
+              ).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                axios.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_BAD_REQUEST") || err?.error_code === "ERR_2FA_006") {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  if (error_code === "AUTHEN_FAIL") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
           }
         }
-      );
-    },
-    [env2]
-  );
-  const logout = useCallback2(
-    async (data) => {
-      console.log(data);
-      return env2?.requests?.post(
-        "/logout" /* LOGOUT */,
-        {},
-        {
-          headers: {
-            "Content-Type": "application/json"
-          },
-          withCredentials: true,
-          useRefreshToken: true
+        return Promise.reject(await handleError3(error));
+      }
+    );
+    const handleResponse = (res) => {
+      if (res && res.data) {
+        return res.data;
+      }
+      return res;
+    };
+    const handleError2 = (error) => {
+      if (error.isAxiosError && error.code === "ECONNABORTED") {
+        console.error("Request Timeout Error:", error);
+        return "Request Timeout Error";
+      } else if (error.isAxiosError && !error.response) {
+        console.error("Network Error:", error);
+        return "Network Error";
+      } else {
+        console.error("Other Error:", error?.response);
+        const errorMessage = error?.response?.data?.message || "An error occurred";
+        return { message: errorMessage, status: error?.response?.status };
+      }
+    };
+    const clearAuthToken = async () => {
+      await localStorage2.clearToken();
+      if (typeof window !== "undefined") {
+        window.location.href = `/login`;
+      }
+    };
+    function formatUrl(url, db2) {
+      return url + (db2 ? "?db=" + db2 : "");
+    }
+    const responseBody = (response) => response;
+    const requests = {
+      get: (url, headers) => instance.get(formatUrl(url, db), headers).then(responseBody),
+      post: (url, body, headers) => instance.post(formatUrl(url, db), body, headers).then(responseBody),
+      post_excel: (url, body, headers) => instance.post(formatUrl(url, db), body, {
+        responseType: "arraybuffer",
+        headers: {
+          "Content-Type": typeof window !== "undefined" ? "application/json" : "application/javascript",
+          Accept: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
         }
-      );
-    },
-    [env2]
-  );
-  return {
-    login,
-    forgotPassword,
-    forgotPasswordSSO,
-    resetPassword,
-    resetPasswordSSO,
-    updatePassword,
-    isValidToken,
-    isValidActionToken,
-    loginSocial,
-    getProviders,
-    getAccessByCode,
-    logout
-  };
-}
+      }).then(responseBody),
+      put: (url, body, headers) => instance.put(formatUrl(url, db), body, headers).then(responseBody),
+      patch: (url, body) => instance.patch(formatUrl(url, db), body).then(responseBody),
+      delete: (url, body) => instance.delete(formatUrl(url, db), body).then(responseBody)
+    };
+    return requests;
+  }
+};
 
 // src/provider/env-provider.tsx
-import { createContext, useContext, useState as useState2, useCallback as useCallback3 } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { jsx as jsx5 } from "react/jsx-runtime";
 var initialEnvState = {
   env: null,
   baseUrl: "",
@@ -4620,15 +4738,15 @@ function EnvProvider({
   localStorageUtils: localStorageUtil = localStorageUtils(),
   sessionStorageUtils: sessionStorageUtil = sessionStorageUtils()
 }) {
-  const [env2, setEnvState] = useState2({
+  const [env, setEnvState] = useState3({
     ...initialEnvState,
     localStorageUtils: localStorageUtil,
     sessionStorageUtils: sessionStorageUtil
   });
-  const setupEnv = useCallback3(
+  const setupEnv = useCallback10(
     (envConfig) => {
       const updatedEnv = {
-        ...env2,
+        ...env,
         ...envConfig,
         localStorageUtils: localStorageUtil,
         sessionStorageUtils: sessionStorageUtil
@@ -4637,33 +4755,33 @@ function EnvProvider({
       setEnvState({ ...updatedEnv, requests });
       return updatedEnv;
     },
-    [env2, localStorageUtil, sessionStorageUtil]
+    [env, localStorageUtil, sessionStorageUtil]
   );
-  const setUid2 = useCallback3((uid) => {
+  const setUid2 = useCallback10((uid) => {
     setEnvState((prev) => ({
       ...prev,
       context: { ...prev.context, uid }
     }));
   }, []);
-  const setLang2 = useCallback3((lang) => {
+  const setLang2 = useCallback10((lang) => {
     setEnvState((prev) => ({
       ...prev,
       context: { ...prev.context, lang }
     }));
   }, []);
-  const setAllowCompanies2 = useCallback3((allowed_company_ids) => {
+  const setAllowCompanies2 = useCallback10((allowed_company_ids) => {
     setEnvState((prev) => ({
       ...prev,
       context: { ...prev.context, allowed_company_ids }
     }));
   }, []);
-  const setCompanies2 = useCallback3((companies) => {
+  const setCompanies2 = useCallback10((companies) => {
     setEnvState((prev) => ({
       ...prev,
       companies
     }));
   }, []);
-  const setDefaultCompany2 = useCallback3(
+  const setDefaultCompany2 = useCallback10(
     (defaultCompany) => {
       setEnvState((prev) => ({
         ...prev,
@@ -4672,29 +4790,29 @@ function EnvProvider({
     },
     []
   );
-  const setUserInfo = useCallback3((user) => {
+  const setUserInfo = useCallback10((user) => {
     setEnvState((prev) => ({
       ...prev,
       user
     }));
   }, []);
-  const setConfig2 = useCallback3((config) => {
+  const setConfig2 = useCallback10((config) => {
     setEnvState((prev) => ({
       ...prev,
       config
     }));
   }, []);
-  const setEnvFile2 = useCallback3((envFile) => {
+  const setEnvFile2 = useCallback10((envFile) => {
     setEnvState((prev) => ({
       ...prev,
       envFile
     }));
   }, []);
-  return /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsx5(
     EnvContext.Provider,
     {
       value: {
-        env: env2,
+        env,
         setupEnv,
         setUid: setUid2,
         setLang: setLang2,
@@ -4717,10 +4835,64 @@ function useEnv() {
   return context;
 }
 
+// src/provider/service-provider.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+
+// src/hooks/auth/use-forgot-password.ts
+import { useMutation } from "@tanstack/react-query";
+var useForgotPassword = () => {
+  const { forgotPassword } = useAuthService();
+  return useMutation({
+    mutationFn: (email) => {
+      return forgotPassword(email);
+    }
+  });
+};
+var use_forgot_password_default = useForgotPassword;
+
+// src/hooks/auth/use-forgotpassword-sso.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+var useForgotPasswordSSO = () => {
+  const { forgotPasswordSSO } = useAuthService();
+  return useMutation2({
+    mutationFn: ({
+      email,
+      with_context,
+      method
+    }) => {
+      return forgotPasswordSSO({ email, with_context, method });
+    }
+  });
+};
+var use_forgotpassword_sso_default = useForgotPasswordSSO;
+
+// src/hooks/auth/use-get-provider.ts
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+var useGetProvider = () => {
+  const { getProviders } = useAuthService();
+  return useMutation3({
+    mutationFn: (data) => {
+      return getProviders(data?.db);
+    }
+  });
+};
+var use_get_provider_default = useGetProvider;
+
+// src/hooks/auth/use-isvalid-token.ts
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+var useIsValidToken = () => {
+  const { isValidToken } = useAuthService();
+  return useMutation4({
+    mutationFn: (token) => {
+      return isValidToken(token);
+    }
+  });
+};
+var use_isvalid_token_default = useIsValidToken;
+
 // src/hooks/auth/use-login-credential.tsx
+import { useMutation as useMutation5 } from "@tanstack/react-query";
 var useLoginCredential = () => {
-  const { env: env2 } = useEnv();
-  console.log("useLoginCredential called", env2, new Error().stack);
   const { login } = useAuthService();
   return useMutation5({
     mutationFn: (data) => {
@@ -4733,9 +4905,10 @@ var use_login_credential_default = useLoginCredential;
 // src/hooks/auth/use-login-socical.ts
 import { useMutation as useMutation6 } from "@tanstack/react-query";
 var useLoginSocial = () => {
+  const { loginSocial } = useAuthService();
   return useMutation6({
     mutationFn: (data) => {
-      return auth_service_default.loginSocial(data);
+      return loginSocial(data);
     }
   });
 };
@@ -4744,9 +4917,10 @@ var use_login_socical_default = useLoginSocial;
 // src/hooks/auth/use-reset-password.ts
 import { useMutation as useMutation7 } from "@tanstack/react-query";
 var useResetPassword = () => {
+  const { resetPassword } = useAuthService();
   return useMutation7({
     mutationFn: (request) => {
-      return auth_service_default.resetPassword(request.data, request.token);
+      return resetPassword(request.data, request.token);
     }
   });
 };
@@ -4755,13 +4929,14 @@ var use_reset_password_default = useResetPassword;
 // src/hooks/auth/use-reset-password-sso.ts
 import { useMutation as useMutation8 } from "@tanstack/react-query";
 var useResetPasswordSSO = () => {
+  const { resetPasswordSSO } = useAuthService();
   return useMutation8({
     mutationFn: ({
       method,
       password,
       with_context
     }) => {
-      return auth_service_default.resetPasswordSSO({
+      return resetPasswordSSO({
         method,
         password,
         with_context
@@ -4774,9 +4949,10 @@ var use_reset_password_sso_default = useResetPasswordSSO;
 // src/hooks/auth/use-update-password.ts
 import { useMutation as useMutation9 } from "@tanstack/react-query";
 var useUpdatePassword = () => {
+  const { updatePassword } = useAuthService();
   return useMutation9({
     mutationFn: (request) => {
-      return auth_service_default.updatePassword(request.data, request.token);
+      return updatePassword(request.data, request.token);
     }
   });
 };
@@ -4785,9 +4961,10 @@ var use_update_password_default = useUpdatePassword;
 // src/hooks/auth/use-logout.ts
 import { useMutation as useMutation10 } from "@tanstack/react-query";
 var useLogout = () => {
+  const { logout } = useAuthService();
   return useMutation10({
     mutationFn: (data) => {
-      return auth_service_default.logout(data);
+      return logout(data);
     }
   });
 };
@@ -4796,9 +4973,10 @@ var use_logout_default = useLogout;
 // src/hooks/auth/use-get-access-by-code.ts
 import { useMutation as useMutation11 } from "@tanstack/react-query";
 var useGetAccessByCode = () => {
+  const { getAccessByCode } = useAuthService();
   return useMutation11({
     mutationFn: ({ code }) => {
-      return auth_service_default.getAccessByCode(code);
+      return getAccessByCode(code);
     }
   });
 };
@@ -4807,12 +4985,13 @@ var use_get_access_by_code_default = useGetAccessByCode;
 // src/hooks/auth/use-validate-action-token.ts
 import { useMutation as useMutation12 } from "@tanstack/react-query";
 var useValidateActionToken = () => {
+  const { isValidActionToken } = useAuthService();
   return useMutation12({
     mutationFn: ({
       actionToken,
       path
     }) => {
-      return auth_service_default.isValidActionToken(actionToken, path);
+      return isValidActionToken(actionToken, path);
     }
   });
 };
@@ -4821,8 +5000,9 @@ var use_validate_action_token_default = useValidateActionToken;
 // src/hooks/company/use-get-company-info.ts
 import { useMutation as useMutation13 } from "@tanstack/react-query";
 var useGetCompanyInfo = () => {
+  const { getInfoCompany } = useCompanyService();
   return useMutation13({
-    mutationFn: (id) => company_service_default.getInfoCompany(id)
+    mutationFn: (id) => getInfoCompany(id)
   });
 };
 var use_get_company_info_default = useGetCompanyInfo;
@@ -4830,8 +5010,9 @@ var use_get_company_info_default = useGetCompanyInfo;
 // src/hooks/company/use-get-current-company.ts
 import { useMutation as useMutation14 } from "@tanstack/react-query";
 var useGetCurrentCompany = () => {
+  const { getCurrentCompany } = useCompanyService();
   return useMutation14({
-    mutationFn: () => company_service_default.getCurrentCompany()
+    mutationFn: () => getCurrentCompany()
   });
 };
 var use_get_current_company_default = useGetCurrentCompany;
@@ -4839,6 +5020,7 @@ var use_get_current_company_default = useGetCurrentCompany;
 // src/hooks/company/use-get-list-company.ts
 import { useQuery } from "@tanstack/react-query";
 var useGetListCompany = (companyIDs = []) => {
+  const { getList } = useModelService();
   const companySpec = {
     id: {},
     name: {}
@@ -4850,7 +5032,7 @@ var useGetListCompany = (companyIDs = []) => {
   };
   return useQuery({
     queryKey: ["list_company" /* LIST_COMPANY */, companyIDs],
-    queryFn: () => model_service_default.getList(getListParams),
+    queryFn: () => getList(getListParams),
     refetchOnWindowFocus: false
   });
 };
@@ -4859,6 +5041,7 @@ var use_get_list_company_default = useGetListCompany;
 // src/hooks/excel/use-export-excel.ts
 import { useMutation as useMutation15 } from "@tanstack/react-query";
 var useExportExcel = () => {
+  const { exportExcel } = useExcelService();
   return useMutation15({
     mutationFn: ({
       model,
@@ -4869,7 +5052,7 @@ var useExportExcel = () => {
       importCompat,
       context,
       groupby
-    }) => excel_service_default.exportExcel({
+    }) => exportExcel({
       model,
       domain,
       ids,
@@ -4886,6 +5069,7 @@ var use_export_excel_default = useExportExcel;
 // src/hooks/excel/use-get-field-export.ts
 import { useMutation as useMutation16 } from "@tanstack/react-query";
 var useGetFieldExport = () => {
+  const { getFieldExport } = useExcelService();
   return useMutation16({
     mutationFn: ({
       ids,
@@ -4898,7 +5082,7 @@ var useGetFieldExport = () => {
       name,
       context,
       importCompat
-    }) => excel_service_default.getFieldExport({
+    }) => getFieldExport({
       ids,
       model,
       isShow,
@@ -4917,9 +5101,10 @@ var use_get_field_export_default = useGetFieldExport;
 // src/hooks/excel/use-get-file-excel.ts
 import { useQuery as useQuery2 } from "@tanstack/react-query";
 var useGetFileExcel = ({ model }) => {
+  const { getFileExcel } = useExcelService();
   return useQuery2({
     queryKey: [],
-    queryFn: () => excel_service_default.getFileExcel({
+    queryFn: () => getFileExcel({
       model
     }).then((res) => {
       if (res) {
@@ -4935,13 +5120,14 @@ var use_get_file_excel_default = useGetFileExcel;
 // src/hooks/excel/use-parse-preview.ts
 import { useMutation as useMutation17 } from "@tanstack/react-query";
 var useParsePreview = () => {
+  const { parsePreview } = useExcelService();
   return useMutation17({
     mutationFn: ({
       id,
       selectedSheet,
       isHeader,
       context
-    }) => excel_service_default.parsePreview({
+    }) => parsePreview({
       id,
       selectedSheet,
       isHeader,
@@ -4954,8 +5140,9 @@ var use_parse_preview_default = useParsePreview;
 // src/hooks/excel/use-upload-file.ts
 import { useMutation as useMutation18 } from "@tanstack/react-query";
 var useUploadFile = () => {
+  const { uploadFile } = useExcelService();
   return useMutation18({
-    mutationFn: ({ formData }) => excel_service_default.uploadFile({
+    mutationFn: ({ formData }) => uploadFile({
       formData
     })
   });
@@ -4965,8 +5152,9 @@ var use_upload_file_default = useUploadFile;
 // src/hooks/excel/use-upload-id-file.ts
 import { useMutation as useMutation19 } from "@tanstack/react-query";
 var useUploadIdFile = () => {
+  const { uploadIdFile } = useExcelService();
   return useMutation19({
-    mutationFn: ({ formData }) => excel_service_default.uploadIdFile({
+    mutationFn: ({ formData }) => uploadIdFile({
       formData
     })
   });
@@ -4976,6 +5164,7 @@ var use_upload_id_file_default = useUploadIdFile;
 // src/hooks/excel/uss-execute-import.ts
 import { useMutation as useMutation20 } from "@tanstack/react-query";
 var useExecuteImport = () => {
+  const { executeImport } = useExcelService();
   return useMutation20({
     mutationFn: ({
       fields,
@@ -4984,7 +5173,7 @@ var useExecuteImport = () => {
       options,
       dryrun,
       context
-    }) => excel_service_default.executeImport({
+    }) => executeImport({
       fields,
       columns,
       idFile,
@@ -4999,9 +5188,10 @@ var uss_execute_import_default = useExecuteImport;
 // src/hooks/form/use-change-status.ts
 import { useMutation as useMutation21 } from "@tanstack/react-query";
 var useChangeStatus = () => {
+  const { changeStatus } = useFormService();
   return useMutation21({
     mutationFn: ({ data }) => {
-      return form_service_default.changeStatus({
+      return changeStatus({
         data
       });
     }
@@ -5012,8 +5202,9 @@ var use_change_status_default = useChangeStatus;
 // src/hooks/form/use-delete-comment.ts
 import { useMutation as useMutation22 } from "@tanstack/react-query";
 var useDeleteComment = () => {
+  const { deleteComment } = useFormService();
   return useMutation22({
-    mutationFn: ({ data }) => form_service_default.deleteComment({
+    mutationFn: ({ data }) => deleteComment({
       data
     })
   });
@@ -5023,9 +5214,10 @@ var use_delete_comment_default = useDeleteComment;
 // src/hooks/form/use-get-comment.ts
 import { useQuery as useQuery3 } from "@tanstack/react-query";
 var useGetComment = ({ data, queryKey }) => {
+  const { getComment } = useFormService();
   return useQuery3({
     queryKey,
-    queryFn: () => form_service_default.getComment({ data }).then((res) => {
+    queryFn: () => getComment({ data }).then((res) => {
       if (res) {
         return res;
       }
@@ -5043,9 +5235,10 @@ var useGetFormView = ({
   queryKey,
   enabled
 }) => {
+  const { getFormView } = useFormService();
   return useQuery4({
     queryKey,
-    queryFn: () => form_service_default.getFormView({ data }).then((res) => {
+    queryFn: () => getFormView({ data }).then((res) => {
       if (res) {
         return res;
       }
@@ -5063,9 +5256,10 @@ var useGetImage = ({
   queryKey,
   src
 }) => {
+  const { getImage } = useFormService();
   return useQuery5({
     queryKey,
-    queryFn: () => form_service_default.getImage({ data }).then((res) => {
+    queryFn: () => getImage({ data }).then((res) => {
       if (res) {
         return res;
       }
@@ -5079,8 +5273,9 @@ var use_get_image_default = useGetImage;
 // src/hooks/form/use-send-comment.ts
 import { useMutation as useMutation23 } from "@tanstack/react-query";
 var useSendComment = () => {
+  const { sentComment } = useFormService();
   return useMutation23({
-    mutationFn: ({ data }) => form_service_default.sentComment({
+    mutationFn: ({ data }) => sentComment({
       data
     })
   });
@@ -5090,8 +5285,9 @@ var use_send_comment_default = useSendComment;
 // src/hooks/form/use-upload-image.ts
 import { useMutation as useMutation24 } from "@tanstack/react-query";
 var useUploadImage = () => {
+  const { uploadImage } = useFormService();
   return useMutation24({
-    mutationFn: ({ data }) => form_service_default.uploadImage({
+    mutationFn: ({ data }) => uploadImage({
       data
     })
   });
@@ -5101,8 +5297,9 @@ var use_upload_image_default = useUploadImage;
 // src/hooks/model/use-delete.ts
 import { useMutation as useMutation25 } from "@tanstack/react-query";
 var useDelete = () => {
+  const { deleteApi } = useModelService();
   return useMutation25({
-    mutationFn: ({ ids, model }) => model_service_default.delete({ ids, model })
+    mutationFn: ({ ids, model }) => deleteApi({ ids, model })
   });
 };
 var use_delete_default = useDelete;
@@ -5110,16 +5307,16 @@ var use_delete_default = useDelete;
 // src/hooks/model/use-get-all.ts
 import { useQuery as useQuery6 } from "@tanstack/react-query";
 var useGetAll = ({ data, queryKey, viewResponse }) => {
+  const { getAll } = useModelService();
   return useQuery6({
     queryKey,
-    queryFn: () => model_service_default.getAll({ data }).then((res) => {
+    queryFn: () => getAll({ data }).then((res) => {
       if (res) {
         return res;
       }
     }),
     enabled: !!data.specification && !!data.model && !!data.domain && !!viewResponse,
     refetchOnWindowFocus: false
-    // placeholderData: keepPreviousData,
   });
 };
 var use_get_all_default = useGetAll;
@@ -5127,9 +5324,10 @@ var use_get_all_default = useGetAll;
 // src/hooks/model/use-get-conversion-rate.ts
 import { useQuery as useQuery7 } from "@tanstack/react-query";
 var useGetConversionRate = () => {
+  const { getConversionRate } = useModelService();
   return useQuery7({
     queryKey: ["currency-rate"],
-    queryFn: () => model_service_default.getConversionRate().then((res) => {
+    queryFn: () => getConversionRate().then((res) => {
       if (res) {
         return res;
       }
@@ -5142,9 +5340,10 @@ var use_get_conversion_rate_default = useGetConversionRate;
 // src/hooks/model/use-get-currency.ts
 import { useQuery as useQuery8 } from "@tanstack/react-query";
 var useGetCurrency = () => {
+  const { getCurrency } = useModelService();
   return useQuery8({
     queryKey: ["currency"],
-    queryFn: () => model_service_default.getCurrency().then((res) => {
+    queryFn: () => getCurrency().then((res) => {
       if (res) {
         return res;
       }
@@ -5157,13 +5356,14 @@ var use_get_currency_default = useGetCurrency;
 // src/hooks/model/use-get-detail.ts
 import { useMutation as useMutation26 } from "@tanstack/react-query";
 var useGetDetail = () => {
+  const { getDetail } = useModelService();
   return useMutation26({
     mutationFn: ({
       model,
       ids,
       specification,
       context
-    }) => model_service_default.getDetail({
+    }) => getDetail({
       model,
       ids,
       specification,
@@ -5176,9 +5376,10 @@ var use_get_detail_default = useGetDetail;
 // src/hooks/model/use-get-field-onchange.ts
 import { useQuery as useQuery9 } from "@tanstack/react-query";
 var useGetFieldOnChange = ({ model }) => {
+  const { getListFieldsOnchange } = useModelService();
   return useQuery9({
     queryKey: [`field-onchange-${model}`, model],
-    queryFn: () => model_service_default.getListFieldsOnchange({
+    queryFn: () => getListFieldsOnchange({
       model
     }).then((res) => {
       if (res) {
@@ -5198,9 +5399,10 @@ var useGetListMyBankAccount = ({
   spectification,
   model
 }) => {
+  const { getListMyBankAccount } = useModelService();
   return useQuery10({
     queryKey: ["bank-account", model, domain],
-    queryFn: () => model_service_default.getListMyBankAccount({
+    queryFn: () => getListMyBankAccount({
       domain,
       spectification,
       model
@@ -5342,9 +5544,10 @@ var use_model_default = useModel;
 
 // src/hooks/model/use-odoo-data-transform.ts
 var useOdooDataTransform = () => {
+  const { toDataJS, parseORMOdoo } = useModelService();
   return {
-    toDataJS: model_service_default.toDataJS,
-    parseORM: model_service_default.parseORMOdoo
+    toDataJS,
+    parseORM: parseORMOdoo
   };
 };
 var use_odoo_data_transform_default = useOdooDataTransform;
@@ -5352,6 +5555,7 @@ var use_odoo_data_transform_default = useOdooDataTransform;
 // src/hooks/model/use-onchange-form.ts
 import { useMutation as useMutation27 } from "@tanstack/react-query";
 var useOnChangeForm = () => {
+  const { onChange } = useModelService();
   return useMutation27({
     mutationFn: ({
       ids,
@@ -5360,7 +5564,7 @@ var useOnChangeForm = () => {
       context,
       object,
       fieldChange
-    }) => model_service_default.onChange({
+    }) => onChange({
       ids,
       model,
       specification,
@@ -5375,6 +5579,7 @@ var use_onchange_form_default = useOnChangeForm;
 // src/hooks/model/use-save.ts
 import { useMutation as useMutation28 } from "@tanstack/react-query";
 var useSave = () => {
+  const { save } = useModelService();
   return useMutation28({
     mutationFn: ({
       ids,
@@ -5383,7 +5588,7 @@ var useSave = () => {
       specification,
       context,
       path
-    }) => model_service_default.save({ ids, model, data, specification, context, path })
+    }) => save({ ids, model, data, specification, context, path })
   });
 };
 var use_save_default = useSave;
@@ -5391,8 +5596,9 @@ var use_save_default = useSave;
 // src/hooks/user/use-get-profile.ts
 import { useMutation as useMutation29 } from "@tanstack/react-query";
 var useGetProfile = (path) => {
+  const { getProfile } = useUserService();
   return useMutation29({
-    mutationFn: () => user_service_default.getProfile(path)
+    mutationFn: () => getProfile(path)
   });
 };
 var use_get_profile_default = useGetProfile;
@@ -5400,8 +5606,9 @@ var use_get_profile_default = useGetProfile;
 // src/hooks/user/use-get-user.ts
 import { useMutation as useMutation30 } from "@tanstack/react-query";
 var useGetUser = () => {
+  const { getUser } = useUserService();
   return useMutation30({
-    mutationFn: ({ id, context }) => user_service_default.getUser({
+    mutationFn: ({ id, context }) => getUser({
       id,
       context
     })
@@ -5412,9 +5619,10 @@ var use_get_user_default = useGetUser;
 // src/hooks/user/use-switch-locale.ts
 import { useMutation as useMutation31 } from "@tanstack/react-query";
 var useSwitchLocale = () => {
+  const { switchUserLocale } = useUserService();
   return useMutation31({
     mutationFn: ({ data }) => {
-      return user_service_default.switchUserLocale({
+      return switchUserLocale({
         id: data.id,
         values: data.values
       });
@@ -5425,121 +5633,488 @@ var use_switch_locale_default = useSwitchLocale;
 
 // src/hooks/view/use-button.ts
 import { useMutation as useMutation32 } from "@tanstack/react-query";
+var useButton = () => {
+  const { callButton } = useActionService();
+  return useMutation32({
+    mutationFn: ({
+      model,
+      ids,
+      context,
+      method
+    }) => callButton({
+      model,
+      ids,
+      context,
+      method
+    }),
+    onSuccess: (response) => {
+      return response;
+    }
+  });
+};
+var use_button_default = useButton;
 
 // src/hooks/view/use-duplicate-record.ts
 import { useMutation as useMutation33 } from "@tanstack/react-query";
+var useDuplicateRecord = () => {
+  const { duplicateRecord } = useActionService();
+  return useMutation33({
+    mutationFn: ({
+      id,
+      model,
+      context
+    }) => duplicateRecord({
+      id,
+      model,
+      context
+    })
+  });
+};
+var use_duplicate_record_default = useDuplicateRecord;
 
 // src/hooks/view/use-get-action-detail.ts
 import { useQuery as useQuery11 } from "@tanstack/react-query";
+var useGetActionDetail = ({
+  aid,
+  context,
+  enabled,
+  id,
+  model,
+  queryKey
+}) => {
+  const { getFormView } = useFormService();
+  const { getActionDetail } = useViewService();
+  const data = {
+    id,
+    model: model ?? "",
+    context
+  };
+  return useQuery11({
+    queryKey,
+    queryFn: async () => {
+      if (aid) {
+        const res = await getActionDetail(aid, context);
+        if (res && res.length > 0) {
+          return res[0];
+        }
+      } else {
+        const res = await getFormView({ data });
+        return res;
+      }
+    },
+    enabled,
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+};
+var use_get_action_detail_default = useGetActionDetail;
 
 // src/hooks/view/use-get-calendar.ts
 import { useQuery as useQuery12 } from "@tanstack/react-query";
+var useGetCalendar = (listDataProps, queryKey, enabled) => {
+  const { getListCalendar } = useModelService();
+  return useQuery12({
+    queryKey,
+    queryFn: () => getListCalendar({ data: listDataProps }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    enabled,
+    refetchOnWindowFocus: false,
+    staleTime: 0
+  });
+};
+var use_get_calendar_default = useGetCalendar;
 
 // src/hooks/view/use-get-groups.ts
 import { useQuery as useQuery13 } from "@tanstack/react-query";
+var useGetGroups = ({
+  model,
+  width_context
+}) => {
+  const { getGroups } = useKanbanService();
+  return useQuery13({
+    queryKey: [model, width_context],
+    queryFn: () => getGroups({
+      model,
+      width_context
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_groups_default = useGetGroups;
 
 // src/hooks/view/use-get-list-data.ts
 import { useQuery as useQuery14 } from "@tanstack/react-query";
+var useGetListData = (listDataProps, queryKey, enabled) => {
+  const { getAll } = useModelService();
+  return useQuery14({
+    queryKey,
+    queryFn: () => getAll({ data: listDataProps }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    enabled,
+    refetchOnWindowFocus: false,
+    staleTime: 0
+  });
+};
+var use_get_list_data_default = useGetListData;
 
 // src/hooks/view/use-get-menu.ts
 import { useQuery as useQuery15 } from "@tanstack/react-query";
+var useGetMenu = (context, enabled) => {
+  const { getMenu } = useViewService();
+  return useQuery15({
+    queryKey: ["menus" /* MENU */, context],
+    queryFn: () => getMenu(context).then((res) => {
+      if (res && res?.records && res?.records?.length > 0) {
+        return res?.records;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false,
+    staleTime: Infinity,
+    enabled
+  });
+};
+var use_get_menu_default = useGetMenu;
 
 // src/hooks/view/use-get-print-report.ts
 import { useMutation as useMutation34 } from "@tanstack/react-query";
+var useGetPrintReport = () => {
+  const { getPrintReportName } = useActionService();
+  return useMutation34({
+    mutationFn: ({ id }) => getPrintReportName({
+      id
+    })
+  });
+};
+var use_get_print_report_default = useGetPrintReport;
 
 // src/hooks/view/use-get-progress-bar.ts
 import { useQuery as useQuery16 } from "@tanstack/react-query";
+var useGetProGressBar = ({
+  field,
+  color,
+  model,
+  width_context
+}) => {
+  const { getProgressBar } = useKanbanService();
+  return useQuery16({
+    queryKey: [],
+    queryFn: () => getProgressBar({
+      field,
+      color,
+      model,
+      width_context
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_progress_bar_default = useGetProGressBar;
 
 // src/hooks/view/use-get-selection.ts
 import { useQuery as useQuery17 } from "@tanstack/react-query";
+var useGetSelection = ({
+  data,
+  queryKey,
+  enabled
+}) => {
+  const { getSelectionItem } = useViewService();
+  return useQuery17({
+    queryKey,
+    queryFn: () => getSelectionItem({ data }),
+    enabled,
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_selection_default = useGetSelection;
 
 // src/hooks/view/use-get-view.ts
 import { useQuery as useQuery18 } from "@tanstack/react-query";
+var useGetView = (viewParams, actData) => {
+  const { getView } = useViewService();
+  return useQuery18({
+    queryKey: ["get_view_by_action" /* GET_VIEW_BY_ACTION */, viewParams],
+    queryFn: () => getView(viewParams),
+    enabled: !!actData,
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+};
+var use_get_view_default = useGetView;
 
 // src/hooks/view/use-load-action.ts
 import { useMutation as useMutation35 } from "@tanstack/react-query";
+var useLoadAction = () => {
+  const { loadAction } = useActionService();
+  return useMutation35({
+    mutationFn: ({
+      idAction,
+      context
+    }) => {
+      return loadAction({
+        idAction,
+        context
+      });
+    }
+  });
+};
+var use_load_action_default = useLoadAction;
 
 // src/hooks/view/use-load-message.ts
 import { useQuery as useQuery19 } from "@tanstack/react-query";
+var useLoadMessage = () => {
+  const { loadMessages } = useViewService();
+  return useQuery19({
+    queryKey: [`load-message-failure`],
+    queryFn: () => loadMessages(),
+    refetchOnWindowFocus: false
+  });
+};
+var use_load_message_default = useLoadMessage;
 
 // src/hooks/view/use-print.ts
 import { useMutation as useMutation36 } from "@tanstack/react-query";
+var usePrint = () => {
+  const { print } = useActionService();
+  return useMutation36({
+    mutationFn: ({ id, report, db }) => print({
+      id,
+      report,
+      db
+    })
+  });
+};
+var use_print_default = usePrint;
 
 // src/hooks/view/use-remove-row.ts
 import { useMutation as useMutation37 } from "@tanstack/react-query";
+var useRemoveRow = () => {
+  const { removeRows } = useActionService();
+  return useMutation37({
+    mutationFn: ({
+      model,
+      ids,
+      context
+    }) => removeRows({
+      model,
+      ids,
+      context
+    })
+  });
+};
+var use_remove_row_default = useRemoveRow;
 
 // src/hooks/view/use-resequence.ts
 import { useQuery as useQuery20 } from "@tanstack/react-query";
+var useGetResequence = (model, resIds, context, offset) => {
+  const { getResequence } = useViewService();
+  return useQuery20({
+    queryKey: [],
+    queryFn: () => getResequence({
+      model,
+      ids: resIds,
+      context,
+      offset
+    }),
+    enabled: false,
+    refetchOnWindowFocus: false
+  });
+};
+var use_resequence_default = useGetResequence;
 
 // src/hooks/view/use-run-action.ts
 import { useMutation as useMutation38 } from "@tanstack/react-query";
+var useRunAction = () => {
+  const { runAction } = useActionService();
+  return useMutation38({
+    mutationFn: ({
+      idAction,
+      context
+    }) => runAction({
+      idAction,
+      context
+    })
+  });
+};
+var use_run_action_default = useRunAction;
 
 // src/hooks/view/use-signin-sso.ts
 import { useMutation as useMutation39 } from "@tanstack/react-query";
+var useSignInSSO = () => {
+  const { signInSSO } = useViewService();
+  return useMutation39({
+    mutationFn: ({
+      redirect_uri,
+      state,
+      client_id,
+      response_type,
+      path
+    }) => {
+      return signInSSO({
+        redirect_uri,
+        state,
+        client_id,
+        response_type
+      });
+    }
+  });
+};
+var use_signin_sso_default = useSignInSSO;
 
 // src/hooks/view/use-verify-2FA.ts
 import { useMutation as useMutation40 } from "@tanstack/react-query";
+var useVerify2FA = () => {
+  const { verify2FA } = useViewService();
+  return useMutation40({
+    mutationFn: ({
+      method,
+      with_context,
+      code,
+      device,
+      location
+    }) => {
+      return verify2FA({
+        method,
+        with_context,
+        code,
+        device,
+        location
+      });
+    }
+  });
+};
+var use_verify_2FA_default = useVerify2FA;
 
 // src/hooks/view/uset-get-2FA-method.ts
 import { useMutation as useMutation41 } from "@tanstack/react-query";
-
-// src/hooks/view/use-get-fields-view-security.ts
-import { useMutation as useMutation42 } from "@tanstack/react-query";
+var useGet2FAMethods = () => {
+  const { get2FAMethods } = useViewService();
+  return useMutation41({
+    mutationFn: ({
+      method,
+      with_context
+    }) => {
+      return get2FAMethods({
+        method,
+        with_context
+      });
+    }
+  });
+};
+var uset_get_2FA_method_default = useGet2FAMethods;
 
 // src/hooks/view/use-grant-access.ts
-import { useMutation as useMutation43 } from "@tanstack/react-query";
+import { useMutation as useMutation42 } from "@tanstack/react-query";
+var useGrantAccess = () => {
+  const { grantAccess } = useViewService();
+  return useMutation42({
+    mutationFn: ({
+      redirect_uri,
+      state,
+      client_id,
+      scopes
+    }) => {
+      return grantAccess({
+        redirect_uri,
+        state,
+        client_id,
+        scopes
+      });
+    }
+  });
+};
+var use_grant_access_default = useGrantAccess;
 
 // src/hooks/view/use-remove-totp-setup.ts
-import { useMutation as useMutation44 } from "@tanstack/react-query";
+import { useMutation as useMutation43 } from "@tanstack/react-query";
+var useRemoveTotpSetup = () => {
+  const { removeTotpSetUp } = useViewService();
+  return useMutation43({
+    mutationFn: ({ method, token }) => {
+      return removeTotpSetUp({
+        method,
+        token
+      });
+    }
+  });
+};
+var use_remove_totp_setup_default = useRemoveTotpSetup;
 
 // src/hooks/view/use-request-setup-totp.ts
-import { useMutation as useMutation45 } from "@tanstack/react-query";
+import { useMutation as useMutation44 } from "@tanstack/react-query";
+var useRequestSetupTotp = () => {
+  const { requestSetupTotp } = useViewService();
+  return useMutation44({
+    mutationFn: ({ method, token }) => {
+      return requestSetupTotp({
+        method,
+        token
+      });
+    }
+  });
+};
+var use_request_setup_totp_default = useRequestSetupTotp;
 
 // src/hooks/view/use-settings-web-read-2fa.ts
-import { useMutation as useMutation46 } from "@tanstack/react-query";
+import { useMutation as useMutation45 } from "@tanstack/react-query";
+var useSettingsWebRead2fa = () => {
+  const { settingsWebRead2fa } = useViewService();
+  return useMutation45({
+    mutationFn: ({
+      method,
+      token,
+      kwargs,
+      model
+    }) => {
+      return settingsWebRead2fa({
+        method,
+        model,
+        kwargs,
+        token
+      });
+    }
+  });
+};
+var use_settings_web_read_2fa_default = useSettingsWebRead2fa;
 
 // src/hooks/view/use-verify-totp.ts
-import { useMutation as useMutation47 } from "@tanstack/react-query";
-
-// src/provider/version-gate-provider.tsx
-import { Fragment, jsx as jsx5 } from "react/jsx-runtime";
-var VersionGate = ({ children }) => {
-  const queryClient = useQueryClient();
-  const [ready, setReady] = useState3(false);
-  const { getVersion } = useViewService();
-  const login = use_login_credential_default();
-  useEffect2(() => {
-    const clearVersion = () => {
-      queryClient.clear();
-      localStorage.removeItem("__api_version__");
-    };
-    const validateVersion = async () => {
-      const serverVersion = await getVersion();
-      const cached = localStorage.getItem("__api_version__");
-      if (cached !== serverVersion?.api_version) {
-        clearVersion();
-        localStorage.setItem("__api_version__", serverVersion?.api_version);
-      } else {
-        console.log("Api version:", serverVersion?.api_version);
-      }
-      setReady(true);
-    };
-    validateVersion();
-    if (typeof window !== "undefined") {
-      const onKey = (e) => {
-        const key = e.key.toLowerCase();
-        const isHardRefresh = (key === "f5" || key === "r") && e.ctrlKey && (key !== "r" || e.shiftKey) || key === "r" && e.metaKey && e.shiftKey || key === "r" && e.metaKey && e.altKey;
-        if (isHardRefresh) clearVersion();
-      };
-      window.addEventListener("keydown", onKey);
-      return () => window.removeEventListener("keydown", onKey);
+import { useMutation as useMutation46 } from "@tanstack/react-query";
+var useVerifyTotp = () => {
+  const { verifyTotp } = useViewService();
+  return useMutation46({
+    mutationFn: ({
+      method,
+      action_token,
+      code
+    }) => {
+      return verifyTotp({
+        method,
+        action_token,
+        code
+      });
     }
-  }, [queryClient]);
-  return ready ? /* @__PURE__ */ jsx5(Fragment, { children }) : null;
+  });
 };
+var use_verify_totp_default = useVerifyTotp;
 
 // src/provider/service-provider.tsx
-import { createContext as createContext2, useContext as useContext2 } from "react";
 import { jsx as jsx6 } from "react/jsx-runtime";
 var ServiceContext = createContext2(null);
 var ServiceProvider = ({
@@ -5588,7 +6163,32 @@ var ServiceProvider = ({
     useSave: use_save_default,
     useGetProfile: use_get_profile_default,
     useGetUser: use_get_user_default,
-    useSwitchLocale: use_switch_locale_default
+    useSwitchLocale: use_switch_locale_default,
+    useButton: use_button_default,
+    useDuplicateRecord: use_duplicate_record_default,
+    useGet2FAMethods: uset_get_2FA_method_default,
+    useGetActionDetail: use_get_action_detail_default,
+    useGetCalendar: use_get_calendar_default,
+    useGetGroups: use_get_groups_default,
+    useGetListData: use_get_list_data_default,
+    useGetMenu: use_get_menu_default,
+    useGetPrintReport: use_get_print_report_default,
+    useGetProGressBar: use_get_progress_bar_default,
+    useGetResequence: use_resequence_default,
+    useGetSelection: use_get_selection_default,
+    useGetView: use_get_view_default,
+    useLoadAction: use_load_action_default,
+    useLoadMessage: use_load_message_default,
+    usePrint: use_print_default,
+    useRemoveRow: use_remove_row_default,
+    useRunAction: use_run_action_default,
+    useSignInSSO: use_signin_sso_default,
+    useVerify2FA: use_verify_2FA_default,
+    useGrantAccess: use_grant_access_default,
+    useRemoveTotpSetup: use_remove_totp_setup_default,
+    useRequestSetupTotp: use_request_setup_totp_default,
+    useSettingsWebRead2fa: use_settings_web_read_2fa_default,
+    useVerifyTotp: use_verify_totp_default
   };
   return /* @__PURE__ */ jsx6(ServiceContext.Provider, { value: services, children });
 };