@envisiongroup/porygon 1.0.0-rc.9 → 1.0.1

package/dist/react-components/tables/EFWTable/components/EFWTableRow/EFWTableRow.d.ts

@@ -1,22 +1,6 @@
 import { default as React } from 'react';
-import { Row } from '@tanstack/react-table';
-import { VirtualItem, Virtualizer } from '@tanstack/react-virtual';
-import { EFWTableItem } from '../../EFWTable.types';
+import { EFWTableRowProps } from './EFWTableRow.types';
 
-interface EFWTableRowProps {
-    row: Row<EFWTableItem>;
-    virtualRow: VirtualItem | null;
-    rowVirtualizer: Virtualizer<HTMLDivElement, Element> | null;
-    useVirtualization: boolean;
-    enableSelection: boolean;
-    gridTemplateColumns: string;
-    columnSizing: Record<string, number>;
-    stickyColumnsInfo: {
-        stickyColumns: string[];
-        stickyPositions: Record<string, number>;
-    };
-    onRowClick: (row: Row<EFWTableItem>, event: React.MouseEvent) => void;
-}
 /**
  * Componente EFWTableRow exportado directamente sin memoización.
  * TanStack Table maneja internamente el estado de selección y los objetos row
@@ -24,4 +8,3 @@ interface EFWTableRowProps {
  * lo que hace que React.memo no detecte los cambios correctamente.
  */
 export declare const EFWTableRow: React.FC<EFWTableRowProps>;
-export {};

package/dist/react-components/tables/EFWTable/components/EFWTableRow/EFWTableRow.js

@@ -1,60 +1,98 @@
-import { jsx as s } from "react/jsx-runtime";
-import { tokens as t } from "@fluentui/react-components";
-import { EFWTableCell as p } from "../EFWTableCell/EFWTableCell.js";
-const b = ({
+import { jsx as i } from "react/jsx-runtime";
+import k from "react";
+import { makeStyles as R, tokens as o, mergeClasses as h } from "@fluentui/react-components";
+import { EFWTableCell as T } from "../EFWTableCell/EFWTableCell.js";
+const I = 900, E = R({
+  tableRow: {
+    display: "grid",
+    backgroundColor: o.colorNeutralBackground1,
+    borderBottom: `0.5px solid ${o.colorNeutralStroke1}`,
+    "&:hover": {
+      backgroundColor: o.colorNeutralBackground1Hover
+    },
+    "&.selected": {
+      backgroundColor: o.colorNeutralBackground1Selected,
+      "&:hover": {
+        backgroundColor: o.colorNeutralBackground1Selected
+      }
+    }
+  }
+}), D = ({
   row: r,
-  virtualRow: d,
-  rowVirtualizer: c,
-  useVirtualization: n,
-  enableSelection: o,
-  gridTemplateColumns: u,
-  columnSizing: a,
-  stickyColumnsInfo: g,
-  onRowClick: i
+  stripeIndex: m,
+  dense: f = !0,
+  rowAnimationSignal: n,
+  virtualRow: c,
+  rowVirtualizer: l,
+  useVirtualization: t,
+  enableSelection: b,
+  gridTemplateColumns: g,
+  columnSizing: p,
+  stickyColumnsInfo: y,
+  onRowClick: w,
+  onRowDoubleClick: d
 }) => {
-  const l = (e, m) => e ? t.colorNeutralBackground1Selected : m ? t.colorNeutralBackground1Hover : t.colorNeutralBackground1;
-  return /* @__PURE__ */ s(
+  const x = E(), a = k.useRef(null), C = r.getIsSelected(), B = m & 1 ? "odd" : "even", S = h(x.tableRow, "table-row", C && "selected"), s = n?.delay ?? 0, u = n?.token, N = k.useCallback((e) => {
+    e && t && l?.measureElement(e), a.current?.cancel(), a.current = null, !(!e || !u) && typeof e.animate == "function" && (typeof window < "u" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches || (a.current = e.animate(
+      [
+        {
+          backgroundColor: o.colorNeutralBackground1,
+          boxShadow: "0 0 0 0 transparent"
+          //transform: 'scale(1)',
+        },
+        {
+          backgroundColor: o.colorBrandBackground2,
+          boxShadow: `inset 0 0 0 2px ${o.colorBrandStroke1}`
+          //transform: 'scale(1.002)',
+        },
+        {
+          backgroundColor: o.colorNeutralBackground1,
+          boxShadow: "0 0 0 0 transparent"
+          //transform: 'scale(1)',
+        }
+      ],
+      {
+        delay: s,
+        duration: I,
+        easing: "ease-out"
+      }
+    )));
+  }, [s, u, l, t]);
+  return /* @__PURE__ */ i(
     "div",
     {
-      ...n && d ? {
-        "data-index": d.index,
-        ref: (e) => c?.measureElement(e)
+      "data-row-index": r.index,
+      "data-row-parity": B,
+      ref: N,
+      ...t && c ? {
+        "data-index": c.index
       } : {},
-      className: "table-row",
-      onClick: (e) => i(r, e),
+      className: S,
+      role: "row",
+      tabIndex: 0,
+      onKeyDown: (e) => {
+        (e.key === "Enter" || e.key === " ") && (e.preventDefault(), e.currentTarget.click());
+      },
+      onClick: (e) => w(r, e),
+      onDoubleClick: d ? (e) => d(r, e) : void 0,
       style: {
-        display: "grid",
-        gridTemplateColumns: u,
-        cursor: o ? "pointer" : "default",
-        borderBottom: `0.5px solid ${t.colorNeutralStroke1}`,
-        "--current-row-bg": l(r.getIsSelected())
+        gridTemplateColumns: g,
+        cursor: b ? "pointer" : "default"
       },
-      onMouseEnter: o ? (e) => {
-        e.currentTarget.style.setProperty(
-          "--current-row-bg",
-          l(r.getIsSelected(), !0)
-        );
-      } : void 0,
-      onMouseLeave: o ? (e) => {
-        e.currentTarget.style.setProperty(
-          "--current-row-bg",
-          l(r.getIsSelected())
-        );
-      } : void 0,
-      children: r.getVisibleCells().map((e) => /* @__PURE__ */ s(
-        p,
+      children: r.getVisibleCells().map((e) => /* @__PURE__ */ i(
+        T,
         {
           cell: e,
-          columnSizing: a,
-          stickyColumnsInfo: g,
-          useVirtualization: n
+          dense: f,
+          columnSizing: p,
+          stickyColumnsInfo: y,
+          useVirtualization: t
         },
         e.id
       ))
-    },
-    r.id
+    }
   );
-}, x = b;
+}, F = D;
 export {
-  x as EFWTableRow
+  F as EFWTableRow
 };

package/dist/react-components/tables/EFWTable/components/EFWTableRow/EFWTableRow.types.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { Row } from '@tanstack/react-table';
+import { VirtualItem, Virtualizer } from '@tanstack/react-virtual';
+import { EFWTableItem, EFWTableRowAnimationSignal } from '../../EFWTable.types';
+
+export interface EFWTableRowProps {
+    row: Row<EFWTableItem>;
+    stripeIndex: number;
+    dense?: boolean;
+    rowAnimationSignal?: EFWTableRowAnimationSignal;
+    virtualRow: VirtualItem | null;
+    rowVirtualizer: Virtualizer<HTMLDivElement, Element> | null;
+    useVirtualization: boolean;
+    enableSelection: boolean;
+    gridTemplateColumns: string;
+    columnSizing: Record<string, number>;
+    stickyColumnsInfo: {
+        stickyColumns: string[];
+        stickyPositions: Record<string, number>;
+    };
+    onRowClick: (row: Row<EFWTableItem>, event: React.MouseEvent) => void;
+    onRowDoubleClick?: (row: Row<EFWTableItem>, event: React.MouseEvent) => void;
+}

package/dist/react-components/tables/EFWTable/hooks/useDefaultAddButton/useDefaultAddButton.d.ts

@@ -1,4 +1,5 @@
 import { EFWFormFieldProps } from '../../../../forms/EFWForm';
 import { EFWTableCommandBarButton, DefaultDrawerButtonProps } from '../../components/EFWTableCommandBar/EFWTableCommandBar.types';
+import { EFWTableLocaleText } from '../../../../i18n';
 
-export declare const useDefaultAddButton: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]>(addButtonConfig: DefaultDrawerButtonProps<T>) => EFWTableCommandBarButton<T>;
+export declare const useDefaultAddButton: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]>(addButtonConfig: DefaultDrawerButtonProps<T>, localeText: EFWTableLocaleText) => EFWTableCommandBarButton<T>;

package/dist/react-components/tables/EFWTable/hooks/useDefaultAddButton/useDefaultAddButton.js

@@ -1,74 +1,91 @@
-import { jsx as t, jsxs as W } from "react/jsx-runtime";
-import { Text as A } from "@fluentui/react-components";
-import { Add20Regular as D } from "@fluentui/react-icons";
-import { getErrorMessage as d } from "../../../../commons/utils.js";
-import { mergeButtonProps as _, generateFormProps as j } from "../../components/EFWTableCommandBar/EFWTableCommandBar.utils.js";
-import { useFormController as G } from "../../../../forms/EFWForm/EFWForm.hooks.js";
-import { EFWForm as L } from "../../../../forms/EFWForm/EFWForm.js";
-const Q = (c) => {
-  const { formRef: p, getValues: m, validateForm: u, setDisabled: r, addMessageBar: s, removeAllMessagesBar: f } = G(), g = _({
+import { jsx as n } from "react/jsx-runtime";
+import { Text as V } from "@fluentui/react-components";
+import { Add20Regular as $ } from "@fluentui/react-icons";
+import { getErrorMessage as c } from "../../../../commons/utils.js";
+import { mergeButtonProps as q, generateFormProps as G } from "../../components/EFWTableCommandBar/EFWTableCommandBar.utils.js";
+import { useFormController as H } from "../../../../forms/EFWForm/EFWForm.hooks.js";
+import { EFWForm as J } from "../../../../forms/EFWForm/EFWForm.js";
+const te = (p, u) => {
+  const e = u, { formRef: m, getValues: f, validateForm: g, setDisabled: t, addMessageBar: a, removeAllMessagesBar: b } = H(), w = q({
     enabled: !0,
     props: {
-      children: "Nuevo",
+      children: e.addButtonLabel,
       appearance: "primary",
-      icon: /* @__PURE__ */ t(D, {}),
+      icon: /* @__PURE__ */ n($, {}),
+      collapseLabel: "xs",
       drawerConfig: {
-        title: "Nuevo elemento",
+        title: e.addDrawerTitle,
         size: "small",
         position: "end"
       }
     }
-  }, c), { enabled: C, props: F, form: b } = g, { children: n, appearance: v, icon: a, drawerConfig: h } = F || {}, { title: w, size: y, position: x, modalType: B } = h || {};
+  }, p), { enabled: C, props: T, form: x, insertPosition: y = "start" } = w, { children: s, appearance: B, icon: i, collapseLabel: D, drawerConfig: F, style: L, className: R } = T || {}, {
+    title: h,
+    size: E,
+    position: k,
+    modalType: v,
+    labels: A,
+    contentRenderDelay: P,
+    deferContentRendering: M
+  } = F || {};
   return {
     enabled: C,
     kind: "EFWDrawerButton",
     props: {
-      icon: a,
-      children: n,
-      appearance: v,
-      onClick: (N, E, T) => {
-        const { tableMethods: i } = T, k = i.getFields(), M = /* @__PURE__ */ W(A, { children: [
-          "Complete los campos requeridos para crear un nuevo elemento en la tabla. Los campos marcados con asterisco (",
-          /* @__PURE__ */ t("span", { style: { color: "#c00" }, children: "*" }),
-          ") son obligatorios."
-        ] }), P = j(k, b);
-        E({
-          size: y,
-          title: w,
-          position: x,
-          deferContentRendering: !0,
-          modalType: B,
-          content: /* @__PURE__ */ t(L, { formRef: p, description: M, ...P }),
+      icon: i,
+      children: s,
+      appearance: B,
+      collapseLabel: D,
+      style: L,
+      className: R,
+      onClick: (K, z, W) => {
+        const { tableMethods: d } = W, _ = d.getFields(), S = /* @__PURE__ */ n(V, { children: e.addDrawerDescription }), j = G(_, x);
+        z({
+          size: E,
+          title: h,
+          position: k,
+          deferContentRendering: M ?? !0,
+          contentRenderDelay: P,
+          modalType: v,
+          labels: {
+            closeButtonAriaLabel: e.drawerCloseButtonAriaLabel,
+            loadingContentText: e.drawerLoadingContentText,
+            ...A ?? {}
+          },
+          content: /* @__PURE__ */ n(J, { formRef: m, description: S, ...j }),
           buttons: [
             {
               kind: "EFWButton",
               props: {
-                icon: a,
-                children: n,
+                icon: i,
+                children: e.addActionText || s,
                 appearance: "primary",
                 autoLoading: !0,
-                loadingText: "Guardando...",
+                labels: { loadingText: e.addLoadingText },
                 successConfig: {
-                  text: "¡Guardado!"
+                  text: e.addSuccessText
                 },
-                onClick: async (z, o) => {
-                  if (u()) {
-                    const R = m(), l = r(!0);
-                    f();
+                onClick: async (I, o) => {
+                  if (g()) {
+                    const N = f(), l = t(!0);
+                    b();
                     try {
-                      const e = await i.addItem(R);
-                      return e.failed?.length ? (r(!1, l), s({
+                      const r = await d.addItem(
+                        N,
+                        { position: y }
+                      );
+                      return r.failed?.length ? (t(!1, l), a({
                         id: "add-operation-error",
                         intent: "error",
-                        title: "Error al intentar guardar elemento:",
-                        message: d(e.failed[0].error)
+                        title: `${e.addErrorTitle}:`,
+                        message: c(r.failed[0].error)
                       }), { success: !1 }) : (setTimeout(o, 100), { success: !0 });
-                    } catch (e) {
-                      return console.error(e), r(!1, l), s({
+                    } catch (r) {
+                      return console.error(r), t(!1, l), a({
                         id: "delete-unexpected-error",
                         intent: "error",
-                        title: "Error al intentar guardar elemento",
-                        message: d(e)
+                        title: e.addErrorTitle,
+                        message: c(r)
                       }), { success: !1 };
                     }
                   } else
@@ -79,8 +96,8 @@ const Q = (c) => {
             {
               kind: "EFWButton",
               props: {
-                children: "Cancelar",
-                onClick: (z, o) => {
+                children: e.cancelButtonLabel,
+                onClick: (I, o) => {
                   o();
                 }
               }
@@ -92,5 +109,5 @@ const Q = (c) => {
   };
 };
 export {
-  Q as useDefaultAddButton
+  te as useDefaultAddButton
 };

package/dist/react-components/tables/EFWTable/hooks/useDefaultDeleteButton/useDefaultDeleteButton.d.ts

@@ -1,4 +1,5 @@
 import { EFWFormFieldProps } from '../../../../forms/EFWForm';
 import { EFWTableCommandBarButton, DefaultDrawerButtonProps } from '../../components/EFWTableCommandBar/EFWTableCommandBar.types';
+import { EFWTableLocaleText } from '../../../../i18n';
 
-export declare const useDefaultDeleteButton: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]>(deleteButtonConfig?: DefaultDrawerButtonProps<T>) => EFWTableCommandBarButton<T>;
+export declare const useDefaultDeleteButton: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]>(deleteButtonConfig: DefaultDrawerButtonProps<T> | undefined, localeText: EFWTableLocaleText) => EFWTableCommandBarButton<T>;

package/dist/react-components/tables/EFWTable/hooks/useDefaultDeleteButton/useDefaultDeleteButton.js

@@ -1,78 +1,101 @@
-import { jsx as s } from "react/jsx-runtime";
-import { Delete20Regular as z } from "@fluentui/react-icons";
-import { getErrorMessage as E } from "../../../../commons/utils.js";
-import { mergeButtonProps as I, generateFormProps as P } from "../../components/EFWTableCommandBar/EFWTableCommandBar.utils.js";
-import { useFormController as R } from "../../../../forms/EFWForm/EFWForm.hooks.js";
-import { EFWForm as W } from "../../../../forms/EFWForm/EFWForm.js";
-const H = (p = {}) => {
-  const { formRef: g, addMessageBar: c, removeAllMessagesBar: T } = R(), f = I({
+import { jsx as a } from "react/jsx-runtime";
+import { Delete20Regular as j } from "@fluentui/react-icons";
+import { getErrorMessage as m } from "../../../../commons/utils.js";
+import { mergeButtonProps as q } from "../../components/EFWTableCommandBar/EFWTableCommandBar.utils.js";
+import { useFormController as N } from "../../../../forms/EFWForm/EFWForm.hooks.js";
+import { EFWForm as V } from "../../../../forms/EFWForm/EFWForm.js";
+const X = (g = {}, f) => {
+  const e = f, { formRef: w, addMessageBar: c, removeAllMessagesBar: C } = N(), h = q({
     enabled: !0,
     props: {
-      children: "Eliminar",
-      icon: /* @__PURE__ */ s(z, {}),
+      children: e.deleteButtonLabel,
+      icon: /* @__PURE__ */ a(j, {}),
+      collapseLabel: "xs",
       drawerConfig: {
-        title: "Eliminar elemento",
+        title: e.deleteDrawerTitle,
         size: "small",
         position: "end"
       }
     }
-  }, p), { enabled: B, props: h, form: D } = f, { children: d, appearance: w, icon: m, drawerConfig: C } = h || {}, { title: L, size: v, position: y, modalType: F } = C || {};
+  }, g), { enabled: b, props: y } = h, { children: u, appearance: T, icon: p, collapseLabel: x, drawerConfig: B, style: E, className: D } = y || {}, {
+    title: L,
+    size: R,
+    position: k,
+    modalType: M,
+    labels: A,
+    contentRenderDelay: F,
+    deferContentRendering: S
+  } = B || {};
   return {
-    enabled: B,
+    enabled: b,
     kind: "EFWDrawerButton",
     props: {
-      icon: m,
-      children: d,
-      appearance: w,
-      onClick: (j, N, O) => {
-        const { selectedRows: r, tableMethods: u } = O, U = u.getFields(), k = r.length > 1 ? `¿Esta seguro de querer eliminar los ${r.length} elementos seleccionados?` : "¿Esta seguro de querer eliminar el elemento seleccionado?", x = r.length === 1 ? r[0].item : {}, M = r.map((i) => i.index), b = P(U, D);
-        N({
-          size: v,
+      icon: p,
+      children: u,
+      appearance: T,
+      collapseLabel: x,
+      style: E,
+      className: D,
+      onClick: (G, z, W) => {
+        const { selectedRows: o, tableMethods: $ } = W, v = o.length > 1 ? e.deleteConfirmMultiple(o.length) : e.deleteConfirmSingle, P = o.length === 1 ? o[0].item : {}, _ = o.map((i) => i.index);
+        z({
+          size: R,
           title: L,
-          position: y,
-          deferContentRendering: !0,
-          modalType: F,
-          content: /* @__PURE__ */ s(W, { defaultValues: x, formRef: g, description: k, ...b }),
+          position: k,
+          deferContentRendering: S ?? !0,
+          contentRenderDelay: F,
+          modalType: M,
+          labels: {
+            closeButtonAriaLabel: e.drawerCloseButtonAriaLabel,
+            loadingContentText: e.drawerLoadingContentText,
+            ...A ?? {}
+          },
+          content: /* @__PURE__ */ a(V, { defaultValues: P, formRef: w, description: v }),
           buttons: [
             {
               kind: "EFWButton",
               props: {
-                icon: m,
-                children: d,
+                icon: p,
+                children: e.deleteActionText || u,
                 appearance: "primary",
                 autoLoading: !0,
-                loadingText: "Eliminando...",
+                labels: { loadingText: e.deleteLoadingText },
                 successConfig: {
-                  text: "Eliminado!"
+                  text: e.deleteSuccessText
                 },
-                onClick: async (i, a) => {
-                  console.log("[DELETE BUTTON] Click iniciado"), console.log("[DELETE BUTTON] Active element antes:", document.activeElement), T();
+                onClick: async (i, d) => {
+                  C();
                   try {
-                    console.log("[DELETE BUTTON] Ejecutando deleteItems...");
-                    const e = await u.deleteItems(M);
-                    if (console.log("[DELETE BUTTON] deleteItems completado"), console.log("[DELETE BUTTON] Active element después de delete:", document.activeElement), e.failed?.length) {
-                      const n = e.failed.map((o) => E(o.error)), t = e.failed.length > 1;
+                    const r = await $.deleteItems(_);
+                    if (r.failed?.length) {
+                      const s = r.failed.map((t) => {
+                        const l = m(t.error);
+                        return {
+                          key: `delete-error-${t.index}-${l}`,
+                          message: l
+                        };
+                      }), n = r.failed.length > 1;
                       return c({
                         id: "delete-operation-error",
                         intent: "error",
-                        title: t ? "Error al intentar eliminar elementos:" : "Error al intentar eliminar elemento:",
-                        message: /* @__PURE__ */ s("ul", { children: n.map((o, l) => /* @__PURE__ */ s("li", { children: o }, l)) })
+                        title: n ? `${e.deleteErrorTitleMultiple}:` : `${e.deleteErrorTitleSingle}:`,
+                        message: /* @__PURE__ */ a("ul", { children: s.map((t) => /* @__PURE__ */ a("li", { children: t.message }, t.key)) })
                       }), { success: !1 };
                     }
-                    return console.log("[DELETE BUTTON] Cerrando drawer..."), console.log("[DELETE BUTTON] Active element antes de cerrar:", document.activeElement), setTimeout(() => {
+                    return setTimeout(() => {
                       try {
-                        const n = document.activeElement?.closest?.('[role="dialog"]'), t = Array.from(document.querySelectorAll("[data-efw-drawer-focus-sentinel]")), o = n ? t.filter((A) => !n.contains(A)) : t, l = o[o.length - 1] || t[t.length - 1];
-                        l && (console.log("[DELETE BUTTON] Focusing parent drawer sentinel before close"), l.focus());
+                        const s = document.activeElement?.closest?.('[role="dialog"]'), n = Array.from(document.querySelectorAll("[data-efw-drawer-focus-sentinel]")), t = s ? n.filter((I) => !s.contains(I)) : n, l = t[t.length - 1] || n[n.length - 1];
+                        l && l.focus();
                       } catch {
                       }
-                      console.log("[DELETE BUTTON] Ejecutando closeDrawer"), a();
+                      d();
                     }, 100), { success: !0 };
-                  } catch (e) {
-                    return console.error("Error durante actualización:", e), c({
+                  } catch (r) {
+                    return console.error("Error durante actualización:", r), c({
                       id: "delete-unexpected-error",
                       intent: "error",
-                      title: "Error al intentar eliminar elemento",
-                      message: E(e)
+                      title: e.deleteErrorTitleSingle,
+                      message: m(r)
                     }), { success: !1 };
                   }
                 }
@@ -81,9 +104,9 @@ const H = (p = {}) => {
             {
               kind: "EFWButton",
               props: {
-                children: "Cancelar",
-                onClick: (i, a) => {
-                  a();
+                children: e.cancelButtonLabel,
+                onClick: (i, d) => {
+                  d();
                 }
               }
             }
@@ -94,5 +117,5 @@ const H = (p = {}) => {
   };
 };
 export {
-  H as useDefaultDeleteButton
+  X as useDefaultDeleteButton
 };

package/dist/react-components/tables/EFWTable/hooks/useDefaultFilterButton/useDefaultFilterButton.d.ts

@@ -0,0 +1,17 @@
+import { EFWFormFieldProps } from '../../../../forms/EFWForm';
+import { DefaultFilterButtonProps, EFWTableCommandBarButton } from '../../components/EFWTableCommandBar/EFWTableCommandBar.types';
+import { EFWTableLocaleText } from '../../../../i18n';
+
+/**
+ * Hook que crea un botón de filtro por defecto para EFWTable.
+ *
+ * - Siempre visible (agregar a `alwaysButtons` o usar `filterButtonConfig` en EFWTable)
+ * - Abre un drawer con EFWForm que contiene solo los campos con `filterable: true`
+ * - Aplica filtros en tiempo real (live filtering) a medida que el usuario ingresa valores
+ * - Choice/MultiChoice en un mismo campo aplican OR (A o B)
+ * - Distintos campos aplican AND (TanStack)
+ * - El ícono cambia cuando hay filtros activos
+ * - Incluye botón "Limpiar filtros" para quitar todos los filtros
+ * - Los campos Boolean se renderizan como Choice con opciones Sí/No (sin selección = sin filtro)
+ */
+export declare const useDefaultFilterButton: <T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]>(filterButtonConfig: DefaultFilterButtonProps<T>, localeText: EFWTableLocaleText) => EFWTableCommandBarButton<T>;