@apia/api 4.0.25 → 4.0.27

package/dist/index.js

@@ -1,21 +1,21 @@
 import { jsx, jsxs, Fragment } from '@apia/theme/jsx-runtime';
 import * as React from 'react';
-import React__default, { createContext, useState, useCallback, useEffect, useId, memo } from 'react';
+import React__default, { createContext, useState, useCallback, useEffect, useId, useRef, useMemo } from 'react';
 import { Box, Label, spacing, getVariant, Input as Input$1, Select as Select$1 } from '@apia/theme';
-import { debugDispatcher, parseXmlAsync, EventEmitter, arrayOrArray, useMount, encrypt, noNaN, getIndex, getLabel, StatefulEmitter, focus, focusSelector, useLatest } from '@apia/util';
+import { debugDispatcher, parseXmlAsync, EventEmitter, arrayOrArray, useMount, encrypt, noNaN, getIndex, getLabel, StatefulEmitter, focus, focusSelector, useLatest, useIntermediateValue, formatMessage, getDateFormat, Mutex, uniqueId as uniqueId$1 } 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 { Accordion, AccordionItem, useModal, LabelBox, SimpleButton, ApiaUtil, Modal, ProgressBar, DateInput } from '@apia/components';
+import axios, { AxiosError } 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, useResponsiveTableContext, getResponsiveTableContext, TableLoadingContext, makeController2, responsiveTableActions, TableContextReproducer } from '@apia/table';
-import { makeObservable, observable, reaction, toJS, action } from 'mobx';
+import { ResponsiveTableContext, ResponsiveTable, Pagination, Sort, Responsive, Additional, responsiveTableStore, useResponsiveTableContext, getResponsiveTableContext, TableLoadingContext, defaultLabels, makeController2, responsiveTableActions, TableContextReproducer, Grouped } from '@apia/table';
+import { makeObservable, observable, reaction, toJS, action, computed } from 'mobx';
 import { observer } from 'mobx-react-lite';
-import { throttle } from 'lodash-es';
-import { Icon } from '@apia/icons';
+import dayjs from 'dayjs';
+import { Icon, FileIcon } from '@apia/icons';
 
 const ApiaApiId = createContext("apiaApi");
 const ApiaApiContext = ({
@@ -79,6 +79,10 @@ function getColor(color, colors = defaultConfig.colors ?? {
   return colors[color];
 }
 const handleWrongResponse = (error) => {
+  if (error instanceof AxiosError && (error.status === 403 || error.response?.status === 403)) {
+    session.invalidate();
+    return;
+  }
   let errorMessage;
   if (typeof error !== "string") {
     if (error.message)
@@ -379,7 +383,7 @@ async function post(par1, par2) {
     );
   }
   const response = await axios.post(parsedUrl, behaveConfig.postData, behaveConfig.axiosConfig).catch((e) => {
-    handleWrongResponse(new Error(e));
+    handleWrongResponse(e instanceof AxiosError ? e : new Error(e));
   });
   if (response) {
     const result = handleResponse(response, actualUrl, behaveConfig);
@@ -406,7 +410,7 @@ async function get(par1, par2) {
       }
     );
   const response = await axios.get(parsedUrl, behaveConfig.axiosConfig).catch((e) => {
-    handleWrongResponse(new Error(e));
+    handleWrongResponse(e instanceof AxiosError ? e : new Error(e));
   });
   if (response) {
     const result = await handleResponse(
@@ -3226,60 +3230,113 @@ const ApiaApiHandler = React.memo(ApiaApiHandlerNonMemoized);
 const units = ["B", "KB", "MB", "GB"];
 const RangeFilterRenderer = observer(
   ({ filter, state }) => {
-    const { onFilterBlur, onFilterPressEnter, onFilterChange } = useResponsiveTableContext();
-    return /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", gap: 2, alignItems: "center" }, children: [
-      /* @__PURE__ */ jsx(
-        Input$1,
-        {
-          id: "range-filter-from",
-          value: state.value,
-          onChange: (ev) => {
-            state.value = ev.target.value;
-            onFilterChange?.(filter);
-          },
-          onKeyDown: (ev) => {
-            if (ev.code === "Enter") {
-              onFilterPressEnter?.(filter);
+    const multiplier = useRef(1);
+    const lastEmittedHigh = useRef(null);
+    const lastEmittedLow = useRef(null);
+    const lastEmittedMultiplier = useRef(1);
+    if (lastEmittedLow.current !== state.value) {
+      lastEmittedLow.current = state.value;
+      lastEmittedHigh.current = state.valueTo || "";
+    }
+    const emitLow = (currentValue) => {
+      const numberValue = currentValue ?? "";
+      if (lastEmittedLow.current === numberValue && lastEmittedMultiplier.current === multiplier.current) {
+        return;
+      }
+      lastEmittedLow.current = numberValue;
+      lastEmittedMultiplier.current = multiplier.current;
+      const emitValue = numberValue;
+      state.value = emitValue;
+      state.multiplier = multiplier.current;
+    };
+    const emitHigh = (currentValue) => {
+      const numberValue = currentValue ?? "";
+      if (lastEmittedHigh.current === numberValue && lastEmittedMultiplier.current === multiplier.current) {
+        return;
+      }
+      lastEmittedHigh.current = numberValue;
+      lastEmittedMultiplier.current = multiplier.current;
+      const emitValue = numberValue;
+      state.valueTo = emitValue;
+      state.multiplier = multiplier.current;
+    };
+    const [lowValue, setLowValue] = useIntermediateValue(state.value);
+    const [highValue, setHighValue] = useIntermediateValue(state.valueTo);
+    const [unit, setUnit] = useIntermediateValue(state.multiplier);
+    return /* @__PURE__ */ jsxs(
+      Box,
+      {
+        className: `ApiaFilter__Range`,
+        ...getVariant("layout.common.components.filters.rangeFilter"),
+        children: [
+          /* @__PURE__ */ jsx(Box, { className: "ApiaFilter__Range__Low", children: /* @__PURE__ */ jsx(
+            Input$1,
+            {
+              onChange: ({ target: { value: currentValue } }) => {
+                setLowValue(currentValue);
+                emitLow(currentValue);
+              },
+              onBlur: ({ target: { value: currentValue } }) => {
+                emitLow(currentValue);
+              },
+              onKeyDown: ({ code, target }) => {
+                if (code === "Enter") {
+                  emitLow(target.value);
+                }
+              },
+              value: lowValue
             }
-          },
-          onBlur: () => {
-            onFilterBlur?.(filter);
-          }
-        }
-      ),
-      "-",
-      /* @__PURE__ */ jsx(
-        Input$1,
-        {
-          tabIndex: 0,
-          id: "range-filter-to",
-          value: state.valueTo || "",
-          onChange: (e) => state.valueTo = e.target.value
-        }
-      ),
-      /* @__PURE__ */ jsx(
-        Select$1,
-        {
-          onChange: (ev) => {
-          },
-          value: units[Math.log(1) / 10],
-          children: units.map((c) => /* @__PURE__ */ jsx("option", { value: c, children: c }, c))
-        }
-      )
-    ] });
+          ) }),
+          " - ",
+          /* @__PURE__ */ jsx(Box, { className: "ApiaFilter__Range__High", children: /* @__PURE__ */ jsx(
+            Input$1,
+            {
+              onChange: ({ target: { value: currentValue } }) => {
+                setHighValue(currentValue);
+                emitHigh(currentValue);
+              },
+              onBlur: ({ target: { value: currentValue } }) => {
+                emitHigh(currentValue);
+              },
+              onKeyDown: ({ code, target }) => {
+                if (code === "Enter") {
+                  emitHigh(target.value);
+                }
+              },
+              value: highValue
+            }
+          ) }),
+          filter.isSize && /* @__PURE__ */ jsx(
+            Select$1,
+            {
+              className: "ApiaFilter__Range__UnitSelector",
+              onChange: (ev) => {
+                const unit2 = ev.target.value;
+                const index = units.indexOf(unit2);
+                if (index !== -1) {
+                  multiplier.current = 2 ** (index * 10);
+                  setUnit(multiplier.current);
+                  emitLow(lastEmittedLow.current ?? "");
+                }
+              },
+              value: units[Math.log2(unit || 1) / 10],
+              children: units.map((c) => /* @__PURE__ */ jsx("option", { value: c, children: c }, c))
+            }
+          )
+        ]
+      }
+    );
   }
 );
 
 const SelectFilterRenderer = observer(
   ({ filter, state }) => {
-    const { onFilterChange } = useResponsiveTableContext();
     return /* @__PURE__ */ jsx(
       Select$1,
       {
         value: state.value,
         onChange: (ev) => {
           state.value = ev.target.value;
-          onFilterChange?.(filter);
         },
         children: arrayOrArray(filter.options).map((c) => /* @__PURE__ */ jsx("option", { value: c.value, children: c.label }, c.value))
       }
@@ -3310,20 +3367,80 @@ const InputFilterRenderer = observer(
   }
 );
 
-var __defProp$6 = Object.defineProperty;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$6 = (obj, key, value) => {
-  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+const dateFormat = getDateFormat();
+function controlDatesOrder(first, last) {
+  if (!first || !last)
+    return true;
+  if (dayjs(last, dateFormat).isBefore(dayjs(first, dateFormat))) {
+    return false;
+  }
+  return true;
+}
+const DateFilterRenderer = observer(
+  ({ filter, state }) => {
+    const { onFilterBlur, onFilterChange } = useResponsiveTableContext();
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Box, { as: "span", children: state?.filterToId ? formatMessage(window.LBL_DATE_FILTER_FROM_TXT, {
+        TOK1: filter.title ?? ""
+      }) : state.title }),
+      /* @__PURE__ */ jsx(
+        DateInput,
+        {
+          value: state.value,
+          onChange: (date) => {
+            state.value = date;
+            onFilterChange?.(filter);
+          },
+          onBlur: () => {
+            onFilterBlur?.(filter);
+          }
+        }
+      ),
+      (state?.isAdditional || state.group) && state?.filterToId && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Box, { as: "span", children: formatMessage(window.LBL_DATE_FILTER_TO_TXT, {
+          TOK1: state.title ?? ""
+        }) }),
+        /* @__PURE__ */ jsx(
+          DateInput,
+          {
+            value: state.filterToValue,
+            onChange: (date) => {
+              const result = controlDatesOrder(state.value, date);
+              if (result) {
+                state.filterToValue = date;
+                onFilterChange?.(filter);
+              } else {
+                state.filterToValue = void 0;
+                ApiaUtil.instance.notifications.notify({
+                  message: window.MSG_FEC_FIN_MAY_FEC_INI,
+                  type: "warning"
+                });
+              }
+            },
+            onBlur: () => {
+              onFilterBlur?.(filter);
+            }
+          }
+        )
+      ] })
+    ] });
+  }
+);
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class Filter {
   constructor(properties) {
-    __publicField$6(this, "tableName");
-    __publicField$6(this, "filterState", {
+    __publicField$5(this, "tableName");
+    __publicField$5(this, "filterState", {
       runAutomatically: false,
       value: ""
     });
-    __publicField$6(this, "Component", observer(({ filter }) => {
+    __publicField$5(this, "Component", observer(({ filter }) => {
       const { name } = useResponsiveTableContext();
       this.tableName = name;
       if (this.filterState.isRange) {
@@ -3332,6 +3449,9 @@ class Filter {
       if (arrayOrArray(this.filterState.options).length > 0) {
         return this.getSelectRenderer({ filter });
       }
+      if (this.filterState.type === "D" || this.filterState.type === "date") {
+        return this.getDateRenderer({ filter });
+      }
       return this.getInputRenderer({ filter });
     }));
     Object.assign(this.filterState, properties);
@@ -3347,6 +3467,28 @@ class Filter {
         }
       }
     );
+    reaction(
+      () => this.filterState.valueTo,
+      () => {
+        if (this.tableName) {
+          getResponsiveTableContext(this.tableName).onFilterChange?.({
+            id: properties.id,
+            column: properties.column
+          });
+        }
+      }
+    );
+    reaction(
+      () => this.filterState.multiplier,
+      () => {
+        if (this.tableName) {
+          getResponsiveTableContext(this.tableName).onFilterChange?.({
+            id: properties.id,
+            column: properties.column
+          });
+        }
+      }
+    );
   }
   focus() {
   }
@@ -3359,82 +3501,8 @@ class Filter {
   getRangeRenderer({ filter }) {
     return /* @__PURE__ */ jsx(RangeFilterRenderer, { filter, state: this.filterState });
   }
-}
-
-const FilterTypesComponent = observer(
-  ({ filterTypes }) => {
-    return /* @__PURE__ */ jsx(Fragment, { children: filterTypes.conditions.map((f, idx) => {
-      const options = arrayOrArray(f.options.option);
-      return /* @__PURE__ */ jsxs(Label, { children: [
-        /* @__PURE__ */ jsxs(Box, { as: "span", children: [
-          f.text,
-          ":"
-        ] }),
-        /* @__PURE__ */ jsx(
-          Select$1,
-          {
-            title: f.title,
-            onChange: (ev) => {
-              const selectedValue = ev.target.value;
-              filterTypes.conditions[idx].value = selectedValue;
-              filterTypes.setFilterOptions();
-            },
-            disabled: f.readonly || f.disabled,
-            value: f.value,
-            children: options.map((option) => {
-              return /* @__PURE__ */ jsx("option", { value: option.value, children: option.content }, option.value);
-            })
-          }
-        )
-      ] }, f.name);
-    }) });
-  }
-);
-
-var __defProp$5 = Object.defineProperty;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$5 = (obj, key, value) => {
-  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class FilterTypes {
-  constructor() {
-    __publicField$5(this, "conditions", []);
-    __publicField$5(this, "Component", () => /* @__PURE__ */ jsx(FilterTypesComponent, { filterTypes: this }));
-    makeObservable(this, {
-      conditions: observable
-    });
-  }
-  async getFilterTypes() {
-    const result = await ApiaApi.post(
-      makeApiaUrl({
-        ajaxUrl: "apia.query.ModalAction.run?",
-        action: "filterOptions"
-      })
-    );
-    if (!result?.data?.form?.elements?.element)
-      return;
-    this.conditions = arrayOrArray(result.data.form.elements.element);
-  }
-  async initialLoad() {
-    await this.getFilterTypes();
-  }
-  async setFilterOptions() {
-    const result = await ApiaApi.post(
-      makeApiaUrl({
-        ajaxUrl: "apia.query.ModalAction.run?",
-        action: "setFilterOptions"
-      }),
-      {
-        postData: this.conditions.reduce((acc, c) => {
-          acc[c.id] = c.value;
-          return acc;
-        }, {}),
-        postDataTreatement: "stringify"
-      }
-    );
-    if (!result)
-      return;
+  getDateRenderer({ filter }) {
+    return /* @__PURE__ */ jsx(DateFilterRenderer, { filter, state: this.filterState });
   }
 }
 
@@ -3449,13 +3517,12 @@ class TableController {
   constructor(initialState) {
     __publicField$4(this, "emitter", new EventEmitter());
     __publicField$4(this, "tableName", `TableController${controllerCount++}`);
-    __publicField$4(this, "tableSelectionController");
     __publicField$4(this, "controllerComponent", () => null);
-    __publicField$4(this, "filterTypes", new FilterTypes());
     __publicField$4(this, "state", {
-      finishedLoading: false,
+      finishedFirstLoad: false,
       columns: /* @__PURE__ */ new Map(),
       filters: /* @__PURE__ */ new Map(),
+      isLoading: false,
       pagination: { currentPage: 0, totalPages: 0, totalRecords: 0 },
       props: {},
       rows: []
@@ -3464,44 +3531,57 @@ class TableController {
       return /* @__PURE__ */ jsx(
         TableLoadingContext.Provider,
         {
-          value: { current: this.state.finishedLoading },
+          value: { current: this.state.finishedFirstLoad },
           children: /* @__PURE__ */ jsx(this.TableContext, { children })
         }
       );
     }));
-    __publicField$4(this, "TableContext", memo(({ children }) => {
-      const state = this.state;
-      const props = toJS(state.props);
-      return /* @__PURE__ */ jsx(
-        ResponsiveTableContext,
-        {
-          ...props,
-          columns: [...toJS(state.columns).values()],
-          rows: [],
-          filters: this.parseFilters(),
-          FiltersRenderer: useCallback(
-            (filterId) => this.state.filters.get(filterId).Component,
-            []
-          ),
-          name: this.tableName,
-          SelectionHandler: this.controllerComponent,
-          onSortChange: this.emitter.emit.bind(this.emitter, "onSortChange"),
-          onChangeSelection: this.emitter.emit.bind(
-            this.emitter,
-            "onChangeSelection"
-          ),
-          onFilterBlur: this.emitter.emit.bind(this.emitter, "onFilterBlur"),
-          onFilterChange: this.emitter.emit.bind(this.emitter, "onFilterChange"),
-          onFilterPressEnter: this.emitter.emit.bind(
-            this.emitter,
-            "onFilterPressEnter"
-          ),
-          onRowClick: this.emitter.emit.bind(this.emitter, "onRowClick"),
-          onSelectRows: this.emitter.emit.bind(this.emitter, "onSelectRows"),
-          children
-        }
-      );
-    }));
+    __publicField$4(this, "TableContext", observer(
+      ({ children }) => {
+        const state = this.state;
+        const props = toJS(state.props);
+        const columns = useMemo(
+          () => [...toJS(state.columns).values()],
+          [state.columns]
+        );
+        return /* @__PURE__ */ jsx(
+          ResponsiveTableContext,
+          {
+            ...props,
+            columns,
+            rows: useMemo(() => [], []),
+            filters: useMemo(() => this.parseFilters(), [this.state.filters]),
+            FiltersRenderer: useCallback(
+              (filterId) => this.state.filters.get(filterId).Component,
+              []
+            ),
+            customLabels: {
+              noRegisters: this.state.finishedFirstLoad ? defaultLabels.noRegisters : ""
+            },
+            name: this.tableName,
+            SelectionHandler: this.controllerComponent,
+            onSortChange: this.emitter.emit.bind(this.emitter, "onSortChange"),
+            onChangeSelection: this.emitter.emit.bind(
+              this.emitter,
+              "onChangeSelection"
+            ),
+            onFilterBlur: this.emitter.emit.bind(this.emitter, "onFilterBlur"),
+            onFilterChange: this.emitter.emit.bind(
+              this.emitter,
+              "onFilterChange"
+            ),
+            onFilterPressEnter: this.emitter.emit.bind(
+              this.emitter,
+              "onFilterPressEnter"
+            ),
+            onRowClick: this.emitter.emit.bind(this.emitter, "onRowClick"),
+            onSelectRows: this.emitter.emit.bind(this.emitter, "onSelectRows"),
+            isLoading: this.state.isLoading,
+            children
+          }
+        );
+      }
+    ));
     __publicField$4(this, "Pagination", observer(() => {
       return /* @__PURE__ */ jsx(
         Pagination,
@@ -3510,7 +3590,9 @@ class TableController {
           pageCount: this.state.pagination.totalPages,
           recordsCount: this.state.pagination.totalRecords,
           onPageChange: this.emitter.emit.bind(this.emitter, "onPage"),
-          onRefresh: this.emitter.emit.bind(this.emitter, "onRefresh", null)
+          onRefresh: this.emitter.emit.bind(this.emitter, "onRefresh", null),
+          isLoading: this.state.isLoading,
+          hideMaximizeButton: true
         }
       );
     }));
@@ -3519,8 +3601,7 @@ class TableController {
       state: observable,
       updateState: action
     });
-    const [controller, controllerComponent] = makeController2(this.tableName);
-    this.tableSelectionController = controller;
+    const [, controllerComponent] = makeController2(this.tableName);
     this.controllerComponent = controllerComponent;
     if (initialState) {
       Object.assign(this.state, initialState);
@@ -3565,12 +3646,14 @@ class TableController {
   parseFilters() {
     return [...toJS(this.state.filters).values()].map((c) => {
       return {
+        ...c.filterState,
         id: c.filterState.id,
-        column: c.filterState.column,
+        column: c.filterState.isAdditional ? "" : c.filterState.column,
         asAdditional: c.filterState.isAdditional || this.state.columns.get(c.filterState.column || "")?.hidden,
         options: c.filterState.options,
         detectOnChange: c.filterState.runAutomatically,
-        runAutomatically: c.filterState.runAutomatically
+        runAutomatically: c.filterState.runAutomatically,
+        title: c.filterState.title
       };
     });
   }
@@ -3605,23 +3688,62 @@ class QueryController {
     this.ajaxUrl = ajaxUrl;
     __publicField$3(this, "hasInited", false);
     __publicField$3(this, "initializing", false);
+    __publicField$3(this, "mutex", new Mutex());
     __publicField$3(this, "structure", null);
     __publicField$3(this, "tableController");
-    /**
-     * Allows to throttle calls to actual refresh method.
-     */
-    __publicField$3(this, "executeRefresh", throttle(
-      async () => {
-        await this.actualRefreshMethod();
-      },
-      300,
-      { leading: false, trailing: true }
-    ));
+    __publicField$3(this, "conditions", []);
+    __publicField$3(this, "timeout", -1);
     this.tableController = this.buildTableController();
     this.initEvents();
+    makeObservable(this, { conditions: observable, isLoading: computed });
+    reaction(
+      () => this.mutex.isBusy,
+      () => this.tableController.state.isLoading = this.mutex.isBusy
+    );
+  }
+  async actualRefreshMethod() {
+    const newValues = this.getFiltersValuesMap();
+    if (!this.areRequiredFilters()) {
+      await this.mutex.acquire();
+      try {
+        this.tableController.state.finishedFirstLoad = false;
+        const refresh = await ApiaApi.post(
+          makeApiaUrl(this.getRefreshParameters()),
+          {
+            postData: newValues,
+            postDataTreatement: "stringify",
+            stringifyOptions: { arrayFormat: "repeat" }
+          }
+        );
+        this.parseRefreshResponse(refresh?.data);
+      } finally {
+        this.tableController.state.finishedFirstLoad = true;
+        this.mutex.release();
+      }
+    }
+  }
+  areRequiredFilters() {
+    return !![...this.tableController.state.filters.values()].find(
+      (c) => c.filterState.required && !c.filterState.value && !c.filterState.isHidden
+    );
+  }
+  buildTableController() {
+    return new TableController();
+  }
+  async clearFilters() {
+    this.tableController.state.filters.forEach((c) => {
+      c.filterState.value = "";
+      c.filterState.valueTo = "";
+    });
+  }
+  executeRefresh() {
+    clearTimeout(this.timeout);
+    this.timeout = setTimeout(() => {
+      this.actualRefreshMethod();
+    }, 300);
   }
   getTableControllerDefaultProps() {
-    return {};
+    return { statesColumns: [] };
   }
   getEventsHandlers() {
     return {
@@ -3643,21 +3765,20 @@ class QueryController {
       onSelectRows: (_ev) => {
       },
       onSortChange: (ev) => {
-        this.sort(String(ev.columnIndex));
+        const isDesc = ["Up", "Desc", "D"].includes(ev.sortValue ?? "A");
+        const col = this.tableController.state?.columns.get(ev.column.name);
+        if (col) {
+          col.currentSorting = isDesc ? "D" : "A";
+          this.tableController.state.columns = new Map(
+            this.tableController.state.columns
+          );
+        }
+        this.sort(String(ev.columnIndex), isDesc ? "Des" : "Asc");
       },
       onPage: this.page.bind(this),
       onRefresh: () => this.refresh(true)
     };
   }
-  buildTableController() {
-    return new TableController();
-  }
-  initEvents() {
-    const handlers = this.getEventsHandlers();
-    Object.entries(handlers).forEach(([eventName, handler]) => {
-      this.tableController.on(eventName, handler.bind(this));
-    });
-  }
   getLoadStructureParameters() {
     return {
       ajaxUrl: this.ajaxUrl,
@@ -3675,14 +3796,17 @@ class QueryController {
   }
   getFiltersValuesMap() {
     return [...this.tableController.state.filters.values()].reduce((result, filterWrapper) => {
-      const { id, value, filterToId, valueTo } = filterWrapper.filterState;
-      result[id] = value;
-      if (filterToId !== void 0 && valueTo !== void 0) {
-        result[filterToId] = valueTo;
+      const { id, value, filterToId, filterToValue } = filterWrapper.filterState;
+      result[id] = filterWrapper.filterState.multiplier ? value * filterWrapper.filterState.multiplier : value;
+      if (filterToId !== void 0 && filterToValue != void 0) {
+        result[filterToId] = filterWrapper.filterState.multiplier ? Number(filterToValue) * filterWrapper.filterState.multiplier : filterToValue;
       }
       return result;
     }, {});
   }
+  get isLoading() {
+    return this.mutex.isBusy;
+  }
   getPageParameters() {
     return {
       ajaxUrl: this.ajaxUrl,
@@ -3704,6 +3828,64 @@ class QueryController {
       orderJustThisColumn: true
     };
   }
+  async getStructure() {
+    const result = await ApiaApi.post(
+      makeApiaUrl(this.getLoadStructureParameters())
+    );
+    if (!result?.data) {
+      throw new Error("Cannot load Input query structure");
+    }
+    return this.parseLoadStructureResponse(result.data);
+  }
+  initEvents() {
+    const handlers = this.getEventsHandlers();
+    Object.entries(handlers).forEach(([eventName, handler]) => {
+      this.tableController.on(eventName, handler.bind(this));
+    });
+  }
+  async initialLoad() {
+    if (this.initializing && !this.hasInited) {
+      throw new Error("Cannot initialize the query twice");
+    }
+    this.initializing = true;
+    if (!this.hasInited) {
+      const structure = await this.getStructure();
+      this.structure = structure;
+      this.parseStructure(structure);
+      this.tableController.updateState({
+        props: this.getTableControllerDefaultProps()
+      });
+      this.hasInited = true;
+      this.initializing = false;
+      this.loadFilterTypes();
+      if (!this.structure.queryData?.noExecFirstTime)
+        this.refresh();
+    }
+  }
+  async loadFilterTypes() {
+    if (!this.structure?.hideFilterTypes) {
+      const result = await ApiaApi.post(
+        makeApiaUrl({
+          ajaxUrl: "apia.query.ModalAction.run?",
+          action: "filterOptions"
+        })
+      );
+      if (result?.data?.form?.elements?.element) {
+        this.conditions = arrayOrArray(result.data.form.elements.element);
+      }
+    }
+  }
+  async page(num) {
+    await this.mutex.acquire();
+    try {
+      const page = await ApiaApi.post(
+        makeApiaUrl({ ...this.getPageParameters(), pageNumber: num })
+      );
+      this.parseRefreshResponse(page?.data);
+    } finally {
+      this.mutex.release();
+    }
+  }
   parseLoadStructureResponse(response) {
     const typedResponse = response;
     const retrievedColumns = arrayOrArray(typedResponse.columns.column);
@@ -3713,33 +3895,35 @@ class QueryController {
           label: c.title,
           name: c.name,
           additionalData: c,
-          allowSorting: c.enableOrder === "1",
+          allowSorting: c.enableOrder !== false,
           ariaLabel: c.title,
           currentSorting: c.order,
-          hidden: c.hide === "1",
-          hideFromAccordion: c.hide === "1",
+          hidden: c.hide === true || c.hide == "1",
+          hideFromAccordion: c.hide === true,
           id: c.name,
           showAsAdditional: c.asMoreInformation,
           title: c.toolTip,
-          width: c.width
+          width: c.width === "" || c.width === void 0 ? "300px" : c.width
         };
         return column;
       }),
-      description: typedResponse.queryData.description,
+      description: typedResponse.queryData?.description,
       filters: arrayOrArray(typedResponse.filters.filter).filter((f) => !!f.column).map((f, i) => {
         const filter = {
-          id: `filter${String(i + 1)}`,
+          id: f.id ?? `filter${String(i + 1)}`,
+          // Id generado en APIA
+          filterToId: f?.filterToId ?? f.type == "D" ? `filter${String(i + 1)}i` : void 0,
           // Id generado en APIA
           value: f.currentValue,
-          filterToId: f?.filterToId,
-          valueTo: f?.filterToValue,
-          avoidLabel: false,
+          avoidLabel: f.type === "D" || f.type === "date" ? true : false,
+          filterToValue: f?.filterToValue,
           column: f.column,
           isAdditional: f.asAdditional,
           isHidden: f.hideFilterOption,
           title: f.title,
           tooltip: f.toolTip,
           type: f.type,
+          hideToFilter: true,
           onChange: () => {
           },
           options: [],
@@ -3754,10 +3938,11 @@ class QueryController {
         (c) => c.asMoreInformation
       ),
       isDynamic: false,
-      title: typedResponse.queryData.title,
+      title: typedResponse.queryData?.title,
       openFiltersAutomatically: typedResponse.filters.openFiltersAutomatically,
       runFiltersAutomatically: typedResponse.filters.runFiltersAutomatically,
-      hideFilterTypes: typedResponse.filters.hideFilterTypes
+      hideFilterTypes: typedResponse.filters.hideFilterTypes,
+      queryData: typedResponse?.queryData
     };
   }
   parseRefreshResponse(response) {
@@ -3780,20 +3965,11 @@ class QueryController {
             }))
           ].filter(Boolean),
           className: r.classToAdd,
-          id: r.id
+          id: r.id ?? uniqueId$1("row")
         };
       })
     ]);
   }
-  async getStructure() {
-    const result = await ApiaApi.post(
-      makeApiaUrl(this.getLoadStructureParameters())
-    );
-    if (!result?.data) {
-      throw new Error("Cannot load Input query structure");
-    }
-    return this.parseLoadStructureResponse(result.data);
-  }
   parseStructure(structure) {
     const columns = new Map(
       arrayOrArray(structure.columns).map((c) => [c.name, c])
@@ -3803,139 +3979,176 @@ class QueryController {
         return [f.id, new Filter(f)];
       })
     );
-    this.tableController.updateState({
-      columns,
-      filters
-    });
-  }
-  updatePageState(pageInfo) {
-    const currentPage = Number(pageInfo?.currentPage ?? 0);
-    const totalPages = Number(pageInfo?.pageCount ?? 0);
-    const totalRecords = Number(pageInfo?.totalRecords ?? 0);
-    this.tableController.updateState({
-      pagination: { currentPage, totalPages, totalRecords }
-    });
-  }
-  updateRows(rows) {
-    this.tableController.state.rows = rows;
-  }
-  async clearFilters() {
-    const result = await ApiaApi.post(
-      makeApiaUrl({ ...this.getClearFiltersParameters() })
-    );
-    if (!result?.data)
-      return;
-    const structure = this.parseLoadStructureResponse(result.data);
-    this.parseStructure(structure);
-    this.refresh();
-  }
-  async initialLoad() {
-    if (this.initializing && !this.hasInited) {
-      throw new Error("Cannot initialize the query twice");
+    if (columns.size) {
+      this.tableController.updateState({
+        columns
+      });
     }
-    this.initializing = true;
-    if (!this.hasInited) {
-      this.structure = await this.getStructure();
-      this.parseStructure(this.structure);
+    if (filters.size) {
       this.tableController.updateState({
-        props: this.getTableControllerDefaultProps()
+        filters
       });
-      this.hasInited = true;
-      this.initializing = false;
     }
   }
-  async page(num) {
-    const page = await ApiaApi.post(
-      makeApiaUrl({ ...this.getPageParameters(), pageNumber: num })
-    );
-    this.parseRefreshResponse(page?.data);
+  async refresh(now = true) {
+    return now ? this.actualRefreshMethod() : this.executeRefresh();
   }
-  areRequiredFilters() {
-    return !![...this.tableController.state.filters.values()].find(
-      (c) => c.filterState.required && !c.filterState.value && !c.filterState.isHidden
+  async setFilterOptions() {
+    await ApiaApi.post(
+      makeApiaUrl({
+        ajaxUrl: this.ajaxUrl,
+        action: "setFilterOptions"
+      }),
+      {
+        postData: this.conditions.reduce((acc, c) => {
+          acc[c.id] = c.value;
+          return acc;
+        }, {}),
+        postDataTreatement: "stringify"
+      }
     );
   }
-  async actualRefreshMethod() {
-    if (!this.areRequiredFilters()) {
-      const refresh = await ApiaApi.post(
-        makeApiaUrl(this.getRefreshParameters()),
-        {
-          postData: this.getFiltersValuesMap(),
-          postDataTreatement: "stringify",
-          stringifyOptions: { arrayFormat: "repeat" }
-        }
+  async sort(column, orderType) {
+    await this.mutex.acquire();
+    try {
+      const result = await ApiaApi.post(
+        makeApiaUrl({
+          ...this.getSortParameters(),
+          orderBy: column,
+          orderType
+        })
       );
-      this.parseRefreshResponse(refresh?.data);
+      if (result?.data) {
+        const structure = this.parseLoadStructureResponse(result.data);
+        this.parseStructure(structure);
+        this.parseRefreshResponse(result.data);
+      }
+    } finally {
+      this.mutex.release();
     }
   }
-  async refresh(now = true) {
-    return now ? this.actualRefreshMethod() : this.executeRefresh();
+  updatePageState(pageInfo) {
+    const currentPage = Number(pageInfo?.currentPage ?? 0);
+    const totalPages = Number(pageInfo?.pageCount ?? 0);
+    const totalRecords = Number(pageInfo?.totalRecords ?? 0);
+    this.tableController.updateState({
+      pagination: { currentPage, totalPages, totalRecords }
+    });
   }
-  async sort(column) {
-    const result = await ApiaApi.post(
-      makeApiaUrl({ ...this.getSortParameters(), orderBy: column })
-    );
-    if (result?.data) {
-      const structure = this.parseLoadStructureResponse(result.data);
-      this.parseStructure(structure);
-    }
-    this.refresh();
+  updateRows(rows) {
+    this.tableController.state.rows = rows;
   }
 }
 
+const FilterTypesComponent = observer(
+  ({ queryController }) => {
+    return /* @__PURE__ */ jsx(Fragment, { children: queryController.conditions.map((f, idx) => {
+      const options = arrayOrArray(f.options.option);
+      return /* @__PURE__ */ jsxs(Label, { children: [
+        /* @__PURE__ */ jsxs(Box, { as: "span", children: [
+          f.text,
+          ":"
+        ] }),
+        /* @__PURE__ */ jsx(
+          Select$1,
+          {
+            title: f.title,
+            onChange: (ev) => {
+              const selectedValue = ev.target.value;
+              queryController.conditions[idx].value = selectedValue;
+              queryController.setFilterOptions();
+            },
+            disabled: f.readonly || f.disabled,
+            value: f.value,
+            children: options.map((option) => {
+              return /* @__PURE__ */ jsx("option", { value: option.value, children: option.content }, option.value);
+            })
+          }
+        )
+      ] }, f.name);
+    }) });
+  }
+);
+
 const AdditionalFiltersComponent = ({
-  tableController
+  queryController
 }) => {
   const filterTitle = getLabel("sbtFilters").text;
   const sortTitle = getLabel("titOrderBy").text;
   const filterTypes = getLabel("btnFilterType").text;
-  const hasAdditional = !![...tableController.state.filters.values()].find(
-    (f) => f.filterState.isAdditional
-  );
-  const hasFilters = !![...tableController.state.filters.values()].find(
-    (f) => !f.filterState.isAdditional && f.filterState.column
-  );
-  const hasSortable = !![...tableController.state.columns.values()].find(
-    (c) => c.allowSorting
+  const hasAdditional = !![
+    ...queryController.tableController.state.filters.values()
+  ].find((f) => f.filterState.isAdditional || !f.filterState.column);
+  const hasFilters = !![
+    ...queryController.tableController.state.filters.values()
+  ].find((f) => !f.filterState.isAdditional && f.filterState.column);
+  const hasSortable = !![
+    ...queryController.tableController.state.columns.values()
+  ].find((c) => c.allowSorting !== false);
+  const hasGroupFilter = [
+    ...queryController.tableController.state.filters.values()
+  ].find((f) => f.filterState.group && f.filterState.group !== "")?.filterState;
+  return /* @__PURE__ */ jsx(
+    TableContextReproducer,
+    {
+      tableName: queryController.tableController.getTableName(),
+      children: /* @__PURE__ */ jsxs(Accordion, { className: "additionalFiltersContent", singleExpand: true, children: [
+        hasFilters && /* @__PURE__ */ jsx(
+          AccordionItem,
+          {
+            id: "Responsive",
+            defaultExpanded: true,
+            buttonProps: { ariaLabel: filterTitle, label: filterTitle },
+            children: /* @__PURE__ */ jsx(Responsive, {})
+          }
+        ),
+        hasAdditional && /* @__PURE__ */ jsx(
+          AccordionItem,
+          {
+            id: "Additional",
+            buttonProps: {
+              ariaLabel: window.ADDITIONAL_FILTERS_LABEL,
+              label: window.ADDITIONAL_FILTERS_LABEL
+            },
+            children: /* @__PURE__ */ jsx(Additional, {})
+          }
+        ),
+        hasGroupFilter && /* @__PURE__ */ jsx(
+          AccordionItem,
+          {
+            id: "Group",
+            buttonProps: {
+              ariaLabel: getLabel("titMetadata").text,
+              label: getLabel("titMetadata").text
+            },
+            children: /* @__PURE__ */ jsx(
+              Grouped,
+              {
+                tableName: queryController.tableController.getTableName(),
+                group: hasGroupFilter?.group ?? ""
+              }
+            )
+          }
+        ),
+        hasSortable && /* @__PURE__ */ jsx(
+          AccordionItem,
+          {
+            id: "Sort",
+            buttonProps: { ariaLabel: sortTitle, label: sortTitle },
+            children: /* @__PURE__ */ jsx(Sort, {})
+          }
+        ),
+        hasFilters && !queryController.structure?.hideFilterTypes && /* @__PURE__ */ jsx(
+          AccordionItem,
+          {
+            id: "FilterTypes",
+            buttonProps: { ariaLabel: filterTypes, label: filterTypes },
+            children: /* @__PURE__ */ jsx(FilterTypesComponent, { queryController })
+          }
+        )
+      ] })
+    }
   );
-  return /* @__PURE__ */ jsx(TableContextReproducer, { tableName: tableController.getTableName(), children: /* @__PURE__ */ jsxs(Accordion, { className: "additionalFiltersContent", singleExpand: true, children: [
-    hasFilters && /* @__PURE__ */ jsx(
-      AccordionItem,
-      {
-        id: "Responsive",
-        defaultExpanded: true,
-        buttonProps: { ariaLabel: filterTitle, label: filterTitle },
-        children: /* @__PURE__ */ jsx(Responsive, {})
-      }
-    ),
-    hasAdditional && /* @__PURE__ */ jsx(
-      AccordionItem,
-      {
-        id: "Additional",
-        buttonProps: {
-          ariaLabel: "todo: additional",
-          label: "todo:additional"
-        },
-        children: /* @__PURE__ */ jsx(Additional, {})
-      }
-    ),
-    hasSortable && /* @__PURE__ */ jsx(
-      AccordionItem,
-      {
-        id: "Sort",
-        buttonProps: { ariaLabel: sortTitle, label: sortTitle },
-        children: /* @__PURE__ */ jsx(Sort, {})
-      }
-    ),
-    hasFilters && /* @__PURE__ */ jsx(
-      AccordionItem,
-      {
-        id: "FilterTypes",
-        buttonProps: { ariaLabel: filterTypes, label: filterTypes },
-        children: /* @__PURE__ */ jsx(tableController.filterTypes.Component, {})
-      }
-    )
-  ] }) });
 };
 
 var __defProp$2 = Object.defineProperty;
@@ -3944,6 +4157,34 @@ var __publicField$2 = (obj, key, value) => {
   __defNormalProp$2(obj, key + "" , value);
   return value;
 };
+const ButtonsBar = observer(
+  ({ queryController }) => {
+    return /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", flexDirection: "row", gap: "10px" }, children: [
+      /* @__PURE__ */ jsx(
+        SimpleButton,
+        {
+          variant: "primary-sm",
+          onClick: () => {
+            queryController.refresh();
+          },
+          disabled: queryController.isLoading,
+          children: getLabel("btnSearch").text
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        SimpleButton,
+        {
+          variant: "outline-sm",
+          onClick: () => {
+            queryController.clearFilters();
+          },
+          disabled: queryController.isLoading,
+          children: getLabel("btnClearFilter").text
+        }
+      )
+    ] });
+  }
+);
 class AdditionalFiltersModal {
   constructor(queryController) {
     this.queryController = queryController;
@@ -3951,39 +4192,13 @@ class AdditionalFiltersModal {
   }
   getModalDefinition() {
     return {
-      children: /* @__PURE__ */ jsx(
-        AdditionalFiltersComponent,
-        {
-          tableController: this.queryController.tableController
-        }
-      ),
+      children: /* @__PURE__ */ jsx(AdditionalFiltersComponent, { queryController: this.queryController }),
       onConfirm: () => {
       },
       confirmProps: {
         hideConfirmButton: true,
         hideCancelButton: true,
-        additionalButtonsOnRight: /* @__PURE__ */ jsxs(Box, { sx: { display: "flex", flexDirection: "row", gap: "10px" }, children: [
-          /* @__PURE__ */ jsx(
-            SimpleButton,
-            {
-              variant: "primary-sm",
-              onClick: () => {
-                this.queryController.refresh();
-              },
-              children: getLabel("btnSearch").text
-            }
-          ),
-          /* @__PURE__ */ jsx(
-            SimpleButton,
-            {
-              variant: "outline-sm",
-              onClick: () => {
-                this.queryController.clearFilters();
-              },
-              children: getLabel("btnClearFilter").text
-            }
-          )
-        ] })
+        additionalButtonsOnRight: /* @__PURE__ */ jsx(ButtonsBar, { queryController: this.queryController })
       },
       draggable: true,
       variant: "layout.common.modals.apiaFinder.additionalFiltersModal",
@@ -3991,7 +4206,6 @@ class AdditionalFiltersModal {
     };
   }
   async openModal(properties) {
-    this.queryController.tableController.filterTypes.initialLoad();
     this.modalHandler = ApiaUtil.instance.modals.open({
       ...this.getModalDefinition(),
       ...properties
@@ -4095,11 +4309,11 @@ class QueryModalController {
     return this.emitter.on(ev, cb);
   }
   async openModal(properties) {
+    await this.queryController.initialLoad();
     this.modalHandler = ApiaUtil.instance.modals.open({
       ...this.getModalDefinition(),
       ...properties
     });
-    await this.queryController.initialLoad();
     return this.onConfirmResolve();
   }
   getModalHandler() {
@@ -4132,6 +4346,9 @@ class GenericListQuery extends QueryController {
     super(ajaxUrl);
     this.ajaxUrl = ajaxUrl;
   }
+  getClearFiltersParameters() {
+    return { ...super.getClearFiltersParameters(), action: "filter" };
+  }
   getTableControllerDefaultProps() {
     return {
       ...super.getTableControllerDefaultProps(),
@@ -4142,122 +4359,82 @@ class GenericListQuery extends QueryController {
     return { ...super.getLoadStructureParameters(), action: "filter" };
   }
   getRefreshParameters() {
-    return { ...super.getRefreshParameters() };
-  }
-  getSortParameters() {
-    return {
-      ...super.getSortParameters()
-    };
-  }
-  getFilterParameters() {
     return {
-      ajaxUrl: this.ajaxUrl,
+      ...super.getRefreshParameters(),
       action: "filter",
-      react: true,
       isAjax: true
     };
   }
-  getFiltersValuesMap() {
-    return {};
-  }
-  async filter() {
-    const filterResult = await ApiaApi.post(
-      makeApiaUrl(this.getFilterParameters()),
-      {
-        postData: {
-          ...super.getFiltersValuesMap(),
-          externalUser: false,
-          selectOnlyOne: false,
-          globalAndEnv: true,
-          hierarchy: false,
-          forOrgUnit: false,
-          forCurrentEnv: false
-        },
-        postDataTreatement: "stringify",
-        stringifyOptions: { arrayFormat: "repeat" }
-      }
-    );
-    if (!filterResult?.data)
+  parseRefreshResponse(response) {
+    if (!response)
       return;
-    const structure = this.parseLoadStructureResponse(filterResult.data);
+    const structure = this.parseLoadStructureResponse(response);
     this.parseStructure(structure);
     setTimeout(() => {
-      this.parseRefreshResponse(filterResult.data);
-    }, 200);
+      super.parseRefreshResponse(response);
+    }, 0);
   }
   parseLoadStructureResponse(response) {
     const typedResponse = response;
-    const retrievedColumns = arrayOrArray(
-      typedResponse.function?.messages?.result?.columns?.column
-    );
-    const retrievedFilters = arrayOrArray(
-      typedResponse.function?.messages?.result?.filters?.filter
-    );
-    const returnObject = {
-      columns: retrievedColumns.map((c) => {
-        const column = {
-          label: c.label,
-          name: c.name
-        };
-        return column;
-      }),
-      filters: arrayOrArray(retrievedFilters).map((f, i) => {
-        const filter = {
-          id: `filter${String(i + 1)}`,
-          value: f.value,
-          avoidLabel: false,
-          isHidden: f.isHidden,
-          column: f.column,
-          title: f.title,
-          tooltip: f.tooltip,
-          type: f.type,
-          onChange: () => {
-          },
-          options: [],
-          placeholder: f.title,
-          readonly: f.readonly,
-          required: f.required
-        };
-        return filter;
-      }),
-      description: "",
-      hasAdditionalInformation: false,
-      hideFilterTypes: false,
-      isDynamic: false,
-      openFiltersAutomatically: false,
-      runFiltersAutomatically: false,
-      title: ""
-    };
-    return returnObject;
-  }
-  async initialLoad() {
-    this.tableController.updateState({
-      props: this.getTableControllerDefaultProps()
+    return super.parseLoadStructureResponse({
+      columns: { ...typedResponse.function.messages.result.columns },
+      filters: {
+        ...typedResponse.function.messages.result.filters,
+        runFiltersAutomatically: true
+      }
     });
-    await this.refresh();
   }
-  async refresh() {
-    await this.filter();
+}
+
+class UsersQuery extends GenericListQuery {
+  constructor() {
+    super("apia.modals.UsersAction.run");
   }
-  async sort(column) {
-    const result = await ApiaApi.post(
-      makeApiaUrl({ ...this.getSortParameters(), orderBy: column })
-    );
-    if (result?.data) {
-      const structure = this.parseLoadStructureResponse(result.data);
-      this.parseStructure(structure);
-    }
-    return super.refresh();
+  getFiltersValuesMap() {
+    return {
+      ...super.getFiltersValuesMap(),
+      externalUser: false,
+      selectOnlyOne: false,
+      globalAndEnv: true,
+      hierarchy: false,
+      forOrgUnit: false,
+      forCurrentEnv: false
+    };
+  }
+  parseLoadStructureResponse(response) {
+    const structure = { ...super.parseLoadStructureResponse(response) };
+    structure.hideFilterTypes = true;
+    return structure;
   }
 }
+const makeApiaUsersModal2 = () => new QueryModalController(new UsersQuery());
 
-const ApiaUsersModal2 = new QueryModalController(
-  new GenericListQuery("apia.modals.UsersAction.run")
-);
-
-const ApiaPoolsModals2 = new QueryModalController(
-  new GenericListQuery("apia.modals.PoolsAction.run")
-);
+class PoolsQuery extends GenericListQuery {
+  constructor() {
+    super("apia.modals.PoolsAction.run");
+  }
+  getFiltersValuesMap() {
+    return {
+      ...super.getFiltersValuesMap(),
+      showAutogenerated: false,
+      showNotAutogenerated: false,
+      showCurrentEnv: true,
+      showGlobal: true,
+      selectOnlyOne: false,
+      forHierarchy: false,
+      showOnlyPoolsInHierarchy: false,
+      showOnlyPoolsOutsideHierarchy: false,
+      refreshParameters: false,
+      fetchAllInHierarchy: false
+    };
+  }
+  parseLoadStructureResponse(response) {
+    const structure = { ...super.parseLoadStructureResponse(response) };
+    structure.hideFilterTypes = true;
+    return structure;
+  }
+}
+const makeApiaPoolsModals2 = () => new QueryModalController(new PoolsQuery());
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -4288,9 +4465,49 @@ class MonDocQuery extends QueryController {
       ]
     };
   }
+  async initialLoad() {
+    await super.initialLoad();
+    await this.loadMetadataFilters();
+    await this.setFilters();
+  }
+  async loadMetadataFilters() {
+    const res = await ApiaApi.post(
+      makeApiaUrl({
+        ajaxUrl: this.ajaxUrl,
+        action: "loadMetadata",
+        docTypeId: !this.hasInited ? this.dynamicParams.docTypeSel : this.tableController.state.filters.get("txtDocTypeId")?.filterState.value
+      })
+    );
+    if (res?.data?.docMetadata?.metadata) {
+      const parsedFilters = res.data.docMetadata.metadata.map((c) => {
+        const filter = {
+          ...c,
+          group: "metadata",
+          hideToFilter: true,
+          filterToId: `${String(c.id)}i`,
+          filterToValue: c.value2,
+          avoidLabel: c.type === "D"
+        };
+        return filter;
+      });
+      const metadataFilters = new Map(
+        arrayOrArray(parsedFilters).map((f) => {
+          return [f.id, new Filter(f)];
+        })
+      );
+      this.tableController.updateState({
+        filters: new Map([
+          ...this.tableController.state.filters.entries(),
+          ...metadataFilters.entries()
+        ])
+      });
+    }
+  }
+  async loadFilterTypes() {
+  }
   processFilterChangeEvent(ev) {
     this.tableController.state.filters.get(ev.id);
-    this.filter();
+    this.refresh();
   }
   getLoadStructureParameters() {
     return {
@@ -4302,59 +4519,106 @@ class MonDocQuery extends QueryController {
       ...this.dynamicParams
     };
   }
-  getRefreshParameters() {
-    return { ...super.getRefreshParameters() };
-  }
-  getSortParameters() {
-    return {
-      ...super.getSortParameters()
-    };
-  }
   setDynamicParams(params) {
     this.dynamicParams = params;
   }
-  getFilterParameters() {
+  getClearFiltersParameters() {
+    return { ...super.getClearFiltersParameters(), action: "filter" };
+  }
+  getRefreshParameters() {
     return {
-      ajaxUrl: this.ajaxUrl,
+      ...super.getRefreshParameters(),
       action: "filter",
-      react: true,
       isAjax: true
     };
   }
+  getFiltersValuesMap() {
+    const metadataValues = [];
+    const filtersValues = [
+      ...this.tableController.state.filters.values()
+    ].reduce((result, filterWrapper) => {
+      const { id, value, type, group, multiplier, filterToId, filterToValue } = filterWrapper.filterState;
+      if (group?.match(/metadata(\d+)/)) {
+        if (value !== "") {
+          const prefix = `${id}${window.PRIMARY_SEPARATOR}`;
+          if (type) {
+            const t = type === "apiaNumber" ? "N" : type;
+            metadataValues.push(
+              `${prefix}${t}${window.PRIMARY_SEPARATOR}${value}`
+            );
+            if (filterToValue) {
+              metadataValues.push(
+                `${prefix}${t}${window.PRIMARY_SEPARATOR}${filterToValue}`
+              );
+            }
+          } else {
+            metadataValues.push(`${prefix}${value}`);
+          }
+        }
+        return result;
+      }
+      result[id] = multiplier ? value * multiplier : value;
+      if (filterToId !== void 0 && filterToValue != void 0) {
+        result[filterToId] = multiplier ? Number(filterToValue) * multiplier : filterToValue;
+      }
+      return result;
+    }, {});
+    return {
+      ...filtersValues,
+      strDocMetadata: metadataValues.join(";")
+    };
+  }
   getEventsHandlers() {
     return {
       ...super.getEventsHandlers(),
-      onFilterChange: () => {
-        this.filter();
+      onFilterChange: (e) => {
+        if (e.id === "txtDocTypeId") {
+          this.loadMetadataFilters();
+        }
+        this.refresh(false);
       }
     };
   }
-  async filter() {
-    const filterResult = await ApiaApi.post(
-      makeApiaUrl(this.getFilterParameters()),
-      {
-        postData: {
-          ...super.getFiltersValuesMap()
-        },
-        postDataTreatement: "stringify",
-        stringifyOptions: { arrayFormat: "repeat" }
-      }
-    );
-    if (!filterResult?.data)
-      return;
-    setTimeout(() => {
-      this.parseRefreshResponse(filterResult.data);
-    }, 200);
-  }
   parseRefreshResponse(response) {
-    const rows = response?.function?.messages?.result?.table?.row;
+    const rows = arrayOrArray(response?.function?.messages?.result?.table?.row);
     const pageState = response?.function.messages.result.pageInfo;
     this.updatePageState(pageState);
     this.updateRows([
-      ...arrayOrArray(rows).map(
-        (r) => ({
+      ...rows.map((r) => {
+        const cells = arrayOrArray(r.cell);
+        const fileName = typeof cells[1] === "string" ? cells[1] : typeof cells[1] === "object" && cells[1] ? cells[1].content : "";
+        return {
           rowProps: r,
+          isLocked: r.docLock,
+          states: [
+            {
+              Icon: () => /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  title: getLabel("lblLockedDocument").text,
+                  icon: "Locked",
+                  sx: { display: r.docLock ? "block" : "none" }
+                }
+              ),
+              tooltip: ""
+            },
+            {
+              Icon: () => /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  title: getLabel("lblReadOnly").text,
+                  icon: "Readonly",
+                  size: 22,
+                  sx: { display: r.uneditableTR ? "block" : "none" }
+                }
+              ),
+              tooltip: ""
+            }
+          ],
           cells: [
+            {
+              children: /* @__PURE__ */ jsx(FileIcon, { docName: fileName })
+            },
             ...arrayOrArray(r.cell).map((c) => {
               if (typeof c === "string") {
                 return { children: c };
@@ -4370,9 +4634,10 @@ class MonDocQuery extends QueryController {
               return { children: c };
             })
           ],
-          id: r?.id
-        })
-      )
+          id: r?.id,
+          className: `${r.boldType ? "bold" : ""} ${r["expired-doc"] ? "expired" : ""} `
+        };
+      })
     ]);
   }
   parseLoadStructureResponse(response) {
@@ -4381,17 +4646,15 @@ class MonDocQuery extends QueryController {
     const retrievedFilters = arrayOrArray(typedResponse.filters);
     const returnObject = {
       columns: retrievedColumns.map((c) => {
-        if (c.name === "docFile")
-          return null;
         const column = {
           label: c.label,
           name: c.name,
           allowSorting: c.allowSorting,
           dataSortBy: c.dataSortBy,
-          minWidth: "25%",
           sort: c.sort,
           toolTip: c.toolTip,
-          width: "25%"
+          minWidth: c.name === "docFile" ? "50px" : "25%",
+          width: c.name === "docFile" ? "50px" : "25%"
         };
         return column;
       }).filter((c) => c !== null),
@@ -4399,13 +4662,15 @@ class MonDocQuery extends QueryController {
         const filter = {
           id: f.id,
           filterToId: f?.filterToId,
-          valueTo: f?.filterToValue,
-          value: f.currentValue,
-          avoidLabel: false,
+          filterToValue: f?.filterToValue,
+          isAdditional: f.type === "date",
+          value: f?.options?.[1].value ?? f.currentValue,
           column: f.column,
           title: f.title,
           tooltip: f.toolTip,
-          type: f.options ? "date" : "S",
+          hideToFilter: true,
+          avoidLabel: f.type === "date",
+          type: f.type,
           onChange: () => {
           },
           options: f.options?.map((option) => ({
@@ -4415,8 +4680,6 @@ class MonDocQuery extends QueryController {
           placeholder: f.title,
           isRange: f.isRange,
           isSize: f.isSize
-          // readonly: f.readonly,
-          // required: f.required,
         };
         return filter;
       }),
@@ -4426,21 +4689,22 @@ class MonDocQuery extends QueryController {
       isDynamic: false,
       openFiltersAutomatically: false,
       runFiltersAutomatically: true,
-      title: ""
+      title: "",
+      queryData: { noExecFirstTime: true }
     };
     return returnObject;
   }
-  async sort(column) {
-    const result = await ApiaApi.post(
-      makeApiaUrl({ ...this.getSortParameters(), orderBy: column })
+  async setFilters() {
+    await ApiaApi.post(
+      makeApiaUrl({
+        ajaxUrl: this.ajaxUrl,
+        action: "setFilters",
+        txtDocTypeId: this.tableController.state.filters.get("txtDocTypeId")?.filterState.value
+      })
     );
-    if (result?.data) {
-      this.parseRefreshResponse(result.data);
-    }
-    return super.refresh();
   }
 }
-class ApiaMonDocModal extends QueryModalController {
+class ApiaMonDocModal2 extends QueryModalController {
   constructor() {
     super(new MonDocQuery("/apia.execution.CustMonDocumentAction.run"));
   }
@@ -4451,7 +4715,6 @@ class ApiaMonDocModal extends QueryModalController {
     return super.openModal(properties);
   }
 }
-const ApiaMonDocModal2 = new ApiaMonDocModal();
 
-export { ApiaApi, ApiaApiHandler, ApiaMonDocModal2, ApiaPoolsModals2, ApiaUsersModal2, GenericListQuery, QueryController, QueryModalController, getFunction, getModal, isHtmlResponse, isXmlResponse, makeApiaUrl, parseSuccessfulResponse };
+export { ApiaApi, ApiaApiHandler, ApiaMonDocModal2, GenericListQuery, QueryController, QueryModalController, getFunction, getModal, isHtmlResponse, isXmlResponse, makeApiaPoolsModals2, makeApiaUrl, makeApiaUsersModal2, parseSuccessfulResponse };
 //# sourceMappingURL=index.js.map