@1771technologies/lytenyte-pro 1.0.0-beta.33 → 1.0.0-beta.36

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;

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

@@ -3,12 +3,53 @@ import { InclusionCheckbox } from "./inclusion-checkbox.js";
 import { Root } from "./root.js";
 import { useFilterTree } from "./hooks/use-filter-tree.js";
 export declare const FilterTree: {
-    Root: typeof Root;
-    Panel: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & import("react").RefAttributes<HTMLUListElement>>;
-    PassiveScroll: typeof ForceSyncScrolling;
-    Leaf: import("react").ForwardRefExoticComponent<Omit<import("./leaf.js").FilterTreeLeafProps & import("react").ClassAttributes<HTMLLIElement> & import("react").LiHTMLAttributes<HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
-    Branch: import("react").ForwardRefExoticComponent<Omit<import("./branch.js").FilterTreeBranch & import("react").ClassAttributes<HTMLLIElement> & import("react").LiHTMLAttributes<HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
-    Label: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & import("./label.js").LabelProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
-    Checkbox: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & InclusionCheckbox, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
-    useFilterTree: typeof useFilterTree;
+  Root: typeof Root;
+  Panel: import("react").ForwardRefExoticComponent<
+    Omit<
+      import("react").DetailedHTMLProps<
+        import("react").HTMLAttributes<HTMLUListElement>,
+        HTMLUListElement
+      >,
+      "ref"
+    > &
+      import("react").RefAttributes<HTMLUListElement>
+  >;
+  PassiveScroll: typeof ForceSyncScrolling;
+  Leaf: import("react").ForwardRefExoticComponent<
+    Omit<
+      import("./leaf.js").FilterTreeLeafProps &
+        import("react").ClassAttributes<HTMLLIElement> &
+        import("react").LiHTMLAttributes<HTMLLIElement>,
+      "ref"
+    > &
+      import("react").RefAttributes<HTMLLIElement>
+  >;
+  Branch: import("react").ForwardRefExoticComponent<
+    Omit<
+      import("./branch.js").FilterTreeBranch &
+        import("react").ClassAttributes<HTMLLIElement> &
+        import("react").LiHTMLAttributes<HTMLLIElement>,
+      "ref"
+    > &
+      import("react").RefAttributes<HTMLLIElement>
+  >;
+  Label: import("react").ForwardRefExoticComponent<
+    Omit<
+      import("react").ClassAttributes<HTMLDivElement> &
+        import("react").HTMLAttributes<HTMLDivElement> &
+        import("./label.js").LabelProps,
+      "ref"
+    > &
+      import("react").RefAttributes<HTMLDivElement>
+  >;
+  Checkbox: import("react").ForwardRefExoticComponent<
+    Omit<
+      import("react").ClassAttributes<HTMLDivElement> &
+        import("react").HTMLAttributes<HTMLDivElement> &
+        InclusionCheckbox,
+      "ref"
+    > &
+      import("react").RefAttributes<HTMLDivElement>
+  >;
+  useFilterTree: typeof useFilterTree;
 };

package/dist/filter-tree/filter-tree.js

@@ -7,12 +7,12 @@ import { Leaf } from "./leaf.js";
 import { Root } from "./root.js";
 import { useFilterTree } from "./hooks/use-filter-tree.js";
 export const FilterTree = {
-    Root,
-    Panel: TreePanel,
-    PassiveScroll: ForceSyncScrolling,
-    Leaf: Leaf,
-    Branch: Branch,
-    Label: Label,
-    Checkbox: InclusionCheckbox,
-    useFilterTree,
+  Root,
+  Panel: TreePanel,
+  PassiveScroll: ForceSyncScrolling,
+  Leaf: Leaf,
+  Branch: Branch,
+  Label: Label,
+  Checkbox: InclusionCheckbox,
+  useFilterTree,
 };

package/dist/filter-tree/hooks/use-filter-tree.d.ts

@@ -3,35 +3,41 @@ import type { Column, FilterIn, FilterInFilterItem, Grid } from "../../+types";
 import type { PathRoot } from "@1771technologies/lytenyte-shared";
 import type { TreeVirtualItem } from "../../tree-view/virtualized/make-virtual-tree";
 export interface UseTreeFilterReturn<T> {
-    readonly rootProps: {
-        readonly fetchItems: () => void;
-        readonly loading: boolean;
-        readonly error: any;
-        readonly pivotMode: boolean;
-        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<FilterInFilterItem>;
-        readonly columnId: string;
-        readonly items: FilterInFilterItem[];
-        readonly applyChangesImmediately: boolean;
-        readonly filterIn: FilterIn;
-        readonly filterInChange: Dispatch<SetStateAction<FilterIn>>;
-    };
-    readonly tree: TreeVirtualItem<FilterInFilterItem>[];
-    readonly spacer: JSX.Element;
-    readonly apply: () => void;
-    readonly reset: () => void;
+  readonly rootProps: {
+    readonly fetchItems: () => void;
+    readonly loading: boolean;
+    readonly error: any;
+    readonly pivotMode: boolean;
+    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<FilterInFilterItem>;
+    readonly columnId: string;
+    readonly items: FilterInFilterItem[];
+    readonly applyChangesImmediately: boolean;
+    readonly filterIn: FilterIn;
+    readonly filterInChange: Dispatch<SetStateAction<FilterIn>>;
+  };
+  readonly tree: TreeVirtualItem<FilterInFilterItem>[];
+  readonly spacer: JSX.Element;
+  readonly apply: () => void;
+  readonly reset: () => void;
 }
 export interface UseFilterTreeArgs<T> {
-    grid: Grid<T>;
-    column: Column<T>;
-    treeItemHeight?: number;
-    pivotMode?: boolean;
-    applyChangesImmediately?: boolean;
+  grid: Grid<T>;
+  column: Column<T>;
+  treeItemHeight?: number;
+  pivotMode?: boolean;
+  applyChangesImmediately?: boolean;
 }
-export declare function useFilterTree<T>({ grid, column, treeItemHeight, pivotMode, applyChangesImmediately, }: UseFilterTreeArgs<T>): UseTreeFilterReturn<T>;
+export declare function useFilterTree<T>({
+  grid,
+  column,
+  treeItemHeight,
+  pivotMode,
+  applyChangesImmediately,
+}: UseFilterTreeArgs<T>): UseTreeFilterReturn<T>;

package/dist/filter-tree/hooks/use-filter-tree.js

@@ -1,96 +1,98 @@
 import { useEffect, useMemo, useState } from "react";
 import { useVirtualizedTree } from "../../tree-view/virtualized/use-virtualized-tree";
 import { useEvent } from "@1771technologies/lytenyte-react-hooks";
-export function useFilterTree({ grid, column, treeItemHeight = 24, pivotMode, applyChangesImmediately = false, }) {
-    const [items, setItems] = useState([]);
-    const [expansions, onExpansionChange] = useState({});
-    const [loading, setLoading] = useState(false);
-    const [error, setError] = useState();
-    const rds = grid.state.rowDataSource.useValue();
-    const filterModel = grid.state.filterInModel.useValue();
-    const pivotModel = grid.state.columnPivotModel.useValue().filtersIn;
-    const currentPivotMode = grid.state.columnPivotMode.useValue();
-    const model = (pivotMode ?? currentPivotMode) ? pivotModel : filterModel;
-    const existingFilter = useMemo(() => {
-        const filter = model[column.id];
-        return filter ?? { kind: "in", operator: "not_in", value: new Set() };
-    }, [column.id, model]);
-    const [changes, setChanges] = useState(() => existingFilter);
-    // Keep in sync with any external changes.
-    useEffect(() => {
-        setChanges(existingFilter);
-    }, [existingFilter]);
-    const fetchItems = useEvent(() => {
-        const items = rds.inFilterItems(column);
-        if ("then" in items) {
-            setLoading(true);
-            items
-                .then((res) => {
-                setItems(res);
-                setError(null);
-            })
-                .catch((error) => setError(error))
-                .finally(() => setLoading(false));
-        }
-        else {
-            setItems(items);
-            setError(null);
-            setLoading(false);
-        }
-    });
-    useEffect(() => {
-        fetchItems();
-    }, [column, fetchItems, rds]);
-    const itemsWithSelectAll = useMemo(() => {
-        return [{ id: "__LNG__SELECT_ALL", label: "(Select All)", value: "" }, ...items];
-    }, [items]);
-    const virt = useVirtualizedTree({
-        itemHeight: treeItemHeight,
-        paths: itemsWithSelectAll,
-        expansions,
-        expansionDefault: true,
-        nonAdjacentPathTrees: false,
-    });
-    const apply = useEvent(() => {
-        if (applyChangesImmediately)
-            return;
-        if (pivotMode) {
-            grid.state.columnPivotModel.set((prev) => {
-                return {
-                    ...prev,
-                    filtersIn: { ...prev.filtersIn, [column.id]: changes },
-                };
-            });
-        }
-        else {
-            grid.state.filterInModel.set((prev) => ({ ...prev, [column.id]: changes }));
-        }
-    });
-    const reset = useEvent(() => {
-        if (applyChangesImmediately)
-            return;
-        setChanges(existingFilter);
-    });
-    return {
-        rootProps: {
-            fetchItems,
-            items,
-            grid,
-            columnId: column.id,
-            expansions,
-            pivotMode: pivotMode ?? currentPivotMode,
-            onExpansionChange,
-            treeRef: virt.ref,
-            loading,
-            error,
-            filterIn: changes,
-            filterInChange: setChanges,
-            applyChangesImmediately,
-            ...virt.rootProps,
-        },
-        spacer: virt.spacer,
-        tree: virt.virtualTree,
-        apply,
-        reset,
-    };
+export function useFilterTree({
+  grid,
+  column,
+  treeItemHeight = 24,
+  pivotMode,
+  applyChangesImmediately = false,
+}) {
+  const [items, setItems] = useState([]);
+  const [expansions, onExpansionChange] = useState({});
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState();
+  const rds = grid.state.rowDataSource.useValue();
+  const filterModel = grid.state.filterInModel.useValue();
+  const pivotModel = grid.state.columnPivotModel.useValue().filtersIn;
+  const currentPivotMode = grid.state.columnPivotMode.useValue();
+  const model = (pivotMode ?? currentPivotMode) ? pivotModel : filterModel;
+  const existingFilter = useMemo(() => {
+    const filter = model[column.id];
+    return filter ?? { kind: "in", operator: "not_in", value: new Set() };
+  }, [column.id, model]);
+  const [changes, setChanges] = useState(() => existingFilter);
+  // Keep in sync with any external changes.
+  useEffect(() => {
+    setChanges(existingFilter);
+  }, [existingFilter]);
+  const fetchItems = useEvent(() => {
+    const items = rds.inFilterItems(column);
+    if ("then" in items) {
+      setLoading(true);
+      items
+        .then((res) => {
+          setItems(res);
+          setError(null);
+        })
+        .catch((error) => setError(error))
+        .finally(() => setLoading(false));
+    } else {
+      setItems(items);
+      setError(null);
+      setLoading(false);
+    }
+  });
+  useEffect(() => {
+    fetchItems();
+  }, [column, fetchItems, rds]);
+  const itemsWithSelectAll = useMemo(() => {
+    return [{ id: "__LNG__SELECT_ALL", label: "(Select All)", value: "" }, ...items];
+  }, [items]);
+  const virt = useVirtualizedTree({
+    itemHeight: treeItemHeight,
+    paths: itemsWithSelectAll,
+    expansions,
+    expansionDefault: true,
+    nonAdjacentPathTrees: false,
+  });
+  const apply = useEvent(() => {
+    if (applyChangesImmediately) return;
+    if (pivotMode) {
+      grid.state.columnPivotModel.set((prev) => {
+        return {
+          ...prev,
+          filtersIn: { ...prev.filtersIn, [column.id]: changes },
+        };
+      });
+    } else {
+      grid.state.filterInModel.set((prev) => ({ ...prev, [column.id]: changes }));
+    }
+  });
+  const reset = useEvent(() => {
+    if (applyChangesImmediately) return;
+    setChanges(existingFilter);
+  });
+  return {
+    rootProps: {
+      fetchItems,
+      items,
+      grid,
+      columnId: column.id,
+      expansions,
+      pivotMode: pivotMode ?? currentPivotMode,
+      onExpansionChange,
+      treeRef: virt.ref,
+      loading,
+      error,
+      filterIn: changes,
+      filterInChange: setChanges,
+      applyChangesImmediately,
+      ...virt.rootProps,
+    },
+    spacer: virt.spacer,
+    tree: virt.virtualTree,
+    apply,
+    reset,
+  };
 }

package/dist/filter-tree/hooks/use-tree-item.d.ts

@@ -1,8 +1,8 @@
 import type { FilterInFilterItem } from "../../+types.js";
 import type { TreeVirtualItem } from "../../tree-view/virtualized/make-virtual-tree.js";
 export declare function useTreeItem(item: TreeVirtualItem<FilterInFilterItem>): {
-    onCheckChange: (b?: boolean) => void;
-    isChecked: boolean;
-    isIndeterminate: boolean;
-    item: TreeVirtualItem<FilterInFilterItem>;
+  onCheckChange: (b?: boolean) => void;
+  isChecked: boolean;
+  isIndeterminate: boolean;
+  item: TreeVirtualItem<FilterInFilterItem>;
 };

package/dist/filter-tree/hooks/use-tree-item.js

@@ -2,115 +2,108 @@ import { useCallback, useMemo } from "react";
 import { useGrid } from "../../grid-provider/use-grid.js";
 import { useTreeContext } from "../context.js";
 function isSelectAll(item) {
-    return item.kind === "leaf" && item.leaf.data.id === "__LNG__SELECT_ALL";
+  return item.kind === "leaf" && item.leaf.data.id === "__LNG__SELECT_ALL";
 }
 export function useTreeItem(item) {
-    const { filter, filterChange, pivotMode, columnId, items, applyChangesImmediately } = useTreeContext();
-    const grid = useGrid();
-    const itemValues = useMemo(() => {
-        if (item.kind === "leaf")
-            return [item.leaf.data.value];
-        const leafItems = [];
-        const stack = [...item.children.values()];
-        while (stack.length) {
-            const c = stack.pop();
-            if (c.kind === "leaf")
-                leafItems.push(c.leaf.data.value);
-            else
-                stack.push(...c.children.values());
+  const { filter, filterChange, pivotMode, columnId, items, applyChangesImmediately } =
+    useTreeContext();
+  const grid = useGrid();
+  const itemValues = useMemo(() => {
+    if (item.kind === "leaf") return [item.leaf.data.value];
+    const leafItems = [];
+    const stack = [...item.children.values()];
+    while (stack.length) {
+      const c = stack.pop();
+      if (c.kind === "leaf") leafItems.push(c.leaf.data.value);
+      else stack.push(...c.children.values());
+    }
+    return leafItems;
+  }, [item]);
+  const isChecked = useMemo(() => {
+    if (filter.operator === "in") {
+      if (isSelectAll(item)) {
+        return items.every((c) => filter.value.has(c.value));
+      }
+      return itemValues.every((c) => filter.value.has(c));
+    } else {
+      if (isSelectAll(item)) {
+        return filter.value.size === 0;
+      }
+      return itemValues.every((c) => !filter.value.has(c));
+    }
+  }, [filter.operator, filter.value, item, itemValues, items]);
+  const isIndeterminate = useMemo(() => {
+    if (filter.operator === "in") {
+      if (isSelectAll(item)) {
+        return !isChecked && items.some((c) => filter.value.has(c));
+      }
+      return !isChecked && itemValues.some((c) => filter.value.has(c));
+    } else {
+      if (isSelectAll(item)) {
+        return !isChecked && filter.value.size > 0 && items.some((c) => !filter.value.has(c));
+      }
+      return !isChecked && itemValues.some((c) => !filter.value.has(c));
+    }
+  }, [item, isChecked, itemValues, filter, items]);
+  const onCheckChange = useCallback(
+    (b) => {
+      const checked = b ?? !isChecked;
+      let nextValue;
+      const operator = filter.operator;
+      if (isSelectAll(item)) {
+        if (operator === "in") {
+          nextValue = checked ? new Set(items.map((c) => c.value)) : new Set();
+        } else {
+          nextValue = checked ? new Set() : new Set(items.map((c) => c.value));
         }
-        return leafItems;
-    }, [item]);
-    const isChecked = useMemo(() => {
-        if (filter.operator === "in") {
-            if (isSelectAll(item)) {
-                return items.every((c) => filter.value.has(c.value));
-            }
-            return itemValues.every((c) => filter.value.has(c));
+      } else {
+        nextValue = new Set(filter.value);
+        if (operator === "in") {
+          if (checked) itemValues.forEach((c) => nextValue.add(c));
+          else itemValues.forEach((c) => nextValue.delete(c));
+        } else {
+          if (checked) itemValues.forEach((c) => nextValue.delete(c));
+          else itemValues.forEach((c) => nextValue.add(c));
         }
-        else {
-            if (isSelectAll(item)) {
-                return filter.value.size === 0;
-            }
-            return itemValues.every((c) => !filter.value.has(c));
+      }
+      if (!applyChangesImmediately) {
+        filterChange({ kind: "in", operator, value: nextValue });
+      } else {
+        if (pivotMode) {
+          grid.state.columnPivotModel.set((prev) => {
+            return {
+              ...prev,
+              filtersIn: {
+                ...prev.filtersIn,
+                [columnId]: { kind: "in", operator, value: nextValue },
+              },
+            };
+          });
+        } else {
+          grid.state.filterInModel.set((prev) => ({
+            ...prev,
+            [columnId]: { kind: "in", operator, value: nextValue },
+          }));
         }
-    }, [filter.operator, filter.value, item, itemValues, items]);
-    const isIndeterminate = useMemo(() => {
-        if (filter.operator === "in") {
-            if (isSelectAll(item)) {
-                return !isChecked && items.some((c) => filter.value.has(c));
-            }
-            return !isChecked && itemValues.some((c) => filter.value.has(c));
-        }
-        else {
-            if (isSelectAll(item)) {
-                return (!isChecked && filter.value.size > 0 && items.some((c) => !filter.value.has(c)));
-            }
-            return !isChecked && itemValues.some((c) => !filter.value.has(c));
-        }
-    }, [item, isChecked, itemValues, filter, items]);
-    const onCheckChange = useCallback((b) => {
-        const checked = b ?? !isChecked;
-        let nextValue;
-        const operator = filter.operator;
-        if (isSelectAll(item)) {
-            if (operator === "in") {
-                nextValue = checked ? new Set(items.map((c) => c.value)) : new Set();
-            }
-            else {
-                nextValue = checked ? new Set() : new Set(items.map((c) => c.value));
-            }
-        }
-        else {
-            nextValue = new Set(filter.value);
-            if (operator === "in") {
-                if (checked)
-                    itemValues.forEach((c) => nextValue.add(c));
-                else
-                    itemValues.forEach((c) => nextValue.delete(c));
-            }
-            else {
-                if (checked)
-                    itemValues.forEach((c) => nextValue.delete(c));
-                else
-                    itemValues.forEach((c) => nextValue.add(c));
-            }
-        }
-        if (!applyChangesImmediately) {
-            filterChange({ kind: "in", operator, value: nextValue });
-        }
-        else {
-            if (pivotMode) {
-                grid.state.columnPivotModel.set((prev) => {
-                    return {
-                        ...prev,
-                        filtersIn: {
-                            ...prev.filtersIn,
-                            [columnId]: { kind: "in", operator, value: nextValue },
-                        },
-                    };
-                });
-            }
-            else {
-                grid.state.filterInModel.set((prev) => ({
-                    ...prev,
-                    [columnId]: { kind: "in", operator, value: nextValue },
-                }));
-            }
-        }
-    }, [
-        isChecked,
-        item,
-        itemValues,
-        filter.operator,
-        filter.value,
-        applyChangesImmediately,
-        items,
-        filterChange,
-        pivotMode,
-        grid.state.columnPivotModel,
-        grid.state.filterInModel,
-        columnId,
-    ]);
-    return useMemo(() => ({ onCheckChange, isChecked, isIndeterminate, item }), [isChecked, isIndeterminate, item, onCheckChange]);
+      }
+    },
+    [
+      isChecked,
+      item,
+      itemValues,
+      filter.operator,
+      filter.value,
+      applyChangesImmediately,
+      items,
+      filterChange,
+      pivotMode,
+      grid.state.columnPivotModel,
+      grid.state.filterInModel,
+      columnId,
+    ],
+  );
+  return useMemo(
+    () => ({ onCheckChange, isChecked, isIndeterminate, item }),
+    [isChecked, isIndeterminate, item, onCheckChange],
+  );
 }

package/dist/filter-tree/inclusion-checkbox.d.ts

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