@1771technologies/lytenyte-pro 1.0.0-beta.11 → 1.0.0-beta.12

package/dist/column-manager/leaf.js

@@ -5,36 +5,46 @@ import { TreeLeaf } from "../tree-view/leaf";
 import { dragState, DropWrap } from "@1771technologies/lytenyte-dragon";
 import { useGrid } from "../grid-provider/use-grid";
 export const Leaf = forwardRef(function ColumnManagerLeaf({ item, ...props }, forwarded) {
-    const context = useMemo(() => {
-        return { item: item };
-    }, [item]);
-    const grid = useGrid();
-    const id = grid.state.gridId.useValue();
-    const accepted = `${id}/columns`;
-    return (_jsx(ColumnItemContext.Provider, { value: context, children: _jsx(DropWrap, { accepted: [accepted], onEnter: (el) => {
-                const data = dragState.data
-                    .get()
-                    ?.siteLocalData?.[accepted]?.at(-1);
-                if (!data)
-                    return;
-                const columns = [item.leaf.data];
-                const move = data.id;
-                if (columns.some((c) => c.id === move))
-                    return;
-                const allColumns = grid.state.columns.get();
-                const moveIndex = allColumns.findIndex((c) => c.id === move);
-                if (moveIndex === -1)
-                    return;
-                const thisIndex = allColumns.findIndex((c) => c.id === columns[0].id);
-                const isBefore = thisIndex > moveIndex;
-                if (isBefore) {
-                    el.setAttribute("data-ln-is-before", "true");
-                }
-                else {
-                    el.setAttribute("data-ln-is-after", "true");
-                }
-            }, onLeave: (el) => {
-                el.removeAttribute("data-ln-is-before");
-                el.removeAttribute("data-ln-is-after");
-            }, as: _jsx(TreeLeaf, { ...props, itemId: item.leaf.data.id, ref: forwarded, ...item.attrs, style: { ...props.style, ...item.attrs.style }, "data-ln-column-manager-leaf": true, "data-ln-column-id": item.leaf.data.id }) }) }));
+  const context = useMemo(() => {
+    return { item: item };
+  }, [item]);
+  const grid = useGrid();
+  const id = grid.state.gridId.useValue();
+  const accepted = `${id}/columns`;
+  return _jsx(ColumnItemContext.Provider, {
+    value: context,
+    children: _jsx(DropWrap, {
+      accepted: [accepted],
+      onEnter: (el) => {
+        const data = dragState.data.get()?.siteLocalData?.[accepted]?.at(-1);
+        if (!data) return;
+        const columns = [item.leaf.data];
+        const move = data.id;
+        if (columns.some((c) => c.id === move)) return;
+        const allColumns = grid.state.columns.get();
+        const moveIndex = allColumns.findIndex((c) => c.id === move);
+        if (moveIndex === -1) return;
+        const thisIndex = allColumns.findIndex((c) => c.id === columns[0].id);
+        const isBefore = thisIndex > moveIndex;
+        if (isBefore) {
+          el.setAttribute("data-ln-is-before", "true");
+        } else {
+          el.setAttribute("data-ln-is-after", "true");
+        }
+      },
+      onLeave: (el) => {
+        el.removeAttribute("data-ln-is-before");
+        el.removeAttribute("data-ln-is-after");
+      },
+      as: _jsx(TreeLeaf, {
+        ...props,
+        itemId: item.leaf.data.id,
+        ref: forwarded,
+        ...item.attrs,
+        style: { ...props.style, ...item.attrs.style },
+        "data-ln-column-manager-leaf": true,
+        "data-ln-column-id": item.leaf.data.id,
+      }),
+    }),
+  });
 });

package/dist/column-manager/move-handle.d.ts

@@ -3,10 +3,18 @@ import { type ReactNode } from "react";
 import type { Column } from "../+types";
 import type { TreeVirtualItem } from "../tree-view/virtualized/make-virtual-tree";
 export interface MoveHandleProps {
-    readonly slot?: SlotComponent;
-    readonly placeholder?: (p: {
-        columns: Column<any>[];
-        item: TreeVirtualItem<Column<any>>;
-    }) => ReactNode;
+  readonly slot?: SlotComponent;
+  readonly placeholder?: (p: {
+    columns: Column<any>[];
+    item: TreeVirtualItem<Column<any>>;
+  }) => ReactNode;
 }
-export declare const MoveHandle: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & MoveHandleProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const MoveHandle: import("react").ForwardRefExoticComponent<
+  Omit<
+    import("react").ClassAttributes<HTMLDivElement> &
+      import("react").HTMLAttributes<HTMLDivElement> &
+      MoveHandleProps,
+    "ref"
+  > &
+    import("react").RefAttributes<HTMLDivElement>
+>;

package/dist/column-manager/move-handle.js

@@ -1,58 +1,62 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useDraggable } from "@1771technologies/lytenyte-dragon";
-import { useCombinedRefs, useSlot, } from "@1771technologies/lytenyte-react-hooks";
+import { useCombinedRefs, useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { forwardRef, useMemo } from "react";
 import { useColumnItemContext } from "./context";
 import { useColumnsFromContext } from "./use-columns-from-context";
 import { useGrid } from "../grid-provider/use-grid";
-export const MoveHandle = forwardRef(function MoveHandle({ slot, placeholder: Placeholder, ...props }, forwarded) {
-    const item = useColumnItemContext().item;
-    const grid = useGrid();
-    const columns = useColumnsFromContext(item);
-    const base = grid.state.columnBase.useValue();
-    const isMovable = useMemo(() => {
-        return columns.every((c) => c.uiHints?.movable ?? base.uiHints?.movable);
-    }, [base.uiHints?.movable, columns]);
-    const { dragProps: { ref, ...otherProps }, } = useDraggable({
-        getItems: () => {
-            return {
-                siteLocalData: {
-                    [`${grid.state.gridId.get()}/columns`]: columns,
-                },
-            };
+export const MoveHandle = forwardRef(function MoveHandle(
+  { slot, placeholder: Placeholder, ...props },
+  forwarded,
+) {
+  const item = useColumnItemContext().item;
+  const grid = useGrid();
+  const columns = useColumnsFromContext(item);
+  const base = grid.state.columnBase.useValue();
+  const isMovable = useMemo(() => {
+    return columns.every((c) => c.uiHints?.movable ?? base.uiHints?.movable);
+  }, [base.uiHints?.movable, columns]);
+  const {
+    dragProps: { ref, ...otherProps },
+  } = useDraggable({
+    getItems: () => {
+      return {
+        siteLocalData: {
+          [`${grid.state.gridId.get()}/columns`]: columns,
         },
-        onDrop: (p) => {
-            const move = p.dropElement.getAttribute("data-ln-column-id");
-            if (!move)
-                return null;
-            if (columns.some((c) => c.id === move))
-                return;
-            const allColumns = grid.state.columns.get();
-            const moveIndex = allColumns.findIndex((c) => c.id === move);
-            if (moveIndex === -1)
-                return;
-            const thisIndex = allColumns.findIndex((c) => c.id === columns[0].id);
-            const isBefore = thisIndex > moveIndex;
-            grid.api.columnMove({
-                moveColumns: columns,
-                moveTarget: move,
-                before: isBefore,
-            });
-        },
-        placeholder: () => {
-            if (Placeholder)
-                return _jsx(Placeholder, { columns: columns, item: item });
-            return (_jsx("div", { children: item.kind === "branch"
-                    ? item.branch.data.joinPath.at(-1)
-                    : (item.leaf.data.name ?? item.leaf.data.id) }));
-        },
-    });
-    const combined = useCombinedRefs(ref, forwarded);
-    const additionalProps = isMovable ? otherProps : {};
-    const renderer = useSlot({
-        props: [{ "aria-label": "Drag to move column" }, additionalProps, props],
-        ref: isMovable ? combined : forwarded,
-        slot: slot ?? _jsx("div", {}),
-    });
-    return renderer;
+      };
+    },
+    onDrop: (p) => {
+      const move = p.dropElement.getAttribute("data-ln-column-id");
+      if (!move) return null;
+      if (columns.some((c) => c.id === move)) return;
+      const allColumns = grid.state.columns.get();
+      const moveIndex = allColumns.findIndex((c) => c.id === move);
+      if (moveIndex === -1) return;
+      const thisIndex = allColumns.findIndex((c) => c.id === columns[0].id);
+      const isBefore = thisIndex > moveIndex;
+      grid.api.columnMove({
+        moveColumns: columns,
+        moveTarget: move,
+        before: isBefore,
+      });
+    },
+    placeholder: () => {
+      if (Placeholder) return _jsx(Placeholder, { columns: columns, item: item });
+      return _jsx("div", {
+        children:
+          item.kind === "branch"
+            ? item.branch.data.joinPath.at(-1)
+            : (item.leaf.data.name ?? item.leaf.data.id),
+      });
+    },
+  });
+  const combined = useCombinedRefs(ref, forwarded);
+  const additionalProps = isMovable ? otherProps : {};
+  const renderer = useSlot({
+    props: [{ "aria-label": "Drag to move column" }, additionalProps, props],
+    ref: isMovable ? combined : forwarded,
+    slot: slot ?? _jsx("div", {}),
+  });
+  return renderer;
 });

package/dist/column-manager/root.d.ts

@@ -3,7 +3,13 @@ import type { Column, Grid } from "../+types";
 import type { UseColumnManagerReturn } from "./use-column-manager";
 import type { PathRoot } from "@1771technologies/lytenyte-shared";
 export type ColumnManagerRootProps<T> = UseColumnManagerReturn<T>["rootProps"] & {
-    readonly grid: Grid<T>;
-    readonly root: PathRoot<Column<any>>;
+  readonly grid: Grid<T>;
+  readonly root: PathRoot<Column<any>>;
 };
-export declare function Root<T>({ grid, children, treeRef, root, ...rootProps }: PropsWithChildren<ColumnManagerRootProps<T>>): import("react/jsx-runtime").JSX.Element;
+export declare function Root<T>({
+  grid,
+  children,
+  treeRef,
+  root,
+  ...rootProps
+}: PropsWithChildren<ColumnManagerRootProps<T>>): import("react/jsx-runtime").JSX.Element;

package/dist/column-manager/root.js

@@ -4,17 +4,30 @@ import { GridProvider } from "../grid-provider/provider";
 import { TreeRoot } from "../tree-view/root";
 import { branchLookupContext } from "./branch-lookup-context";
 export function Root({ grid, children, treeRef, root, ...rootProps }) {
-    const branchLookup = useMemo(() => {
-        const stack = [...root.children.values()];
-        const lookup = {};
-        while (stack.length) {
-            const item = stack.pop();
-            if (item.kind === "leaf")
-                continue;
-            lookup[item.data.idOccurrence] = item;
-            stack.push(...item.children.values());
-        }
-        return lookup;
-    }, [root.children]);
-    return (_jsx(branchLookupContext.Provider, { value: branchLookup, children: _jsx(GridProvider, { value: grid, children: _jsx(TreeRoot, { selectMode: "multiple", transitionEnter: 200, transitionExit: 200, expansionDefault: true, ref: treeRef, ...rootProps, children: children }) }) }));
+  const branchLookup = useMemo(() => {
+    const stack = [...root.children.values()];
+    const lookup = {};
+    while (stack.length) {
+      const item = stack.pop();
+      if (item.kind === "leaf") continue;
+      lookup[item.data.idOccurrence] = item;
+      stack.push(...item.children.values());
+    }
+    return lookup;
+  }, [root.children]);
+  return _jsx(branchLookupContext.Provider, {
+    value: branchLookup,
+    children: _jsx(GridProvider, {
+      value: grid,
+      children: _jsx(TreeRoot, {
+        selectMode: "multiple",
+        transitionEnter: 200,
+        transitionExit: 200,
+        expansionDefault: true,
+        ref: treeRef,
+        ...rootProps,
+        children: children,
+      }),
+    }),
+  });
 }

package/dist/column-manager/use-column-manager.d.ts

@@ -3,17 +3,17 @@ import type { Column, Grid } from "../+types.js";
 import type { TreeVirtualItem } from "../tree-view/virtualized/make-virtual-tree.js";
 import type { PathRoot } from "@1771technologies/lytenyte-shared";
 export interface UseColumnManagerReturn<T> {
-    readonly rootProps: {
-        readonly grid: Grid<T>;
-        readonly expansions: Record<string, boolean>;
-        readonly onExpansionChange: Dispatch<SetStateAction<Record<string, boolean>>>;
-        readonly treeRef: (el: HTMLElement | null) => void;
-        readonly getAllIds: () => Set<string>;
-        readonly getIdsBetweenNodes: (left: HTMLElement, right: HTMLElement) => string[];
-        readonly onFocusChange: (el: HTMLElement | null) => void;
-        readonly root: PathRoot<Column<T>>;
-    };
-    readonly tree: TreeVirtualItem<Column<T>>[];
-    readonly spacer: JSX.Element;
+  readonly rootProps: {
+    readonly grid: Grid<T>;
+    readonly expansions: Record<string, boolean>;
+    readonly onExpansionChange: Dispatch<SetStateAction<Record<string, boolean>>>;
+    readonly treeRef: (el: HTMLElement | null) => void;
+    readonly getAllIds: () => Set<string>;
+    readonly getIdsBetweenNodes: (left: HTMLElement, right: HTMLElement) => string[];
+    readonly onFocusChange: (el: HTMLElement | null) => void;
+    readonly root: PathRoot<Column<T>>;
+  };
+  readonly tree: TreeVirtualItem<Column<T>>[];
+  readonly spacer: JSX.Element;
 }
 export declare function useColumnManager<T>(grid: Grid<T>): UseColumnManagerReturn<T>;

package/dist/column-manager/use-column-manager.js

@@ -1,24 +1,24 @@
 import { useState } from "react";
 import { useVirtualizedTree } from "../tree-view/virtualized/use-virtualized-tree.js";
 export function useColumnManager(grid) {
-    const [expansions, onExpansionChange] = useState({});
-    const columns = grid.state.columns.useValue();
-    const virt = useVirtualizedTree({
-        paths: columns,
-        expansions,
-        itemHeight: 24,
-        expansionDefault: true,
-        nonAdjacentPathTrees: true,
-    });
-    return {
-        rootProps: {
-            grid,
-            expansions,
-            onExpansionChange,
-            treeRef: virt.ref,
-            ...virt.rootProps,
-        },
-        spacer: virt.spacer,
-        tree: virt.virtualTree,
-    };
+  const [expansions, onExpansionChange] = useState({});
+  const columns = grid.state.columns.useValue();
+  const virt = useVirtualizedTree({
+    paths: columns,
+    expansions,
+    itemHeight: 24,
+    expansionDefault: true,
+    nonAdjacentPathTrees: true,
+  });
+  return {
+    rootProps: {
+      grid,
+      expansions,
+      onExpansionChange,
+      treeRef: virt.ref,
+      ...virt.rootProps,
+    },
+    spacer: virt.spacer,
+    tree: virt.virtualTree,
+  };
 }

package/dist/column-manager/use-columns-from-context.js

@@ -1,23 +1,23 @@
 import { useMemo } from "react";
 import { useBranchLookup } from "./branch-lookup-context.js";
 export function useColumnsFromContext(item) {
-    const lookup = useBranchLookup();
-    const columns = useMemo(() => {
-        if (item.kind === "branch") {
-            const allChildren = [];
-            const branch = lookup[item.branch.data.idOccurrence];
-            const stack = [...branch.children.values()];
-            while (stack.length) {
-                const p = stack.pop();
-                if (p.kind === "branch") {
-                    stack.push(...p.children.values());
-                    continue;
-                }
-                allChildren.push(p.data);
-            }
-            return allChildren;
+  const lookup = useBranchLookup();
+  const columns = useMemo(() => {
+    if (item.kind === "branch") {
+      const allChildren = [];
+      const branch = lookup[item.branch.data.idOccurrence];
+      const stack = [...branch.children.values()];
+      while (stack.length) {
+        const p = stack.pop();
+        if (p.kind === "branch") {
+          stack.push(...p.children.values());
+          continue;
         }
-        return [item.leaf.data];
-    }, [item, lookup]);
-    return columns;
+        allChildren.push(p.data);
+      }
+      return allChildren;
+    }
+    return [item.leaf.data];
+  }, [item, lookup]);
+  return columns;
 }

package/dist/column-manager/visibility-checkbox.d.ts

@@ -1,9 +1,17 @@
 import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
 export interface VisibilityCheckbox {
-    readonly slot?: SlotComponent<{
-        visible: boolean;
-        indeterminate: boolean;
-        toggle: (s?: boolean) => void;
-    }>;
+  readonly slot?: SlotComponent<{
+    visible: boolean;
+    indeterminate: boolean;
+    toggle: (s?: boolean) => void;
+  }>;
 }
-export declare const VisibilityCheckbox: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & VisibilityCheckbox, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const VisibilityCheckbox: import("react").ForwardRefExoticComponent<
+  Omit<
+    import("react").ClassAttributes<HTMLDivElement> &
+      import("react").HTMLAttributes<HTMLDivElement> &
+      VisibilityCheckbox,
+    "ref"
+  > &
+    import("react").RefAttributes<HTMLDivElement>
+>;

package/dist/column-manager/visibility-checkbox.js

@@ -4,27 +4,40 @@ import { useColumnItemContext } from "./context";
 import { forwardRef, useCallback, useMemo } from "react";
 import { useGrid } from "../grid-provider/use-grid";
 import { useColumnsFromContext } from "./use-columns-from-context";
-export const VisibilityCheckbox = forwardRef(function VisibilityCheckbox({ slot, ...props }, forwarded) {
-    const { item } = useColumnItemContext();
-    const grid = useGrid();
-    const base = grid.state.columnBase.useValue();
-    const columns = useColumnsFromContext(item);
-    const [isVisible, isIndeterminate] = useMemo(() => {
-        const allVisible = columns.every((c) => !(c.hide ?? base.hide));
-        const someVisible = columns.some((c) => !(c.hide ?? base.hide));
-        return [allVisible, !allVisible && someVisible];
-    }, [base.hide, columns]);
-    const toggle = useCallback((s) => {
-        const next = s ?? isVisible;
-        grid.api.columnUpdate(Object.fromEntries(columns.map((c) => [c.id, { hide: next }])));
-    }, [columns, grid.api, isVisible]);
-    const rendered = useSlot({
-        props: [props],
-        ref: forwarded,
-        slot: slot ?? (_jsx("input", { type: "checkbox", checked: isVisible, "aria-label": "visibility toggle", onChange: () => {
-                toggle();
-            } })),
-        state: { visible: isVisible, indeterminate: isIndeterminate, toggle },
-    });
-    return rendered;
+export const VisibilityCheckbox = forwardRef(function VisibilityCheckbox(
+  { slot, ...props },
+  forwarded,
+) {
+  const { item } = useColumnItemContext();
+  const grid = useGrid();
+  const base = grid.state.columnBase.useValue();
+  const columns = useColumnsFromContext(item);
+  const [isVisible, isIndeterminate] = useMemo(() => {
+    const allVisible = columns.every((c) => !(c.hide ?? base.hide));
+    const someVisible = columns.some((c) => !(c.hide ?? base.hide));
+    return [allVisible, !allVisible && someVisible];
+  }, [base.hide, columns]);
+  const toggle = useCallback(
+    (s) => {
+      const next = s ?? isVisible;
+      grid.api.columnUpdate(Object.fromEntries(columns.map((c) => [c.id, { hide: next }])));
+    },
+    [columns, grid.api, isVisible],
+  );
+  const rendered = useSlot({
+    props: [props],
+    ref: forwarded,
+    slot:
+      slot ??
+      _jsx("input", {
+        type: "checkbox",
+        checked: isVisible,
+        "aria-label": "visibility toggle",
+        onChange: () => {
+          toggle();
+        },
+      }),
+    state: { visible: isVisible, indeterminate: isIndeterminate, toggle },
+  });
+  return rendered;
 });

package/dist/context.d.ts

@@ -1,10 +1,10 @@
 import type { Grid } from "./+types";
 import type { InternalAtoms } from "./state/+types";
 export interface GridRootContext {
-    readonly ref: (el: HTMLElement | SVGElement | null) => void;
-    readonly grid: Grid<any> & {
-        internal: InternalAtoms;
-    };
+  readonly ref: (el: HTMLElement | SVGElement | null) => void;
+  readonly grid: Grid<any> & {
+    internal: InternalAtoms;
+  };
 }
 export declare const RootProvider: import("react").Provider<GridRootContext>;
 export declare const useGridRoot: () => GridRootContext;

package/dist/filter-tree/branch.d.ts

@@ -2,9 +2,17 @@ import type { TreeVirtualBranch } from "../tree-view/virtualized/make-virtual-tr
 import type { FilterInFilterItem } from "../+types";
 import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
 export interface FilterTreeBranch {
-    readonly item: TreeVirtualBranch<FilterInFilterItem>;
-    readonly label: SlotComponent;
-    readonly labelWrap?: SlotComponent;
-    readonly expander?: SlotComponent;
+  readonly item: TreeVirtualBranch<FilterInFilterItem>;
+  readonly label: SlotComponent;
+  readonly labelWrap?: SlotComponent;
+  readonly expander?: SlotComponent;
 }
-export declare const Branch: import("react").ForwardRefExoticComponent<Omit<FilterTreeBranch & import("react").ClassAttributes<HTMLLIElement> & import("react").LiHTMLAttributes<HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+export declare const Branch: import("react").ForwardRefExoticComponent<
+  Omit<
+    FilterTreeBranch &
+      import("react").ClassAttributes<HTMLLIElement> &
+      import("react").LiHTMLAttributes<HTMLLIElement>,
+    "ref"
+  > &
+    import("react").RefAttributes<HTMLLIElement>
+>;

package/dist/filter-tree/branch.js

@@ -5,17 +5,27 @@ import { useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { FilterTreeItemContext } from "./context";
 import { useTreeItem } from "./hooks/use-tree-item";
 export const Branch = forwardRef(function Branch({ item, labelWrap, label, ...props }, forwarded) {
-    const value = useTreeItem(item);
-    const labelSlot = useSlot({
-        slot: labelWrap ?? _jsx("div", {}),
-        props: [
-            {
-                onClick: () => value.onCheckChange(),
-            },
-        ],
-    });
-    return (_jsx(FilterTreeItemContext.Provider, { value: value, children: _jsx(TreeBranch, { ...props, itemId: item.branch.data.idOccurrence, ref: forwarded, ...item.attrs, onKeyDown: (ev) => {
-                if (ev.key === " ")
-                    value.onCheckChange();
-            }, label: label, labelWrap: labelSlot }) }));
+  const value = useTreeItem(item);
+  const labelSlot = useSlot({
+    slot: labelWrap ?? _jsx("div", {}),
+    props: [
+      {
+        onClick: () => value.onCheckChange(),
+      },
+    ],
+  });
+  return _jsx(FilterTreeItemContext.Provider, {
+    value: value,
+    children: _jsx(TreeBranch, {
+      ...props,
+      itemId: item.branch.data.idOccurrence,
+      ref: forwarded,
+      ...item.attrs,
+      onKeyDown: (ev) => {
+        if (ev.key === " ") value.onCheckChange();
+      },
+      label: label,
+      labelWrap: labelSlot,
+    }),
+  });
 });

package/dist/filter-tree/context.d.ts

@@ -2,26 +2,26 @@ import { type Dispatch, type SetStateAction } from "react";
 import type { TreeVirtualItem } from "../tree-view/virtualized/make-virtual-tree";
 import type { FilterIn, FilterInFilterItem } from "../+types";
 export interface TreeItemContextValue {
-    readonly item: TreeVirtualItem<FilterInFilterItem>;
-    readonly onCheckChange: (b?: boolean) => void;
-    readonly isChecked: boolean;
-    readonly isIndeterminate: boolean;
+  readonly item: TreeVirtualItem<FilterInFilterItem>;
+  readonly onCheckChange: (b?: boolean) => void;
+  readonly isChecked: boolean;
+  readonly isIndeterminate: boolean;
 }
 export declare const FilterTreeContext: import("react").Context<{
-    items: FilterInFilterItem[];
-    pivotMode: boolean;
-    columnId: string;
-    filter: FilterIn;
-    filterChange: Dispatch<SetStateAction<FilterIn>>;
-    applyChangesImmediately: boolean;
+  items: FilterInFilterItem[];
+  pivotMode: boolean;
+  columnId: string;
+  filter: FilterIn;
+  filterChange: Dispatch<SetStateAction<FilterIn>>;
+  applyChangesImmediately: boolean;
 }>;
 export declare const useTreeContext: () => {
-    items: FilterInFilterItem[];
-    pivotMode: boolean;
-    columnId: string;
-    filter: FilterIn;
-    filterChange: Dispatch<SetStateAction<FilterIn>>;
-    applyChangesImmediately: boolean;
+  items: FilterInFilterItem[];
+  pivotMode: boolean;
+  columnId: string;
+  filter: FilterIn;
+  filterChange: Dispatch<SetStateAction<FilterIn>>;
+  applyChangesImmediately: boolean;
 };
 export declare const FilterTreeItemContext: import("react").Context<TreeItemContextValue>;
 export declare const useTreeItemContext: () => TreeItemContextValue;