@fctc/edu-logic-lib 1.0.8 → 1.0.10

package/dist/hooks.js

@@ -1,194 +1,4864 @@
 'use strict';
 
-var chunkEK43MEN4_js = require('./chunk-EK43MEN4.js');
-require('./chunk-FVGPSTJ7.js');
-require('./chunk-P2IGWJDZ.js');
-require('./chunk-GGOFXFSX.js');
-require('./chunk-S7YF2I23.js');
-require('./chunk-4K3QAEZ6.js');
-require('./chunk-RZBHZYXG.js');
-require('./chunk-UY6GNZNB.js');
-require('./chunk-IXDDYGKE.js');
+var reactQuery = require('@tanstack/react-query');
+var toolkit = require('@reduxjs/toolkit');
+var axios = require('axios');
+var React = require('react');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var React__default = /*#__PURE__*/_interopDefault(React);
 
-Object.defineProperty(exports, "useButton", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_button_default; }
-});
-Object.defineProperty(exports, "useChangeStatus", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_change_status_default; }
-});
-Object.defineProperty(exports, "useDelete", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_delete_default; }
-});
-Object.defineProperty(exports, "useDeleteComment", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_delete_comment_default; }
-});
-Object.defineProperty(exports, "useDuplicateRecord", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_duplicate_record_default; }
-});
-Object.defineProperty(exports, "useExecuteImport", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.uss_execute_import_default; }
-});
-Object.defineProperty(exports, "useExportExcel", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_export_excel_default; }
-});
-Object.defineProperty(exports, "useField", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_field_default; }
-});
-Object.defineProperty(exports, "useForgotPassword", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_forgot_password_default; }
-});
-Object.defineProperty(exports, "useGetAll", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_all_default; }
-});
-Object.defineProperty(exports, "useGetComment", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_comment_default; }
-});
-Object.defineProperty(exports, "useGetCompanyInfo", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_company_info_default; }
-});
-Object.defineProperty(exports, "useGetCurrentCompany", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_current_company_default; }
-});
-Object.defineProperty(exports, "useGetDetail", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_detail_default; }
-});
-Object.defineProperty(exports, "useGetFieldExport", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_field_export_default; }
-});
-Object.defineProperty(exports, "useGetFieldOnChange", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_field_onchange_default; }
-});
-Object.defineProperty(exports, "useGetFileExcel", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_file_excel_default; }
-});
-Object.defineProperty(exports, "useGetFormView", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_form_view_default; }
-});
-Object.defineProperty(exports, "useGetImage", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_image_default; }
-});
-Object.defineProperty(exports, "useGetListData", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_list_data_default; }
-});
-Object.defineProperty(exports, "useGetMenu", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_menu_default; }
-});
-Object.defineProperty(exports, "useGetProfile", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_profile_default; }
-});
-Object.defineProperty(exports, "useGetProvider", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_provider_default; }
-});
-Object.defineProperty(exports, "useGetSelection", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_selection_default; }
-});
-Object.defineProperty(exports, "useGetUser", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_user_default; }
-});
-Object.defineProperty(exports, "useGetView", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_get_view_default; }
-});
-Object.defineProperty(exports, "useIsValidToken", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_isvalid_token_default; }
-});
-Object.defineProperty(exports, "useLoadAction", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_load_action_default; }
-});
-Object.defineProperty(exports, "useLoginCredential", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_login_credential_default; }
-});
-Object.defineProperty(exports, "useLoginSocial", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_login_socical_default; }
-});
-Object.defineProperty(exports, "useModel", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_model_default; }
-});
-Object.defineProperty(exports, "useOdooDataTransform", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_odoo_data_transform_default; }
-});
-Object.defineProperty(exports, "useOnChangeForm", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_onchange_form_default; }
-});
-Object.defineProperty(exports, "useParsePreview", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_parse_preview_default; }
-});
-Object.defineProperty(exports, "usePrint", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_print_default; }
-});
-Object.defineProperty(exports, "useRemoveRow", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_remove_row_default; }
-});
-Object.defineProperty(exports, "useResetPassword", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_reset_password_default; }
+// src/hooks/auth/use-forgot-password.ts
+
+// src/constants/api/uri-constant.ts
+var UriConstants = /* @__PURE__ */ ((UriConstants2) => {
+  UriConstants2["AUTH_TOKEN_PATH"] = "/authentication/oauth2/token";
+  UriConstants2["GENTOKEN_SOCIAL"] = "/token/generate";
+  UriConstants2["CALL_PATH"] = "/call";
+  UriConstants2["COMPANY_PATH"] = "/company";
+  UriConstants2["PROFILE_PATH"] = "/userinfo";
+  UriConstants2["RESET_PASSWORD_PATH"] = "/reset_password";
+  UriConstants2["CHANGE_PASSWORD_PATH"] = "/change_password";
+  UriConstants2["UPDATE_PASSWORD_PATH"] = "/change_password_parent";
+  UriConstants2["LOAD_ACTION"] = `/load_action`;
+  UriConstants2["REPORT_PATH"] = `/report`;
+  UriConstants2["RUN_ACTION_PATH"] = `/run_action`;
+  UriConstants2["UPLOAD_FILE_PATH"] = `/upload/file`;
+  UriConstants2["GET_MESSAGE"] = `/chatter/thread/messages`;
+  UriConstants2["SENT_MESSAGE"] = `/chatter/message/post`;
+  UriConstants2["UPLOAD_IMAGE"] = `/mail/attachment/upload`;
+  UriConstants2["DELETE_MESSAGE"] = `/chatter/message/update_content`;
+  UriConstants2["IMAGE_PATH"] = `/web/image`;
+  UriConstants2["LOAD_MESSAGE"] = `/load_message_failures`;
+  UriConstants2["TOKEN"] = `/check_token`;
+  UriConstants2["CREATE_UPDATE_PATH"] = `/create_update`;
+  UriConstants2["TWOFA_METHOD_PATH"] = `/id/api/v2/call`;
+  UriConstants2["SIGNIN_SSO"] = `/signin-sso/oauth`;
+  return UriConstants2;
+})(UriConstants || {});
+var initialState = {
+  baseUrl: "",
+  requests: null,
+  companies: [],
+  user: {},
+  envFile: null,
+  defaultCompany: {
+    id: null,
+    logo: "",
+    secondary_color: "",
+    primary_color: ""
+  },
+  context: {
+    uid: null,
+    allowed_company_ids: [],
+    lang: "vi_VN",
+    tz: "Asia/Saigon"
+  }
+};
+var envSlice = toolkit.createSlice({
+  name: "env",
+  initialState,
+  reducers: {
+    setEnv: (state, action) => {
+      Object.assign(state, action.payload);
+    },
+    setUid: (state, action) => {
+      state.context.uid = action.payload;
+    },
+    setAllowCompanies: (state, action) => {
+      state.context.allowed_company_ids = action.payload;
+    },
+    setCompanies: (state, action) => {
+      state.companies = action.payload;
+    },
+    setDefaultCompany: (state, action) => {
+      state.defaultCompany = action.payload;
+    },
+    setLang: (state, action) => {
+      state.context.lang = action.payload;
+    },
+    setUser: (state, action) => {
+      state.user = action.payload;
+    },
+    setEnvFile: (state, action) => {
+      state.envFile = action.payload;
+    }
+  }
 });
-Object.defineProperty(exports, "useRunAction", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_run_action_default; }
+var {
+  setEnv,
+  setUid,
+  setLang,
+  setAllowCompanies,
+  setCompanies,
+  setDefaultCompany,
+  setUser,
+  setEnvFile
+} = envSlice.actions;
+var env_slice_default = envSlice.reducer;
+var initialState2 = {
+  dataParse: null,
+  idFile: null,
+  isFileLoaded: false,
+  loadingImport: false,
+  selectedFile: null,
+  errorData: null
+};
+var excelSlice = toolkit.createSlice({
+  name: "excel",
+  initialState: initialState2,
+  reducers: {
+    setDataParse: (state, action) => {
+      state.dataParse = action.payload;
+    },
+    setIdFile: (state, action) => {
+      state.idFile = action.payload;
+    },
+    setIsFileLoaded: (state, action) => {
+      state.isFileLoaded = action.payload;
+    },
+    setLoadingImport: (state, action) => {
+      state.loadingImport = action.payload;
+    },
+    setSelectedFile: (state, action) => {
+      state.selectedFile = action.payload;
+    },
+    setErrorData: (state, action) => {
+      state.errorData = action.payload;
+    }
+  }
 });
-Object.defineProperty(exports, "useSave", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_save_default; }
+var {
+  setDataParse,
+  setIdFile,
+  setIsFileLoaded,
+  setLoadingImport,
+  setSelectedFile,
+  setErrorData
+} = excelSlice.actions;
+var excel_slice_default = excelSlice.reducer;
+var initialState3 = {
+  viewDataStore: {},
+  isShowingModalDetail: false,
+  isShowModalTranslate: false,
+  formSubmitComponent: {},
+  fieldTranslation: null,
+  listSubject: {},
+  dataUser: {}
+};
+var formSlice = toolkit.createSlice({
+  name: "form",
+  initialState: initialState3,
+  reducers: {
+    setViewDataStore: (state, action) => {
+      state.viewDataStore = action.payload;
+    },
+    setIsShowingModalDetail: (state, action) => {
+      state.isShowingModalDetail = action.payload;
+    },
+    setIsShowModalTranslate: (state, action) => {
+      state.isShowModalTranslate = action.payload;
+    },
+    setFormSubmitComponent: (state, action) => {
+      state.formSubmitComponent[action.payload.key] = action.payload.component;
+    },
+    setFieldTranslate: (state, action) => {
+      state.fieldTranslation = action.payload;
+    },
+    setListSubject: (state, action) => {
+      state.listSubject = action.payload;
+    },
+    setDataUser: (state, action) => {
+      state.dataUser = action.payload;
+    }
+  }
 });
-Object.defineProperty(exports, "useSendComment", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_send_comment_default; }
+var {
+  setViewDataStore,
+  setIsShowingModalDetail,
+  setIsShowModalTranslate,
+  setFormSubmitComponent,
+  setFieldTranslate,
+  setListSubject,
+  setDataUser
+} = formSlice.actions;
+var form_slice_default = formSlice.reducer;
+var initialState4 = {
+  pageLimit: 10,
+  fields: {},
+  order: "",
+  selectedRowKeys: [],
+  indexRowTableModal: -2,
+  footerGroupTable: {},
+  page: 0,
+  domainTable: []
+};
+var listSlice = toolkit.createSlice({
+  name: "list",
+  initialState: initialState4,
+  reducers: {
+    setPageLimit: (state, action) => {
+      state.pageLimit = action.payload;
+    },
+    setFields: (state, action) => {
+      state.fields = action.payload;
+    },
+    setOrder: (state, action) => {
+      state.order = action.payload;
+    },
+    setSelectedRowKeys: (state, action) => {
+      state.selectedRowKeys = action.payload;
+    },
+    setIndexRowTableModal: (state, action) => {
+      state.indexRowTableModal = action.payload;
+    },
+    setPage: (state, action) => {
+      state.page = action.payload;
+    },
+    setDomainTable: (state, action) => {
+      state.domainTable = action.payload;
+    }
+  }
 });
-Object.defineProperty(exports, "useSwitchLocale", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_switch_locale_default; }
+var {
+  setPageLimit,
+  setFields,
+  setOrder,
+  setSelectedRowKeys,
+  setIndexRowTableModal,
+  setPage,
+  setDomainTable
+} = listSlice.actions;
+var list_slice_default = listSlice.reducer;
+var initialState5 = {
+  menuList: []
+};
+var navbarSlice = toolkit.createSlice({
+  name: "navbar",
+  initialState: initialState5,
+  reducers: {
+    setMenuList: (state, action) => {
+      state.menuList = action.payload;
+    }
+  }
 });
-Object.defineProperty(exports, "useUpdatePassword", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_update_password_default; }
+var { setMenuList } = navbarSlice.actions;
+var navbar_slice_default = navbarSlice.reducer;
+var initialState6 = {
+  profile: {}
+};
+var profileSlice = toolkit.createSlice({
+  name: "profile",
+  initialState: initialState6,
+  reducers: {
+    setProfile: (state, action) => {
+      state.profile = action.payload;
+    }
+  }
 });
-Object.defineProperty(exports, "useUploadFile", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_upload_file_default; }
+var { setProfile } = profileSlice.actions;
+var profile_slice_default = profileSlice.reducer;
+var initialState7 = {
+  groupByDomain: null,
+  tableHead: [],
+  searchString: "",
+  hoveredIndexSearchList: null,
+  selectedTags: [],
+  firstDomain: null,
+  searchMap: {},
+  typeFieldsSearch: "",
+  modelSearch: "",
+  filterBy: [],
+  groupBy: []
+};
+var searchSlice = toolkit.createSlice({
+  name: "search",
+  initialState: initialState7,
+  reducers: {
+    setGroupByDomain: (state, action) => {
+      state.groupByDomain = action.payload;
+    },
+    setTableHead: (state, action) => {
+      state.tableHead = action.payload;
+    },
+    setSearchString: (state, action) => {
+      state.searchString = action.payload;
+    },
+    setHoveredIndexSearchList: (state, action) => {
+      state.hoveredIndexSearchList = action.payload;
+    },
+    setSelectedTags: (state, action) => {
+      state.selectedTags = action.payload;
+    },
+    setFirstDomain: (state, action) => {
+      state.firstDomain = action.payload;
+    },
+    setTypeFieldsSearch: (state, action) => {
+      state.typeFieldsSearch = action.payload;
+    },
+    setModelSearch: (state, action) => {
+      state.modelSearch = action.payload;
+    },
+    setFilterBy: (state, action) => {
+      state.filterBy = action.payload;
+    },
+    setGroupBy: (state, action) => {
+      state.groupBy = action.payload;
+    },
+    setSearchMap: (state, action) => {
+      state.searchMap = action.payload;
+    },
+    updateSearchMap: (state, action) => {
+      if (!state.searchMap[action.payload.key]) {
+        state.searchMap[action.payload.key] = [];
+      }
+      state.searchMap[action.payload.key].push(action.payload.value);
+    },
+    removeKeyFromSearchMap: (state, action) => {
+      const { key, item } = action.payload;
+      const values = state.searchMap[key];
+      if (!values) return;
+      if (item) {
+        const filtered = values.filter((value) => value.name !== item.name);
+        if (filtered.length > 0) {
+          state.searchMap[key] = filtered;
+        } else {
+          delete state.searchMap[key];
+        }
+      } else {
+        delete state.searchMap[key];
+      }
+    },
+    clearSearchMap: (state) => {
+      state.searchMap = {};
+    }
+  }
 });
-Object.defineProperty(exports, "useUploadIdFile", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_upload_id_file_default; }
+var {
+  setGroupByDomain,
+  setSelectedTags,
+  setSearchString,
+  setHoveredIndexSearchList,
+  setFirstDomain,
+  setTableHead,
+  setFilterBy,
+  setTypeFieldsSearch,
+  setModelSearch,
+  setSearchMap,
+  updateSearchMap,
+  removeKeyFromSearchMap,
+  setGroupBy,
+  clearSearchMap
+} = searchSlice.actions;
+var search_slice_default = searchSlice.reducer;
+
+// node_modules/redux/dist/redux.mjs
+function formatProdErrorMessage(code) {
+  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
+}
+var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
+var ActionTypes = {
+  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
+  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
+  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
+};
+var actionTypes_default = ActionTypes;
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
+}
+function miniKindOf(val) {
+  if (val === void 0)
+    return "undefined";
+  if (val === null)
+    return "null";
+  const type = typeof val;
+  switch (type) {
+    case "boolean":
+    case "string":
+    case "number":
+    case "symbol":
+    case "function": {
+      return type;
+    }
+  }
+  if (Array.isArray(val))
+    return "array";
+  if (isDate(val))
+    return "date";
+  if (isError(val))
+    return "error";
+  const constructorName = ctorName(val);
+  switch (constructorName) {
+    case "Symbol":
+    case "Promise":
+    case "WeakMap":
+    case "WeakSet":
+    case "Map":
+    case "Set":
+      return constructorName;
+  }
+  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
+}
+function ctorName(val) {
+  return typeof val.constructor === "function" ? val.constructor.name : null;
+}
+function isError(val) {
+  return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
+}
+function isDate(val) {
+  if (val instanceof Date)
+    return true;
+  return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
+}
+function kindOf(val) {
+  let typeOfVal = typeof val;
+  if (process.env.NODE_ENV !== "production") {
+    typeOfVal = miniKindOf(val);
+  }
+  return typeOfVal;
+}
+function warning(message) {
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    console.error(message);
+  }
+  try {
+    throw new Error(message);
+  } catch (e) {
+  }
+}
+function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
+  const reducerKeys = Object.keys(reducers);
+  const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
+  if (reducerKeys.length === 0) {
+    return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
+  }
+  if (!isPlainObject(inputState)) {
+    return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
+  }
+  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
+  unexpectedKeys.forEach((key) => {
+    unexpectedKeyCache[key] = true;
+  });
+  if (action && action.type === actionTypes_default.REPLACE)
+    return;
+  if (unexpectedKeys.length > 0) {
+    return `Unexpected ${unexpectedKeys.length > 1 ? "keys" : "key"} "${unexpectedKeys.join('", "')}" found in ${argumentName}. Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}". Unexpected keys will be ignored.`;
+  }
+}
+function assertReducerShape(reducers) {
+  Object.keys(reducers).forEach((key) => {
+    const reducer = reducers[key];
+    const initialState8 = reducer(void 0, {
+      type: actionTypes_default.INIT
+    });
+    if (typeof initialState8 === "undefined") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : `The slice reducer for key "${key}" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);
+    }
+    if (typeof reducer(void 0, {
+      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
+    }) === "undefined") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : `The slice reducer for key "${key}" returned undefined when probed with a random type. Don't try to handle '${actionTypes_default.INIT}' or other actions in "redux/*" namespace. They are considered private. Instead, you must return the current state for any unknown actions, unless it is undefined, in which case you must return the initial state, regardless of the action type. The initial state may not be undefined, but can be null.`);
+    }
+  });
+}
+function combineReducers(reducers) {
+  const reducerKeys = Object.keys(reducers);
+  const finalReducers = {};
+  for (let i = 0; i < reducerKeys.length; i++) {
+    const key = reducerKeys[i];
+    if (process.env.NODE_ENV !== "production") {
+      if (typeof reducers[key] === "undefined") {
+        warning(`No reducer provided for key "${key}"`);
+      }
+    }
+    if (typeof reducers[key] === "function") {
+      finalReducers[key] = reducers[key];
+    }
+  }
+  const finalReducerKeys = Object.keys(finalReducers);
+  let unexpectedKeyCache;
+  if (process.env.NODE_ENV !== "production") {
+    unexpectedKeyCache = {};
+  }
+  let shapeAssertionError;
+  try {
+    assertReducerShape(finalReducers);
+  } catch (e) {
+    shapeAssertionError = e;
+  }
+  return function combination(state = {}, action) {
+    if (shapeAssertionError) {
+      throw shapeAssertionError;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      const warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);
+      if (warningMessage) {
+        warning(warningMessage);
+      }
+    }
+    let hasChanged = false;
+    const nextState = {};
+    for (let i = 0; i < finalReducerKeys.length; i++) {
+      const key = finalReducerKeys[i];
+      const reducer = finalReducers[key];
+      const previousStateForKey = state[key];
+      const nextStateForKey = reducer(previousStateForKey, action);
+      if (typeof nextStateForKey === "undefined") {
+        const actionType = action && action.type;
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : `When called with an action of type ${actionType ? `"${String(actionType)}"` : "(unknown type)"}, the slice reducer for key "${key}" returned undefined. To ignore an action, you must explicitly return the previous state. If you want this reducer to hold no value, you can return null instead of undefined.`);
+      }
+      nextState[key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
+    }
+    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
+    return hasChanged ? nextState : state;
+  };
+}
+
+// src/store/store.ts
+var rootReducer = combineReducers({
+  env: env_slice_default,
+  navbar: navbar_slice_default,
+  list: list_slice_default,
+  search: search_slice_default,
+  form: form_slice_default,
+  excel: excel_slice_default,
+  profile: profile_slice_default
 });
-Object.defineProperty(exports, "useUploadImage", {
-  enumerable: true,
-  get: function () { return chunkEK43MEN4_js.use_upload_image_default; }
+var envStore = toolkit.configureStore({
+  reducer: rootReducer,
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+    serializableCheck: false
+  })
 });
+var MAINT_KEY = "MAINTENANCE_ACTIVE";
+var MAINT_AT = "MAINTENANCE_AT";
+var MAINT_LAST_PATH = "MAINTENANCE_LAST_PATH";
+var hasRedirectedToMaintenance = false;
+function setMaintenanceFlags() {
+  if (typeof window === "undefined") return;
+  const { pathname, search } = window.location;
+  const lastPath = pathname + (search || "");
+  if (pathname !== "/maintenance" && !window.localStorage.getItem(MAINT_LAST_PATH)) {
+    window.localStorage.setItem(MAINT_LAST_PATH, lastPath);
+  }
+  window.localStorage.setItem(MAINT_KEY, "true");
+  window.localStorage.setItem(MAINT_AT, String(Date.now()));
+}
+async function clearMaintenanceAndExit(getToken, opts) {
+  if (typeof window === "undefined") return;
+  const forceLogin = opts?.forceLogin === true;
+  const clearTokenOnForce = opts?.clearTokenOnForce !== false;
+  window.localStorage.removeItem(MAINT_KEY);
+  window.localStorage.removeItem(MAINT_AT);
+  const lastPath = window.localStorage.getItem(MAINT_LAST_PATH);
+  window.localStorage.removeItem(MAINT_LAST_PATH);
+  try {
+    if (forceLogin) {
+      if (clearTokenOnForce) {
+        try {
+          await opts?.clearToken?.();
+        } catch {
+        }
+      }
+      window.location.replace("/login");
+      return;
+    }
+    const token = await getToken();
+    if (token) {
+      const target = lastPath && lastPath !== "/maintenance" ? lastPath : "/";
+      window.location.replace(target);
+    } else {
+      window.location.replace("/login");
+    }
+  } catch {
+    window.location.replace("/login");
+  }
+}
+var axiosClient = {
+  init(config) {
+    const localStorage = config.localStorageUtils;
+    const sessionStorage = config.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);
+        }
+      });
+      failedQueue = [];
+    };
+    const instance = axios__default.default.create({
+      adapter: axios__default.default.defaults.adapter,
+      baseURL: config.baseUrl,
+      timeout: 5e4,
+      paramsSerializer: (params) => new URLSearchParams(params).toString()
+    });
+    if (typeof window !== "undefined") {
+      const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
+      const onMaintenancePage = window.location.pathname === "/maintenance";
+      if (isMaint && !onMaintenancePage) {
+        hasRedirectedToMaintenance = true;
+        window.location.replace("/maintenance");
+      }
+      if (isMaint && onMaintenancePage) {
+        const healthUrl = config.healthUrl || `${(config.baseUrl || "").replace(/\/+$/, "")}/health`;
+        (async () => {
+          try {
+            await axios__default.default.get(healthUrl, { timeout: 8e3 });
+            await clearMaintenanceAndExit(() => localStorage.getAccessToken(), {
+              forceLogin: true,
+              clearTokenOnForce: true,
+              clearToken: () => localStorage.clearToken()
+            });
+          } catch {
+          }
+        })();
+      }
+    }
+    instance.interceptors.request.use(
+      async (configReq) => {
+        const token = await localStorage.getAccessToken();
+        if (token) {
+          configReq.headers["Authorization"] = "Bearer " + token;
+        }
+        return configReq;
+      },
+      (error) => Promise.reject(error)
+    );
+    instance.interceptors.response.use(
+      (response) => {
+        if (typeof window !== "undefined") {
+          const isMaint = window.localStorage.getItem(MAINT_KEY) === "true";
+          const onMaintenancePage = window.location.pathname === "/maintenance";
+          if (isMaint && onMaintenancePage) {
+            (async () => {
+              await clearMaintenanceAndExit(
+                () => localStorage.getAccessToken(),
+                {
+                  forceLogin: true,
+                  clearTokenOnForce: true,
+                  clearToken: () => localStorage.clearToken()
+                }
+              );
+            })();
+          } else if (isMaint) {
+            window.localStorage.removeItem(MAINT_KEY);
+            window.localStorage.removeItem(MAINT_AT);
+            window.localStorage.removeItem(MAINT_LAST_PATH);
+          }
+        }
+        return handleResponse(response);
+      },
+      async (error) => {
+        const status = error?.response?.status;
+        if (status === 503) {
+          if (typeof window !== "undefined") {
+            setMaintenanceFlags();
+            if (!hasRedirectedToMaintenance && window.location.pathname !== "/maintenance") {
+              hasRedirectedToMaintenance = true;
+              window.location.replace("/maintenance");
+            }
+          }
+          return Promise.reject({
+            code: 503,
+            message: "SERVICE_UNAVAILABLE",
+            original: error?.response?.data
+          });
+        }
+        const handleError = async (err) => {
+          if (!err.response) {
+            return err;
+          }
+          const { data } = err.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].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((token) => {
+              originalRequest.headers["Authorization"] = "Bearer " + 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 sessionStorage.getBrowserSession();
+          const refreshToken = await localStorage.getRefreshToken();
+          const accessTokenExp = await localStorage.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__default.default.post(
+                `${config.baseUrl}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
+                }
+              ).then(async (res) => {
+                const data = res.data;
+                await localStorage.setToken(data.access_token);
+                await localStorage.setRefreshToken(data.refresh_token);
+                axios__default.default.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + 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")) {
+                  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;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError(error));
+      }
+    );
+    const handleResponse = (res) => {
+      if (res && res.data) {
+        return res.data;
+      }
+      return res;
+    };
+    const clearAuthToken = async () => {
+      await localStorage.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"
+        }
+      }).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 EnvStore = class {
+  envStore;
+  baseUrl;
+  requests;
+  context;
+  defaultCompany;
+  config;
+  companies;
+  user;
+  db;
+  localStorageUtils;
+  sessionStorageUtils;
+  constructor(envStore2, localStorageUtils, sessionStorageUtils) {
+    this.envStore = envStore2;
+    this.localStorageUtils = localStorageUtils;
+    this.sessionStorageUtils = sessionStorageUtils;
+    this.setup();
+  }
+  setup() {
+    const env2 = this.envStore.getState().env;
+    this.baseUrl = env2?.baseUrl;
+    this.requests = env2?.requests;
+    this.context = env2?.context;
+    this.defaultCompany = env2?.defaultCompany;
+    this.config = env2?.config;
+    this.companies = env2?.companies || [];
+    this.user = env2?.user;
+    this.db = env2?.db;
+  }
+  setupEnv(envConfig) {
+    const dispatch = this.envStore.dispatch;
+    const env2 = {
+      ...envConfig,
+      localStorageUtils: this.localStorageUtils,
+      sessionStorageUtils: this.sessionStorageUtils
+    };
+    const requests = axiosClient.init(env2);
+    dispatch(setEnv({ ...env2, requests }));
+    this.setup();
+  }
+  setUid(uid) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setUid(uid));
+    this.setup();
+  }
+  setLang(lang) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setLang(lang));
+    this.setup();
+  }
+  setAllowCompanies(allowCompanies) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setAllowCompanies(allowCompanies));
+    this.setup();
+  }
+  setCompanies(companies) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setCompanies(companies));
+    this.setup();
+  }
+  setDefaultCompany(company) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setDefaultCompany(company));
+    this.setup();
+  }
+  setUserInfo(userInfo) {
+    const dispatch = this.envStore.dispatch;
+    dispatch(setUser(userInfo));
+    this.setup();
+  }
+};
+var env = null;
+function getEnv() {
+  if (!env) env = new EnvStore(envStore);
+  return env;
+}
+
+// src/utils/domain/py_tokenizer.ts
+var TokenizerError = class extends Error {
+};
+var directMap = {
+  "\\": "\\",
+  '"': '"',
+  "'": "'",
+  a: "\x07",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	",
+  v: "\v"
+};
+function decodeStringLiteral(str, unicode) {
+  const out = [];
+  let code;
+  for (let i = 0; i < str.length; ++i) {
+    if (str[i] !== "\\") {
+      out.push(str[i]);
+      continue;
+    }
+    const escape = str[i + 1];
+    if (escape in directMap) {
+      out.push(directMap[escape]);
+      ++i;
+      continue;
+    }
+    switch (escape) {
+      case "\n":
+        ++i;
+        continue;
+      case "N":
+        if (!unicode) {
+          break;
+        }
+        throw new TokenizerError("SyntaxError: \\N{} escape not implemented");
+      case "u":
+        if (!unicode) {
+          break;
+        }
+        const uni = str.slice(i + 2, i + 6);
+        if (!/[0-9a-f]{4}/i.test(uni)) {
+          throw new TokenizerError(
+            [
+              "SyntaxError: (unicode error) 'unicodeescape' codec",
+              " can't decode bytes in position ",
+              i,
+              "-",
+              i + 4,
+              ": truncated \\uXXXX escape"
+            ].join("")
+          );
+        }
+        code = parseInt(uni, 16);
+        out.push(String.fromCharCode(code));
+        i += 5;
+        continue;
+      case "U":
+        if (!unicode) {
+          break;
+        }
+        throw new TokenizerError("SyntaxError: \\U escape not implemented");
+      case "x":
+        const hex = str.slice(i + 2, i + 4);
+        if (!/[0-9a-f]{2}/i.test(hex)) {
+          if (!unicode) {
+            throw new TokenizerError("ValueError: invalid \\x escape");
+          }
+          throw new TokenizerError(
+            [
+              "SyntaxError: (unicode error) 'unicodeescape'",
+              " codec can't decode bytes in position ",
+              i,
+              "-",
+              i + 2,
+              ": truncated \\xXX escape"
+            ].join("")
+          );
+        }
+        code = parseInt(hex, 16);
+        out.push(String.fromCharCode(code));
+        i += 3;
+        continue;
+      default:
+        if (!/[0-8]/.test(escape)) {
+          break;
+        }
+        const r = /[0-8]{1,3}/g;
+        r.lastIndex = i + 1;
+        const m = r.exec(str);
+        if (!m) break;
+        const oct = m[0];
+        code = parseInt(oct, 8);
+        out.push(String.fromCharCode(code));
+        i += oct.length;
+        continue;
+    }
+    out.push("\\");
+  }
+  return out.join("");
+}
+var constants = /* @__PURE__ */ new Set(["None", "False", "True"]);
+var comparators = [
+  "in",
+  "not",
+  "not in",
+  "is",
+  "is not",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "<>",
+  "!=",
+  "=="
+];
+var binaryOperators = [
+  "or",
+  "and",
+  "|",
+  "^",
+  "&",
+  "<<",
+  ">>",
+  "+",
+  "-",
+  "*",
+  "/",
+  "//",
+  "%",
+  "~",
+  "**",
+  "."
+];
+var unaryOperators = ["-"];
+var symbols = /* @__PURE__ */ new Set([
+  ...["(", ")", "[", "]", "{", "}", ":", ","],
+  ...["if", "else", "lambda", "="],
+  ...comparators,
+  ...binaryOperators,
+  ...unaryOperators
+]);
+function group(...args) {
+  return "(" + args.join("|") + ")";
+}
+var Name = "[a-zA-Z_]\\w*";
+var Whitespace = "[ \\f\\t]*";
+var DecNumber = "\\d+(L|l)?";
+var IntNumber = DecNumber;
+var Exponent = "[eE][+-]?\\d+";
+var PointFloat = group(`\\d+\\.\\d*(${Exponent})?`, `\\.\\d+(${Exponent})?`);
+var FloatNumber = group(PointFloat, `\\d+${Exponent}`);
+var Number2 = group(FloatNumber, IntNumber);
+var Operator = group(
+  "\\*\\*=?",
+  ">>=?",
+  "<<=?",
+  "<>",
+  "!=",
+  "//=?",
+  "[+\\-*/%&|^=<>]=?",
+  "~"
+);
+var Bracket = "[\\[\\]\\(\\)\\{\\}]";
+var Special = "[:;.,`@]";
+var Funny = group(Operator, Bracket, Special);
+var ContStr = group(
+  "([uU])?'([^\\n'\\\\]*(?:\\\\.[^\\n'\\\\]*)*)'",
+  '([uU])?"([^\\n"\\\\]*(?:\\\\.[^\\n"\\\\]*)*)"'
+);
+var PseudoToken = Whitespace + group(Number2, Funny, ContStr, Name);
+var NumberPattern = new RegExp("^" + Number2 + "$");
+var StringPattern = new RegExp("^" + ContStr + "$");
+var NamePattern = new RegExp("^" + Name + "$");
+var strip = new RegExp("^" + Whitespace);
+function tokenize(str) {
+  const tokens = [];
+  const max = str.length;
+  let start = 0;
+  let end = 0;
+  const pseudoprog = new RegExp(PseudoToken, "g");
+  while (pseudoprog.lastIndex < max) {
+    const pseudomatch = pseudoprog.exec(str);
+    if (!pseudomatch) {
+      if (/^\s+$/.test(str.slice(end))) {
+        break;
+      }
+      throw new TokenizerError(
+        "Failed to tokenize <<" + str + ">> at index " + (end || 0) + "; parsed so far: " + tokens
+      );
+    }
+    if (pseudomatch.index > end) {
+      if (str.slice(end, pseudomatch.index).trim()) {
+        throw new TokenizerError("Invalid expression");
+      }
+    }
+    start = pseudomatch.index;
+    end = pseudoprog.lastIndex;
+    let token = str.slice(start, end).replace(strip, "");
+    if (NumberPattern.test(token)) {
+      tokens.push({
+        type: 0,
+        value: parseFloat(token)
+      });
+    } else if (StringPattern.test(token)) {
+      const m = StringPattern.exec(token);
+      if (!m) throw new TokenizerError("Invalid string match");
+      tokens.push({
+        type: 1,
+        value: decodeStringLiteral(
+          m[3] !== void 0 ? m[3] : m[5],
+          !!(m[2] || m[4])
+        )
+      });
+    } else if (symbols.has(token)) {
+      if (token === "in" && tokens.length > 0 && tokens[tokens.length - 1].value === "not") {
+        token = "not in";
+        tokens.pop();
+      } else if (token === "not" && tokens.length > 0 && tokens[tokens.length - 1].value === "is") {
+        token = "is not";
+        tokens.pop();
+      }
+      tokens.push({
+        type: 2,
+        value: token
+      });
+    } else if (constants.has(token)) {
+      tokens.push({
+        type: 4,
+        value: token
+      });
+    } else if (NamePattern.test(token)) {
+      tokens.push({
+        type: 3,
+        value: token
+      });
+    } else {
+      throw new TokenizerError("Invalid expression");
+    }
+  }
+  return tokens;
+}
+
+// src/utils/domain/py_parser.ts
+var ParserError = class extends Error {
+};
+var chainedOperators = new Set(comparators);
+var infixOperators = /* @__PURE__ */ new Set([...binaryOperators, ...comparators]);
+function bp(symbol) {
+  switch (symbol) {
+    case "=":
+      return 10;
+    case "if":
+      return 20;
+    case "in":
+    case "not in":
+    case "is":
+    case "is not":
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+    case "<>":
+    case "==":
+    case "!=":
+      return 60;
+    case "or":
+      return 30;
+    case "and":
+      return 40;
+    case "not":
+      return 50;
+    case "|":
+      return 70;
+    case "^":
+      return 80;
+    case "&":
+      return 90;
+    case "<<":
+    case ">>":
+      return 100;
+    case "+":
+    case "-":
+      return 110;
+    case "*":
+    case "/":
+    case "//":
+    case "%":
+      return 120;
+    case "**":
+      return 140;
+    case ".":
+    case "(":
+    case "[":
+      return 150;
+    default:
+      return 0;
+  }
+}
+function bindingPower(token) {
+  return token.type === 2 ? bp(token.value) : 0;
+}
+function isSymbol(token, value) {
+  return token.type === 2 && token.value === value;
+}
+function parsePrefix(current, tokens) {
+  switch (current.type) {
+    case 0:
+      return { type: 0, value: current.value };
+    case 1:
+      return { type: 1, value: current.value };
+    case 4:
+      if (current.value === "None") {
+        return {
+          type: 3
+          /* None */
+        };
+      } else {
+        return { type: 2, value: current.value === "True" };
+      }
+    case 3:
+      return { type: 5, value: current.value };
+    case 2:
+      switch (current.value) {
+        case "-":
+        case "+":
+        case "~":
+          return {
+            type: 6,
+            op: current.value,
+            right: _parse(tokens, 130)
+          };
+        case "not":
+          return {
+            type: 6,
+            op: current.value,
+            right: _parse(tokens, 50)
+          };
+        case "(":
+          const content = [];
+          let isTuple = false;
+          while (tokens[0] && !isSymbol(tokens[0], ")")) {
+            content.push(_parse(tokens, 0));
+            if (tokens[0]) {
+              if (tokens[0] && isSymbol(tokens[0], ",")) {
+                isTuple = true;
+                tokens.shift();
+              } else if (!isSymbol(tokens[0], ")")) {
+                throw new ParserError("parsing error");
+              }
+            } else {
+              throw new ParserError("parsing error");
+            }
+          }
+          if (!tokens[0] || !isSymbol(tokens[0], ")")) {
+            throw new ParserError("parsing error");
+          }
+          tokens.shift();
+          isTuple = isTuple || content.length === 0;
+          return isTuple ? { type: 10, value: content } : content[0];
+        case "[":
+          const value = [];
+          while (tokens[0] && !isSymbol(tokens[0], "]")) {
+            value.push(_parse(tokens, 0));
+            if (tokens[0]) {
+              if (isSymbol(tokens[0], ",")) {
+                tokens.shift();
+              } else if (!isSymbol(tokens[0], "]")) {
+                throw new ParserError("parsing error");
+              }
+            }
+          }
+          if (!tokens[0] || !isSymbol(tokens[0], "]")) {
+            throw new ParserError("parsing error");
+          }
+          tokens.shift();
+          return { type: 4, value };
+        case "{":
+          const dict = {};
+          while (tokens[0] && !isSymbol(tokens[0], "}")) {
+            const key = _parse(tokens, 0);
+            if (key.type !== 1 && key.type !== 0 || !tokens[0] || !isSymbol(tokens[0], ":")) {
+              throw new ParserError("parsing error");
+            }
+            tokens.shift();
+            const val = _parse(tokens, 0);
+            dict[key.value] = val;
+            if (isSymbol(tokens[0], ",")) {
+              tokens.shift();
+            }
+          }
+          if (!tokens.shift()) {
+            throw new ParserError("parsing error");
+          }
+          return { type: 11, value: dict };
+        default:
+          throw new ParserError("Token cannot be parsed");
+      }
+    default:
+      throw new ParserError("Token cannot be parsed");
+  }
+}
+function parseInfix(left, current, tokens) {
+  switch (current.type) {
+    case 2:
+      if (infixOperators.has(current.value)) {
+        let right = _parse(tokens, bindingPower(current));
+        if (current.value === "and" || current.value === "or") {
+          return {
+            type: 14,
+            op: current.value,
+            left,
+            right
+          };
+        } else if (current.value === ".") {
+          if (right.type === 5) {
+            return {
+              type: 15,
+              obj: left,
+              key: right.value
+            };
+          } else {
+            throw new ParserError("invalid obj lookup");
+          }
+        }
+        let op = {
+          type: 7,
+          op: current.value,
+          left,
+          right
+        };
+        while (chainedOperators.has(current.value) && tokens[0] && tokens[0].type === 2 && chainedOperators.has(tokens[0].value)) {
+          const nextToken = tokens.shift();
+          op = {
+            type: 14,
+            op: "and",
+            left: op,
+            right: {
+              type: 7,
+              op: nextToken.value,
+              left: right,
+              right: _parse(tokens, bindingPower(nextToken))
+            }
+          };
+          right = op.right;
+        }
+        return op;
+      }
+      switch (current.value) {
+        case "(":
+          const args = [];
+          const kwargs = {};
+          while (tokens[0] && !isSymbol(tokens[0], ")")) {
+            const arg = _parse(tokens, 0);
+            if (arg.type === 9) {
+              kwargs[arg.name.value] = arg.value;
+            } else {
+              args.push(arg);
+            }
+            if (tokens[0] && isSymbol(tokens[0], ",")) {
+              tokens.shift();
+            }
+          }
+          if (!tokens[0] || !isSymbol(tokens[0], ")")) {
+            throw new ParserError("parsing error");
+          }
+          tokens.shift();
+          return { type: 8, fn: left, args, kwargs };
+        case "=":
+          if (left.type === 5) {
+            return {
+              type: 9,
+              name: left,
+              value: _parse(tokens, 10)
+            };
+          }
+          break;
+        case "[":
+          const key = _parse(tokens);
+          if (!tokens[0] || !isSymbol(tokens[0], "]")) {
+            throw new ParserError("parsing error");
+          }
+          tokens.shift();
+          return {
+            type: 12,
+            target: left,
+            key
+          };
+        case "if":
+          const condition = _parse(tokens);
+          if (!tokens[0] || !isSymbol(tokens[0], "else")) {
+            throw new ParserError("parsing error");
+          }
+          tokens.shift();
+          const ifFalse = _parse(tokens);
+          return {
+            type: 13,
+            condition,
+            ifTrue: left,
+            ifFalse
+          };
+      }
+  }
+  throw new ParserError("Token cannot be parsed");
+}
+function _parse(tokens, bp2 = 0) {
+  const token = tokens.shift();
+  if (!token) {
+    throw new ParserError("Unexpected end of input");
+  }
+  let expr = parsePrefix(token, tokens);
+  while (tokens[0] && bindingPower(tokens[0]) > bp2) {
+    expr = parseInfix(expr, tokens.shift(), tokens);
+  }
+  return expr;
+}
+function parse(tokens) {
+  if (tokens.length) {
+    return _parse(tokens, 0);
+  }
+  throw new ParserError("Missing token");
+}
+function parseArgs(args, spec) {
+  const last = args[args.length - 1];
+  const unnamedArgs = typeof last === "object" ? args.slice(0, -1) : args;
+  const kwargs = typeof last === "object" ? last : {};
+  for (const [index, val] of unnamedArgs.entries()) {
+    kwargs[spec[index]] = val;
+  }
+  return kwargs;
+}
+
+// src/utils/domain/py_date.ts
+var AssertionError = class extends Error {
+};
+var ValueError = class extends Error {
+};
+var NotSupportedError = class extends Error {
+};
+function fmt2(n) {
+  return String(n).padStart(2, "0");
+}
+function fmt4(n) {
+  return String(n).padStart(4, "0");
+}
+function divmod(a, b, fn) {
+  let mod = a % b;
+  if (mod > 0 && b < 0 || mod < 0 && b > 0) {
+    mod += b;
+  }
+  return fn(Math.floor(a / b), mod);
+}
+function assert(bool, message = "AssertionError") {
+  if (!bool) {
+    throw new AssertionError(message);
+  }
+}
+var DAYS_IN_MONTH = [
+  null,
+  31,
+  28,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+var DAYS_BEFORE_MONTH = [null];
+for (let dbm = 0, i = 1; i < DAYS_IN_MONTH.length; ++i) {
+  DAYS_BEFORE_MONTH.push(dbm);
+  dbm += DAYS_IN_MONTH[i];
+}
+function daysInMonth(year, month) {
+  if (month === 2 && isLeap(year)) {
+    return 29;
+  }
+  return DAYS_IN_MONTH[month];
+}
+function isLeap(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function daysBeforeYear(year) {
+  const y = year - 1;
+  return y * 365 + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400);
+}
+function daysBeforeMonth(year, month) {
+  const postLeapFeb = month > 2 && isLeap(year);
+  return DAYS_BEFORE_MONTH[month] + (postLeapFeb ? 1 : 0);
+}
+function ymd2ord(year, month, day) {
+  const dim = daysInMonth(year, month);
+  if (!(1 <= day && day <= dim)) {
+    throw new ValueError(`day must be in 1..${dim}`);
+  }
+  return daysBeforeYear(year) + daysBeforeMonth(year, month) + day;
+}
+var DI400Y = daysBeforeYear(401);
+var DI100Y = daysBeforeYear(101);
+var DI4Y = daysBeforeYear(5);
+function ord2ymd(n) {
+  --n;
+  let n400 = 0, n100 = 0, n4 = 0, n1 = 0, n0 = 0;
+  divmod(n, DI400Y, (_n400, n2) => {
+    n400 = _n400;
+    divmod(n2, DI100Y, (_n100, n3) => {
+      n100 = _n100;
+      divmod(n3, DI4Y, (_n4, n5) => {
+        n4 = _n4;
+        divmod(n5, 365, (_n1, n6) => {
+          n1 = _n1;
+          n0 = n6;
+        });
+      });
+    });
+  });
+  n = n0;
+  const year = n400 * 400 + 1 + n100 * 100 + n4 * 4 + n1;
+  if (n1 === 4 || n100 === 100) {
+    assert(n0 === 0);
+    return {
+      year: year - 1,
+      month: 12,
+      day: 31
+    };
+  }
+  const leapyear = n1 === 3 && (n4 !== 24 || n100 === 3);
+  assert(leapyear === isLeap(year));
+  let month = n + 50 >> 5;
+  let preceding = DAYS_BEFORE_MONTH[month] + (month > 2 && leapyear ? 1 : 0);
+  if (preceding > n) {
+    --month;
+    preceding -= DAYS_IN_MONTH[month] + (month === 2 && leapyear ? 1 : 0);
+  }
+  n -= preceding;
+  return {
+    year,
+    month,
+    day: n + 1
+  };
+}
+function tmxxx(year, month, day, hour, minute, second, microsecond) {
+  hour = hour || 0;
+  minute = minute || 0;
+  second = second || 0;
+  microsecond = microsecond || 0;
+  if (microsecond < 0 || microsecond > 999999) {
+    divmod(microsecond, 1e6, (carry, ms) => {
+      microsecond = ms;
+      second += carry;
+    });
+  }
+  if (second < 0 || second > 59) {
+    divmod(second, 60, (carry, s) => {
+      second = s;
+      minute += carry;
+    });
+  }
+  if (minute < 0 || minute > 59) {
+    divmod(minute, 60, (carry, m) => {
+      minute = m;
+      hour += carry;
+    });
+  }
+  if (hour < 0 || hour > 23) {
+    divmod(hour, 24, (carry, h) => {
+      hour = h;
+      day += carry;
+    });
+  }
+  if (month < 1 || month > 12) {
+    divmod(month - 1, 12, (carry, m) => {
+      month = m + 1;
+      year += carry;
+    });
+  }
+  const dim = daysInMonth(year, month);
+  if (day < 1 || day > dim) {
+    if (day === 0) {
+      --month;
+      if (month > 0) {
+        day = daysInMonth(year, month);
+      } else {
+        --year;
+        month = 12;
+        day = 31;
+      }
+    } else if (day === dim + 1) {
+      ++month;
+      day = 1;
+      if (month > 12) {
+        month = 1;
+        ++year;
+      }
+    } else {
+      const r = ord2ymd(ymd2ord(year, month, 1) + (day - 1));
+      year = r.year;
+      month = r.month;
+      day = r.day;
+    }
+  }
+  return {
+    year,
+    month,
+    day,
+    hour,
+    minute,
+    second,
+    microsecond
+  };
+}
+var PyDate = class _PyDate {
+  constructor(year, month, day) {
+    this.year = year;
+    this.month = month;
+    this.day = day;
+  }
+  static today() {
+    return this.convertDate(/* @__PURE__ */ new Date());
+  }
+  static convertDate(date) {
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    return new _PyDate(year, month, day);
+  }
+  static create(...args) {
+    const { year, month, day } = parseArgs(args, ["year", "month", "day"]);
+    return new _PyDate(year, month, day);
+  }
+  add(timedelta) {
+    const s = tmxxx(this.year, this.month, this.day + timedelta.days, 0, 0, 0);
+    return new _PyDate(s.year, s.month, s.day);
+  }
+  isEqual(other) {
+    if (!(other instanceof _PyDate)) {
+      return false;
+    }
+    return this.year === other.year && this.month === other.month && this.day === other.day;
+  }
+  strftime(format) {
+    return format.replace(/%([A-Za-z])/g, (m, c) => {
+      switch (c) {
+        case "Y":
+          return fmt4(this.year);
+        case "m":
+          return fmt2(this.month);
+        case "d":
+          return fmt2(this.day);
+        default:
+          throw new ValueError(`No known conversion for ${m}`);
+      }
+    });
+  }
+  substract(other) {
+    if (other instanceof PyTimeDelta) {
+      return this.add(other.negate());
+    }
+    if (other instanceof _PyDate) {
+      return PyTimeDelta.create(this.toordinal() - other.toordinal());
+    }
+    throw new NotSupportedError();
+  }
+  toJSON() {
+    return this.strftime("%Y-%m-%d");
+  }
+  toordinal() {
+    return ymd2ord(this.year, this.month, this.day);
+  }
+};
+var PyDateTime = class _PyDateTime {
+  constructor(year, month, day, hour, minute, second, microsecond) {
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    this.hour = hour;
+    this.minute = minute;
+    this.second = second;
+    this.microsecond = microsecond;
+  }
+  static now() {
+    return this.convertDate(/* @__PURE__ */ new Date());
+  }
+  static convertDate(date) {
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const hour = date.getHours();
+    const minute = date.getMinutes();
+    const second = date.getSeconds();
+    return new _PyDateTime(year, month, day, hour, minute, second, 0);
+  }
+  static create(...args) {
+    const namedArgs = parseArgs(args, [
+      "year",
+      "month",
+      "day",
+      "hour",
+      "minute",
+      "second",
+      "microsecond"
+    ]);
+    const year = namedArgs.year;
+    const month = namedArgs.month;
+    const day = namedArgs.day;
+    const hour = namedArgs.hour || 0;
+    const minute = namedArgs.minute || 0;
+    const second = namedArgs.second || 0;
+    const ms = namedArgs.microsecond / 1e3 || 0;
+    return new _PyDateTime(year, month, day, hour, minute, second, ms);
+  }
+  static combine(...args) {
+    const { date, time } = parseArgs(args, ["date", "time"]);
+    return _PyDateTime.create(
+      date.year,
+      date.month,
+      date.day,
+      time.hour,
+      time.minute,
+      time.second
+    );
+  }
+  add(timedelta) {
+    const s = tmxxx(
+      this.year,
+      this.month,
+      this.day + timedelta.days,
+      this.hour,
+      this.minute,
+      this.second + timedelta.seconds,
+      this.microsecond + timedelta.microseconds
+    );
+    return new _PyDateTime(
+      s.year,
+      s.month,
+      s.day,
+      s.hour,
+      s.minute,
+      s.second,
+      s.microsecond
+    );
+  }
+  isEqual(other) {
+    if (!(other instanceof _PyDateTime)) {
+      return false;
+    }
+    return this.year === other.year && this.month === other.month && this.day === other.day && this.hour === other.hour && this.minute === other.minute && this.second === other.second && this.microsecond === other.microsecond;
+  }
+  strftime(format) {
+    return format.replace(/%([A-Za-z])/g, (m, c) => {
+      switch (c) {
+        case "Y":
+          return fmt4(this.year);
+        case "m":
+          return fmt2(this.month);
+        case "d":
+          return fmt2(this.day);
+        case "H":
+          return fmt2(this.hour);
+        case "M":
+          return fmt2(this.minute);
+        case "S":
+          return fmt2(this.second);
+        default:
+          throw new ValueError(`No known conversion for ${m}`);
+      }
+    });
+  }
+  substract(timedelta) {
+    return this.add(timedelta.negate());
+  }
+  toJSON() {
+    return this.strftime("%Y-%m-%d %H:%M:%S");
+  }
+  to_utc() {
+    const d = new Date(
+      this.year,
+      this.month - 1,
+      this.day,
+      this.hour,
+      this.minute,
+      this.second
+    );
+    const timedelta = PyTimeDelta.create({ minutes: d.getTimezoneOffset() });
+    return this.add(timedelta);
+  }
+};
+var PyTime = class _PyTime extends PyDate {
+  constructor(hour, minute, second) {
+    const now = /* @__PURE__ */ new Date();
+    const year = now.getFullYear();
+    const month = now.getMonth() + 1;
+    const day = now.getDate();
+    super(year, month, day);
+    this.hour = hour;
+    this.minute = minute;
+    this.second = second;
+    this.hour = hour;
+    this.minute = minute;
+    this.second = second;
+  }
+  static create(...args) {
+    const namedArgs = parseArgs(args, ["hour", "minute", "second"]);
+    const hour = namedArgs.hour || 0;
+    const minute = namedArgs.minute || 0;
+    const second = namedArgs.second || 0;
+    return new _PyTime(hour, minute, second);
+  }
+  strftime(format) {
+    return format.replace(/%([A-Za-z])/g, (m, c) => {
+      switch (c) {
+        case "Y":
+          return fmt4(this.year);
+        case "m":
+          return fmt2(this.month);
+        case "d":
+          return fmt2(this.day);
+        case "H":
+          return fmt2(this.hour);
+        case "M":
+          return fmt2(this.minute);
+        case "S":
+          return fmt2(this.second);
+        default:
+          throw new ValueError(`No known conversion for ${m}`);
+      }
+    });
+  }
+  toJSON() {
+    return this.strftime("%H:%M:%S");
+  }
+};
+var DAYS_IN_YEAR = [
+  31,
+  59,
+  90,
+  120,
+  151,
+  181,
+  212,
+  243,
+  273,
+  304,
+  334,
+  366
+];
+var TIME_PERIODS = ["hour", "minute", "second"];
+var PERIODS = ["year", "month", "day", ...TIME_PERIODS];
+var RELATIVE_KEYS = "years months weeks days hours minutes seconds microseconds leapdays".split(
+  " "
+);
+var ABSOLUTE_KEYS = "year month day hour minute second microsecond weekday nlyearday yearday".split(
+  " "
+);
+var argsSpec = ["dt1", "dt2"];
+var PyRelativeDelta = class _PyRelativeDelta {
+  static create(...args) {
+    const params = parseArgs(args, argsSpec);
+    if ("dt1" in params) {
+      throw new Error("relativedelta(dt1, dt2) is not supported for now");
+    }
+    for (const period of PERIODS) {
+      if (period in params) {
+        const val = params[period];
+        assert(val >= 0, `${period} ${val} is out of range`);
+      }
+    }
+    for (const key of RELATIVE_KEYS) {
+      params[key] = params[key] || 0;
+    }
+    for (const key of ABSOLUTE_KEYS) {
+      params[key] = key in params ? params[key] : null;
+    }
+    params.days += 7 * params.weeks;
+    let yearDay = 0;
+    if (params.nlyearday) {
+      yearDay = params.nlyearday;
+    } else if (params.yearday) {
+      yearDay = params.yearday;
+      if (yearDay > 59) {
+        params.leapDays = -1;
+      }
+    }
+    if (yearDay) {
+      for (let monthIndex = 0; monthIndex < DAYS_IN_YEAR.length; monthIndex++) {
+        if (yearDay <= DAYS_IN_YEAR[monthIndex]) {
+          params.month = monthIndex + 1;
+          if (monthIndex === 0) {
+            params.day = yearDay;
+          } else {
+            params.day = yearDay - DAYS_IN_YEAR[monthIndex - 1];
+          }
+          break;
+        }
+      }
+    }
+    return new _PyRelativeDelta(params);
+  }
+  static add(date, delta) {
+    if (!(date instanceof PyDate || date instanceof PyDateTime)) {
+      throw new NotSupportedError();
+    }
+    const s = tmxxx(
+      (delta.year || date.year) + delta.years,
+      (delta.month || date.month) + delta.months,
+      delta.day || date.day,
+      delta.hour || (date instanceof PyDateTime ? date.hour : 0),
+      delta.minute || (date instanceof PyDateTime ? date.minute : 0),
+      delta.second || (date instanceof PyDateTime ? date.second : 0),
+      delta.microseconds || (date instanceof PyDateTime ? date.microsecond : 0)
+    );
+    const newDateTime = new PyDateTime(
+      s.year,
+      s.month,
+      s.day,
+      s.hour,
+      s.minute,
+      s.second,
+      s.microsecond
+    );
+    let leapDays = 0;
+    if (delta.leapDays && newDateTime.month > 2 && isLeap(newDateTime.year)) {
+      leapDays = delta.leapDays;
+    }
+    const temp = newDateTime.add(
+      PyTimeDelta.create({
+        days: delta.days + leapDays,
+        hours: delta.hours,
+        minutes: delta.minutes,
+        seconds: delta.seconds,
+        microseconds: delta.microseconds
+      })
+    );
+    const hasTime = Boolean(
+      temp.hour || temp.minute || temp.second || temp.microsecond
+    );
+    const returnDate = !hasTime && date instanceof PyDate ? new PyDate(temp.year, temp.month, temp.day) : temp;
+    if (delta.weekday !== null) {
+      const wantedDow = delta.weekday + 1;
+      const _date = new Date(
+        returnDate.year,
+        returnDate.month - 1,
+        returnDate.day
+      );
+      const days = (7 - _date.getDay() + wantedDow) % 7;
+      return returnDate.add(new PyTimeDelta(days, 0, 0));
+    }
+    return returnDate;
+  }
+  static substract(date, delta) {
+    return _PyRelativeDelta.add(date, delta.negate());
+  }
+  constructor(params = {}, sign = 1) {
+    this.years = sign * params.years;
+    this.months = sign * params.months;
+    this.days = sign * params.days;
+    this.hours = sign * params.hours;
+    this.minutes = sign * params.minutes;
+    this.seconds = sign * params.seconds;
+    this.microseconds = sign * params.microseconds;
+    this.leapDays = params.leapDays;
+    this.year = params.year;
+    this.month = params.month;
+    this.day = params.day;
+    this.hour = params.hour;
+    this.minute = params.minute;
+    this.second = params.second;
+    this.microsecond = params.microsecond;
+    this.weekday = params.weekday;
+  }
+  years;
+  months;
+  days;
+  hours;
+  minutes;
+  seconds;
+  microseconds;
+  leapDays;
+  year;
+  month;
+  day;
+  hour;
+  minute;
+  second;
+  microsecond;
+  weekday;
+  negate() {
+    return new _PyRelativeDelta(this, -1);
+  }
+  isEqual() {
+    throw new NotSupportedError();
+  }
+};
+var TIME_DELTA_KEYS = "weeks days hours minutes seconds milliseconds microseconds".split(" ");
+function modf(x) {
+  const mod = x % 1;
+  return [mod < 0 ? mod + 1 : mod, Math.floor(x)];
+}
+var PyTimeDelta = class _PyTimeDelta {
+  constructor(days, seconds, microseconds) {
+    this.days = days;
+    this.seconds = seconds;
+    this.microseconds = microseconds;
+  }
+  static create(...args) {
+    const namedArgs = parseArgs(args, ["days", "seconds", "microseconds"]);
+    for (const key of TIME_DELTA_KEYS) {
+      namedArgs[key] = namedArgs[key] || 0;
+    }
+    let d = 0;
+    let s = 0;
+    let us = 0;
+    const days = namedArgs.days + namedArgs.weeks * 7;
+    let seconds = namedArgs.seconds + 60 * namedArgs.minutes + 3600 * namedArgs.hours;
+    let microseconds = namedArgs.microseconds + 1e3 * namedArgs.milliseconds;
+    const [dFrac, dInt] = modf(days);
+    d = dInt;
+    let daysecondsfrac = 0;
+    if (dFrac) {
+      const [dsFrac, dsInt] = modf(dFrac * 24 * 3600);
+      s = dsInt;
+      daysecondsfrac = dsFrac;
+    }
+    const [sFrac, sInt] = modf(seconds);
+    seconds = sInt;
+    const secondsfrac = sFrac + daysecondsfrac;
+    divmod(seconds, 24 * 3600, (days2, seconds2) => {
+      d += days2;
+      s += seconds2;
+    });
+    microseconds += secondsfrac * 1e6;
+    divmod(microseconds, 1e6, (seconds2, microseconds2) => {
+      divmod(seconds2, 24 * 3600, (days2, seconds3) => {
+        d += days2;
+        s += seconds3;
+        us += Math.round(microseconds2);
+      });
+    });
+    return new _PyTimeDelta(d, s, us);
+  }
+  add(other) {
+    return _PyTimeDelta.create({
+      days: this.days + other.days,
+      seconds: this.seconds + other.seconds,
+      microseconds: this.microseconds + other.microseconds
+    });
+  }
+  divide(n) {
+    const us = (this.days * 24 * 3600 + this.seconds) * 1e6 + this.microseconds;
+    return _PyTimeDelta.create({ microseconds: Math.floor(us / n) });
+  }
+  isEqual(other) {
+    if (!(other instanceof _PyTimeDelta)) {
+      return false;
+    }
+    return this.days === other.days && this.seconds === other.seconds && this.microseconds === other.microseconds;
+  }
+  isTrue() {
+    return this.days !== 0 || this.seconds !== 0 || this.microseconds !== 0;
+  }
+  multiply(n) {
+    return _PyTimeDelta.create({
+      days: n * this.days,
+      seconds: n * this.seconds,
+      microseconds: n * this.microseconds
+    });
+  }
+  negate() {
+    return _PyTimeDelta.create({
+      days: -this.days,
+      seconds: -this.seconds,
+      microseconds: -this.microseconds
+    });
+  }
+  substract(other) {
+    return _PyTimeDelta.create({
+      days: this.days - other.days,
+      seconds: this.seconds - other.seconds,
+      microseconds: this.microseconds - other.microseconds
+    });
+  }
+  total_seconds() {
+    return this.days * 86400 + this.seconds + this.microseconds / 1e6;
+  }
+};
+
+// src/utils/domain/py_builtin.ts
+var EvaluationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EvaluationError";
+  }
+};
+function execOnIterable(iterable, func) {
+  if (iterable === null) {
+    throw new EvaluationError("value not iterable");
+  }
+  if (typeof iterable === "object" && !Array.isArray(iterable) && !(iterable instanceof Set)) {
+    iterable = Object.keys(iterable);
+  }
+  if (typeof iterable?.[Symbol.iterator] !== "function") {
+    throw new EvaluationError("value not iterable");
+  }
+  return func(iterable);
+}
+var BUILTINS = {
+  /**
+   * @param {any} value
+   * @returns {boolean}
+   */
+  bool(value) {
+    switch (typeof value) {
+      case "number":
+        return value !== 0;
+      case "string":
+        return value !== "";
+      case "boolean":
+        return value;
+      case "object":
+        if (value === null || value === void 0) {
+          return false;
+        }
+        if ("isTrue" in value && typeof value.isTrue === "function") {
+          return value.isTrue();
+        }
+        if (value instanceof Array) {
+          return !!value.length;
+        }
+        if (value instanceof Set) {
+          return !!value.size;
+        }
+        return Object.keys(value).length !== 0;
+      default:
+        return true;
+    }
+  },
+  set(iterable) {
+    if (arguments.length > 2) {
+      throw new EvaluationError(
+        `set expected at most 1 argument, got (${arguments.length - 1})`
+      );
+    }
+    return execOnIterable(
+      iterable,
+      (iterable2) => new Set(iterable2)
+    );
+  },
+  time: {
+    strftime(format) {
+      return PyDateTime.now().strftime(format);
+    }
+  },
+  context_today() {
+    return PyDate.today();
+  },
+  get current_date() {
+    return this.today;
+  },
+  get today() {
+    return PyDate.today().strftime("%Y-%m-%d");
+  },
+  get now() {
+    return PyDateTime.now().strftime("%Y-%m-%d %H:%M:%S");
+  },
+  datetime: {
+    time: PyTime,
+    timedelta: PyTimeDelta,
+    datetime: PyDateTime,
+    date: PyDate
+  },
+  relativedelta: PyRelativeDelta,
+  true: true,
+  false: false
+};
+
+// src/utils/domain/py_utils.ts
+function toPyValue(value) {
+  switch (typeof value) {
+    case "string":
+      return { type: 1, value };
+    case "number":
+      return { type: 0, value };
+    case "boolean":
+      return { type: 2, value };
+    case "object":
+      if (Array.isArray(value)) {
+        return { type: 4, value: value.map(toPyValue) };
+      } else if (value === null) {
+        return {
+          type: 3
+          /* None */
+        };
+      } else if (value instanceof Date) {
+        return {
+          type: 1,
+          value: String(PyDateTime.convertDate(value))
+        };
+      } else if (value instanceof PyDate || value instanceof PyDateTime) {
+        return { type: 1, value };
+      } else {
+        const content = {};
+        for (const key in value) {
+          content[key] = toPyValue(value[key]);
+        }
+        return { type: 11, value: content };
+      }
+    default:
+      throw new Error("Invalid type");
+  }
+}
+function formatAST(ast, lbp = 0) {
+  switch (ast.type) {
+    case 3:
+      return "None";
+    case 1:
+      return JSON.stringify(ast.value);
+    case 0:
+      return String(ast.value);
+    case 2:
+      return ast.value ? "True" : "False";
+    case 4:
+      return `[${ast.value.map(formatAST).join(", ")}]`;
+    case 6:
+      if (ast.op === "not") {
+        return `not ${formatAST(ast.right, 50)}`;
+      }
+      return `${ast.op}${formatAST(ast.right, 130)}`;
+    case 7:
+      const abp = bp(ast.op);
+      const binaryStr = `${formatAST(ast.left, abp)} ${ast.op} ${formatAST(ast.right, abp)}`;
+      return abp < lbp ? `(${binaryStr})` : binaryStr;
+    case 11:
+      const pairs = [];
+      for (const k in ast.value) {
+        pairs.push(`"${k}": ${formatAST(ast.value[k])}`);
+      }
+      return `{${pairs.join(", ")}}`;
+    case 10:
+      return `(${ast.value.map(formatAST).join(", ")})`;
+    case 5:
+      return ast.value;
+    case 12:
+      return `${formatAST(ast.target)}[${formatAST(ast.key)}]`;
+    case 13:
+      const { ifTrue, condition, ifFalse } = ast;
+      return `${formatAST(ifTrue)} if ${formatAST(condition)} else ${formatAST(ifFalse)}`;
+    case 14:
+      const boolAbp = bp(ast.op);
+      const boolStr = `${formatAST(ast.left, boolAbp)} ${ast.op} ${formatAST(ast.right, boolAbp)}`;
+      return boolAbp < lbp ? `(${boolStr})` : boolStr;
+    case 15:
+      return `${formatAST(ast.obj, 150)}.${ast.key}`;
+    case 8:
+      const args = ast.args.map(formatAST);
+      const kwargs = [];
+      for (const kwarg in ast.kwargs) {
+        kwargs.push(`${kwarg} = ${formatAST(ast.kwargs[kwarg])}`);
+      }
+      const argStr = args.concat(kwargs).join(", ");
+      return `${formatAST(ast.fn)}(${argStr})`;
+    default:
+      throw new Error("invalid expression: " + JSON.stringify(ast));
+  }
+}
+var PY_DICT = /* @__PURE__ */ Object.create(null);
+function toPyDict(obj) {
+  return new Proxy(obj, {
+    getPrototypeOf() {
+      return PY_DICT;
+    }
+  });
+}
+
+// src/utils/domain/py_interpreter.ts
+var isTrue = BUILTINS.bool;
+function applyUnaryOp(ast, context) {
+  const value = evaluate(ast.right, context);
+  switch (ast.op) {
+    case "-":
+      if (value instanceof Object && "negate" in value) {
+        return value.negate();
+      }
+      return -value;
+    case "+":
+      return value;
+    case "not":
+      return !isTrue(value);
+    default:
+      throw new EvaluationError(`Unknown unary operator: ${ast.op}`);
+  }
+}
+function pytypeIndex(val) {
+  switch (typeof val) {
+    case "object":
+      return val === null ? 1 : Array.isArray(val) ? 5 : 3;
+    case "number":
+      return 2;
+    case "string":
+      return 4;
+    default:
+      throw new EvaluationError(`Unknown type: ${typeof val}`);
+  }
+}
+function isLess(left, right) {
+  if (typeof left === "number" && typeof right === "number") {
+    return left < right;
+  }
+  if (typeof left === "boolean") {
+    left = left ? 1 : 0;
+  }
+  if (typeof right === "boolean") {
+    right = right ? 1 : 0;
+  }
+  const leftIndex = pytypeIndex(left);
+  const rightIndex = pytypeIndex(right);
+  if (leftIndex === rightIndex) {
+    return left < right;
+  }
+  return leftIndex < rightIndex;
+}
+function isEqual(left, right) {
+  if (typeof left !== typeof right) {
+    if (typeof left === "boolean" && typeof right === "number") {
+      return right === (left ? 1 : 0);
+    }
+    if (typeof left === "number" && typeof right === "boolean") {
+      return left === (right ? 1 : 0);
+    }
+    return false;
+  }
+  if (left instanceof Object && "isEqual" in left) {
+    return left.isEqual(right);
+  }
+  return left === right;
+}
+function isIn(left, right) {
+  if (Array.isArray(right)) {
+    return right.includes(left);
+  }
+  if (typeof right === "string" && typeof left === "string") {
+    return right.includes(left);
+  }
+  if (typeof right === "object") {
+    return left in right;
+  }
+  return false;
+}
+function applyBinaryOp(ast, context) {
+  const left = evaluate(ast.left, context);
+  const right = evaluate(ast.right, context);
+  switch (ast.op) {
+    case "+": {
+      const relativeDeltaOnLeft = left instanceof PyRelativeDelta;
+      const relativeDeltaOnRight = right instanceof PyRelativeDelta;
+      if (relativeDeltaOnLeft || relativeDeltaOnRight) {
+        const date = relativeDeltaOnLeft ? right : left;
+        const delta = relativeDeltaOnLeft ? left : right;
+        return PyRelativeDelta.add(date, delta);
+      }
+      const timeDeltaOnLeft = left instanceof PyTimeDelta;
+      const timeDeltaOnRight = right instanceof PyTimeDelta;
+      if (timeDeltaOnLeft && timeDeltaOnRight) {
+        return left.add(right);
+      }
+      if (timeDeltaOnLeft) {
+        if (right instanceof PyDate || right instanceof PyDateTime) {
+          return right.add(left);
+        } else {
+          throw new NotSupportedError();
+        }
+      }
+      if (timeDeltaOnRight) {
+        if (left instanceof PyDate || left instanceof PyDateTime) {
+          return left.add(right);
+        } else {
+          throw new NotSupportedError();
+        }
+      }
+      if (left instanceof Array && right instanceof Array) {
+        return [...left, ...right];
+      }
+      return left + right;
+    }
+    case "-": {
+      const isRightDelta = right instanceof PyRelativeDelta;
+      if (isRightDelta) {
+        return PyRelativeDelta.substract(left, right);
+      }
+      const timeDeltaOnRight = right instanceof PyTimeDelta;
+      if (timeDeltaOnRight) {
+        if (left instanceof PyTimeDelta) {
+          return left.substract(right);
+        } else if (left instanceof PyDate || left instanceof PyDateTime) {
+          return left.substract(right);
+        } else {
+          throw new NotSupportedError();
+        }
+      }
+      if (left instanceof PyDate) {
+        return left.substract(right);
+      }
+      return left - right;
+    }
+    case "*": {
+      const timeDeltaOnLeft = left instanceof PyTimeDelta;
+      const timeDeltaOnRight = right instanceof PyTimeDelta;
+      if (timeDeltaOnLeft || timeDeltaOnRight) {
+        const number = timeDeltaOnLeft ? right : left;
+        const delta = timeDeltaOnLeft ? left : right;
+        return delta.multiply(number);
+      }
+      return left * right;
+    }
+    case "/":
+      return left / right;
+    case "%":
+      return left % right;
+    case "//":
+      if (left instanceof PyTimeDelta) {
+        return left.divide(right);
+      }
+      return Math.floor(left / right);
+    case "**":
+      return left ** right;
+    case "==":
+      return isEqual(left, right);
+    case "<>":
+    case "!=":
+      return !isEqual(left, right);
+    case "<":
+      return isLess(left, right);
+    case ">":
+      return isLess(right, left);
+    case ">=":
+      return isEqual(left, right) || isLess(right, left);
+    case "<=":
+      return isEqual(left, right) || isLess(left, right);
+    case "in":
+      return isIn(left, right);
+    case "not in":
+      return !isIn(left, right);
+    default:
+      throw new EvaluationError(`Unknown binary operator: ${ast.op}`);
+  }
+}
+var DICT = {
+  get(...args) {
+    const { key, defValue } = parseArgs(args, ["key", "defValue"]);
+    const self = this;
+    if (key in self) {
+      return self[key];
+    } else if (defValue !== void 0) {
+      return defValue;
+    }
+    return null;
+  }
+};
+var STRING = {
+  lower() {
+    return this.toLowerCase();
+  },
+  upper() {
+    return this.toUpperCase();
+  }
+};
+function applyFunc(key, func, set, ...args) {
+  if (args.length === 1) {
+    return new Set(set);
+  }
+  if (args.length > 2) {
+    throw new EvaluationError(
+      `${key}: py_js supports at most 1 argument, got (${args.length - 1})`
+    );
+  }
+  return execOnIterable(args[0], func);
+}
+var SET = {
+  intersection(...args) {
+    return applyFunc(
+      "intersection",
+      (iterable) => {
+        const intersection = /* @__PURE__ */ new Set();
+        for (const i of iterable) {
+          if (this.has(i)) {
+            intersection.add(i);
+          }
+        }
+        return intersection;
+      },
+      this,
+      ...args
+    );
+  },
+  difference(...args) {
+    return applyFunc(
+      "difference",
+      (iterable) => {
+        iterable = new Set(iterable);
+        const difference = /* @__PURE__ */ new Set();
+        for (const e of this) {
+          if (!iterable.has(e)) {
+            difference.add(e);
+          }
+        }
+        return difference;
+      },
+      this,
+      ...args
+    );
+  },
+  union(...args) {
+    return applyFunc(
+      "union",
+      (iterable) => {
+        return /* @__PURE__ */ new Set([...this, ...iterable]);
+      },
+      this,
+      ...args
+    );
+  }
+};
+function methods(_class) {
+  return Object.getOwnPropertyNames(_class.prototype).map(
+    (prop) => _class.prototype[prop]
+  );
+}
+var allowedFns = /* @__PURE__ */ new Set([
+  BUILTINS.time.strftime,
+  BUILTINS.set,
+  BUILTINS.bool,
+  BUILTINS.context_today,
+  BUILTINS.datetime.datetime.now,
+  BUILTINS.datetime.datetime.combine,
+  BUILTINS.datetime.date.today,
+  ...methods(BUILTINS.relativedelta),
+  ...Object.values(BUILTINS.datetime).flatMap((obj) => methods(obj)),
+  ...Object.values(SET),
+  ...Object.values(DICT),
+  ...Object.values(STRING)
+]);
+var unboundFn = /* @__PURE__ */ Symbol("unbound function");
+function evaluate(ast, context = {}) {
+  const dicts = /* @__PURE__ */ new Set();
+  let pyContext;
+  const evalContext = Object.create(context);
+  if (!evalContext?.context) {
+    Object.defineProperty(evalContext, "context", {
+      get() {
+        if (!pyContext) {
+          pyContext = toPyDict(context);
+        }
+        return pyContext;
+      }
+    });
+  }
+  function _innerEvaluate(ast2) {
+    switch (ast2?.type) {
+      case 0:
+      // Number
+      case 1:
+        return ast2.value;
+      case 5:
+        if (ast2.value in evalContext) {
+          if (typeof evalContext[ast2.value] === "object" && evalContext[ast2.value]?.id && ast2?.value !== "parent") {
+            return evalContext[ast2.value]?.id;
+          }
+          return evalContext[ast2.value] ?? false;
+        } else if (ast2.value in BUILTINS) {
+          return BUILTINS[ast2.value];
+        } else {
+          return false;
+        }
+      case 3:
+        return null;
+      case 2:
+        return ast2.value;
+      case 6:
+        return applyUnaryOp(ast2, evalContext);
+      case 7:
+        return applyBinaryOp(ast2, evalContext);
+      case 14:
+        const left = _evaluate(ast2.left);
+        if (ast2.op === "and") {
+          return isTrue(left) ? _evaluate(ast2.right) : left;
+        } else {
+          return isTrue(left) ? left : _evaluate(ast2.right);
+        }
+      case 4:
+      // List
+      case 10:
+        return ast2.value.map(_evaluate);
+      case 11:
+        const dict = {};
+        for (const key2 in ast2.value) {
+          dict[key2] = _evaluate(ast2.value[key2]);
+        }
+        dicts.add(dict);
+        return dict;
+      case 8:
+        const fnValue = _evaluate(ast2.fn);
+        const args = ast2.args.map(_evaluate);
+        const kwargs = {};
+        for (const kwarg in ast2.kwargs) {
+          kwargs[kwarg] = _evaluate(ast2?.kwargs[kwarg]);
+        }
+        if (fnValue === PyDate || fnValue === PyDateTime || fnValue === PyTime || fnValue === PyRelativeDelta || fnValue === PyTimeDelta) {
+          return fnValue.create(...args, kwargs);
+        }
+        return fnValue(...args, kwargs);
+      case 12:
+        const dictVal = _evaluate(ast2.target);
+        const key = _evaluate(ast2.key);
+        return dictVal[key];
+      case 13:
+        if (isTrue(_evaluate(ast2.condition))) {
+          return _evaluate(ast2.ifTrue);
+        } else {
+          return _evaluate(ast2.ifFalse);
+        }
+      case 15:
+        let leftVal = _evaluate(ast2.obj);
+        let result;
+        if (dicts.has(leftVal) || Object.isPrototypeOf.call(PY_DICT, leftVal)) {
+          result = DICT[ast2.key];
+        } else if (typeof leftVal === "string") {
+          result = STRING[ast2.key];
+        } else if (leftVal instanceof Set) {
+          result = SET[ast2.key];
+        } else if (ast2.key === "get" && typeof leftVal === "object") {
+          result = DICT[ast2.key];
+          leftVal = toPyDict(leftVal);
+        } else if (typeof leftVal === "number") {
+          result = leftVal;
+        } else if (Array.isArray(leftVal[ast2.key])) {
+          result = leftVal[ast2.key]?.map(
+            (value) => value?.id ?? value
+          );
+        } else {
+          result = leftVal[ast2.key]?.id ?? leftVal[ast2.key] ?? false;
+        }
+        if (typeof result === "function") {
+          const bound = result.bind(leftVal);
+          bound[unboundFn] = result;
+          return bound;
+        }
+        return result;
+      default:
+        throw new EvaluationError(`AST of type ${ast2.type} cannot be evaluated`);
+    }
+  }
+  function _evaluate(ast2) {
+    const val = _innerEvaluate(ast2);
+    if (typeof val === "function" && !allowedFns.has(val) && !allowedFns.has(val[unboundFn])) {
+      throw new Error("Invalid Function Call");
+    }
+    return val;
+  }
+  return _evaluate(ast);
+}
+
+// src/utils/domain/py.ts
+function parseExpr(expr) {
+  const tokens = tokenize(expr);
+  return parse(tokens);
+}
+function evaluateExpr(expr, context = {}) {
+  let ast;
+  try {
+    ast = parseExpr(expr);
+  } catch (error) {
+    throw new EvalError(
+      `Can not parse python expression: (${expr})
+Error: ${error.message}`
+    );
+  }
+  try {
+    return evaluate(ast, context);
+  } catch (error) {
+    throw new EvalError(
+      `Can not evaluate python expression: (${expr})
+Error: ${error.message}`
+    );
+  }
+}
+function evaluateBooleanExpr(expr, context = {}) {
+  if (!expr || expr === "False" || expr === "0") {
+    return false;
+  }
+  if (expr === "True" || expr === "1") {
+    return true;
+  }
+  return evaluateExpr(`bool(${expr})`, context);
+}
+
+// src/utils/domain/objects.ts
+function shallowEqual(obj1, obj2, comparisonFn = (a, b) => a === b) {
+  if (!obj1 || !obj2 || typeof obj1 !== "object" || typeof obj2 !== "object") {
+    return obj1 === obj2;
+  }
+  const obj1Keys = Object.keys(obj1);
+  return obj1Keys.length === Object.keys(obj2).length && obj1Keys.every((key) => comparisonFn(obj1[key], obj2[key]));
+}
+
+// src/utils/domain/arrays.ts
+var shallowEqual2 = shallowEqual;
+
+// src/utils/domain/strings.ts
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/utils/domain/domain.ts
+var InvalidDomainError = class extends Error {
+};
+var Domain = class _Domain {
+  ast = { type: -1, value: null };
+  static TRUE;
+  static FALSE;
+  static combine(domains, operator) {
+    if (domains.length === 0) {
+      return new _Domain([]);
+    }
+    const domain1 = domains[0] instanceof _Domain ? domains[0] : new _Domain(domains[0]);
+    if (domains.length === 1) {
+      return domain1;
+    }
+    const domain2 = _Domain.combine(domains.slice(1), operator);
+    const result = new _Domain([]);
+    const astValues1 = domain1.ast.value;
+    const astValues2 = domain2.ast.value;
+    const op = operator === "AND" ? "&" : "|";
+    const combinedAST = {
+      type: 4,
+      value: astValues1.concat(astValues2)
+    };
+    result.ast = normalizeDomainAST(combinedAST, op);
+    return result;
+  }
+  static and(domains) {
+    return _Domain.combine(domains, "AND");
+  }
+  static or(domains) {
+    return _Domain.combine(domains, "OR");
+  }
+  static not(domain) {
+    const result = new _Domain(domain);
+    result.ast.value.unshift({ type: 1, value: "!" });
+    return result;
+  }
+  static removeDomainLeaves(domain, keysToRemove) {
+    function processLeaf(elements, idx, operatorCtx, newDomain2) {
+      const leaf = elements[idx];
+      if (leaf.type === 10) {
+        if (keysToRemove.includes(leaf.value[0].value)) {
+          if (operatorCtx === "&") {
+            newDomain2.ast.value.push(..._Domain.TRUE.ast.value);
+          } else if (operatorCtx === "|") {
+            newDomain2.ast.value.push(..._Domain.FALSE.ast.value);
+          }
+        } else {
+          newDomain2.ast.value.push(leaf);
+        }
+        return 1;
+      } else if (leaf.type === 1) {
+        if (leaf.value === "|" && elements[idx + 1].type === 10 && elements[idx + 2].type === 10 && keysToRemove.includes(elements[idx + 1].value[0].value) && keysToRemove.includes(elements[idx + 2].value[0].value)) {
+          newDomain2.ast.value.push(..._Domain.TRUE.ast.value);
+          return 3;
+        }
+        newDomain2.ast.value.push(leaf);
+        if (leaf.value === "!") {
+          return 1 + processLeaf(elements, idx + 1, "&", newDomain2);
+        }
+        const firstLeafSkip = processLeaf(
+          elements,
+          idx + 1,
+          leaf.value,
+          newDomain2
+        );
+        const secondLeafSkip = processLeaf(
+          elements,
+          idx + 1 + firstLeafSkip,
+          leaf.value,
+          newDomain2
+        );
+        return 1 + firstLeafSkip + secondLeafSkip;
+      }
+      return 0;
+    }
+    const d = new _Domain(domain);
+    if (d.ast.value.length === 0) {
+      return d;
+    }
+    const newDomain = new _Domain([]);
+    processLeaf(d.ast.value, 0, "&", newDomain);
+    return newDomain;
+  }
+  constructor(descr = []) {
+    if (descr instanceof _Domain) {
+      return new _Domain(descr.toString());
+    } else {
+      let rawAST;
+      try {
+        rawAST = typeof descr === "string" ? parseExpr(descr) : toAST(descr);
+      } catch (error) {
+        throw new InvalidDomainError(
+          `Invalid domain representation: ${descr}`,
+          {
+            cause: error
+          }
+        );
+      }
+      this.ast = normalizeDomainAST(rawAST);
+    }
+  }
+  contains(record) {
+    const expr = evaluate(this.ast, record);
+    return matchDomain(record, expr);
+  }
+  toString() {
+    return formatAST(this.ast);
+  }
+  toList(context) {
+    return evaluate(this.ast, context);
+  }
+  toJson() {
+    try {
+      const evaluatedAsList = this.toList({});
+      const evaluatedDomain = new _Domain(evaluatedAsList);
+      if (evaluatedDomain.toString() === this.toString()) {
+        return evaluatedAsList;
+      }
+      return this.toString();
+    } catch {
+      return this.toString();
+    }
+  }
+};
+var TRUE_LEAF = [1, "=", 1];
+var FALSE_LEAF = [0, "=", 1];
+var TRUE_DOMAIN = new Domain([TRUE_LEAF]);
+var FALSE_DOMAIN = new Domain([FALSE_LEAF]);
+Domain.TRUE = TRUE_DOMAIN;
+Domain.FALSE = FALSE_DOMAIN;
+function toAST(domain) {
+  const elems = domain.map((elem) => {
+    switch (elem) {
+      case "!":
+      case "&":
+      case "|":
+        return { type: 1, value: elem };
+      default:
+        return {
+          type: 10,
+          value: elem.map(toPyValue)
+        };
+    }
+  });
+  return { type: 4, value: elems };
+}
+function normalizeDomainAST(domain, op = "&") {
+  if (domain.type !== 4) {
+    if (domain.type === 10) {
+      const value = domain.value;
+      if (value.findIndex((e) => e.type === 10) === -1 || !value.every((e) => e.type === 10 || e.type === 1)) {
+        throw new InvalidDomainError("Invalid domain AST");
+      }
+    } else {
+      throw new InvalidDomainError("Invalid domain AST");
+    }
+  }
+  if (domain.value.length === 0) {
+    return domain;
+  }
+  let expected = 1;
+  for (const child of domain.value) {
+    switch (child.type) {
+      case 1:
+        if (child.value === "&" || child.value === "|") {
+          expected++;
+        } else if (child.value !== "!") {
+          throw new InvalidDomainError("Invalid domain AST");
+        }
+        break;
+      case 4:
+      /* list */
+      case 10:
+        if (child.value.length === 3) {
+          expected--;
+          break;
+        }
+        throw new InvalidDomainError("Invalid domain AST");
+      default:
+        throw new InvalidDomainError("Invalid domain AST");
+    }
+  }
+  const values = domain.value.slice();
+  while (expected < 0) {
+    expected++;
+    values.unshift({ type: 1, value: op });
+  }
+  if (expected > 0) {
+    throw new InvalidDomainError(
+      `invalid domain ${formatAST(domain)} (missing ${expected} segment(s))`
+    );
+  }
+  return { type: 4, value: values };
+}
+function matchCondition(record, condition) {
+  if (typeof condition === "boolean") {
+    return condition;
+  }
+  const [field, operator, value] = condition;
+  if (typeof field === "string") {
+    const names = field.split(".");
+    if (names.length >= 2) {
+      return matchCondition(record[names[0]], [
+        names.slice(1).join("."),
+        operator,
+        value
+      ]);
+    }
+  }
+  let likeRegexp, ilikeRegexp;
+  if (["like", "not like", "ilike", "not ilike"].includes(operator)) {
+    likeRegexp = new RegExp(
+      `(.*)${escapeRegExp(value).replaceAll("%", "(.*)")}(.*)`,
+      "g"
+    );
+    ilikeRegexp = new RegExp(
+      `(.*)${escapeRegExp(value).replaceAll("%", "(.*)")}(.*)`,
+      "gi"
+    );
+  }
+  const fieldValue = typeof field === "number" ? field : record[field];
+  switch (operator) {
+    case "=?":
+      if ([false, null].includes(value)) {
+        return true;
+      }
+    // eslint-disable-next-line no-fallthrough
+    case "=":
+    case "==":
+      if (Array.isArray(fieldValue) && Array.isArray(value)) {
+        return shallowEqual2(fieldValue, value);
+      }
+      return fieldValue === value;
+    case "!=":
+    case "<>":
+      return !matchCondition(record, [field, "==", value]);
+    case "<":
+      return fieldValue < value;
+    case "<=":
+      return fieldValue <= value;
+    case ">":
+      return fieldValue > value;
+    case ">=":
+      return fieldValue >= value;
+    case "in": {
+      const val = Array.isArray(value) ? value : [value];
+      const fieldVal = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
+      return fieldVal.some((fv) => val.includes(fv));
+    }
+    case "not in": {
+      const val = Array.isArray(value) ? value : [value];
+      const fieldVal = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
+      return !fieldVal.some((fv) => val.includes(fv));
+    }
+    case "like":
+      if (fieldValue === false) {
+        return false;
+      }
+      return Boolean(fieldValue.match(likeRegexp));
+    case "not like":
+      if (fieldValue === false) {
+        return false;
+      }
+      return Boolean(!fieldValue.match(likeRegexp));
+    case "=like":
+      if (fieldValue === false) {
+        return false;
+      }
+      return new RegExp(escapeRegExp(value).replace(/%/g, ".*")).test(
+        fieldValue
+      );
+    case "ilike":
+      if (fieldValue === false) {
+        return false;
+      }
+      return Boolean(fieldValue.match(ilikeRegexp));
+    case "not ilike":
+      if (fieldValue === false) {
+        return false;
+      }
+      return Boolean(!fieldValue.match(ilikeRegexp));
+    case "=ilike":
+      if (fieldValue === false) {
+        return false;
+      }
+      return new RegExp(escapeRegExp(value).replace(/%/g, ".*"), "i").test(
+        fieldValue
+      );
+  }
+  throw new InvalidDomainError("could not match domain");
+}
+function makeOperators(record) {
+  const match = matchCondition.bind(null, record);
+  return {
+    "!": (x) => !match(x),
+    "&": (a, b) => match(a) && match(b),
+    "|": (a, b) => match(a) || match(b)
+  };
+}
+function matchDomain(record, domain) {
+  if (domain.length === 0) {
+    return true;
+  }
+  const operators = makeOperators(record);
+  const reversedDomain = Array.from(domain).reverse();
+  const condStack = [];
+  for (const item of reversedDomain) {
+    const operator = typeof item === "string" && operators[item];
+    if (operator) {
+      const operands = condStack.splice(-operator.length);
+      condStack.push(operator(...operands));
+    } else {
+      condStack.push(item);
+    }
+  }
+  return matchCondition(record, condStack.pop());
+}
+var checkDomain = (context, domain) => {
+  try {
+    if (domain === void 0 || domain === "0" || domain === "False" || domain === false) {
+      return false;
+    } else if (domain === "1" || domain === "True" || domain === true) {
+      return true;
+    }
+    try {
+      if (context && domain) {
+        const d = new Domain(domain);
+        return d.contains(context);
+      }
+    } catch (error) {
+      if (context && domain) {
+        const domainEval = evaluateBooleanExpr(domain, context);
+        return domainEval;
+      }
+      return false;
+    }
+    return false;
+  } catch (e) {
+    return false;
+  }
+};
+var matchDomains = (context, domains) => {
+  if (Array.isArray(domains)) {
+    if (domains?.length > 0) {
+      return domains && domains.some((domain) => checkDomain(context, domain));
+    }
+  } else return checkDomain(context, domains);
+  return false;
+};
+
+// src/utils/function.ts
+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,/;
+    if (dataUriPattern.test(str)) {
+      return true;
+    }
+    const base64Pattern = (
+      // eslint-disable-next-line no-useless-escape
+      /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{2}==)?$/
+    );
+    return base64Pattern.test(str);
+  } catch (e) {
+    return false;
+  }
+};
+
+// src/services/action-service/index.ts
+var ActionService = {
+  async loadAction({
+    idAction,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      action_id: idAction,
+      with_context: {
+        ...context
+      }
+    };
+    return env2.requests.post(`${"/load_action" /* LOAD_ACTION */}`, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async callButton({
+    model,
+    ids = [],
+    context,
+    method
+  }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        model,
+        method,
+        ids,
+        with_context: context
+      };
+      return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (error) {
+      console.error("Error when calling button action:", error);
+      throw error;
+    }
+  },
+  async removeRows({
+    model,
+    ids,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "unlink",
+      ids,
+      with_context: context
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async duplicateRecord({
+    model,
+    id,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "copy",
+      ids: id,
+      with_context: context
+    };
+    return env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  },
+  async print({ id, report, db }) {
+    const env2 = getEnv();
+    const jsonData = {
+      report,
+      id,
+      type: "pdf",
+      file_response: true,
+      db
+    };
+    const queryString = toQueryString(jsonData);
+    const urlWithParams = `${"/report" /* REPORT_PATH */}?${queryString}`;
+    return env2.requests.get(urlWithParams, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      responseType: "arraybuffer"
+    });
+  },
+  async runAction({
+    idAction,
+    context
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      action_id: idAction,
+      with_context: {
+        ...context
+      }
+    };
+    return env2.requests.post(`${"/run_action" /* RUN_ACTION_PATH */}`, jsonData, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var action_service_default = ActionService;
+
+// 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, {
+      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 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"
+      }
+    });
+  },
+  async loginSocial({
+    state,
+    access_token
+  }) {
+    const env2 = getEnv();
+    return env2?.requests?.post(
+      "/token/generate" /* GENTOKEN_SOCIAL */,
+      { state, access_token },
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+  },
+  async getProviders(db) {
+    const env2 = getEnv();
+    return env2?.requests?.get("/oauth/providers", { params: { db } });
+  }
+};
+var auth_service_default = AuthService;
+
+// src/constants/widget/widget-avatar-constant.ts
+var WIDGETAVATAR = /* @__PURE__ */ ((WIDGETAVATAR2) => {
+  WIDGETAVATAR2["many2one_avatar_user"] = "many2one_avatar_user";
+  WIDGETAVATAR2["many2many_avatar_user"] = "many2many_avatar_user";
+  return WIDGETAVATAR2;
+})(WIDGETAVATAR || {});
+
+// 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();
+    const jsonData = {
+      ids: [id],
+      model: "res.company" /* COMPANY */,
+      method: "web_read" /* WEB_READ */,
+      kwargs: {
+        specification: {
+          primary_color: {},
+          secondary_color: {},
+          logo: {},
+          display_name: {},
+          secondary_logo: {}
+        }
+      }
+    };
+    return await env2?.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();
+    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 env2.requests.post("/call" /* CALL_PATH */, jsonData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  },
+  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, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      }
+    });
+  },
+  async getFileExcel({ model, context }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "get_import_templates" /* GET_IMPORT */,
+      args: [],
+      with_context: context
+    };
+    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 = {
+      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 = {
+      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;
+
+// src/services/form-service/index.ts
+var FormService = {
+  async getComment({ data }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        thread_id: data.thread_id,
+        thread_model: data.thread_model,
+        limit: 100,
+        with_context: {
+          lang: data.lang
+        }
+      };
+      return env2.requests.post("/chatter/thread/messages" /* GET_MESSAGE */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (error) {
+      console.error("Error when sending message:", error);
+      throw error;
+    }
+  },
+  async sentComment({ data }) {
+    try {
+      const env2 = getEnv();
+      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 env2.requests.post("/chatter/message/post" /* SENT_MESSAGE */, jsonData, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (error) {
+      console.error("Error when sent message:", error);
+      throw error;
+    }
+  },
+  async deleteComment({ data }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        attachment_ids: [],
+        attachment_tokens: [],
+        body: "",
+        message_id: data.message_id
+      };
+      return env2.requests.post("/chatter/message/update_content" /* DELETE_MESSAGE */, 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"
+          }
+        }
+      );
+    } 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, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    } catch (error) {
+      console.error("Error when sent message:", error);
+      throw error;
+    }
+  },
+  async getFormView({ data }) {
+    try {
+      const env2 = getEnv();
+      const jsonData = {
+        model: data.model,
+        method: "get_formview_action",
+        ids: data.id ? [data.id] : [],
+        with_context: data.context
+      };
+      return env2.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 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 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 = {}
+  }) {
+    const env2 = getEnv();
+    const jsonData = {
+      model,
+      method: "web_save" /* WEB_SAVE */,
+      with_context: context,
+      ids,
+      kwargs: {
+        vals: data,
+        specification
+      }
+    };
+    return env2?.requests?.post("/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, index) => {
+              const relation = viewData?.models?.[model]?.[key]?.relation;
+              if (relation !== void 0) {
+                if (viewData?.models?.[relation]) {
+                  if (item?.length >= 3) {
+                    if (item[0] === 2 /* DELETE */) {
+                      delete data[key][index];
+                      return;
+                    }
+                    return ModelService.toDataJS(
+                      { ...item[OBJECT_POSITION], id: `virtual_${index}` },
+                      viewData,
+                      relation
+                    );
+                  } else {
+                    return ModelService.toDataJS(item, viewData, relation);
+                  }
+                } else {
+                  if (item?.length >= 3) {
+                    if (!item[OBJECT_POSITION] || item[0] === 2 /* DELETE */) {
+                      delete data[key][index];
+                      return;
+                    }
+                    return item[OBJECT_POSITION];
+                  } else {
+                    return item;
+                  }
+                }
+              }
+            });
+          }
+        }
+      }
+    }
+    return { ...data };
+  }
+};
+var model_service_default = ModelService;
+
+// src/services/user-service/index.ts
+var UserService = {
+  async getProfile() {
+    const env2 = getEnv();
+    return env2.requests.get("/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, {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var user_service_default = UserService;
+
+// src/services/view-service/index.ts
+var ViewService = {
+  async getView({
+    model,
+    views,
+    context = {},
+    options = {},
+    aid
+  }) {
+    const env2 = getEnv();
+    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"
+      }
+    });
+  },
+  async getMenu(context) {
+    const env2 = getEnv();
+    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: {}
+              // res_model: {},
+            }
+          },
+          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: {}
+                  // res_model: {},
+                }
+              },
+              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: {}
+                      // res_model: {},
+                    }
+                  },
+                  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: {}
+                          // res_model: {},
+                        }
+                      },
+                      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: ""
+              }
+            },
+            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"
+      }
+    });
+  },
+  async getSelectionItem({ data }) {
+    const env2 = getEnv();
+    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"
+      }
+    });
+  },
+  async loadMessages() {
+    const env2 = getEnv();
+    return env2.requests.post(
+      "/load_message_failures" /* LOAD_MESSAGE */,
+      {},
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+  },
+  async getVersion() {
+    const env2 = getEnv();
+    return env2?.requests.get("", {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+};
+var view_service_default = ViewService;
+
+// src/hooks/auth/use-forgot-password.ts
+var useForgotPassword = () => {
+  return reactQuery.useMutation({
+    mutationFn: (email) => {
+      return auth_service_default.forgotPassword(email);
+    }
+  });
+};
+var use_forgot_password_default = useForgotPassword;
+var useGetProvider = () => {
+  return reactQuery.useMutation({
+    mutationFn: (data) => {
+      return auth_service_default.getProviders(data?.db);
+    }
+  });
+};
+var use_get_provider_default = useGetProvider;
+var useIsValidToken = () => {
+  return reactQuery.useMutation({
+    mutationFn: (token) => {
+      return auth_service_default.isValidToken(token);
+    }
+  });
+};
+var use_isvalid_token_default = useIsValidToken;
+var useLoginCredential = () => {
+  return reactQuery.useMutation({
+    mutationFn: (data) => {
+      return auth_service_default.login(data);
+    }
+  });
+};
+var use_login_credential_default = useLoginCredential;
+var useLoginSocial = () => {
+  return reactQuery.useMutation({
+    mutationFn: (data) => {
+      return auth_service_default.loginSocial(data);
+    }
+  });
+};
+var use_login_socical_default = useLoginSocial;
+var useResetPassword = () => {
+  return reactQuery.useMutation({
+    mutationFn: (request) => {
+      return auth_service_default.resetPassword(request.data, request.token);
+    }
+  });
+};
+var use_reset_password_default = useResetPassword;
+var useUpdatePassword = () => {
+  return reactQuery.useMutation({
+    mutationFn: (request) => {
+      return auth_service_default.updatePassword(request.data, request.token);
+    }
+  });
+};
+var use_update_password_default = useUpdatePassword;
+var useField = (props) => {
+  const [invisible, setInvisible] = React__default.default.useState(true);
+  const [required, setRequired] = React__default.default.useState(false);
+  const [readonly, setReadOnly] = React__default.default.useState(false);
+  const {
+    invisible: inv,
+    required: req,
+    readonly: rea,
+    onchangeData,
+    rootField,
+    index,
+    name
+  } = props;
+  const nameField = rootField ? `${rootField?.name}.${index}.${name}` : null;
+  React.useEffect(() => {
+    if (onchangeData && Object.keys(onchangeData).length > 0) {
+      setRequired(
+        typeof req === "object" ? matchDomains(onchangeData, req) : checkDomain(onchangeData, req)
+      );
+      setInvisible(matchDomains(onchangeData, inv));
+      setReadOnly(
+        typeof req === "object" ? matchDomains(onchangeData, rea) : checkDomain(onchangeData, rea)
+      );
+    }
+  }, [onchangeData]);
+  return {
+    invisible,
+    required,
+    readonly,
+    nameField
+  };
+};
+var use_field_default = useField;
+var useGetCompanyInfo = () => {
+  return reactQuery.useMutation({
+    mutationFn: (id) => company_service_default.getInfoCompany(id)
+  });
+};
+var use_get_company_info_default = useGetCompanyInfo;
+var useGetCurrentCompany = () => {
+  return reactQuery.useMutation({
+    mutationFn: () => company_service_default.getCurrentCompany()
+  });
+};
+var use_get_current_company_default = useGetCurrentCompany;
+var useChangeStatus = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => {
+      return form_service_default.changeStatus({
+        data
+      });
+    }
+  });
+};
+var use_change_status_default = useChangeStatus;
+var useDeleteComment = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => form_service_default.deleteComment({
+      data
+    })
+  });
+};
+var use_delete_comment_default = useDeleteComment;
+var useGetComment = ({ data, queryKey }) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => form_service_default.getComment({ data }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled: !!data.thread_id && !isNaN(data.thread_id),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_comment_default = useGetComment;
+var useGetFormView = ({
+  data,
+  queryKey,
+  enabled
+}) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => form_service_default.getFormView({ data }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled,
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_form_view_default = useGetFormView;
+var useGetImage = ({
+  data,
+  queryKey,
+  src
+}) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => form_service_default.getImage({ data }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    enabled: !src && !isBase64File(src),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_image_default = useGetImage;
+var useSendComment = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => form_service_default.sentComment({
+      data
+    })
+  });
+};
+var use_send_comment_default = useSendComment;
+var useUploadImage = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => form_service_default.uploadImage({
+      data
+    })
+  });
+};
+var use_upload_image_default = useUploadImage;
+var useExportExcel = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      model,
+      domain,
+      ids,
+      fields,
+      type,
+      importCompat,
+      context,
+      groupby
+    }) => excel_service_default.exportExcel({
+      model,
+      domain,
+      ids,
+      fields,
+      type,
+      importCompat,
+      context,
+      groupby
+    })
+  });
+};
+var use_export_excel_default = useExportExcel;
+var useGetFieldExport = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      ids,
+      model,
+      isShow,
+      parentField,
+      fieldType,
+      parentName,
+      prefix,
+      name,
+      context,
+      importCompat
+    }) => excel_service_default.getFieldExport({
+      ids,
+      model,
+      isShow,
+      parentField,
+      fieldType,
+      parentName,
+      prefix,
+      name,
+      context,
+      importCompat
+    })
+  });
+};
+var use_get_field_export_default = useGetFieldExport;
+var useGetFileExcel = ({
+  model,
+  context
+}) => {
+  return reactQuery.useQuery({
+    queryKey: [],
+    queryFn: () => excel_service_default.getFileExcel({
+      model,
+      context
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_file_excel_default = useGetFileExcel;
+var useParsePreview = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      id,
+      selectedSheet,
+      isHeader,
+      context
+    }) => excel_service_default.parsePreview({
+      id,
+      selectedSheet,
+      isHeader,
+      context
+    })
+  });
+};
+var use_parse_preview_default = useParsePreview;
+var useUploadFile = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ formData }) => excel_service_default.uploadFile({
+      formData
+    })
+  });
+};
+var use_upload_file_default = useUploadFile;
+var useUploadIdFile = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ formData }) => excel_service_default.uploadIdFile({
+      formData
+    })
+  });
+};
+var use_upload_id_file_default = useUploadIdFile;
+var useExecuteImport = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      fields,
+      columns,
+      idFile,
+      options,
+      dryrun,
+      context
+    }) => excel_service_default.executeImport({
+      fields,
+      columns,
+      idFile,
+      options,
+      dryrun,
+      context
+    })
+  });
+};
+var uss_execute_import_default = useExecuteImport;
+var useDelete = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ ids, model }) => model_service_default.delete({ ids, model })
+  });
+};
+var use_delete_default = useDelete;
+var useGetAll = ({ data, queryKey, viewResponse }) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => model_service_default.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;
+var useGetDetail = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      model,
+      ids,
+      specification,
+      context
+    }) => model_service_default.getDetail({
+      model,
+      ids,
+      specification,
+      context
+    })
+  });
+};
+var use_get_detail_default = useGetDetail;
+var useGetFieldOnChange = ({ model }) => {
+  return reactQuery.useQuery({
+    queryKey: [`field-onchange-${model}`, model],
+    queryFn: () => model_service_default.getListFieldsOnchange({
+      model
+    }).then((res) => {
+      if (res) {
+        return res;
+      }
+    }),
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+};
+var use_get_field_onchange_default = useGetFieldOnChange;
+
+// src/models/base-model/index.ts
+var BaseModel = class {
+  name;
+  view;
+  actContext;
+  fields;
+  constructor(init) {
+    this.name = init.name;
+    this.view = init.view;
+    this.actContext = init.actContext;
+    this.fields = init.fields;
+  }
+  getSpecificationByFields({
+    fields = [],
+    specification = {},
+    modelsData,
+    model,
+    modelRoot
+  }) {
+    if (Array.isArray(fields)) {
+      let spec = { ...specification };
+      fields.forEach((field) => {
+        if (!field?.type_co || field?.name && field?.type_co === "field" /* FIELD */) {
+          if (modelsData?.[model]?.[field?.name]) {
+            if (modelsData?.[model]?.[field?.name]?.type === "one2many" /* ONE2MANY */ || modelsData?.[model]?.[field?.name]?.type === "many2many" /* MANY2MANY */) {
+              const relation = modelsData?.[model]?.[field?.name]?.relation;
+              const modelRelation = modelsData?.[relation];
+              if (modelRelation) {
+                spec[field?.name] = {
+                  fields: {}
+                };
+                if (modelRoot && modelRoot === relation) {
+                  spec[field?.name].fields = { id: {} };
+                } else {
+                  spec[field?.name].fields = this.getSpecificationByFields({
+                    fields: Object.values(modelRelation),
+                    specification: {},
+                    modelsData,
+                    model: relation,
+                    modelRoot: model
+                  });
+                }
+              } else {
+                spec[field?.name] = {
+                  fields: {
+                    id: {},
+                    display_name: {}
+                  }
+                };
+              }
+            } else if (modelsData?.[model]?.[field?.name]?.type === "many2one" /* MANY2ONE */) {
+              spec[field?.name] = {
+                fields: {
+                  id: {},
+                  display_name: {},
+                  ...WIDGETAVATAR[field?.widget] ? { image_256: {} } : {},
+                  ...field?.name === "currency_id" && fields?.find((item) => item?.widget === "monetary") ? { symbol: {} } : {},
+                  ...field?.widget === "many2many_binary" ? { mimetype: {} } : {}
+                }
+              };
+            } else {
+              spec[field?.name] = {};
+            }
+          }
+        } else if (field?.type_co === "group" /* GROUP */ || field?.type_co === "div" /* DIV */ || field?.type_co === "span" /* SPAN */) {
+          const specGroup = this.getSpecificationByFields({
+            fields: field?.fields,
+            specification: spec,
+            modelsData,
+            model
+          });
+          spec = { ...spec, ...specGroup };
+        } else if (field?.type_co === "tree" /* TREE */ || field?.type_co === "list" /* LIST */) {
+          const relation = modelsData?.[model]?.[field?.name]?.relation;
+          const specTreee = this.getSpecificationByFields({
+            fields: field?.fields,
+            specification: {},
+            modelsData,
+            model: relation,
+            modelRoot: model
+          });
+          spec = {
+            ...spec,
+            [field?.name]: {
+              fields: { ...spec?.[field?.name]?.fields, ...specTreee }
+            }
+          };
+        }
+      });
+      return spec;
+    } else {
+      console.warn("fields is not array");
+    }
+  }
+  getTreeProps() {
+    const props = this.view?.views?.list || {};
+    return props;
+  }
+  getTreeFields() {
+    const fields = this.view?.views?.list?.fields || [];
+    return fields;
+  }
+  getSpecification() {
+    const specInit = {};
+    const modelData = this.view?.models || {};
+    const specification = this.getSpecificationByFields({
+      fields: this.fields,
+      specification: specInit,
+      modelsData: modelData,
+      model: this.name,
+      modelRoot: ""
+    });
+    return specification;
+  }
+};
+var base_model_default = BaseModel;
+
+// src/hooks/model/use-model.ts
+var useModel = () => {
+  const initModel = (modelData) => {
+    switch (modelData?.name) {
+      default:
+        return new base_model_default(modelData);
+    }
+  };
+  return {
+    initModel
+  };
+};
+var use_model_default = useModel;
+
+// src/hooks/model/use-odoo-data-transform.ts
+var useOdooDataTransform = () => {
+  return {
+    toDataJS: model_service_default.toDataJS,
+    parseORM: model_service_default.parseORMOdoo
+  };
+};
+var use_odoo_data_transform_default = useOdooDataTransform;
+var useOnChangeForm = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      ids,
+      model,
+      specification,
+      context,
+      object,
+      fieldChange
+    }) => model_service_default.onChange({
+      ids,
+      model,
+      specification,
+      context,
+      object,
+      fieldChange
+    })
+  });
+};
+var use_onchange_form_default = useOnChangeForm;
+var useSave = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      ids,
+      model,
+      data,
+      specification,
+      context
+    }) => model_service_default.save({ ids, model, data, specification, context })
+  });
+};
+var use_save_default = useSave;
+var useGetProfile = () => {
+  return reactQuery.useMutation({
+    mutationFn: () => user_service_default.getProfile()
+  });
+};
+var use_get_profile_default = useGetProfile;
+var useGetUser = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ id, context }) => user_service_default.getUser({
+      id,
+      context
+    })
+  });
+};
+var use_get_user_default = useGetUser;
+var useSwitchLocale = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ data }) => {
+      return user_service_default.switchUserLocale({
+        id: data.id,
+        values: data.values
+      });
+    }
+  });
+};
+var use_switch_locale_default = useSwitchLocale;
+var useButton = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      model,
+      ids,
+      context,
+      method
+    }) => action_service_default.callButton({
+      model,
+      ids,
+      context,
+      method
+    }),
+    onSuccess: (response) => {
+      return response;
+    }
+  });
+};
+var use_button_default = useButton;
+var useDuplicateRecord = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      id,
+      model,
+      context
+    }) => action_service_default.duplicateRecord({
+      id,
+      model,
+      context
+    })
+  });
+};
+var use_duplicate_record_default = useDuplicateRecord;
+var useGetListData = (listDataProps, queryKey, enabled) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => model_service_default.getAll({ data: listDataProps }).then((res) => {
+      if (res) {
+        return res;
+      }
+      return [];
+    }),
+    enabled,
+    refetchOnWindowFocus: false,
+    staleTime: 0
+  });
+};
+var use_get_list_data_default = useGetListData;
+var useGetMenu = ({ context, enabled, queryKey }) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: async () => {
+      const res = await view_service_default.getMenu(context);
+      if (res?.records && Array.isArray(res.records) && res.records.length > 0) {
+        return res.records;
+      }
+      return [];
+    },
+    refetchOnWindowFocus: false,
+    staleTime: Infinity,
+    enabled
+  });
+};
+var use_get_menu_default = useGetMenu;
+var useGetSelection = ({
+  data,
+  queryKey,
+  enabled
+}) => {
+  return reactQuery.useQuery({
+    queryKey,
+    queryFn: () => view_service_default.getSelectionItem({ data }),
+    enabled,
+    refetchOnWindowFocus: false
+  });
+};
+var use_get_selection_default = useGetSelection;
+var useGetView = (viewParams, actData) => {
+  return reactQuery.useQuery({
+    queryKey: ["get_view_by_action" /* GET_VIEW_BY_ACTION */, viewParams],
+    queryFn: () => view_service_default.getView(viewParams),
+    enabled: !!actData,
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+};
+var use_get_view_default = useGetView;
+var useLoadAction = ({
+  idAction,
+  context
+}) => {
+  return reactQuery.useQuery({
+    queryKey: ["load_action", idAction],
+    queryFn: () => action_service_default.loadAction({
+      idAction,
+      context
+    }),
+    enabled: false,
+    staleTime: Infinity,
+    gcTime: Infinity
+  });
+};
+var use_load_action_default = useLoadAction;
+var usePrint = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({ id, report, db }) => action_service_default.print({
+      id,
+      report,
+      db
+    })
+  });
+};
+var use_print_default = usePrint;
+var useRemoveRow = () => {
+  return reactQuery.useMutation({
+    mutationFn: ({
+      model,
+      ids,
+      context
+    }) => action_service_default.removeRows({
+      model,
+      ids,
+      context
+    })
+  });
+};
+var use_remove_row_default = useRemoveRow;
+var useRunAction = ({ idAction, context }) => {
+  return reactQuery.useQuery({
+    queryKey: ["run_action", idAction],
+    queryFn: () => action_service_default.runAction({
+      idAction,
+      context
+    }),
+    enabled: false,
+    staleTime: Infinity,
+    gcTime: Infinity
+  });
+};
+var use_run_action_default = useRunAction;
+
+exports.useButton = use_button_default;
+exports.useChangeStatus = use_change_status_default;
+exports.useDelete = use_delete_default;
+exports.useDeleteComment = use_delete_comment_default;
+exports.useDuplicateRecord = use_duplicate_record_default;
+exports.useExecuteImport = uss_execute_import_default;
+exports.useExportExcel = use_export_excel_default;
+exports.useField = use_field_default;
+exports.useForgotPassword = use_forgot_password_default;
+exports.useGetAll = use_get_all_default;
+exports.useGetComment = use_get_comment_default;
+exports.useGetCompanyInfo = use_get_company_info_default;
+exports.useGetCurrentCompany = use_get_current_company_default;
+exports.useGetDetail = use_get_detail_default;
+exports.useGetFieldExport = use_get_field_export_default;
+exports.useGetFieldOnChange = use_get_field_onchange_default;
+exports.useGetFileExcel = use_get_file_excel_default;
+exports.useGetFormView = use_get_form_view_default;
+exports.useGetImage = use_get_image_default;
+exports.useGetListData = use_get_list_data_default;
+exports.useGetMenu = use_get_menu_default;
+exports.useGetProfile = use_get_profile_default;
+exports.useGetProvider = use_get_provider_default;
+exports.useGetSelection = use_get_selection_default;
+exports.useGetUser = use_get_user_default;
+exports.useGetView = use_get_view_default;
+exports.useIsValidToken = use_isvalid_token_default;
+exports.useLoadAction = use_load_action_default;
+exports.useLoginCredential = use_login_credential_default;
+exports.useLoginSocial = use_login_socical_default;
+exports.useModel = use_model_default;
+exports.useOdooDataTransform = use_odoo_data_transform_default;
+exports.useOnChangeForm = use_onchange_form_default;
+exports.useParsePreview = use_parse_preview_default;
+exports.usePrint = use_print_default;
+exports.useRemoveRow = use_remove_row_default;
+exports.useResetPassword = use_reset_password_default;
+exports.useRunAction = use_run_action_default;
+exports.useSave = use_save_default;
+exports.useSendComment = use_send_comment_default;
+exports.useSwitchLocale = use_switch_locale_default;
+exports.useUpdatePassword = use_update_password_default;
+exports.useUploadFile = use_upload_file_default;
+exports.useUploadIdFile = use_upload_id_file_default;
+exports.useUploadImage = use_upload_image_default;