mimir-ui-kit 1.38.43 → 1.39.0

package/dist/components/SelectSearch/SelectSearch.js

@@ -7,7 +7,7 @@ import { Icon as O } from "../../icons/Icon.js";
 import { Button as Q } from "../Button/Button.js";
 import { I as B } from "../../Input-DAmc_HxO.js";
 import { EInputVariant as X } from "../Input/constants.js";
-import { H as Y, U as M, G as j, K as Z, W as ee } from "../../combobox-BD-GHvMy.js";
+import { H as Y, U as M, G as j, K as Z, W as ee } from "../../combobox-Dv6-ANkb.js";
 import '../../assets/SelectSearch.css';const te = "_disabled_1bph7_6", oe = "_container_1bph7_13", ne = "_full_1bph7_28", se = "_button_1bph7_40", ae = "_options_1bph7_54", ie = "_top_1bph7_65", le = "_bottom_1bph7_71", re = "_m_1bph7_98", ce = "_l_1bph7_113", de = "_option_1bph7_54", pe = "_clear_1bph7_167", e = {
   "select-search": "_select-search_1bph7_2",
   disabled: te,

package/dist/components/Table/ColumnOrderSettings.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+
+type TColumnOrderSettingsProps = {
+    columns: {
+        id: string;
+        header: ReactNode;
+    }[];
+    columnOrder: string[];
+    onColumnOrderChange: (newOrder: string[]) => void;
+    isOpen: boolean;
+    onClose: () => void;
+    defaultColumnOrder?: string[];
+    visibleColumns?: Record<string, boolean>;
+    onVisibleColumnsChange?: (visibleColumns: Record<string, boolean>) => void;
+    requiredColumns?: string[];
+};
+export declare const ColumnOrderSettings: ({ columns, columnOrder, onColumnOrderChange, isOpen, onClose, defaultColumnOrder, visibleColumns, onVisibleColumnsChange, requiredColumns }: TColumnOrderSettingsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Table/ColumnOrderSettings.js

@@ -0,0 +1,177 @@
+import { jsxs as g, jsx as s } from "react/jsx-runtime";
+import { c as x } from "../../index-DIxK0V-G.js";
+import { useState as p, useEffect as J, useCallback as l } from "react";
+import { c as r } from "../../stories.module-fud786VB.js";
+import { Icon as K } from "../../icons/Icon.js";
+import { Button as O } from "../Button/Button.js";
+import { EButtonVariantBorderless as M, EButtonForm as k, EButtonVariantOutline as Q, EButtonVariantDefault as U } from "../Button/constants.js";
+import { EDrawerPosition as W } from "../Drawer/constants.js";
+import { Drawer as X } from "../Drawer/Drawer.js";
+import { Switcher as Y } from "../Switcher/Switcher.js";
+const ot = ({
+  columns: m,
+  columnOrder: E,
+  onColumnOrderChange: w,
+  isOpen: D,
+  onClose: h,
+  defaultColumnOrder: I,
+  visibleColumns: S = {},
+  onVisibleColumnsChange: u,
+  requiredColumns: n = []
+}) => {
+  const [i, v] = p([]), [o, b] = p(null), [y, d] = p(null), [N, B] = p({});
+  J(() => {
+    D && (v([...E]), B({ ...S }));
+  }, [D, E, S]);
+  const L = l(
+    (t) => {
+      n.includes(t) || b(t);
+    },
+    [n]
+  ), V = l(
+    (t, e) => {
+      t.preventDefault(), !(!o || o === e || n.includes(e)) && d(e);
+    },
+    [o, n]
+  ), z = l(
+    (t, e) => {
+      if (t.preventDefault(), !o || o === e || n.includes(e))
+        return;
+      const a = [...i], f = a.indexOf(o), c = a.indexOf(e);
+      a.splice(f, 1), a.splice(c, 0, o), v(a), d(null);
+    },
+    [o, i, n]
+  ), A = l(() => {
+    b(null), d(null);
+  }, []), F = l(
+    (t, e) => {
+      t.preventDefault(), !(o === e || n.includes(e)) && d(e);
+    },
+    [o, n]
+  ), R = l(() => {
+    d(null);
+  }, []), j = l(
+    (t, e) => {
+      !e && n.includes(t) || B((a) => ({
+        ...a,
+        [t]: e
+      }));
+    },
+    [n]
+  ), G = l(() => {
+    w(i), u == null || u(N), h();
+  }, [
+    i,
+    N,
+    w,
+    u,
+    h
+  ]), H = () => {
+    h();
+  }, P = l(() => {
+    const t = I || m.map((a) => a.id);
+    v(t);
+    const e = {};
+    m.forEach((a) => {
+      e[a.id] = !0;
+    }), B(e);
+  }, [m, I]), T = /* @__PURE__ */ g("div", { className: r.columnOrderFooter, children: [
+    /* @__PURE__ */ s(
+      O,
+      {
+        onClick: P,
+        variant: M.Asphalt,
+        form: k.BorderlessButton,
+        className: r.footerButton,
+        size: "xxl",
+        children: "По умолчанию"
+      }
+    ),
+    /* @__PURE__ */ g("div", { className: r.footerButtonGroup, children: [
+      /* @__PURE__ */ s(
+        O,
+        {
+          onClick: H,
+          variant: Q.Asphalt,
+          form: k.OutlineButton,
+          className: r.footerButton,
+          size: "xxl",
+          children: "Отменить"
+        }
+      ),
+      /* @__PURE__ */ s(
+        O,
+        {
+          onClick: G,
+          variant: U.PrimarySapphire,
+          className: r.footerButton,
+          size: "xxl",
+          children: "Сохранить"
+        }
+      )
+    ] })
+  ] });
+  return /* @__PURE__ */ s(
+    X,
+    {
+      isOpen: D,
+      onClose: h,
+      title: "Настройка порядка столбцов",
+      position: W.RIGHT,
+      classNameContent: r.columnOrderDrawer,
+      showCloseButton: !0,
+      footer: T,
+      children: /* @__PURE__ */ s("div", { className: r.columnOrderList, children: i.map((t) => {
+        const e = m.find((c) => c.id === t), a = n.includes(t), f = N[t] !== !1;
+        return e ? /* @__PURE__ */ g(
+          "div",
+          {
+            draggable: !a,
+            onDragStart: () => L(t),
+            onDragOver: (c) => V(c, t),
+            onDrop: (c) => z(c, t),
+            onDragEnd: A,
+            onDragEnter: (c) => F(c, t),
+            onDragLeave: R,
+            className: x(r.columnOrderItem, {
+              [r.dragging]: o === t,
+              [r.dragOver]: y === t,
+              [r.disabled]: a,
+              [r.hidden]: !f
+            }),
+            children: [
+              /* @__PURE__ */ s(
+                K,
+                {
+                  iconName: "DragHandleVertical24px",
+                  className: x(r.iconDrag, {
+                    [r.iconDisabled]: a
+                  })
+                }
+              ),
+              /* @__PURE__ */ g("div", { className: r.columnNameAndSwitch, children: [
+                /* @__PURE__ */ s("div", { className: r.columnName, children: typeof e.header == "string" ? e.header : "Столбец" }),
+                /* @__PURE__ */ s(
+                  Y,
+                  {
+                    checked: f,
+                    onChange: () => j(t, !f),
+                    disabled: a,
+                    className: x(r.columnSwitch, {
+                      [r.disabled]: a
+                    }),
+                    hasLabel: !1
+                  }
+                )
+              ] })
+            ]
+          },
+          t
+        ) : null;
+      }) })
+    }
+  );
+};
+export {
+  ot as ColumnOrderSettings
+};

package/dist/components/Table/Table.d.ts

@@ -0,0 +1,3 @@
+import { TTableProps } from './types';
+
+export declare const Table: <T extends Record<string, unknown>>({ data, columns, tableClassNameContainer, isSelectable, selectedRowIds, onSelectedRowsChange, isLoading, onSort, virtualized, height, width, variant, displayMode, scrollContainerClassName, tableClassName, headerClassName, headerTextClassName, headerRowClassName, headerCellClassName, bodyClassName, virtualBodyClassName, rowClassName, cellClassName, selectCellClassName, scrollButtonsClassName, cardClassName, cardHeaderClassName, cardValueClassName, initialSorting, initialRowSelection, serverSideSorting, columnOrder, onColumnOrderChange, visibleColumns, globalFilter, onGlobalFilterChange, enableGlobalFilter, columnsToSearch, showScrollButtons, autoShowScrollButtons, buttonsScrollVariant, onCardActionsClick, showCardActions }: TTableProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Table/Table.js

@@ -0,0 +1,204 @@
+import { jsxs as H, jsx as e } from "react/jsx-runtime";
+import { c as m } from "../../index-DIxK0V-G.js";
+import { useEffect as ye, useMemo as T } from "react";
+import { ETableDisplayMode as b, TABLE_OPTIONS as R, ETableVariant as Se, ETableScrollButtonVariant as ge } from "./constants.js";
+import { useTableInstance as Be } from "./hooks/useTableInstance.js";
+import { useTableScroll as Le } from "./hooks/useTableScroll.js";
+import { useTableState as Ne } from "./hooks/useTableState.js";
+import { c as l } from "../../styles.module--QBQYoA9.js";
+import { TableBody as Oe } from "./TableBody.js";
+import { TableCardsView as Ae } from "./TableCardsView.js";
+import { TableHeader as He } from "./TableHeader.js";
+import { TableScrollButtons as Re } from "./TableScrollButtons.js";
+import { Loader as Ie } from "../Loader/Loader.js";
+const Ke = ({
+  data: u,
+  columns: I,
+  tableClassNameContainer: v,
+  isSelectable: t = !1,
+  selectedRowIds: w,
+  onSelectedRowsChange: D,
+  isLoading: F = !1,
+  onSort: V,
+  virtualized: o = !1,
+  height: h = R.DEFAULT_HEIGHT,
+  width: E = R.DEFAULT_WIDTH,
+  variant: n = Se.WhiteHeader,
+  displayMode: d = b.TABLE,
+  scrollContainerClassName: $,
+  tableClassName: x,
+  headerClassName: G,
+  headerTextClassName: J,
+  headerRowClassName: U,
+  headerCellClassName: W,
+  bodyClassName: _,
+  virtualBodyClassName: j,
+  rowClassName: p,
+  cellClassName: y,
+  selectCellClassName: S,
+  scrollButtonsClassName: K,
+  cardClassName: C,
+  cardHeaderClassName: M,
+  cardValueClassName: P,
+  initialSorting: k = [],
+  initialRowSelection: q = {},
+  serverSideSorting: g = !1,
+  columnOrder: a,
+  onColumnOrderChange: Q,
+  visibleColumns: s,
+  globalFilter: X = "",
+  onGlobalFilterChange: B,
+  enableGlobalFilter: Y = !1,
+  columnsToSearch: Z,
+  showScrollButtons: z = !1,
+  autoShowScrollButtons: L = !1,
+  buttonsScrollVariant: ee = ge.WHITE,
+  onCardActionsClick: re,
+  showCardActions: te = !1
+}) => {
+  const {
+    sorting: c,
+    rowSelection: N,
+    internalGlobalFilter: oe,
+    columnOrderToUse: le,
+    handleSortingChange: ne,
+    handleGlobalFilterChange: ae,
+    handleRowSelectionChange: se,
+    handleColumnOrderChange: ce
+  } = Ne({
+    initialSorting: k,
+    initialRowSelection: q,
+    onSort: V,
+    onGlobalFilterChange: B,
+    onColumnOrderChange: Q,
+    serverSideSorting: g,
+    data: u,
+    columnOrder: a
+  }), {
+    scrollContainerRef: r,
+    isOverflowing: fe,
+    handleScrollLeft: ie,
+    handleScrollRight: me
+  } = Le({
+    autoShowScrollButtons: L
+  }), f = B ? X : oe, i = Be({
+    data: u,
+    columns: I,
+    isSelectable: t,
+    sorting: c,
+    rowSelection: N,
+    columnOrderToUse: le,
+    effectiveGlobalFilter: f,
+    handleSortingChange: ne,
+    handleRowSelectionChange: se,
+    handleColumnOrderChange: ce,
+    handleGlobalFilterChange: ae,
+    enableGlobalFilter: Y,
+    serverSideSorting: g,
+    variant: n,
+    rowClassName: p,
+    cellClassName: y,
+    selectCellClassName: S,
+    visibleColumns: s,
+    columnsToSearch: Z,
+    selectedRowIds: w,
+    onSelectedRowsChange: D
+  });
+  ye(() => {
+    if (o && r.current) {
+      const Ee = setTimeout(() => {
+        var O;
+        const de = new Event("scroll", { bubbles: !0 });
+        (O = r.current) == null || O.dispatchEvent(de), setTimeout(() => {
+          var A;
+          const pe = new Event("scroll", { bubbles: !0 });
+          (A = r.current) == null || A.dispatchEvent(pe);
+        }, 50);
+      }, 0);
+      return () => clearTimeout(Ee);
+    }
+  }, [N, o]);
+  const Te = L ? fe : z, be = T(() => ({ height: h, width: E }), [h, E]), ue = T(
+    () => `${JSON.stringify(c)}-${JSON.stringify(a)}-${JSON.stringify(s)}`,
+    [c, a, s]
+  ), he = T(() => `full-table-${f}`, [f]);
+  return /* @__PURE__ */ H(
+    "div",
+    {
+      className: m(l.tableContainer, v),
+      style: be,
+      children: [
+        F && /* @__PURE__ */ e("div", { className: l.loaderOverlay, children: /* @__PURE__ */ e(Ie, {}) }),
+        Te && d === b.TABLE && /* @__PURE__ */ e(
+          Re,
+          {
+            handleScrollLeft: ie,
+            handleScrollRight: me,
+            className: K,
+            buttonsVariant: ee
+          }
+        ),
+        /* @__PURE__ */ e(
+          "div",
+          {
+            ref: r,
+            className: m(l.tableScroll, $),
+            children: d === b.TABLE ? /* @__PURE__ */ H(
+              "table",
+              {
+                className: m(l.table, x),
+                children: [
+                  /* @__PURE__ */ e(
+                    He,
+                    {
+                      table: i,
+                      isSelectable: t,
+                      headerClassName: G,
+                      headerTextClassName: J,
+                      headerCellClassName: W,
+                      headerRowClassName: U,
+                      variant: n
+                    }
+                  ),
+                  /* @__PURE__ */ e(
+                    Oe,
+                    {
+                      table: i,
+                      virtualized: o,
+                      variant: n,
+                      bodyClassName: _,
+                      virtualBodyClassName: j,
+                      rowClassName: p,
+                      cellClassName: y,
+                      selectCellClassName: S,
+                      scrollRef: r,
+                      isSelectable: t
+                    }
+                  )
+                ]
+              },
+              ue
+            ) : /* @__PURE__ */ e(
+              Ae,
+              {
+                table: i,
+                virtualized: o,
+                scrollRef: r,
+                isSelectable: t,
+                cardClassName: C,
+                cardHeaderClassName: M,
+                cardValueClassName: P,
+                onCardActionsClick: re,
+                showCardActions: te
+              }
+            )
+          }
+        )
+      ]
+    },
+    he
+  );
+};
+export {
+  Ke as Table
+};

package/dist/components/Table/TableBody.d.ts

@@ -0,0 +1,5 @@
+import { TTableBodyProps } from './types';
+
+declare function TableBodyComponent<T extends object>({ table, virtualized, bodyClassName, virtualBodyClassName, rowClassName, cellClassName, selectCellClassName, variant, scrollRef, isSelectable }: TTableBodyProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare const TableBody: typeof TableBodyComponent;
+export {};

package/dist/components/Table/TableBody.js

@@ -0,0 +1,109 @@
+import { jsx as c } from "react/jsx-runtime";
+import { c as m } from "../../index-DIxK0V-G.js";
+import { memo as E, useRef as G, useState as x, useEffect as $ } from "react";
+import { ETableVariant as B } from "./constants.js";
+import { useTableVirtualization as H } from "./hooks/useTableVirtualization.js";
+import { c as t } from "../../styles.module--QBQYoA9.js";
+import { TableRow as k } from "./TableRow.js";
+function R({
+  table: r,
+  virtualized: o,
+  bodyClassName: T,
+  virtualBodyClassName: V,
+  rowClassName: f,
+  cellClassName: y,
+  selectCellClassName: u,
+  variant: l = B.WhiteHeader,
+  scrollRef: A,
+  isSelectable: g
+}) {
+  const p = G(null), [i, I] = x(0), [a, K] = x(0), { rows: n } = r.getRowModel(), w = r.getAllColumns();
+  $(() => {
+    o && K((e) => e + 1);
+  }, [w, o]), $(() => {
+    if (o) {
+      const e = r.getState().rowSelection;
+      Object.keys(e).length === n.length && n.length > 0 && I((d) => d + 1);
+    }
+  }, [r.getState().rowSelection, n.length, o]);
+  const { virtualizer: h, rowRefs: W } = H({
+    rows: n,
+    virtualized: o,
+    scrollRef: A,
+    rowSelection: r.getState().rowSelection,
+    columns: w
+  });
+  if (!o)
+    return /* @__PURE__ */ c(
+      "tbody",
+      {
+        ref: p,
+        className: m(t.body, T),
+        children: n.map((e, s) => /* @__PURE__ */ c(
+          k,
+          {
+            row: e,
+            isSelectable: g,
+            variant: l,
+            rowClassName: f,
+            cellClassName: y,
+            selectCellClassName: u,
+            rowIndex: s
+          },
+          `${e.id}-${i}`
+        ))
+      },
+      `tbody-${i}`
+    );
+  const C = h.getVirtualItems(), j = { height: h.getTotalSize(), position: "relative" };
+  return /* @__PURE__ */ c(
+    "tbody",
+    {
+      ref: p,
+      className: m(t.body, t.virtualBody, V),
+      style: j,
+      children: C.map((e) => {
+        const s = n[e.index], S = {
+          position: "absolute",
+          top: 0,
+          transform: `translateY(${e.start}px)`,
+          width: "100%",
+          willChange: "transform"
+        }, d = m(
+          t.row,
+          l === B.WhiteHeader ? e.index % 2 === 0 ? t.rowWhiteBackground : t.rowGrayBackground : e.index % 2 === 0 ? t.rowGrayBackground : t.rowWhiteBackground
+        );
+        return /* @__PURE__ */ c(
+          "tr",
+          {
+            ref: (b) => {
+              b && (W.current[s.id] = b);
+            },
+            style: S,
+            className: d,
+            children: /* @__PURE__ */ c(
+              k,
+              {
+                row: s,
+                isSelectable: g,
+                variant: l,
+                rowClassName: f,
+                cellClassName: y,
+                selectCellClassName: u,
+                isVirtualized: !0,
+                rowIndex: e.index,
+                columnsKey: a
+              }
+            )
+          },
+          `${e.key}-${i}-${a}`
+        );
+      })
+    },
+    `tbody-virtual-${i}-${a}`
+  );
+}
+const J = E(R);
+export {
+  J as TableBody
+};

package/dist/components/Table/TableCard.d.ts

@@ -0,0 +1,5 @@
+import { TTableCardProps } from './types';
+
+declare function TableCardComponent<T extends object>({ row, isSelectable, cardClassName, cardHeaderClassName, cardValueClassName, onSelect, onActionsClick, showActions }: TTableCardProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare const TableCard: typeof TableCardComponent;
+export {};

package/dist/components/Table/TableCard.js

@@ -0,0 +1,45 @@
+import { jsxs as d, jsx as e } from "react/jsx-runtime";
+import { f as b } from "../../index-CVk4sixt.js";
+import { c as o } from "../../index-DIxK0V-G.js";
+import { memo as v } from "react";
+import { c as a } from "../../styles.module--QBQYoA9.js";
+import { Icon as l } from "../../icons/Icon.js";
+import { CheckboxMimir as k } from "../CheckboxMimir/CheckboxMimir.js";
+function A({
+  row: r,
+  isSelectable: m,
+  cardClassName: t,
+  cardHeaderClassName: f,
+  cardValueClassName: h,
+  onSelect: i,
+  onActionsClick: s,
+  showActions: p = !1
+}) {
+  const C = r.getIsSelected(), N = r.getVisibleCells(), u = (c) => {
+    i && i(c);
+  }, g = (c) => {
+    s && s(c, r.original);
+  };
+  return /* @__PURE__ */ d("div", { className: o(a.tableCard, t), children: [
+    m && /* @__PURE__ */ e("div", { className: a.cardCheckbox, children: /* @__PURE__ */ e(
+      k,
+      {
+        checked: C,
+        onChange: u
+      }
+    ) }),
+    p && /* @__PURE__ */ e("div", { className: a.cardActions, onClick: g, children: /* @__PURE__ */ e(l, { iconName: "Kebab24px" }) }),
+    /* @__PURE__ */ e("div", { className: a.cardContent, children: N.map((c) => {
+      const n = c.column, x = typeof n.columnDef.header == "string" ? n.columnDef.header : "";
+      return /* @__PURE__ */ d("div", { className: a.cardField, children: [
+        /* @__PURE__ */ e("div", { className: o(a.cardValue, h), children: b(c.column.columnDef.cell, c.getContext()) }),
+        /* @__PURE__ */ e("div", { className: o(a.cardHeader, f), children: x })
+      ] }, c.id);
+    }) }),
+    /* @__PURE__ */ e("div", { className: a.cardArrow, children: /* @__PURE__ */ e(l, { iconName: "ArrowUpRight32px" }) })
+  ] });
+}
+const V = v(A);
+export {
+  V as TableCard
+};

package/dist/components/Table/TableCardsView.d.ts

@@ -0,0 +1,5 @@
+import { TTableCardsViewProps } from './types';
+
+declare function TableCardsViewComponent<T extends object>({ table, virtualized, scrollRef, isSelectable, cardClassName, cardHeaderClassName, cardValueClassName, onCardActionsClick, showCardActions }: TTableCardsViewProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare const TableCardsView: typeof TableCardsViewComponent;
+export {};

package/dist/components/Table/TableCardsView.js

@@ -0,0 +1,84 @@
+import { jsx as o } from "react/jsx-runtime";
+import { memo as V, useRef as b } from "react";
+import { useTableVirtualization as v } from "./hooks/useTableVirtualization.js";
+import { c as u } from "../../styles.module--QBQYoA9.js";
+import { TableCard as g } from "./TableCard.js";
+function y({
+  table: r,
+  virtualized: s,
+  scrollRef: S,
+  isSelectable: c,
+  cardClassName: l,
+  cardHeaderClassName: a,
+  cardValueClassName: m,
+  onCardActionsClick: f,
+  showCardActions: p = !1
+}) {
+  const h = b(null), { rows: n } = r.getRowModel(), { virtualizer: d, rowRefs: w } = v({
+    rows: n,
+    virtualized: s,
+    scrollRef: S,
+    rowSelection: r.getState().rowSelection
+  });
+  if (!s)
+    return /* @__PURE__ */ o("div", { className: u.cardsContainer, children: n.map((t) => /* @__PURE__ */ o(
+      g,
+      {
+        row: t,
+        isSelectable: c,
+        cardClassName: l,
+        cardHeaderClassName: a,
+        cardValueClassName: m,
+        onSelect: (e) => t.toggleSelected(e),
+        onActionsClick: f,
+        showActions: p
+      },
+      t.id
+    )) });
+  const T = d.getVirtualItems(), x = d.getTotalSize();
+  return /* @__PURE__ */ o(
+    "div",
+    {
+      ref: h,
+      className: u.cardsVirtualContainer,
+      style: { height: x, position: "relative" },
+      children: T.map((t) => {
+        const e = n[t.index];
+        return /* @__PURE__ */ o(
+          "div",
+          {
+            ref: (i) => {
+              i && (w.current[e.id] = i);
+            },
+            style: {
+              position: "absolute",
+              top: 0,
+              transform: `translateY(${t.start}px)`,
+              width: "100%"
+            },
+            children: /* @__PURE__ */ o(
+              g,
+              {
+                row: e,
+                isSelectable: c,
+                cardClassName: l,
+                cardHeaderClassName: a,
+                cardValueClassName: m,
+                onSelect: (i) => e.toggleSelected(i),
+                onActionsClick: f,
+                showActions: p
+              }
+            )
+          },
+          t.key
+        );
+      })
+    }
+  );
+}
+const R = V(
+  y
+);
+export {
+  R as TableCardsView
+};

package/dist/components/Table/TableFilters.d.ts

@@ -0,0 +1,12 @@
+import { TTableFilter, TTableFilterValues } from './types';
+
+type TTableFiltersProps = {
+    filters: TTableFilter[];
+    filterValues: TTableFilterValues;
+    isOpen: boolean;
+    onClose: () => void;
+    onApply: (newFilterValues: TTableFilterValues) => void;
+    onReset: () => void;
+};
+export declare const TableFilters: ({ filters, filterValues, isOpen, onClose, onApply, onReset }: TTableFiltersProps) => import("react/jsx-runtime").JSX.Element;
+export {};