@apia/api 2.0.11 → 3.0.2

package/dist/index.js

@@ -1,4 +1,3213 @@
-export { ApiaApiHandler, getFunction } from './ApiaApiHandler.js';
-export { default as ApiaApi, makeApiaUrl } from './apiaApi.js';
-export { getModal } from './fields/ApiaApiInput.js';
+import { jsx, jsxs, Fragment } from '@apia/theme/jsx-runtime';
+import * as React from 'react';
+import React__default, { createContext, useState, useCallback, useEffect, useId } from 'react';
+import { Box, Label, spacing, getVariant } from '@apia/theme';
+import { debugDispatcher, parseXmlAsync, EventEmitter, arrayOrArray, useMount, encrypt, noNaN, getIndex, getLabel, StatefulEmitter, focus, focusSelector, useLatest } from '@apia/util';
+import { notify, getNotificationMessageObj, dispatchNotifications } from '@apia/notifications';
+import { classToValidate, Checkbox, FileInput, classToValidationFunction, Input, Radio, Select, Textarea, useFormContext, validationsStore, hasSucceedFormValidation, Form } from '@apia/validations';
+import { Accordion, AccordionItem, useModal, LabelBox, SimpleButton, ApiaUtil, Modal, ProgressBar } from '@apia/components';
+import axios from 'axios';
+import merge from 'lodash-es/merge';
+import QueryString from 'qs';
+import { session } from '@apia/session';
+import uniqueId from 'lodash-es/uniqueId';
+import { ResponsiveTableContext, ResponsiveTable, Pagination, Sort, Responsive, Additional, responsiveTableStore } from '@apia/table';
+
+const ApiaApiId = createContext("apiaApi");
+const ApiaApiContext = ({
+  children,
+  id
+}) => {
+  return /* @__PURE__ */ jsx(ApiaApiId.Provider, { value: id, children });
+};
+var ApiaApiContext$1 = React.memo(ApiaApiContext);
+
+debugDispatcher.on(
+  "parseXml",
+  async ([text]) => {
+    const result = await parseXmlAsync(text);
+    console.info(result);
+  },
+  "Acepta un par\xE1metro de tipo string y realiza un parseo como si fuera xml, convirti\xE9ndolo a objeto javascript."
+);
+const defaultConfig = {
+  debug: false,
+  colors: {
+    exception: "red",
+    alert: "yellow",
+    message: "lightgreen"
+  },
+  handleLoad: false
+};
+const STORED_CONFIG = "ApiaApiConfig";
+let forcedConfig = {};
+const storedConfig = localStorage.getItem(STORED_CONFIG);
+if (storedConfig)
+  forcedConfig = JSON.parse(storedConfig);
+function getConfig(outerBehaveConfig) {
+  return merge({}, defaultConfig, outerBehaveConfig, forcedConfig);
+}
+function makeUrl(url, queryData, stringifyOptions) {
+  let finalUrl = url;
+  const questionMarkIndex = finalUrl.indexOf("?");
+  if (questionMarkIndex === -1)
+    finalUrl += "?";
+  else if (questionMarkIndex !== finalUrl.length - 1 && !finalUrl.endsWith("&"))
+    finalUrl += "&";
+  let parsedUrl = `${finalUrl}${queryData ? QueryString.stringify(queryData, stringifyOptions) : ""}`;
+  if (parsedUrl.endsWith("&") || parsedUrl.endsWith("?")) {
+    parsedUrl = parsedUrl.slice(0, parsedUrl.length - 1);
+  }
+  return parsedUrl;
+}
+const getURLActionName = (url) => {
+  const actionIdx = url.match(/action=(\w+)/)?.[1];
+  return actionIdx ?? "noAction";
+};
+class ApiaActionsClass extends EventEmitter {
+}
+const ApiaActions = new ApiaActionsClass();
+function getColor(color, colors = defaultConfig.colors ?? {
+  exception: "red",
+  alert: "yellow",
+  message: "green"
+}) {
+  return colors[color];
+}
+const handleWrongResponse = (error) => {
+  let errorMessage;
+  if (typeof error !== "string") {
+    if (error.message)
+      errorMessage = error.message;
+    else
+      errorMessage = error.toString();
+  } else
+    errorMessage = error;
+  notify({
+    type: "danger",
+    message: error.message.replaceAll("AxiosError", "Error")
+  });
+  console.log("%c ", "font-size:10vh");
+  console.log("%cError in ApiaApi", "color:red;font-size:2em;font-weight:bold");
+  console.log(`red/${errorMessage}`, { error });
+  console.log("%c ", "font-size:10vh");
+};
+function isJsonResponse(response) {
+  return response.headers["content-type"].match("application/json");
+}
+function isXmlResponse(response) {
+  return response.headers["content-type"].match(
+    /(?:application|text)?\/xml/
+  );
+}
+function isHtmlResponse(response) {
+  return response.headers["content-type"].match(
+    /(?:application|text)?\/html/
+  );
+}
+function handleActions(actions) {
+  if (actions) {
+    if (getConfig().debug)
+      console.log(
+        "%cHandled actions: ",
+        `color: ${getConfig().colors?.message ?? "green"}`,
+        { actions }
+      );
+    const actionsArray = arrayOrArray(actions.action);
+    actionsArray.forEach((action) => {
+      ApiaActions.emit("action", {
+        ...action,
+        param: arrayOrArray(action.param)
+      });
+    });
+  }
+}
+function handleOnClose({
+  exceptions,
+  onClose,
+  sysExceptions,
+  sysMessages
+}) {
+  try {
+    import(
+      /* webpackChunkName: "api-[request]" */
+      `/api/onClose/${onClose}.ts`
+    ).then(
+      (func) => {
+        if (exceptions || sysExceptions || sysMessages) {
+          const notificationsObject = getNotificationMessageObj({
+            exceptions,
+            onClose,
+            sysExceptions,
+            sysMessages
+          });
+          if (notificationsObject)
+            notificationsObject.forEach((notification) => {
+              notify({
+                ...notification,
+                onClose: func.default
+              });
+            });
+          else
+            func.default();
+        } else
+          func.default();
+      },
+      (e) => {
+        notify({
+          message: `onClose action not found: ${String(e)}`,
+          type: "danger"
+        });
+      }
+    );
+  } catch (e) {
+    parseMessages({ exceptions, sysExceptions, sysMessages });
+    console.error("Error while handling onClose");
+    console.error(e);
+  }
+}
+function parseMessages(response) {
+  if (!response)
+    return;
+  const { exceptions, sysMessages, sysExceptions } = response;
+  if (exceptions || sysExceptions || sysMessages) {
+    try {
+      dispatchNotifications({
+        exceptions,
+        sysExceptions,
+        sysMessages
+      });
+    } catch (e) {
+      handleWrongResponse(new Error(e));
+    }
+  }
+}
+const parseSuccessfulResponse = async (response, currentUrl, outerBehaveConfig = defaultConfig) => {
+  const behaveConfig = getConfig(outerBehaveConfig);
+  let parsedObj = void 0;
+  if (isJsonResponse(response)) {
+    if (typeof response.data === "string")
+      parsedObj = JSON.parse(
+        response.data.trim()
+      );
+    else if (typeof response.data === "object" && response.data)
+      parsedObj = response.data;
+  } else if (isXmlResponse(response)) {
+    parsedObj = await parseXmlAsync(response.data).catch(
+      (e) => {
+        handleWrongResponse(new Error(e));
+      }
+    );
+  } else if (isHtmlResponse(response)) {
+    console.error(
+      "El contenido devuelto es Html, no se esperaba esa respuesta"
+    );
+    return null;
+  }
+  if (behaveConfig.validateResponse) {
+    const validateResult = await behaveConfig.validateResponse({
+      ...response,
+      data: parsedObj?.load ?? parsedObj
+    });
+    if (typeof validateResult === "string")
+      throw new Error(`Validation error: ${validateResult}`);
+    else if (!validateResult) {
+      throw new Error("Error");
+    }
+  }
+  if (parsedObj) {
+    const {
+      actions,
+      onClose,
+      exceptions,
+      sysExceptions,
+      sysMessages,
+      load,
+      ...rest
+    } = parsedObj;
+    if (rest.code === "-1" && exceptions) {
+      session.invalidate();
+      return null;
+    }
+    if (exceptions && behaveConfig.debug) {
+      console.log(
+        `%cparseSuccessfulResponse`,
+        `color: ${getColor("exception", behaveConfig.colors)}`,
+        {
+          exceptions
+        }
+      );
+    }
+    if (sysExceptions && behaveConfig.debug) {
+      console.log(
+        `%cparseSuccessfulResponse`,
+        `color: ${getColor("exception", behaveConfig.colors)}`,
+        {
+          sysExceptions
+        }
+      );
+    }
+    if (sysMessages && behaveConfig.debug) {
+      console.log(
+        `%cparseSuccessfulResponse`,
+        `color: ${getColor("alert", behaveConfig.colors)}`,
+        {
+          sysMessages
+        }
+      );
+    }
+    handleActions(actions);
+    if (behaveConfig.handleLoad && onClose)
+      handleOnClose({
+        exceptions,
+        onClose,
+        sysExceptions,
+        sysMessages
+      });
+    else
+      parseMessages({ exceptions, sysExceptions, sysMessages });
+    if (load) {
+      if (behaveConfig.handleLoad) {
+        console.log(
+          `%chandleLoad`,
+          `color: ${getColor("message", behaveConfig.colors)}`,
+          {
+            load
+          }
+        );
+        if (!handle(load, currentUrl, {
+          methodsPath: outerBehaveConfig.methodsPath,
+          modalConfiguration: {
+            ...behaveConfig.modalConfiguration,
+            onClose: () => {
+              if (onClose)
+                handleOnClose({
+                  exceptions,
+                  onClose,
+                  sysExceptions,
+                  sysMessages
+                });
+              if (behaveConfig.modalConfiguration?.onClose)
+                behaveConfig.modalConfiguration?.onClose();
+            }
+          }
+        })) {
+          console.log(
+            `%cunhandledLoad -> There is no handler defined`,
+            `color: ${getColor("exception", behaveConfig.colors)}`,
+            {
+              load
+            }
+          );
+        }
+      }
+      return { ...load, sysMessages, exceptions, sysExceptions };
+    }
+    return { ...rest, sysMessages, exceptions, sysExceptions };
+  }
+  return null;
+};
+async function handleResponse(result, currentUrl, outerBehaveConfig = defaultConfig) {
+  const behaveConfig = getConfig(outerBehaveConfig);
+  try {
+    if (!result || result.data === void 0) {
+      if (behaveConfig.debug)
+        console.log(
+          `%cApiaApi wrong response`,
+          `color: ${getColor("alert", behaveConfig.colors)}`
+        );
+    } else {
+      const parsedResponse = await parseSuccessfulResponse(
+        result,
+        currentUrl,
+        behaveConfig
+      );
+      const action = getURLActionName(currentUrl);
+      if (behaveConfig.debug)
+        console.log(
+          `%c <- ApiaApi.${result.config.method ?? ""} ${action} `,
+          `color: ${getColor("message", behaveConfig.colors)}`,
+          {
+            data: parsedResponse
+          }
+        );
+      return {
+        ...result,
+        data: parsedResponse,
+        hasError: !!parsedResponse?.exceptions || !!parsedResponse?.sysExceptions,
+        hasMessages: !!parsedResponse?.sysMessages
+      };
+    }
+  } catch (e) {
+    handleWrongResponse(new Error(e));
+    return null;
+  }
+  return null;
+}
+async function post(par1, par2) {
+  const actualUrl = typeof par1 !== "string" ? makeApiaUrl() : par1;
+  const configParameter = typeof par1 === "string" ? par2 ?? defaultConfig : par1;
+  const behaveConfig = {
+    ...getConfig(configParameter),
+    postData: configParameter.postDataTreatement === "stringify" ? QueryString.stringify(
+      configParameter.postData,
+      configParameter.stringifyOptions
+    ) : configParameter.postData
+  };
+  const parsedUrl = makeUrl(
+    actualUrl,
+    behaveConfig.queryData,
+    behaveConfig.stringifyOptions
+  );
+  if (behaveConfig.debug) {
+    const queryString = actualUrl.split("&");
+    const action = getURLActionName(actualUrl);
+    console.log(
+      `%cApiaApi.post ${action}`,
+      `color: ${getColor("message", behaveConfig.colors)}`,
+      {
+        url: parsedUrl,
+        queryDataInURL: [...queryString],
+        queryData: behaveConfig.queryData,
+        formData: behaveConfig.postData,
+        stringifyOptiopns: behaveConfig.stringifyOptions
+      }
+    );
+  }
+  const response = await axios.post(parsedUrl, behaveConfig.postData, behaveConfig.axiosConfig).catch((e) => {
+    handleWrongResponse(new Error(e));
+  });
+  if (response) {
+    const result = handleResponse(response, actualUrl, behaveConfig);
+    return result;
+  }
+  return null;
+}
+async function get(par1, par2) {
+  const actualUrl = typeof par1 !== "string" ? makeApiaUrl() : par1;
+  const behaveConfig = getConfig(
+    typeof par1 === "string" ? par2 ?? defaultConfig : par1
+  );
+  const parsedUrl = makeUrl(
+    actualUrl,
+    behaveConfig.queryData,
+    behaveConfig.stringifyOptions
+  );
+  if (behaveConfig.debug)
+    console.log(
+      `%cApiaApi.get`,
+      `color: ${getColor("message", behaveConfig.colors)}`,
+      {
+        url: parsedUrl
+      }
+    );
+  const response = await axios.get(parsedUrl, behaveConfig.axiosConfig).catch((e) => {
+    handleWrongResponse(new Error(e));
+  });
+  if (response) {
+    const result = await handleResponse(
+      response,
+      actualUrl,
+      behaveConfig
+    );
+    return result;
+  }
+  return null;
+}
+const ApiaApi = {
+  get,
+  getConfig,
+  post
+};
+function makeApiaUrl(props) {
+  let actualQueryData = {};
+  if (props) {
+    const {
+      ajaxUrl,
+      queryString: queryString2,
+      stringifyOptions,
+      shouldAvoidTabId,
+      preventAsXmlParameter,
+      avoidTabId,
+      tabId: outerTabId,
+      ...rest
+    } = props;
+    actualQueryData = { ...rest };
+  }
+  const queryString = QueryString.stringify(
+    actualQueryData,
+    props?.stringifyOptions ?? {
+      arrayFormat: "repeat",
+      encodeValuesOnly: false
+    }
+  );
+  let actualAjaxUrl = props?.ajaxUrl ?? window.URL_REQUEST_AJAX;
+  if (actualAjaxUrl.indexOf("?") === actualAjaxUrl.length - 1) {
+    actualAjaxUrl = actualAjaxUrl.slice(0, actualAjaxUrl.length - 1);
+  }
+  if (!actualAjaxUrl.startsWith("/")) {
+    actualAjaxUrl = `/${actualAjaxUrl}`;
+  }
+  const match = window.TAB_ID_REQUEST.match(/tokenId=(\w+)/);
+  const currentTokenId = (match ?? [])[1];
+  let tabId = (props?.tabId ? `&tabId=${props.tabId}&tokenId=${currentTokenId}` : window.TAB_ID_REQUEST).slice(1);
+  if (props?.avoidTabId) {
+    tabId = "";
+  }
+  let { CONTEXT } = window;
+  if (CONTEXT?.endsWith("/")) {
+    CONTEXT += CONTEXT.slice(0, CONTEXT.length - 1);
+  }
+  let timestamp = `timestamp=${Date.now()}&`;
+  if (props?.queryString && props.queryString.includes("timestamp=") || queryString?.includes("timestamp=")) {
+    timestamp = "";
+  }
+  const contextWord = CONTEXT.replaceAll("/", "");
+  actualAjaxUrl = actualAjaxUrl.match(
+    new RegExp(`^(?:(?:/?${contextWord})?/)?(.+)$`)
+  )?.[1];
+  return `${contextWord ? "/" : ""}${contextWord}/${actualAjaxUrl}?${timestamp}${!props?.preventAsXmlParameter ? "asXml=true&" : ""}${props?.queryString ? `${props.queryString}&` : ""}${queryString ? `${queryString}&` : ""}${tabId}`;
+}
+var ApiaApi$1 = ApiaApi;
+
+const ApiaApiCheckbox = (props) => {
+  const element = React__default.useMemo(() => props.element, [props.element]);
+  const className = React__default.useMemo(
+    () => element.class ? `handler__checkbox ${element.class}` : "handler__checkbox",
+    [element.class]
+  );
+  const validationRules = React__default.useMemo(
+    () => ({
+      required: element.mandatory,
+      ...classToValidate(element.class)
+    }),
+    [element.class, element.mandatory]
+  );
+  const submitValueParser = React__default.useCallback(
+    (value) => value === "on" || value === true,
+    []
+  );
+  return /* @__PURE__ */ jsx(
+    Checkbox,
+    {
+      className,
+      name: element.id || element.name,
+      label: element.text,
+      title: element.title || element.text,
+      initialValue: String(element.selected) === "true",
+      disabled: element.readonly || element.disabled,
+      validationRules,
+      onChange: element.onChange,
+      submitValueParser
+    }
+  );
+};
+
+const ApiaApiFileInput = (props) => {
+  const element = React__default.useMemo(() => props.element, [props.element]);
+  const className = React__default.useMemo(
+    () => element.class ? `handler__file ${element.class}` : "handler__file",
+    [element.class]
+  );
+  const validationRules = React__default.useMemo(
+    () => ({
+      required: element.mandatory,
+      ...classToValidate(element.class)
+    }),
+    [element.class, element.mandatory]
+  );
+  return /* @__PURE__ */ jsx(
+    FileInput,
+    {
+      className,
+      name: element.id || element.name,
+      label: element.text,
+      title: element.title || element.text,
+      readOnly: element.readonly,
+      disabled: element.disabled,
+      validationRules
+    }
+  );
+};
+ApiaApiFileInput.displayName = "ApiaApiFileInput";
+
+const getModal = (path) => {
+  return React__default.lazy(() => {
+    return new Promise((resolve) => {
+      import(
+        /* webpackChunkName: "handlerModal" */
+        /* webpackInclude: /\.tsx?$/ */
+        `/api/modals/${path}`
+      ).then((result) => {
+        resolve(
+          result
+        );
+      }).catch((error) => {
+        resolve({
+          default: () => {
+            console.error(error);
+            throw new Error(
+              `The above error ocurred at component ApiaApiHandler/${path}, does it exist?`
+            );
+          }
+        });
+      });
+    });
+  });
+};
+const ApiaApiInput = (props) => {
+  const element = React__default.useMemo(() => props.element, [props.element]);
+  const [Submodal, setSubmodal] = React__default.useState(null);
+  useMount(() => {
+    if (element.modalFunction) {
+      const found = element.modalFunction.match(/(?:fnc)?(\w+)\(?\)?$/);
+      if (found) {
+        const modalName = found[found.length - 1];
+        setSubmodal(getModal(modalName));
+      }
+    }
+  });
+  const className = React__default.useMemo(
+    () => element.class ? `handler__${element.type} ${element.class}` : `handler__${element.type}`,
+    [element.class, element.type]
+  );
+  const validationRules = React__default.useMemo(
+    () => ({
+      required: element.mandatory,
+      maxLength: element.maxlength ? Number(element.maxlength) : void 0,
+      pattern: element.regExp,
+      patternMessage: element.regExpMessage,
+      ...classToValidate(element.class)
+    }),
+    [
+      element.class,
+      element.mandatory,
+      element.maxlength,
+      element.regExp,
+      element.regExpMessage
+    ]
+  );
+  const validationFunction = React__default.useMemo(
+    () => classToValidationFunction(element.class),
+    [element.class]
+  );
+  const submitValueParser = React__default.useCallback(
+    (value) => {
+      if (element.type === "password") {
+        return encrypt(
+          window.SALT,
+          window.IV,
+          window.PASSPHRASE,
+          value,
+          Number(window.KEY_SIZE),
+          Number(window.ITERATION_COUNT)
+        );
+      }
+      return value;
+    },
+    [element.type]
+  );
+  if (element.modalFunction) {
+    if (Submodal) {
+      return /* @__PURE__ */ jsx(React__default.Suspense, { children: /* @__PURE__ */ jsx(Submodal, { ...props, element }) });
+    }
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    Input,
+    {
+      type: element.isADate ? "date" : element.type,
+      className,
+      name: element.id || element.name,
+      label: element.text,
+      title: element.title || element.text,
+      value: element.value,
+      readOnly: element.readonly,
+      disabled: element.disabled,
+      validationFunction,
+      validationRules,
+      submitValueParser,
+      onChange: element.onChange,
+      autoComplete: element.type === "password" ? "new-password" : void 0
+    }
+  );
+};
+ApiaApiInput.displayName = "ApiaApiInput";
+
+const ApiaApiRadio = (props) => {
+  const element = React__default.useMemo(() => props.element, [props.element]);
+  const className = React__default.useMemo(
+    () => element.class ? `handler__radio ${element.class}` : "handler__radio",
+    [element.class]
+  );
+  const options = React__default.useMemo(
+    () => arrayOrArray(element.options?.option).map((currOption) => {
+      return { value: currOption.value, label: currOption.content };
+    }),
+    [element.options?.option]
+  );
+  const validationRules = React__default.useMemo(
+    () => ({
+      required: element.mandatory,
+      ...classToValidate(element.class)
+    }),
+    [element.class, element.mandatory]
+  );
+  return /* @__PURE__ */ jsx(
+    Radio,
+    {
+      className,
+      name: element.id || element.name,
+      label: element.text,
+      title: element.title || element.text,
+      initialValue: element.value,
+      disabled: element.readonly || element.disabled,
+      validationRules,
+      options,
+      onChange: element.onChange
+    }
+  );
+};
+ApiaApiRadio.displayName = "ApiaApiRadio";
+
+class ApiaApiSelectOptions extends EventEmitter {
+}
+const apiaApiSelectOptions = new ApiaApiSelectOptions();
+const ApiaApiSelect = (props) => {
+  const element = React__default.useMemo(() => props.element, [props.element]);
+  const className = React__default.useMemo(
+    () => element.class ? `handler__select ${element.class}` : "handler__select",
+    [element.class]
+  );
+  const [options, setOptions] = React__default.useState(
+    arrayOrArray(element.options?.option).map((currOption) => {
+      return { value: currOption.value, label: currOption.content };
+    })
+  );
+  const validationRules = React__default.useMemo(
+    () => ({
+      required: element.mandatory,
+      ...classToValidate(element.class)
+    }),
+    [element.class, element.mandatory]
+  );
+  React__default.useEffect(() => {
+    const unsuscribe = apiaApiSelectOptions.on("setOptions", (ev) => {
+      if (ev.fieldName === element.name) {
+        setOptions(
+          ev.options.map((currOption) => ({
+            value: currOption.value,
+            label: currOption.content
+          }))
+        );
+      }
+    });
+    return () => {
+      unsuscribe();
+    };
+  }, [element.name]);
+  const initialValue = React__default.useMemo(
+    () => options.find((current) => current.value === props.element.value)?.value ?? options[0]?.value ?? "",
+    [options, props.element.value]
+  );
+  return /* @__PURE__ */ jsx(
+    Select,
+    {
+      className,
+      name: element.id || element.name,
+      label: element.text,
+      title: element.title || element.text,
+      initialValue,
+      disabled: element.readonly || element.disabled,
+      validationRules,
+      options,
+      onChange: element.onChange
+    }
+  );
+};
+ApiaApiSelect.displayName = "ApiaApiSelect";
+
+const ApiaApiTextArea = (props) => {
+  const element = React__default.useMemo(() => props.element, [props.element]);
+  const className = React__default.useMemo(
+    () => element.class ? `handler__textarea ${element.class}` : "handler__textarea",
+    [element.class]
+  );
+  const validationRules = React__default.useMemo(
+    () => ({
+      required: element.mandatory,
+      maxLength: element.maxlength ? Number(element.maxlength) : void 0,
+      pattern: element.regExp,
+      patternMessage: element.regExpMessage,
+      ...classToValidate(element.class)
+    }),
+    [
+      element.class,
+      element.mandatory,
+      element.maxlength,
+      element.regExp,
+      element.regExpMessage
+    ]
+  );
+  const validationFunction = React__default.useMemo(
+    () => classToValidationFunction(element.class),
+    [element.class]
+  );
+  return /* @__PURE__ */ jsx(
+    Textarea,
+    {
+      className,
+      name: element.id || element.name,
+      label: element.text,
+      title: element.title || element.text,
+      value: element.value,
+      readOnly: element.readonly,
+      disabled: element.disabled,
+      validationFunction,
+      validationRules,
+      onChange: element.onChange
+    }
+  );
+};
+ApiaApiTextArea.displayName = "ApiaApiTextArea";
+
+function parseResult(result) {
+  if (result) {
+    const { pageInfo } = result.function.messages.result;
+    const { table } = result.function.messages.result;
+    if (table) {
+      table.row = arrayOrArray(table.row);
+      const returnRows = table.row.map((currentRow) => {
+        const returnRow = {
+          id: currentRow.id,
+          cells: arrayOrArray(currentRow.cell).map((currentCell) => {
+            const children = typeof currentCell === "string" ? currentCell : currentCell.label;
+            const returnCell = {
+              children
+            };
+            return returnCell;
+          }),
+          className: `${currentRow.classToAdd ?? ""} ${currentRow.unselectableTR ? "locked" : ""}`
+        };
+        return returnRow;
+      });
+      return {
+        currentPage: Number.parseInt(pageInfo.currentPage, 10),
+        pageCount: Number.parseInt(pageInfo.pageCount, 10),
+        reachedMax: pageInfo.reachedMax,
+        rows: returnRows,
+        recordsCount: noNaN(pageInfo.totalRecords)
+      };
+    }
+  }
+  return {
+    currentPage: 0,
+    pageCount: 0,
+    reachedMax: true,
+    rows: [],
+    recordsCount: 0
+  };
+}
+const defaultFetcher = {
+  async filter({ filters, parameters, path, requestConfig }) {
+    const filterValues = {
+      selectOnlyOne: false
+    };
+    (filters ?? []).forEach((currentFilter) => {
+      filterValues[currentFilter.id] = currentFilter.currentValue;
+    });
+    const result = await ApiaApi$1.post(
+      makeApiaUrl({
+        react: true,
+        action: "filter",
+        ajaxUrl: `/${path}`,
+        isAjax: true,
+        timestamp: Date.now(),
+        stringifyOptions: requestConfig?.stringifyOptions
+      }),
+      {
+        ...requestConfig,
+        postDataTreatement: "stringify",
+        postData: { ...parameters, ...filterValues }
+      }
+    );
+    return parseResult(result?.data);
+  },
+  async page({ page, path, requestConfig }) {
+    const result = await ApiaApi$1.post(
+      makeApiaUrl({
+        react: true,
+        action: "page",
+        ajaxUrl: `/${path}`,
+        pageNumber: page,
+        isAjax: true,
+        stringifyOptions: requestConfig?.stringifyOptions
+      }),
+      {
+        ...requestConfig
+      }
+    );
+    return parseResult(result?.data);
+  },
+  async refresh({ path, requestConfig }) {
+    const result = await ApiaApi$1.post(
+      makeApiaUrl({
+        react: true,
+        action: "refresh",
+        ajaxUrl: `/${path}`,
+        isAjax: true,
+        stringifyOptions: requestConfig?.stringifyOptions
+      }),
+      {
+        ...requestConfig
+      }
+    );
+    return parseResult(result?.data);
+  },
+  async sort({ path, requestConfig, sort }) {
+    const result = await ApiaApi$1.post(
+      makeApiaUrl({
+        react: true,
+        action: "sort",
+        ajaxUrl: `/${path}`,
+        isAjax: true,
+        stringifyOptions: requestConfig?.stringifyOptions
+      }),
+      {
+        ...requestConfig,
+        postData: {
+          orderBy: sort
+        },
+        postDataTreatement: "stringify"
+      }
+    );
+    return parseResult(result?.data);
+  }
+};
+function useFetcher(fetcher = defaultFetcher) {
+  const [isLoading, setIsLoading] = React__default.useState(0);
+  const proxy = React__default.useMemo(() => {
+    return new Proxy(fetcher, {
+      get(obj, prop) {
+        if (prop in obj) {
+          const method = obj[prop];
+          return (args) => {
+            return new Promise((resolve, reject) => {
+              setIsLoading((currentIndex) => currentIndex + 1);
+              method(args).then((result) => {
+                setIsLoading((currentIndex) => currentIndex - 1);
+                resolve(result);
+              }, reject);
+            });
+          };
+        }
+        return void 0;
+      }
+    });
+  }, [fetcher]);
+  return { fetcher: proxy, isLoading: isLoading > 0 };
+}
+
+const ApiaEnvironmentsModal = (props) => {
+  const [actualColumns, setColumns] = useState(
+    environmentsModal.columns.map((current) => ({
+      ...current,
+      currentSorting: getIndex(
+        ["A", "D", null],
+        [
+          ["A", "Up"].includes(current.currentSorting || ""),
+          ["D", "Down"].includes(current.currentSorting || ""),
+          true
+        ]
+      )
+    }))
+  );
+  const [filters, setFilters] = useState(environmentsModal.filters);
+  const [state, setState] = useState(null);
+  const { fetcher } = useFetcher();
+  const filter = useCallback(
+    (newFilters = filters) => {
+      if (newFilters) {
+        fetcher.filter({
+          filters: newFilters,
+          parameters: {
+            txtName: props.initialProps.name,
+            txtTitle: props.initialProps.title,
+            txtDesc: props.initialProps.title,
+            selectOnlyOne: false,
+            txtAdtSql: props.initialProps.adtInfo ?? "",
+            fromGlobalDescAdm: false,
+            usrToUpdate: ""
+          },
+          path: environmentsModal.path,
+          requestConfig: {}
+        }).then((result) => {
+          if (result) {
+            setState(result);
+          }
+        }).catch(console.error);
+      }
+    },
+    [
+      fetcher,
+      filters,
+      props.initialProps.adtInfo,
+      props.initialProps.name,
+      props.initialProps.title
+    ]
+  );
+  useEffect(() => {
+    filter();
+  }, []);
+  useEffect(() => {
+    ApiaEnvironmentsModalEmitter.on("deleteFilters", filter);
+  }, [filter]);
+  const handleFilterChange = useCallback(
+    (ev) => {
+      const newFilters = filters?.map((currentFilter) => {
+        if (currentFilter.column === ev.column) {
+          return { ...ev };
+        }
+        return currentFilter;
+      });
+      setFilters(newFilters);
+      if (ev.runAutomatically)
+        filter(newFilters);
+    },
+    [filters, filter]
+  );
+  const handleSort = useCallback(
+    (ev) => {
+      fetcher.sort({
+        sort: ev.columnIndex,
+        parameters: {},
+        path: environmentsModal.path,
+        requestConfig: {}
+      }).then((result) => {
+        if (result) {
+          setColumns(
+            (currentColumns) => currentColumns.map((column) => {
+              if (column.name === ev.name)
+                return {
+                  ...column,
+                  currentSorting: column.currentSorting === "Down" || column.currentSorting === "D" || !column.currentSorting ? "A" : "D"
+                };
+              return { ...column, currentSorting: null };
+            })
+          );
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleFilterPressEnter = useCallback(() => filter(), [filter]);
+  const handleFilterBlur = useCallback(() => filter(), [filter]);
+  const handlePageChange = useCallback(
+    (page) => {
+      fetcher.page({
+        page,
+        parameters: {},
+        path: environmentsModal.path
+      }).then((result) => {
+        if (result) {
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleRefresh = useCallback(() => {
+    fetcher.refresh({
+      parameters: {},
+      path: environmentsModal.path
+    }).then((result) => {
+      if (result) {
+        setState(result);
+      }
+    }).catch(console.error);
+  }, [fetcher]);
+  return state?.rows && /* @__PURE__ */ jsxs(
+    ResponsiveTableContext,
+    {
+      columns: actualColumns,
+      rows: state?.rows,
+      filters,
+      name: props.tableName ?? environmentsModal.label,
+      variant: "layout.common.modals.table",
+      onFilterChange: handleFilterChange,
+      onSortChange: handleSort,
+      onFilterBlur: handleFilterBlur,
+      onFilterPressEnter: handleFilterPressEnter,
+      isMultiple: true,
+      children: [
+        /* @__PURE__ */ jsx(ResponsiveTable, {}),
+        /* @__PURE__ */ jsx(Box, { className: "pagination__wrapper", children: /* @__PURE__ */ jsx(
+          Pagination,
+          {
+            currentPage: state.currentPage,
+            onPageChange: handlePageChange,
+            onRefresh: handleRefresh,
+            pageCount: state.pageCount,
+            reachedMax: state.reachedMax,
+            recordsCount: state.recordsCount
+          }
+        ) })
+      ]
+    }
+  );
+};
+
+const FiltersModal = ({ tableName }) => {
+  return /* @__PURE__ */ jsx(Box, { className: "additionalFiltersContent", children: /* @__PURE__ */ jsxs(Accordion, { className: "filtersModals__accordion", singleExpand: true, children: [
+    /* @__PURE__ */ jsx(
+      AccordionItem,
+      {
+        id: "Sortpanel",
+        buttonProps: {
+          ariaLabel: window.FINDER_ORDER_BY,
+          label: window.FINDER_ORDER_BY
+        },
+        defaultExpanded: true,
+        children: /* @__PURE__ */ jsx(Sort, { tableName })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      AccordionItem,
+      {
+        id: "Filters",
+        buttonProps: {
+          ariaLabel: window.FINDER_FILTERS,
+          label: window.FINDER_FILTERS
+        },
+        children: /* @__PURE__ */ jsx(Responsive, { tableName })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      AccordionItem,
+      {
+        id: "Additional",
+        buttonProps: {
+          ariaLabel: window.ADDITIONAL_FILTERS_LABEL,
+          label: window.ADDITIONAL_FILTERS_LABEL
+        },
+        children: /* @__PURE__ */ jsx(Additional, { tableName })
+      }
+    )
+  ] }) });
+};
+
+const ApiaEnvironmentsModalEmitter = new EventEmitter();
+const ApiaApiEnvironmentsModalField = (props) => {
+  const { name } = useFormContext();
+  const [selectedRows, setSelectedRows] = useState(
+    props.element.value.split("#").filter((env) => env !== "").map((envData) => {
+      const id2 = envData.split("_$_")[0];
+      const title = envData.split("_$_")[1];
+      return {
+        id: id2,
+        title
+      };
+    })
+  );
+  const {
+    isLoading: isFiltersModalLoading,
+    show: showFiltersModal,
+    ...filtersModalProps
+  } = useModal();
+  const id = useId();
+  const deleteFilters = useCallback(() => {
+    const newFilters = environmentsModal.filters?.map(
+      (currentFilter) => {
+        return {
+          ...currentFilter,
+          currentValue: "",
+          deleteFiltersTimestamp: Date.now()
+        };
+      }
+    );
+    ApiaEnvironmentsModalEmitter.emit("deleteFilters", newFilters);
+  }, []);
+  useEffect(() => {
+    validationsStore.setFieldValue(
+      name,
+      props.element.name,
+      selectedRows.map((e) => e.id).join("#")
+    );
+  }, [name, props.element.name, selectedRows]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Label, { children: getLabel(props.element.text).text }),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: spacing(3)
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            Box,
+            {
+              sx: {
+                maxHeight: "200px",
+                overflow: "auto",
+                width: "100%",
+                display: "flex",
+                flexWrap: "wrap"
+              },
+              children: selectedRows.map((row) => {
+                return /* @__PURE__ */ jsx(
+                  LabelBox,
+                  {
+                    label: row.title,
+                    onClose: () => {
+                      setSelectedRows((prev) => {
+                        return prev.filter((prevRow) => {
+                          return prevRow.id !== row.id;
+                        });
+                      });
+                    }
+                  },
+                  row.id
+                );
+              })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            SimpleButton,
+            {
+              onClick: () => {
+                ApiaUtil.instance.modals.open({
+                  onConfirm: () => {
+                    const rows = responsiveTableStore.getState().responsiveTableSlice[id].rows;
+                    const selectedIndex = responsiveTableStore.getState().responsiveTableSlice[id].selectedRows;
+                    const selectedRows2 = [];
+                    selectedIndex.forEach((i) => {
+                      if (rows[i]) {
+                        selectedRows2.push({
+                          id: rows[i].id,
+                          title: rows[i].cells[1].children
+                        });
+                      }
+                    });
+                    setSelectedRows((prev) => [
+                      ...prev,
+                      ...selectedRows2.filter((newEnv) => {
+                        return !prev.find((prevEnv) => prevEnv.id === newEnv.id);
+                      })
+                    ]);
+                  },
+                  confirmProps: { confirmButtonText: getLabel("btnCon").text },
+                  children: /* @__PURE__ */ jsx(
+                    ApiaEnvironmentsModal,
+                    {
+                      ...filtersModalProps,
+                      initialProps: props.element,
+                      tableName: id
+                    }
+                  ),
+                  size: "xxl",
+                  title: environmentsModal.label,
+                  NavBar: /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        title: window.FILTERS_LABEL,
+                        onClick: () => {
+                          ApiaUtil.instance.modals.open({
+                            children: /* @__PURE__ */ jsx(FiltersModal, { tableName: id }),
+                            variant: "layout.common.modals.tableModal.additionalFiltersModal",
+                            size: "xl",
+                            noHeader: true,
+                            initialFocusGetter(modalInnerRef) {
+                              return modalInnerRef.querySelector(
+                                "select"
+                              );
+                            }
+                          });
+                        },
+                        isLoading: isFiltersModalLoading,
+                        children: window.FILTERS_LABEL
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        onClick: deleteFilters,
+                        title: window.BTN_DELETE_FILTERS,
+                        children: window.BTN_DELETE_FILTERS
+                      }
+                    )
+                  ] })
+                });
+              },
+              sx: {
+                width: "fit-content !important"
+              },
+              children: getLabel("lblAdd").text
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+
+const ApiaTasksModal = (props) => {
+  const [actualColumns, setColumns] = useState(
+    tasksModal.columns.map((current) => ({
+      ...current,
+      currentSorting: getIndex(
+        ["A", "D", null],
+        [
+          ["A", "Up"].includes(current.currentSorting || ""),
+          ["D", "Down"].includes(current.currentSorting || ""),
+          true
+        ]
+      )
+    }))
+  );
+  const [filters, setFilters] = useState(tasksModal.filters);
+  const [state, setState] = useState(null);
+  const { fetcher } = useFetcher();
+  const filter = useCallback(
+    (newFilters = filters) => {
+      if (newFilters) {
+        fetcher.filter({
+          filters: newFilters,
+          parameters: {
+            txtName: props.initialProps.name,
+            txtTitle: props.initialProps.title,
+            txtDesc: props.initialProps.title,
+            selectOnlyOne: false,
+            txtAdtSql: props.initialProps.adtInfo ?? "",
+            usrToUpdate: ""
+          },
+          path: tasksModal.path,
+          requestConfig: {}
+        }).then((result) => {
+          if (result) {
+            setState(result);
+          }
+        }).catch(console.error);
+      }
+    },
+    [
+      fetcher,
+      filters,
+      props.initialProps.adtInfo,
+      props.initialProps.name,
+      props.initialProps.title
+    ]
+  );
+  useEffect(() => {
+    filter();
+  }, []);
+  useEffect(() => {
+    ApiaTasksModalEmitter.on("deleteFilters", filter);
+  }, [filter]);
+  const handleFilterChange = useCallback(
+    (ev) => {
+      const newFilters = filters?.map((currentFilter) => {
+        if (currentFilter.column === ev.column) {
+          return { ...ev };
+        }
+        return currentFilter;
+      });
+      setFilters(newFilters);
+      if (ev.runAutomatically)
+        filter(newFilters);
+    },
+    [filters, filter]
+  );
+  const handleSort = useCallback(
+    (ev) => {
+      fetcher.sort({
+        sort: ev.columnIndex,
+        parameters: {},
+        path: tasksModal.path,
+        requestConfig: {}
+      }).then((result) => {
+        if (result) {
+          setColumns(
+            (currentColumns) => currentColumns.map((column) => {
+              if (column.name === ev.name)
+                return {
+                  ...column,
+                  currentSorting: column.currentSorting === "Down" || column.currentSorting === "D" || !column.currentSorting ? "A" : "D"
+                };
+              return { ...column, currentSorting: null };
+            })
+          );
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleFilterPressEnter = useCallback(() => filter(), [filter]);
+  const handleFilterBlur = useCallback(() => filter(), [filter]);
+  const handlePageChange = useCallback(
+    (page) => {
+      fetcher.page({
+        page,
+        parameters: {},
+        path: tasksModal.path
+      }).then((result) => {
+        if (result) {
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleRefresh = useCallback(() => {
+    fetcher.refresh({
+      parameters: {},
+      path: tasksModal.path
+    }).then((result) => {
+      if (result) {
+        setState(result);
+      }
+    }).catch(console.error);
+  }, [fetcher]);
+  return state?.rows && /* @__PURE__ */ jsxs(
+    ResponsiveTableContext,
+    {
+      columns: actualColumns,
+      rows: state?.rows,
+      filters,
+      name: props.tableName ?? tasksModal.label,
+      variant: "layout.common.modals.table",
+      onFilterChange: handleFilterChange,
+      onSortChange: handleSort,
+      onFilterBlur: handleFilterBlur,
+      onFilterPressEnter: handleFilterPressEnter,
+      isMultiple: true,
+      children: [
+        /* @__PURE__ */ jsx(ResponsiveTable, {}),
+        /* @__PURE__ */ jsx(Box, { className: "pagination__wrapper", children: /* @__PURE__ */ jsx(
+          Pagination,
+          {
+            currentPage: state.currentPage,
+            onPageChange: handlePageChange,
+            onRefresh: handleRefresh,
+            pageCount: state.pageCount,
+            reachedMax: state.reachedMax,
+            recordsCount: state.recordsCount
+          }
+        ) })
+      ]
+    }
+  );
+};
+
+const ApiaTasksModalEmitter = new EventEmitter();
+const ApiaApiTasksModalField = (props) => {
+  const { name } = useFormContext();
+  const [selectedRows, setSelectedRows] = useState(
+    props.element.value.split("#").filter((tsk) => tsk !== "").map((tskData) => {
+      const id2 = tskData.split("_$_")[0];
+      const title = tskData.split("_$_")[1];
+      return {
+        id: id2,
+        title
+      };
+    })
+  );
+  const {
+    isLoading: isFiltersModalLoading,
+    show: showFiltersModal,
+    ...filtersModalProps
+  } = useModal();
+  const id = useId();
+  const deleteFilters = useCallback(() => {
+    const newFilters = tasksModal.filters?.map(
+      (currentFilter) => {
+        return {
+          ...currentFilter,
+          currentValue: "",
+          deleteFiltersTimestamp: Date.now()
+        };
+      }
+    );
+    ApiaTasksModalEmitter.emit("deleteFilters", newFilters);
+  }, []);
+  useEffect(() => {
+    validationsStore.setFieldValue(
+      name,
+      props.element.name,
+      selectedRows.map((e) => e.id).join("#")
+    );
+  }, [name, props.element.name, selectedRows]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Label, { children: getLabel(props.element.text).text }),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: spacing(3)
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            Box,
+            {
+              sx: {
+                maxHeight: "200px",
+                overflow: "auto",
+                width: "100%",
+                display: "flex",
+                flexWrap: "wrap"
+              },
+              children: selectedRows.map((row) => {
+                return /* @__PURE__ */ jsx(
+                  LabelBox,
+                  {
+                    label: row.title,
+                    onClose: () => {
+                      setSelectedRows((prev) => {
+                        return prev.filter((prevRow) => {
+                          return prevRow.id !== row.id;
+                        });
+                      });
+                    }
+                  },
+                  row.id
+                );
+              })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            SimpleButton,
+            {
+              onClick: () => {
+                ApiaUtil.instance.modals.open({
+                  onConfirm: () => {
+                    const rows = responsiveTableStore.getState().responsiveTableSlice[id].rows;
+                    const selectedIndex = responsiveTableStore.getState().responsiveTableSlice[id].selectedRows;
+                    const selectedRows2 = [];
+                    selectedIndex.forEach((i) => {
+                      if (rows[i]) {
+                        selectedRows2.push({
+                          id: rows[i].id,
+                          title: rows[i].cells[1].children
+                        });
+                      }
+                    });
+                    setSelectedRows((prev) => [
+                      ...prev,
+                      ...selectedRows2.filter((newEnv) => {
+                        return !prev.find((prevEnv) => prevEnv.id === newEnv.id);
+                      })
+                    ]);
+                  },
+                  confirmProps: { confirmButtonText: getLabel("btnCon").text },
+                  children: /* @__PURE__ */ jsx(
+                    ApiaTasksModal,
+                    {
+                      ...filtersModalProps,
+                      initialProps: props.element,
+                      tableName: id
+                    }
+                  ),
+                  size: "xxl",
+                  title: environmentsModal.label,
+                  NavBar: /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        title: window.FILTERS_LABEL,
+                        onClick: () => {
+                          ApiaUtil.instance.modals.open({
+                            children: /* @__PURE__ */ jsx(FiltersModal, { tableName: id }),
+                            variant: "layout.common.modals.tableModal.additionalFiltersModal",
+                            size: "xl",
+                            noHeader: true,
+                            initialFocusGetter(modalInnerRef) {
+                              return modalInnerRef.querySelector(
+                                "select"
+                              );
+                            }
+                          });
+                        },
+                        isLoading: isFiltersModalLoading,
+                        children: window.FILTERS_LABEL
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        onClick: deleteFilters,
+                        title: window.BTN_DELETE_FILTERS,
+                        children: window.BTN_DELETE_FILTERS
+                      }
+                    )
+                  ] })
+                });
+              },
+              sx: {
+                width: "fit-content !important"
+              },
+              children: getLabel("lblAdd").text
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+
+const ApiaProcessesModal = (props) => {
+  const [actualColumns, setColumns] = useState(
+    processesModal.columns.map((current) => ({
+      ...current,
+      currentSorting: getIndex(
+        ["A", "D", null],
+        [
+          ["A", "Up"].includes(current.currentSorting || ""),
+          ["D", "Down"].includes(current.currentSorting || ""),
+          true
+        ]
+      )
+    }))
+  );
+  const [filters, setFilters] = useState(processesModal.filters);
+  const [state, setState] = useState(null);
+  const { fetcher } = useFetcher();
+  const filter = useCallback(
+    (newFilters = filters) => {
+      if (newFilters) {
+        fetcher.filter({
+          filters: newFilters,
+          parameters: {
+            txtName: props.initialProps.name,
+            txtTitle: props.initialProps.title,
+            txtDesc: props.initialProps.title,
+            selectOnlyOne: false,
+            showGlobal: false,
+            isScenario: false,
+            showAll: false,
+            txtAdtSql: props.initialProps.adtInfo ?? "",
+            usrToUpdate: ""
+          },
+          path: processesModal.path,
+          requestConfig: {}
+        }).then((result) => {
+          if (result) {
+            setState(result);
+          }
+        }).catch(console.error);
+      }
+    },
+    [
+      fetcher,
+      filters,
+      props.initialProps.adtInfo,
+      props.initialProps.name,
+      props.initialProps.title
+    ]
+  );
+  useEffect(() => {
+    filter();
+  }, []);
+  useEffect(() => {
+    ApiaProcessesModalEmitter.on("deleteFilters", filter);
+  }, [filter]);
+  const handleFilterChange = useCallback(
+    (ev) => {
+      const newFilters = filters?.map((currentFilter) => {
+        if (currentFilter.column === ev.column) {
+          return { ...ev };
+        }
+        return currentFilter;
+      });
+      setFilters(newFilters);
+      if (ev.runAutomatically)
+        filter(newFilters);
+    },
+    [filters, filter]
+  );
+  const handleSort = useCallback(
+    (ev) => {
+      fetcher.sort({
+        sort: ev.columnIndex,
+        parameters: {},
+        path: processesModal.path,
+        requestConfig: {}
+      }).then((result) => {
+        if (result) {
+          setColumns(
+            (currentColumns) => currentColumns.map((column) => {
+              if (column.name === ev.name)
+                return {
+                  ...column,
+                  currentSorting: column.currentSorting === "Down" || column.currentSorting === "D" || !column.currentSorting ? "A" : "D"
+                };
+              return { ...column, currentSorting: null };
+            })
+          );
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleFilterPressEnter = useCallback(() => filter(), [filter]);
+  const handleFilterBlur = useCallback(() => filter(), [filter]);
+  const handlePageChange = useCallback(
+    (page) => {
+      fetcher.page({
+        page,
+        parameters: {},
+        path: processesModal.path
+      }).then((result) => {
+        if (result) {
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleRefresh = useCallback(() => {
+    fetcher.refresh({
+      parameters: {},
+      path: processesModal.path
+    }).then((result) => {
+      if (result) {
+        setState(result);
+      }
+    }).catch(console.error);
+  }, [fetcher]);
+  return state?.rows && /* @__PURE__ */ jsxs(
+    ResponsiveTableContext,
+    {
+      columns: actualColumns,
+      rows: state?.rows,
+      filters,
+      name: props.tableName ?? processesModal.label,
+      variant: "layout.common.modals.table",
+      onFilterChange: handleFilterChange,
+      onSortChange: handleSort,
+      onFilterBlur: handleFilterBlur,
+      onFilterPressEnter: handleFilterPressEnter,
+      isMultiple: true,
+      children: [
+        /* @__PURE__ */ jsx(ResponsiveTable, {}),
+        /* @__PURE__ */ jsx(Box, { className: "pagination__wrapper", children: /* @__PURE__ */ jsx(
+          Pagination,
+          {
+            currentPage: state.currentPage,
+            onPageChange: handlePageChange,
+            onRefresh: handleRefresh,
+            pageCount: state.pageCount,
+            reachedMax: state.reachedMax,
+            recordsCount: state.recordsCount
+          }
+        ) })
+      ]
+    }
+  );
+};
+
+const ApiaProcessesModalEmitter = new EventEmitter();
+const ApiaApiProcessesModalField = (props) => {
+  const { name } = useFormContext();
+  const [selectedRows, setSelectedRows] = useState(
+    props.element.value.split("#").filter((env) => env !== "").map((proData) => {
+      const id2 = proData.split("_$_")[0];
+      const title = proData.split("_$_")[1];
+      return {
+        id: id2,
+        title
+      };
+    })
+  );
+  const {
+    isLoading: isFiltersModalLoading,
+    show: showFiltersModal,
+    ...filtersModalProps
+  } = useModal();
+  const id = useId();
+  const deleteFilters = useCallback(() => {
+    const newFilters = processesModal.filters?.map(
+      (currentFilter) => {
+        return {
+          ...currentFilter,
+          currentValue: "",
+          deleteFiltersTimestamp: Date.now()
+        };
+      }
+    );
+    ApiaProcessesModalEmitter.emit("deleteFilters", newFilters);
+  }, []);
+  useEffect(() => {
+    validationsStore.setFieldValue(
+      name,
+      props.element.name,
+      selectedRows.map((e) => e.id).join("#")
+    );
+  }, [name, props.element.name, selectedRows]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Label, { children: getLabel(props.element.text).text }),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: spacing(3)
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            Box,
+            {
+              sx: {
+                maxHeight: "200px",
+                overflow: "auto",
+                width: "100%",
+                display: "flex",
+                flexWrap: "wrap"
+              },
+              children: selectedRows.map((row) => {
+                return /* @__PURE__ */ jsx(
+                  LabelBox,
+                  {
+                    label: row.title,
+                    onClose: () => {
+                      setSelectedRows((prev) => {
+                        return prev.filter((prevRow) => {
+                          return prevRow.id !== row.id;
+                        });
+                      });
+                    }
+                  },
+                  row.id
+                );
+              })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            SimpleButton,
+            {
+              onClick: () => {
+                ApiaUtil.instance.modals.open({
+                  onConfirm: () => {
+                    const rows = responsiveTableStore.getState().responsiveTableSlice[id].rows;
+                    const selectedIndex = responsiveTableStore.getState().responsiveTableSlice[id].selectedRows;
+                    const selectedRows2 = [];
+                    selectedIndex.forEach((i) => {
+                      if (rows[i]) {
+                        selectedRows2.push({
+                          id: rows[i].id,
+                          title: rows[i].cells[0].children
+                        });
+                      }
+                    });
+                    setSelectedRows((prev) => [
+                      ...prev,
+                      ...selectedRows2.filter((newEnv) => {
+                        return !prev.find((prevEnv) => prevEnv.id === newEnv.id);
+                      })
+                    ]);
+                  },
+                  confirmProps: { confirmButtonText: getLabel("btnCon").text },
+                  children: /* @__PURE__ */ jsx(
+                    ApiaProcessesModal,
+                    {
+                      ...filtersModalProps,
+                      initialProps: props.element,
+                      tableName: id
+                    }
+                  ),
+                  size: "xxl",
+                  title: processesModal.label,
+                  NavBar: /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        title: window.FILTERS_LABEL,
+                        onClick: () => {
+                          ApiaUtil.instance.modals.open({
+                            children: /* @__PURE__ */ jsx(FiltersModal, { tableName: id }),
+                            variant: "layout.common.modals.tableModal.additionalFiltersModal",
+                            size: "xl",
+                            noHeader: true,
+                            initialFocusGetter(modalInnerRef) {
+                              return modalInnerRef.querySelector(
+                                "select"
+                              );
+                            }
+                          });
+                        },
+                        isLoading: isFiltersModalLoading,
+                        children: window.FILTERS_LABEL
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        onClick: deleteFilters,
+                        title: window.BTN_DELETE_FILTERS,
+                        children: window.BTN_DELETE_FILTERS
+                      }
+                    )
+                  ] })
+                });
+              },
+              sx: {
+                width: "fit-content !important"
+              },
+              children: getLabel("lblAdd").text
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+
+const ApiaPoolsModal = (props) => {
+  const [actualColumns, setColumns] = useState(
+    poolsModal.columns.map((current) => ({
+      ...current,
+      currentSorting: getIndex(
+        ["A", "D", null],
+        [
+          ["A", "Up"].includes(current.currentSorting || ""),
+          ["D", "Down"].includes(current.currentSorting || ""),
+          true
+        ]
+      )
+    }))
+  );
+  const [filters, setFilters] = useState(poolsModal.filters);
+  const [state, setState] = useState(null);
+  const { fetcher } = useFetcher();
+  const filter = useCallback(
+    (newFilters = filters) => {
+      if (newFilters) {
+        fetcher.filter({
+          filters: newFilters,
+          parameters: {
+            txtName: props.initialProps.name,
+            txtTitle: props.initialProps.title,
+            txtDesc: props.initialProps.title,
+            selectOnlyOne: false,
+            showAutogenerated: false,
+            showNotAutogenerated: false,
+            showCurrentEnv: false,
+            showGlobal: false,
+            fromEnvs: "",
+            exactMatch: "",
+            showOnlyPoolsInHierarchy: false,
+            forHierarchy: false,
+            showOnlyPoolsOutsideHierarchy: false,
+            refreshParameters: false,
+            fetchAllInHierarchy: false,
+            usrToUpdate: ""
+          },
+          path: poolsModal.path,
+          requestConfig: {}
+        }).then((result) => {
+          if (result) {
+            setState(result);
+          }
+        }).catch(console.error);
+      }
+    },
+    [fetcher, filters, props.initialProps.name, props.initialProps.title]
+  );
+  useEffect(() => {
+    filter();
+  }, []);
+  useEffect(() => {
+    ApiaPoolsModalEmitter.on("deleteFilters", filter);
+  }, [filter]);
+  const handleFilterChange = useCallback(
+    (ev) => {
+      const newFilters = filters?.map((currentFilter) => {
+        if (currentFilter.column === ev.column) {
+          return { ...ev };
+        }
+        return currentFilter;
+      });
+      setFilters(newFilters);
+      if (ev.runAutomatically)
+        filter(newFilters);
+    },
+    [filters, filter]
+  );
+  const handleSort = useCallback(
+    (ev) => {
+      fetcher.sort({
+        sort: ev.columnIndex,
+        parameters: {},
+        path: poolsModal.path,
+        requestConfig: {}
+      }).then((result) => {
+        if (result) {
+          setColumns(
+            (currentColumns) => currentColumns.map((column) => {
+              if (column.name === ev.name)
+                return {
+                  ...column,
+                  currentSorting: column.currentSorting === "Down" || column.currentSorting === "D" || !column.currentSorting ? "A" : "D"
+                };
+              return { ...column, currentSorting: null };
+            })
+          );
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleFilterPressEnter = useCallback(() => filter(), [filter]);
+  const handleFilterBlur = useCallback(() => filter(), [filter]);
+  const handlePageChange = useCallback(
+    (page) => {
+      fetcher.page({
+        page,
+        parameters: {},
+        path: poolsModal.path
+      }).then((result) => {
+        if (result) {
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleRefresh = useCallback(() => {
+    fetcher.refresh({
+      parameters: {},
+      path: poolsModal.path
+    }).then((result) => {
+      if (result) {
+        setState(result);
+      }
+    }).catch(console.error);
+  }, [fetcher]);
+  return state?.rows && /* @__PURE__ */ jsxs(
+    ResponsiveTableContext,
+    {
+      columns: actualColumns,
+      rows: state?.rows,
+      filters,
+      name: props.tableName ?? poolsModal.label,
+      variant: "layout.common.modals.table",
+      onFilterChange: handleFilterChange,
+      onSortChange: handleSort,
+      onFilterBlur: handleFilterBlur,
+      onFilterPressEnter: handleFilterPressEnter,
+      isMultiple: true,
+      children: [
+        /* @__PURE__ */ jsx(ResponsiveTable, {}),
+        /* @__PURE__ */ jsx(Box, { className: "pagination__wrapper", children: /* @__PURE__ */ jsx(
+          Pagination,
+          {
+            currentPage: state.currentPage,
+            onPageChange: handlePageChange,
+            onRefresh: handleRefresh,
+            pageCount: state.pageCount,
+            reachedMax: state.reachedMax,
+            recordsCount: state.recordsCount
+          }
+        ) })
+      ]
+    }
+  );
+};
+
+const ApiaPoolsModalEmitter = new EventEmitter();
+const ApiaApiPoolsModalField = (props) => {
+  const { name } = useFormContext();
+  const [selectedRows, setSelectedRows] = useState(
+    props.element.value.split("#").filter((env) => env !== "").map((envData) => {
+      const id2 = envData.split("_$_")[0];
+      const title = envData.split("_$_")[1];
+      return {
+        id: id2,
+        title
+      };
+    })
+  );
+  const {
+    isLoading: isFiltersModalLoading,
+    show: showFiltersModal,
+    ...filtersModalProps
+  } = useModal();
+  const id = useId();
+  const deleteFilters = useCallback(() => {
+    const newFilters = poolsModal.filters?.map(
+      (currentFilter) => {
+        return {
+          ...currentFilter,
+          currentValue: "",
+          deleteFiltersTimestamp: Date.now()
+        };
+      }
+    );
+    ApiaPoolsModalEmitter.emit("deleteFilters", newFilters);
+  }, []);
+  useEffect(() => {
+    validationsStore.setFieldValue(
+      name,
+      props.element.name,
+      selectedRows.map((e) => e.id).join("#")
+    );
+  }, [name, props.element.name, selectedRows]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Label, { children: getLabel(props.element.text).text }),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: spacing(3)
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            Box,
+            {
+              sx: {
+                maxHeight: "200px",
+                overflow: "auto",
+                width: "100%",
+                display: "flex",
+                flexWrap: "wrap"
+              },
+              children: selectedRows.map((row) => {
+                return /* @__PURE__ */ jsx(
+                  LabelBox,
+                  {
+                    label: row.title,
+                    onClose: () => {
+                      setSelectedRows((prev) => {
+                        return prev.filter((prevRow) => {
+                          return prevRow.id !== row.id;
+                        });
+                      });
+                    }
+                  },
+                  row.id
+                );
+              })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            SimpleButton,
+            {
+              onClick: () => {
+                ApiaUtil.instance.modals.open({
+                  onConfirm: () => {
+                    const rows = responsiveTableStore.getState().responsiveTableSlice[id].rows;
+                    const selectedIndex = responsiveTableStore.getState().responsiveTableSlice[id].selectedRows;
+                    const selectedRows2 = [];
+                    selectedIndex.forEach((i) => {
+                      if (rows[i]) {
+                        selectedRows2.push({
+                          id: rows[i].id,
+                          title: rows[i].cells[0].children
+                        });
+                      }
+                    });
+                    setSelectedRows((prev) => [
+                      ...prev,
+                      ...selectedRows2.filter((newEnv) => {
+                        return !prev.find((prevEnv) => prevEnv.id === newEnv.id);
+                      })
+                    ]);
+                  },
+                  confirmProps: { confirmButtonText: getLabel("btnCon").text },
+                  children: /* @__PURE__ */ jsx(
+                    ApiaPoolsModal,
+                    {
+                      ...filtersModalProps,
+                      initialProps: props.element,
+                      tableName: id
+                    }
+                  ),
+                  size: "xxl",
+                  title: poolsModal.label,
+                  NavBar: /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        title: window.FILTERS_LABEL,
+                        onClick: () => {
+                          ApiaUtil.instance.modals.open({
+                            children: /* @__PURE__ */ jsx(FiltersModal, { tableName: id }),
+                            variant: "layout.common.modals.tableModal.additionalFiltersModal",
+                            size: "xl",
+                            noHeader: true,
+                            initialFocusGetter(modalInnerRef) {
+                              return modalInnerRef.querySelector(
+                                "select"
+                              );
+                            }
+                          });
+                        },
+                        isLoading: isFiltersModalLoading,
+                        children: window.FILTERS_LABEL
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        onClick: deleteFilters,
+                        title: window.BTN_DELETE_FILTERS,
+                        children: window.BTN_DELETE_FILTERS
+                      }
+                    )
+                  ] })
+                });
+              },
+              sx: {
+                width: "fit-content !important"
+              },
+              children: getLabel("lblAdd").text
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+
+const ApiaUsersModal = (props) => {
+  const [actualColumns, setColumns] = useState(
+    usersModal.columns.map((current) => ({
+      ...current,
+      currentSorting: getIndex(
+        ["A", "D", null],
+        [
+          ["A", "Up"].includes(current.currentSorting || ""),
+          ["D", "Down"].includes(current.currentSorting || ""),
+          true
+        ]
+      )
+    }))
+  );
+  const [filters, setFilters] = useState(usersModal.filters);
+  const [state, setState] = useState(null);
+  const { fetcher } = useFetcher();
+  const filter = useCallback(
+    (newFilters = filters) => {
+      if (newFilters) {
+        fetcher.filter({
+          filters: newFilters,
+          parameters: {
+            txtName: props.initialProps.name,
+            txtLogin: props.initialProps.title,
+            txtDesc: props.initialProps.title,
+            externalUser: false,
+            selectOnlyOne: false,
+            globalAndEnv: true,
+            hierarchy: false,
+            forOrgUnit: false,
+            forCurrentEnv: false
+          },
+          path: usersModal.path,
+          requestConfig: {}
+        }).then((result) => {
+          if (result) {
+            setState(result);
+          }
+        }).catch(console.error);
+      }
+    },
+    [fetcher, filters, props.initialProps.name, props.initialProps.title]
+  );
+  useEffect(() => {
+    filter();
+  }, []);
+  useEffect(() => {
+    ApiaUsersModalEmitter.on("deleteFilters", filter);
+  }, [filter]);
+  const handleFilterChange = useCallback(
+    (ev) => {
+      const newFilters = filters?.map((currentFilter) => {
+        if (currentFilter.column === ev.column) {
+          return { ...ev };
+        }
+        return currentFilter;
+      });
+      setFilters(newFilters);
+      if (ev.runAutomatically)
+        filter(newFilters);
+    },
+    [filters, filter]
+  );
+  const handleSort = useCallback(
+    (ev) => {
+      fetcher.sort({
+        sort: ev.columnIndex,
+        parameters: {},
+        path: usersModal.path,
+        requestConfig: {}
+      }).then((result) => {
+        if (result) {
+          setColumns(
+            (currentColumns) => currentColumns.map((column) => {
+              if (column.name === ev.name)
+                return {
+                  ...column,
+                  currentSorting: column.currentSorting === "Down" || column.currentSorting === "D" || !column.currentSorting ? "A" : "D"
+                };
+              return { ...column, currentSorting: null };
+            })
+          );
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleFilterPressEnter = useCallback(() => filter(), [filter]);
+  const handleFilterBlur = useCallback(() => filter(), [filter]);
+  const handlePageChange = useCallback(
+    (page) => {
+      fetcher.page({
+        page,
+        parameters: {},
+        path: usersModal.path
+      }).then((result) => {
+        if (result) {
+          setState(result);
+        }
+      }).catch(console.error);
+    },
+    [fetcher]
+  );
+  const handleRefresh = useCallback(() => {
+    fetcher.refresh({
+      parameters: {},
+      path: usersModal.path
+    }).then((result) => {
+      if (result) {
+        setState(result);
+      }
+    }).catch(console.error);
+  }, [fetcher]);
+  return state?.rows && /* @__PURE__ */ jsxs(
+    ResponsiveTableContext,
+    {
+      columns: actualColumns,
+      rows: state?.rows,
+      filters,
+      name: props.tableName ?? usersModal.label,
+      variant: "layout.common.modals.table",
+      onFilterChange: handleFilterChange,
+      onSortChange: handleSort,
+      onFilterBlur: handleFilterBlur,
+      onFilterPressEnter: handleFilterPressEnter,
+      isMultiple: true,
+      children: [
+        /* @__PURE__ */ jsx(ResponsiveTable, {}),
+        /* @__PURE__ */ jsx(Box, { className: "pagination__wrapper", children: /* @__PURE__ */ jsx(
+          Pagination,
+          {
+            currentPage: state.currentPage,
+            onPageChange: handlePageChange,
+            onRefresh: handleRefresh,
+            pageCount: state.pageCount,
+            reachedMax: state.reachedMax,
+            recordsCount: state.recordsCount
+          }
+        ) })
+      ]
+    }
+  );
+};
+
+const ApiaUsersModalEmitter = new EventEmitter();
+const ApiaApiUsersModalField = (props) => {
+  const { name } = useFormContext();
+  const [selectedRows, setSelectedRows] = useState(
+    props.element.value.split("#").filter((env) => env !== "").map((envData) => {
+      const id2 = envData;
+      return {
+        id: id2
+      };
+    })
+  );
+  const {
+    isLoading: isFiltersModalLoading,
+    show: showFiltersModal,
+    ...filtersModalProps
+  } = useModal();
+  const id = useId();
+  const deleteFilters = useCallback(() => {
+    const newFilters = usersModal.filters?.map(
+      (currentFilter) => {
+        return {
+          ...currentFilter,
+          currentValue: "",
+          deleteFiltersTimestamp: Date.now()
+        };
+      }
+    );
+    ApiaUsersModalEmitter.emit("deleteFilters", newFilters);
+  }, []);
+  useEffect(() => {
+    validationsStore.setFieldValue(
+      name,
+      props.element.name,
+      selectedRows.map((e) => e.id).join("#")
+    );
+  }, [name, props.element.name, selectedRows]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Label, { children: getLabel(props.element.text).text }),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          gap: spacing(3)
+        },
+        children: [
+          /* @__PURE__ */ jsx(
+            Box,
+            {
+              sx: {
+                maxHeight: "200px",
+                overflow: "auto",
+                width: "100%",
+                display: "flex",
+                flexWrap: "wrap"
+              },
+              children: selectedRows.map((row) => {
+                return /* @__PURE__ */ jsx(
+                  LabelBox,
+                  {
+                    label: row.id,
+                    onClose: () => {
+                      setSelectedRows((prev) => {
+                        return prev.filter((prevRow) => {
+                          return prevRow.id !== row.id;
+                        });
+                      });
+                    }
+                  },
+                  row.id
+                );
+              })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            SimpleButton,
+            {
+              onClick: () => {
+                ApiaUtil.instance.modals.open({
+                  onConfirm: () => {
+                    const rows = responsiveTableStore.getState().responsiveTableSlice[id].rows;
+                    const selectedIndex = responsiveTableStore.getState().responsiveTableSlice[id].selectedRows;
+                    const selectedRows2 = [];
+                    selectedIndex.forEach((i) => {
+                      if (rows[i]) {
+                        selectedRows2.push({
+                          id: rows[i].id
+                        });
+                      }
+                    });
+                    setSelectedRows((prev) => [
+                      ...prev,
+                      ...selectedRows2.filter((newEnv) => {
+                        return !prev.find((prevEnv) => prevEnv.id === newEnv.id);
+                      })
+                    ]);
+                  },
+                  // TODO LABEL
+                  confirmProps: { confirmButtonText: getLabel("btnCon").text },
+                  children: /* @__PURE__ */ jsx(
+                    ApiaUsersModal,
+                    {
+                      ...filtersModalProps,
+                      initialProps: props.element,
+                      tableName: id
+                    }
+                  ),
+                  size: "xxl",
+                  title: usersModal.label,
+                  NavBar: /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        title: window.FILTERS_LABEL,
+                        onClick: () => {
+                          ApiaUtil.instance.modals.open({
+                            children: /* @__PURE__ */ jsx(FiltersModal, { tableName: id }),
+                            variant: "layout.common.modals.tableModal.additionalFiltersModal",
+                            size: "xl",
+                            noHeader: true,
+                            initialFocusGetter(modalInnerRef) {
+                              return modalInnerRef.querySelector(
+                                "select"
+                              );
+                            }
+                          });
+                        },
+                        isLoading: isFiltersModalLoading,
+                        children: window.FILTERS_LABEL
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      SimpleButton,
+                      {
+                        variant: "outline-sm",
+                        onClick: deleteFilters,
+                        title: window.BTN_DELETE_FILTERS,
+                        children: window.BTN_DELETE_FILTERS
+                      }
+                    )
+                  ] })
+                });
+              },
+              sx: {
+                width: "fit-content !important"
+              },
+              children: getLabel("lblAdd").text
+            }
+          )
+        ]
+      }
+    )
+  ] });
+};
+
+const parseApiaApiSections = (elements) => {
+  const removeEndingSpacers = (sectionElements) => {
+    if (sectionElements.length > 1) {
+      for (let i = sectionElements.length - 1; i >= 0; i--) {
+        if (sectionElements[i].type === "empty") {
+          sectionElements.pop();
+        } else {
+          return sectionElements;
+        }
+      }
+    }
+    return sectionElements;
+  };
+  const sectionIndexes = [];
+  if (elements[0]?.type !== "2columnTitle") {
+    sectionIndexes.push(-1);
+  }
+  elements.forEach((element, index) => {
+    if (element.type === "2columnTitle") {
+      sectionIndexes.push(index);
+    }
+  });
+  const sections = [];
+  sectionIndexes.forEach((sectionIndex, arrayIndex) => {
+    const start = sectionIndex + 1 < elements.length ? sectionIndex + 1 : elements.length - 1;
+    const end = arrayIndex + 1 < sectionIndexes.length ? sectionIndexes[arrayIndex + 1] : void 0;
+    sections.push({
+      sectionId: `ApiaApiSection_${arrayIndex}`,
+      sectionHeader: sectionIndex !== -1 ? {
+        ...elements[sectionIndex],
+        sectionElementId: `sectionHeader_${arrayIndex}`
+      } : void 0,
+      sectionElements: removeEndingSpacers(elements.slice(start, end)).map(
+        (currentElement) => ({
+          ...currentElement,
+          sectionElementId: `sectionElement_${currentElement.id || currentElement.name || uniqueId()}`
+        })
+      )
+    });
+  });
+  return sections;
+};
+const NonMemoizedApiaApiFieldsContainer = (props) => {
+  const elements = React__default.useMemo(
+    () => arrayOrArray(props?.definition?.form.elements?.element ?? []),
+    [props?.definition?.form.elements?.element]
+  );
+  const sections = React__default.useMemo(
+    () => parseApiaApiSections(elements),
+    [elements]
+  );
+  const renderSectionContent = React__default.useCallback(
+    (sectionId, sectionElements) => {
+      const isVisible = sectionElements.findIndex((element) => element.type !== "hidden") !== -1;
+      return /* @__PURE__ */ jsx(
+        Box,
+        {
+          className: isVisible ? "handler__form__elements__section__content" : `handler__form__elements__section__content handler__hidden`,
+          children: sectionElements.map((current) => {
+            const element = {
+              ...current,
+              onChange() {
+                getFunction(current.onChange, props).then((onChangeMethod) => {
+                  if (onChangeMethod) {
+                    onChangeMethod();
+                  }
+                }).catch(console.error);
+              }
+            };
+            switch (element.type) {
+              case "table": {
+                const data = JSON.parse(element.text);
+                return /* @__PURE__ */ jsx(
+                  Box,
+                  {
+                    ...getVariant("layout.common.tables.information"),
+                    children: /* @__PURE__ */ jsxs("table", { sx: { width: "100%" }, children: [
+                      /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: data.columns.map((column) => {
+                        return /* @__PURE__ */ jsx("th", { children: column }, column);
+                      }) }) }),
+                      /* @__PURE__ */ jsx("tbody", { children: data.rows.map((row) => {
+                        return /* @__PURE__ */ jsx("tr", { children: row.cells.map((cell, i) => {
+                          return /* @__PURE__ */ jsx("td", { children: cell }, `${cell}_${data.columns[i]}`);
+                        }) }, row.cells.join("-"));
+                      }) })
+                    ] })
+                  },
+                  element.sectionElementId
+                );
+              }
+              case "2columnSubTitle":
+                return /* @__PURE__ */ jsx(
+                  Box,
+                  {
+                    className: element.class,
+                    as: "h6",
+                    children: element.value || element.text
+                  },
+                  element.sectionElementId
+                );
+              case "2column":
+                return /* @__PURE__ */ jsx(
+                  Box,
+                  {
+                    dangerouslySetInnerHTML: {
+                      __html: element.value || element.text
+                    },
+                    className: element.class
+                  },
+                  element.sectionElementId
+                );
+              case "checkbox":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiCheckbox,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "file":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiFileInput,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "hidden":
+              case "password":
+              case "text":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiInput,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "select":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiSelect,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "radio":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiRadio,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "textarea":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiTextArea,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "empty":
+                return /* @__PURE__ */ jsx(Box, { className: "spacer" }, element.sectionElementId);
+              case "envsModal":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiEnvironmentsModalField,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "tsksModal":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiTasksModalField,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "procModal":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiProcessesModalField,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "poolModal":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiPoolsModalField,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              case "userModal":
+                return /* @__PURE__ */ jsx(
+                  ApiaApiUsersModalField,
+                  {
+                    ...props,
+                    element
+                  },
+                  element.sectionElementId
+                );
+              default:
+                console.warn(
+                  `Unhandled element type: ${element.type}`,
+                  element
+                );
+                return null;
+            }
+          })
+        },
+        sectionId
+      );
+    },
+    [props]
+  );
+  return /* @__PURE__ */ jsx(Box, { className: "handler__form__elements", children: sections.map((section) => {
+    if (section.sectionHeader) {
+      return renderSectionContent(
+        section.sectionId,
+        section.sectionElements
+      );
+    }
+    return renderSectionContent(section.sectionId, section.sectionElements);
+  }) });
+};
+const ApiaApiFieldsContainer = React__default.memo(
+  NonMemoizedApiaApiFieldsContainer
+);
+ApiaApiFieldsContainer.displayName = "ApiaApiFieldsContainer";
+
+const parseButtons = (buttons) => {
+  return buttons.map((currentButton) => ({
+    ...currentButton,
+    buttonKey: uniqueId(),
+    type: ["submitAjax", "submit"].includes(currentButton.type) ? "submit" : "button"
+  }));
+};
+const NonMemoizedApiaApiButtonsContainer = (props) => {
+  const buttonElements = React__default.useMemo(
+    () => arrayOrArray(props.definition?.form.buttons?.button ?? []),
+    [props.definition?.form.buttons?.button]
+  );
+  const buttons = React__default.useMemo(
+    () => parseButtons(buttonElements),
+    [buttonElements]
+  );
+  const modalConfiguration = React__default.useMemo(
+    () => props.configuration?.modalConfiguration,
+    [props.configuration?.modalConfiguration]
+  );
+  const methodsPath = React__default.useMemo(
+    () => props.configuration?.methodsPath,
+    [props.configuration?.methodsPath]
+  );
+  const { name: apiaApiForm } = useFormContext();
+  const renderButton = React__default.useCallback(
+    (currentButton) => {
+      const key = currentButton.buttonKey;
+      const className = `handler__${currentButton.type ?? ""}`;
+      const onClick = () => {
+        void async function submitForm() {
+          const validationResult = await validationsStore.validateForm(apiaApiForm);
+          if (!hasSucceedFormValidation(validationResult)) {
+            return;
+          }
+          const { submitValues } = validationResult;
+          function runButtonMethod() {
+            void (async () => {
+              if (currentButton.onclick) {
+                const actions = currentButton.onclick.split(";");
+                for await (const action of actions) {
+                  const method = await getFunction(action, {
+                    ...props
+                  });
+                  if (method) {
+                    method({
+                      currentUrl: props.definition?.form.action ?? "noUrl"
+                    });
+                  } else {
+                    throw new Error(
+                      `The requested action is not defined: "${props.definition?.form.action ?? ""}"`
+                    );
+                  }
+                }
+              }
+            })();
+          }
+          if (props?.definition && currentButton.type === "submit") {
+            const formData = new FormData();
+            Object.entries(submitValues).forEach(([name, value]) => {
+              formData.append(name, value ?? "");
+            });
+            const hasContext = props?.definition.form.action.match(
+              new RegExp(`^${window.CONTEXT}/`)
+            );
+            const url = `${hasContext ? "" : window.CONTEXT}${!props?.definition.form.action.startsWith("/") ? "/" : ""}${props?.definition.form.action}`;
+            props.setState((current) => ({
+              ...current,
+              isLoading: true
+            }));
+            void ApiaApi$1.post(url, {
+              postData: props.state.isMultipart ? formData : QueryString.stringify(
+                [...formData.entries(), ["isAjax", true]].reduce((accumulated, [name, value]) => {
+                  const retValue = { ...accumulated };
+                  retValue[name.toString()] = value.toString();
+                  return retValue;
+                }, {})
+              ),
+              handleLoad: true,
+              notificationsCategory: "apiaApiHandler",
+              modalConfiguration,
+              methodsPath
+            }).finally(() => {
+              runButtonMethod();
+              if (props?.definition?.form.closeOnSubmit) {
+                props.close();
+              }
+            });
+          } else {
+            runButtonMethod();
+          }
+        }();
+      };
+      return /* @__PURE__ */ jsx(
+        SimpleButton,
+        {
+          className,
+          disabled: props.state.disabled,
+          id: currentButton.id || currentButton.text,
+          isLoading: props.state.isLoading,
+          title: currentButton.text,
+          type: currentButton.type,
+          onClick,
+          children: currentButton.text
+        },
+        key
+      );
+    },
+    [apiaApiForm, methodsPath, modalConfiguration, props]
+  );
+  return buttons.length > 0 && /* @__PURE__ */ jsx(Box, { className: "handler__form__buttons", children: buttons.map((currentButton) => renderButton(currentButton)) });
+};
+const ApiaApiButtonsContainer = React__default.memo(
+  NonMemoizedApiaApiButtonsContainer
+);
+
+const ApiaApiMessenger = new class extends EventEmitter {
+}();
+const FunctionsDispatcher = new class extends EventEmitter {
+}();
+const apiaApiForm = "ApiaApiForm";
+const methods = {};
+async function getFunction(name, handler) {
+  return new Promise((resolve) => {
+    try {
+      const separateNameFromParametersRegex = /^\/?([\w\d_-]+)\/?(?:\(([^)]*)\))?$/;
+      const match = name.match(separateNameFromParametersRegex);
+      if (match) {
+        const functionName = match[1];
+        const parameters = match[2];
+        const path = [
+          ...handler.configuration?.methodsPath?.split("/").filter((current) => !!current) ?? [],
+          functionName
+        ].join("/");
+        const storeMethodAndResolve = (result) => {
+          if (typeof result.default.default !== "function")
+            notFound();
+          const method = result.default.default;
+          methods[functionName] = (props) => {
+            return method(handler, {
+              ...props,
+              inlineArguments: parameters?.split(",").map((argument) => {
+                if (argument.startsWith("'") || argument.startsWith('"'))
+                  return argument.slice(1, argument.length - 1);
+                return argument;
+              }) ?? []
+            });
+          };
+          resolve(methods[functionName]);
+        };
+        const notFound = () => {
+          throw new Error(
+            `${functionName}.ts not found at ${path}.ts nor ./${functionName}.ts`
+          );
+        };
+        import(
+          /* webpackChunkName: "api-methods-[request]" */
+          `/api/methods/${path}.ts`
+        ).then(storeMethodAndResolve).catch(() => {
+          if (handler.configuration?.methodsPath !== void 0)
+            import(
+              /* webpackChunkName: "api-methods-[request]" */
+              `/api/methods/${functionName}.ts`
+            ).then(storeMethodAndResolve).catch(notFound);
+          else {
+            notFound();
+          }
+        });
+      }
+    } catch (e) {
+      console.error(e);
+      handler.reset();
+      handler.setError({
+        type: "danger",
+        message: "Error while loading current method."
+      });
+    }
+  });
+}
+function isForm(responseObject) {
+  return responseObject.form !== void 0 && typeof responseObject.form === "object" && !!responseObject.form;
+}
+function isFunction(responseObject) {
+  return typeof responseObject.canClose === "boolean" && typeof responseObject.type === "string" && !!responseObject.function;
+}
+function isMessage(responseObject) {
+  if (typeof responseObject.canClose === "boolean" && typeof responseObject.type === "string" && typeof responseObject.text === "object" && responseObject.text && typeof responseObject.text.label === "string") {
+    return true;
+  }
+  return false;
+}
+const modalConfigurationHandler = new StatefulEmitter();
+function useModalConfiguration() {
+  const value = modalConfigurationHandler.useState("value");
+  const latestValue = useLatest(value);
+  return latestValue;
+}
+const currentFormDispatcher = new class currentFormDispatcher2 extends EventEmitter {
+  emit(eventName, params) {
+    super.emit(eventName, params);
+  }
+}();
+function handle(responseObject, currentUrl, configuration) {
+  modalConfigurationHandler.setState("value", configuration);
+  if (isForm(responseObject)) {
+    currentFormDispatcher.emit("form", responseObject);
+    return true;
+  }
+  if (isFunction(responseObject)) {
+    FunctionsDispatcher.emit("method", {
+      name: responseObject.function.name,
+      props: {
+        messages: responseObject.function.messages,
+        attributes: responseObject.function,
+        currentUrl
+      }
+    });
+    return true;
+  }
+  if (isMessage(responseObject)) {
+    ApiaApiMessenger.emit("message", {
+      predicate: responseObject.text.content,
+      title: responseObject.text.title
+    });
+    return true;
+  }
+  return false;
+}
+const initialState = {
+  disabled: false,
+  isLoading: false,
+  isMultipart: false,
+  progress: 0,
+  errors: {}
+};
+const ApiaApiHandlerNonMemoized = () => {
+  const configuration = useModalConfiguration();
+  const [state, setState] = React.useState({
+    ...initialState,
+    windowIndex: -1
+  });
+  const [currentForm2, setCurrentForm] = React.useState(
+    void 0
+  );
+  React.useEffect(() => {
+    return currentFormDispatcher.on("form", setCurrentForm);
+  }, []);
+  const setValue = React.useCallback((name, value) => {
+    return validationsStore.setFieldValue(apiaApiForm, name, value);
+  }, []);
+  React.useEffect(() => {
+    if (!currentForm2)
+      return;
+    const elements = arrayOrArray(currentForm2?.form?.elements?.element ?? []);
+    let isMultipart = false;
+    const elementsValues = Object.values(elements);
+    let i = 0;
+    while (i < elementsValues.length && !isMultipart) {
+      if (elementsValues[i++].type === "file") {
+        isMultipart = true;
+      }
+    }
+    setState((currentState) => {
+      return {
+        ...currentState,
+        ...initialState,
+        isMultipart
+      };
+    });
+  }, [currentForm2]);
+  const { show, onClose, ...modalHookProps } = useModal();
+  const close = React.useCallback(() => {
+    onClose();
+    currentFormDispatcher.emit("form", void 0);
+    setState((currentState) => {
+      return { ...currentState, ...initialState };
+    });
+    configuration.current?.modalConfiguration?.onClose?.();
+    validationsStore.unregisterForm(apiaApiForm);
+  }, [onClose, configuration]);
+  const modalRef = React.useRef(null);
+  React.useEffect(() => {
+    const elements = modalRef.current?.querySelectorAll(
+      "a,input,textarea,button"
+    );
+    if (elements?.length === 1)
+      void focus.on([...elements][0]);
+  });
+  const setError = React.useCallback(
+    (notification) => {
+      notify({ ...notification });
+    },
+    []
+  );
+  const initialFocusGetter = React.useCallback((ref) => {
+    return ref?.querySelector(focusSelector);
+  }, []);
+  const defaultModalProps = React.useMemo(
+    () => ({
+      onClose: close,
+      id: apiaApiForm,
+      title: configuration.current?.modalConfiguration?.modalTitle ?? currentForm2?.form.title,
+      size: "md-fixed",
+      shouldCloseOnEsc: !state.disabled,
+      shouldCloseOnOverlayClick: !state.disabled,
+      initialFocusGetter
+    }),
+    [
+      close,
+      configuration,
+      currentForm2?.form.title,
+      initialFocusGetter,
+      state.disabled
+    ]
+  );
+  const getModalProps = React.useCallback(
+    (innerHandler) => {
+      if (innerHandler.setModalProps) {
+        const overrideProps = innerHandler.setModalProps?.(
+          {
+            methodsPath: innerHandler.configuration?.methodsPath,
+            modalConfiguration: innerHandler.configuration?.modalConfiguration
+          },
+          innerHandler.formDefinition
+        );
+        if (overrideProps) {
+          const currentOnClose = () => {
+            overrideProps?.onClose?.();
+            defaultModalProps.onClose?.();
+          };
+          const currentOnExited = () => {
+            overrideProps?.onExited?.();
+            modalHookProps?.onExited?.();
+          };
+          return {
+            ...defaultModalProps,
+            ...overrideProps,
+            ...modalHookProps,
+            onClose: currentOnClose,
+            onExited: currentOnExited
+          };
+        }
+      }
+      return { ...defaultModalProps, ...modalHookProps };
+    },
+    [defaultModalProps, modalHookProps]
+  );
+  const getHandler = React.useCallback(() => {
+    const newHandler = {
+      alert,
+      close,
+      configuration: configuration.current,
+      formDefinition: currentForm2,
+      reset: () => {
+        return setState((currentState) => {
+          return {
+            ...currentState,
+            ...initialState
+          };
+        });
+      },
+      setError,
+      setMessage: (message) => {
+        if (configuration.current?.modalConfiguration?.onMessage)
+          configuration.current.modalConfiguration.onMessage(message);
+      },
+      setState,
+      state,
+      setValue
+    };
+    return newHandler;
+  }, [close, configuration, currentForm2, setError, state, setValue]);
+  const handler = getHandler();
+  const modalProps = getModalProps(handler);
+  const handleAction = React.useCallback(
+    async (action) => {
+      const innerHandler = getHandler();
+      if (action.toDo === "ajaxHiddeAll") {
+        close();
+      }
+      if (action.toDo === "functionTimedCall") {
+        const method = await getFunction(
+          arrayOrArray(action.param)[1],
+          innerHandler
+        );
+        if (method) {
+          setTimeout(
+            () => method({
+              currentUrl: innerHandler.formDefinition?.form.action ?? "noUrl"
+            }),
+            Number(action.param[0])
+          );
+        }
+      }
+    },
+    [close, getHandler]
+  );
+  const handleFunction = React.useCallback(
+    async ({ name, props: { messages, attributes, currentUrl } }) => {
+      const innerHandler = getHandler();
+      const method = await getFunction(`${name}`, innerHandler);
+      if (method) {
+        method({ messages, attributes, currentUrl });
+      }
+    },
+    [getHandler]
+  );
+  const handleMessage = React.useCallback(
+    (ev) => {
+      const innerHandler = getHandler();
+      notify({
+        message: ev.predicate,
+        type: "warning",
+        onClose: innerHandler.configuration?.modalConfiguration?.onMessageClose
+      });
+      const onMessage = innerHandler.configuration?.modalConfiguration?.onMessage;
+      if (onMessage) {
+        onMessage(ev);
+      }
+    },
+    [getHandler]
+  );
+  React.useEffect(() => {
+    const u1 = ApiaApiMessenger.on("message", handleMessage);
+    const u2 = FunctionsDispatcher.on("method", handleFunction);
+    const u3 = ApiaActions.on("action", handleAction);
+    return () => {
+      u1();
+      u2();
+      u3();
+    };
+  }, [handleAction, handleFunction, handleMessage, state.windowIndex]);
+  React.useEffect(() => {
+    if (currentForm2) {
+      show();
+    }
+  }, [currentForm2]);
+  const formRef = React.useCallback(
+    async (el) => {
+      if (el && currentForm2?.form.onLoad) {
+        const method = await getFunction(
+          `${currentForm2?.form.onLoad}`,
+          getHandler()
+        );
+        if (method) {
+          method();
+        }
+      }
+    },
+    [currentForm2?.form.onLoad, getHandler]
+  );
+  return /* @__PURE__ */ jsx(ApiaApiContext$1, { id: apiaApiForm, children: /* @__PURE__ */ jsx(Modal, { ...modalProps, ref: modalRef, children: currentForm2 && /* @__PURE__ */ jsx(Box, { ...getVariant("layout.common.modals.apiaApi"), children: /* @__PURE__ */ jsxs(
+    Form,
+    {
+      name: apiaApiForm,
+      unregisterOnUnmount: true,
+      avoidFieldsOverride: true,
+      className: "handler__form",
+      children: [
+        /* @__PURE__ */ jsx(ApiaApiFieldsContainer, { definition: currentForm2, ...handler }),
+        state.isMultipart && state.progress > 0 && /* @__PURE__ */ jsx(Box, { className: "progressBox", children: /* @__PURE__ */ jsx(
+          ProgressBar,
+          {
+            id: "ApiaApiHandler progress",
+            progress: state.progress,
+            loading: true
+          }
+        ) }),
+        /* @__PURE__ */ jsx(ApiaApiButtonsContainer, { definition: currentForm2, ...handler }),
+        /* @__PURE__ */ jsx(Box, { ref: formRef, sx: { display: "none" } })
+      ]
+    }
+  ) }) }) });
+};
+const ApiaApiHandler = React.memo(ApiaApiHandlerNonMemoized);
+
+export { ApiaApi$1 as ApiaApi, ApiaApiHandler, getFunction, getModal, makeApiaUrl };
 //# sourceMappingURL=index.js.map