@vuu-ui/vuu-filters 3.3.9 → 3.3.10

package/types/src/filter-editor/FilterEditor.d.ts

@@ -0,0 +1,14 @@
+import type { Filter } from "@vuu-ui/vuu-filter-types";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { HTMLAttributes } from "react";
+import { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export type FilterEditSaveHandler = (filter: Filter) => void;
+export type FilterEditCancelHandler = (filter?: Filter) => void;
+export interface FilterEditorProps extends HTMLAttributes<HTMLDivElement> {
+    columnDescriptors: readonly ColumnDescriptor[];
+    filter?: Filter;
+    onCancel: FilterEditCancelHandler;
+    onSave: FilterEditSaveHandler;
+    vuuTable: VuuTable;
+}
+export declare const FilterEditor: ({ columnDescriptors, filter, onCancel, onSave, vuuTable, ...htmlAttributes }: FilterEditorProps) => import("react").JSX.Element;

package/types/src/filter-editor/index.d.ts

@@ -0,0 +1 @@
+export * from "./FilterEditor";

package/types/src/filter-editor/useFilterEditor.d.ts

@@ -0,0 +1,32 @@
+import type { ColumnDescriptorsByName } from "@vuu-ui/vuu-filter-types";
+import { KeyboardEventHandler, RefCallback } from "react";
+import { FilterEditorProps } from "./FilterEditor";
+import { FilterModel } from "../FilterModel";
+import { FilterClauseCancelHandler } from "../filter-clause";
+import { FilterClauseCombinatorChangeHandler } from "./FilterClauseCombinator";
+import { MenuActionHandler, MenuBuilder } from "@vuu-ui/vuu-context-menu";
+export interface FilterEditorHookProps extends Pick<FilterEditorProps, "columnDescriptors" | "filter" | "onCancel" | "onSave"> {
+    label?: string;
+}
+export declare const useFilterEditor: ({ columnDescriptors, filter, onCancel, onSave, }: FilterEditorHookProps) => {
+    columnsByName: ColumnDescriptorsByName;
+    filterModel: FilterModel;
+    focusSaveButton: () => void;
+    isValid: boolean;
+    onCancelFilterClause: FilterClauseCancelHandler;
+    onCancelFilterEdit: () => void;
+    onChangeFilterCombinator: FilterClauseCombinatorChangeHandler;
+    onKeyDownCombinator: KeyboardEventHandler<HTMLElement>;
+    saveButtonProps: {
+        PopupMenuProps: {
+            icon: string;
+            menuBuilder: MenuBuilder;
+            menuActionHandler: MenuActionHandler;
+            menuLocation: string;
+        };
+        onClick: () => boolean | undefined;
+        onKeyDown: KeyboardEventHandler;
+    };
+    saveButtonRef: import("react").RefObject<HTMLDivElement | null>;
+    setContainer: RefCallback<HTMLDivElement>;
+};

package/types/src/filter-panel/FilterPanel.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes } from "react";
+import { FilterContainerProps } from "../filter-container/FilterContainer";
+export type FilterPanelPermissions = {
+    allowSaveFilter: boolean;
+};
+export interface FilterPanelProps extends HTMLAttributes<HTMLDivElement>, Pick<FilterContainerProps, "filter" | "filterProviderKey" | "onFilterApplied" | "onFilterCleared"> {
+    permissions?: FilterPanelPermissions;
+}
+export declare const FilterPanel: import("react").ForwardRefExoticComponent<FilterPanelProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/filter-panel/useFilterPanel.d.ts

@@ -0,0 +1,14 @@
+import { ReactElement } from "react";
+import { FilterContainerProps } from "../filter-container/FilterContainer";
+import { FilterAppliedHandler } from "../filter-container/useFilterContainer";
+import { FilterContainerFilter } from "@vuu-ui/vuu-filter-types";
+export declare const useFilterPanel: ({ filter, filterProviderKey, onFilterApplied, onFilterCleared, }: Pick<FilterContainerProps, "filter" | "filterProviderKey" | "onFilterApplied" | "onFilterCleared">) => {
+    clearFilter: () => void;
+    disableClear: boolean;
+    disableSave: boolean;
+    filter: FilterContainerFilter | undefined;
+    onFilterApplied: FilterAppliedHandler<FilterContainerFilter>;
+    onFilterCleared: () => void;
+    saveFilter: () => void;
+    saveFilterPrompt: ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+};

package/types/src/filter-pill/FilterMenu.d.ts

@@ -0,0 +1,24 @@
+import { MenuProps } from "@salt-ds/core";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export type FilterPermissions = {
+    /** Closing a filter removes it from current display, without deleting*/
+    allowClose?: boolean;
+    /** Edit the details of the filter itself */
+    allowEdit?: boolean;
+    /** Rename the filter */
+    allowRename?: boolean;
+    /** Removing a filter deletes it entirely */
+    allowRemove?: boolean;
+};
+export type FilterMenuActionHandler = <T extends FilterAction = FilterAction>(filterId: string, filterAction: T, 
+/**
+ * Some menu action handlers may use columns to enrich filter display
+ */
+columns?: ColumnDescriptor[]) => void;
+export interface FilterMenuProps extends Pick<MenuProps, "getVirtualElement" | "onOpenChange" | "open"> {
+    filterId: string;
+    onMenuAction: FilterMenuActionHandler;
+    permissions?: FilterPermissions;
+}
+export type FilterAction = "close" | "remove" | "edit" | "rename";
+export declare const FilterMenu: ({ filterId, getVirtualElement, onMenuAction, onOpenChange, open, permissions, }: FilterMenuProps) => import("react").JSX.Element;

package/types/src/filter-pill/FilterPill.d.ts

@@ -0,0 +1,16 @@
+import { MenuActionHandler } from "@vuu-ui/vuu-context-menu";
+import { ColumnDescriptorsByName, Filter } from "@vuu-ui/vuu-filter-types";
+import { EditableLabelProps, SplitStateButtonProps } from "@vuu-ui/vuu-ui-controls";
+export interface FilterPillProps extends SplitStateButtonProps, Pick<Partial<EditableLabelProps>, "editing" | "editLabelApiRef" | "onExitEditMode"> {
+    allowClose?: boolean;
+    allowDelete?: boolean;
+    allowEdit?: boolean;
+    allowRename?: boolean;
+    columnsByName?: ColumnDescriptorsByName;
+    editable?: boolean;
+    filter: Filter;
+    index?: number;
+    onBeginEdit?: (filter: Filter) => void;
+    onMenuAction?: MenuActionHandler;
+}
+export declare const FilterPill: ({ allowClose, allowDelete, allowEdit, allowRename, className: classNameProp, columnsByName, editable, editing, editLabelApiRef, filter, id: idProp, onBeginEdit, onExitEditMode, onMenuAction, ...htmlAttributes }: FilterPillProps) => import("react").JSX.Element;

package/types/src/filter-pill/FilterPillNext.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes } from "react";
+import { type FilterPermissions } from "./FilterMenu";
+import { type FilterPillNextHookProps } from "./useFilterPillNext";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export interface FilterPillNextProps extends FilterPillNextHookProps, Omit<HTMLAttributes<HTMLButtonElement>, "id"> {
+    /**
+     * If provided, these will be used in tooltip to provide
+     * richer representation of filter.
+     */
+    columns?: ColumnDescriptor[];
+    id: string;
+    permissions?: FilterPermissions;
+    showTooltip?: boolean;
+}
+export declare const FilterPillNext: ({ active, appearence, columns, className, defaultActive, filter, id, onClick, onMenuAction: onMenuActionProp, permissions, showTooltip, ...htmlAttributes }: FilterPillNextProps) => import("react").JSX.Element;

package/types/src/filter-pill/filterAsReactNode.d.ts

@@ -0,0 +1,3 @@
+import { Filter } from "@vuu-ui/vuu-filter-types";
+import { ReactNode } from "react";
+export declare const filterAsReactNode: (f: Filter, getLabel?: (f: Filter) => string) => ReactNode;

package/types/src/filter-pill/getFilterLabel.d.ts

@@ -0,0 +1,2 @@
+import { ColumnDescriptorsByName, Filter } from "@vuu-ui/vuu-filter-types";
+export declare const getFilterLabel: (columnsByName?: ColumnDescriptorsByName) => (filter: Filter) => string;

package/types/src/filter-pill/getFilterTooltipText.d.ts

@@ -0,0 +1,2 @@
+import { ColumnDescriptorsByName, Filter } from "@vuu-ui/vuu-filter-types";
+export declare const getFilterAsFormattedText: (columnsByName?: ColumnDescriptorsByName) => (filter: Filter) => string;

package/types/src/filter-pill/index.d.ts

@@ -0,0 +1 @@
+export * from "./FilterPill";

package/types/src/filter-pill/useFilterPillNext.d.ts

@@ -0,0 +1,25 @@
+import type { VirtualElement } from "@floating-ui/react";
+import { MouseEventHandler } from "react";
+import { FilterMenuActionHandler } from "./FilterMenu";
+import { FilterContainerFilter } from "@vuu-ui/vuu-filter-types";
+export interface FilterPillNextHookProps {
+    active?: boolean;
+    /**
+     * Determines how menu items will be presented
+     * 'button' - menu items will be context menu
+     * 'split-button' - menu items will be dropdowns
+     */
+    appearence?: "split-button" | "button";
+    defaultActive?: boolean;
+    filter: FilterContainerFilter;
+    onMenuAction?: FilterMenuActionHandler;
+}
+export declare const useFilterPillNext: ({ active: activeProp, appearence, defaultActive, filter, onMenuAction, }: FilterPillNextHookProps) => {
+    active: boolean;
+    contextMenuOpen: boolean;
+    onContextMenu: MouseEventHandler<HTMLButtonElement>;
+    onContextMenuOpenChange: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    onMenuAction: FilterMenuActionHandler;
+    tooltipText: string;
+    virtualElement: VirtualElement | null;
+};

package/types/src/filter-pill-menu/FilterPillMenu.d.ts

@@ -0,0 +1,17 @@
+import { MenuOptions } from "./FilterPillMenuOptions";
+import { Filter } from "@vuu-ui/vuu-filter-types";
+import { MenuActionHandler } from "@vuu-ui/vuu-context-menu";
+export interface FilterMenuOptions extends MenuOptions {
+    filter: Filter;
+}
+export interface FilterPillMenuProps {
+    allowClose?: boolean;
+    allowDelete?: boolean;
+    allowEdit?: boolean;
+    allowRename?: boolean;
+    filter: Filter;
+    location?: string;
+    onMenuAction: MenuActionHandler;
+    onMenuClose?: () => void;
+}
+export declare const FilterPillMenu: ({ allowClose, allowDelete, allowEdit, allowRename, filter, location, onMenuAction, onMenuClose, }: FilterPillMenuProps) => import("react").JSX.Element;

package/types/src/filter-pill-menu/FilterPillMenuOptions.d.ts

@@ -0,0 +1,12 @@
+import { ContextMenuItemDescriptor } from "@vuu-ui/vuu-context-menu";
+export type MenuOptions = {
+    [key: string]: unknown;
+};
+export interface FilterPillMenuOptions {
+    tabIndex: number;
+}
+export declare const isFilterPillMenuOptions: (options: unknown) => options is FilterPillMenuOptions;
+export declare const closeCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;
+export declare const deleteCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;
+export declare const renameCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;
+export declare const editCommand: (options?: MenuOptions) => ContextMenuItemDescriptor;

package/types/src/filter-pill-menu/index.d.ts

@@ -0,0 +1 @@
+export * from "./FilterPillMenu";

package/types/src/filter-provider/FilterContext.d.ts

@@ -0,0 +1,39 @@
+import { FilterContainerFilter, FilterContainerFilterDescriptor, FilterContainerFilterDescriptorWithFilter } from "@vuu-ui/vuu-filter-types";
+import { FilterAction } from "../filter-pill/FilterMenu";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export declare const filterDescriptorHasFilter: (f: FilterContainerFilterDescriptor) => f is FilterContainerFilterDescriptorWithFilter;
+export type FilterContextFilterMenuActionHandler = <T extends FilterAction = FilterAction>(key: string, filterId: string, filterAction: T, 
+/**
+ * Some menu action handlers may use columns to enrich filter display
+ */
+columns?: ColumnDescriptor[]) => void;
+export interface FilterContextProps {
+    deleteFilter: (key: string, filterId: string) => void;
+    saveFilter: (key: string, name: string) => void;
+    filterDescriptors: Map<string, FilterContainerFilterDescriptor[]>;
+    onFilterMenuAction?: FilterContextFilterMenuActionHandler;
+    clearCurrentFilter: (key: string) => void;
+    setCurrentFilter: (key: string, filter: string | FilterContainerFilter) => void;
+    filterNameMaxLength?: number;
+}
+export declare const UNSAVED_FILTER = "unsaved-filter";
+export declare const EMPTY_FILTER = "empty-filter";
+export declare const NULL_FILTER = "null-filter";
+export declare const isEmptyFilter: (f?: FilterContainerFilterDescriptor) => boolean;
+export declare const isNullFilter: (f?: FilterContainerFilterDescriptor) => boolean;
+export declare const NullFilterDescriptor: FilterContainerFilterDescriptor;
+export declare const EmptyFilterDescriptor: FilterContainerFilterDescriptor;
+export declare const FilterContext: import("react").Context<FilterContextProps>;
+interface SavedFilterHookProps {
+    availableColumns?: ColumnDescriptor[];
+}
+export declare function useSavedFilters(key?: string, props?: SavedFilterHookProps): {
+    currentFilter: FilterContainerFilterDescriptor;
+    onFilterMenuAction: (filterId: string, filterAction: FilterAction) => void;
+    savedFilters: FilterContainerFilterDescriptorWithFilter[] | undefined;
+    saveFilter: (name: string) => void;
+    clearCurrentFilter: (localKey?: string) => void;
+    setCurrentFilter: (filter: string | FilterContainerFilter, localKey?: string) => void;
+    filterNameMaxLength: number | undefined;
+};
+export {};

package/types/src/filter-provider/FilterProvider.d.ts

@@ -0,0 +1,10 @@
+import { FilterContainerFilterDescriptor } from "@vuu-ui/vuu-filter-types";
+import { ReactNode } from "react";
+export type SavedFilterRecord = Record<string, FilterContainerFilterDescriptor[]>;
+export interface FilterProviderProps {
+    children: ReactNode;
+    onFiltersSaved?: (savedFilters: SavedFilterRecord) => void;
+    savedFilters?: SavedFilterRecord;
+    filterNameMaxLength?: number;
+}
+export declare const FilterProvider: ({ children, onFiltersSaved, savedFilters: savedFiltersProp, filterNameMaxLength, }: FilterProviderProps) => import("react").JSX.Element;

package/types/src/filter-provider/filter-descriptor-utils.d.ts

@@ -0,0 +1,7 @@
+import { FilterContainerFilterDescriptor } from "@vuu-ui/vuu-filter-types";
+export declare function findFilter(filterDescriptors: FilterContainerFilterDescriptor[], filterId: string, throwIfNotFound?: true): FilterContainerFilterDescriptor;
+export declare function findFilter(filterDescriptors: FilterContainerFilterDescriptor[], filterId: string, throwIfNotFound: false): FilterContainerFilterDescriptor | undefined;
+export declare const deactivateFilter: (filterDescriptors: FilterContainerFilterDescriptor[]) => FilterContainerFilterDescriptor[];
+export declare const activateFilter: (filterDescriptors: FilterContainerFilterDescriptor[], activeFilterId?: string) => FilterContainerFilterDescriptor[];
+export declare const insertOrReplaceFilter: (filterDescriptors: FilterContainerFilterDescriptor[], filterDescriptor: FilterContainerFilterDescriptor) => FilterContainerFilterDescriptor[];
+export declare const renameFilter: (filterDescriptors: FilterContainerFilterDescriptor[], filterId: string, name: string) => FilterContainerFilterDescriptor[];

package/types/src/filter-toggle-button/FilterToggleButton.d.ts

@@ -0,0 +1,9 @@
+import { FilterContainerFilterDescriptor } from "@vuu-ui/vuu-filter-types";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export declare const countFilterClauses: ({ filter, }: FilterContainerFilterDescriptor) => number;
+export interface FilterToggleButtonProps {
+    columns: readonly ColumnDescriptor[];
+    filterProviderKey?: string;
+    onToggle: () => void;
+}
+export declare const FilterToggleButton: ({ columns, filterProviderKey, onToggle, }: FilterToggleButtonProps) => import("react").JSX.Element;

package/types/src/filter-utils.d.ts

@@ -0,0 +1,60 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { Filter, FilterClause, FilterCombinatorOp, FilterContainerFilter, FilterContainerFilterDescriptor, FilterWithPartialClause, MultiClauseFilter, NumericFilterClauseOp } from "@vuu-ui/vuu-filter-types";
+export declare const AND = "and";
+export declare const EQUALS = "=";
+export declare const GREATER_THAN = ">";
+export declare const LESS_THAN = "<";
+export declare const OR = "or";
+export declare const STARTS_WITH = "starts";
+export declare const ENDS_WITH = "ends";
+export declare const IN = "in";
+export type FilterType = "and" | "=" | ">" | ">=" | "in" | "<=" | "<" | "NOT_IN" | "NOT_SW" | "or" | "SW";
+export declare const filterClauses: (filter: Partial<Filter> | FilterWithPartialClause | null, clauses?: Partial<FilterClause>[]) => Partial<FilterClause>[];
+type AddFilterOptions = {
+    combineWith: FilterCombinatorOp;
+};
+export declare const removeLastClause: (filter: MultiClauseFilter) => Filter;
+/**
+  Allows an empty FilterClause to be appended to an existing filter - for use
+  in filter editing UI only.
+*/
+export declare const addClause: (existingFilter: Filter, clause: Partial<Filter>, { combineWith }?: AddFilterOptions) => FilterWithPartialClause;
+export declare const addFilter: (existingFilter: Filter | undefined, filter: Filter, { combineWith }?: AddFilterOptions) => Filter | undefined;
+interface CommonFilter {
+    colName?: string;
+    otherColFilters?: Filter[];
+    mode?: any;
+    value?: any;
+    values?: any;
+    op?: "or" | "and";
+    column?: string;
+    filters?: Filter[];
+}
+export interface OtherFilter extends CommonFilter {
+    type: FilterType;
+    values?: any[];
+}
+export declare const removeFilter: (sourceFilter: Filter, filterToRemove: Filter) => {
+    type: string;
+    filters: Filter[];
+} | null;
+export declare const splitFilterOnColumn: (columnName: string, filter?: Filter) => [Filter | undefined, Filter | undefined];
+export declare const overrideColName: (filter: Filter, column: string) => Filter;
+export declare const filterIncludesColumn: (filter: Filter, column: ColumnDescriptor) => boolean;
+export declare const filterEquals: (f1?: Filter, f2?: Filter, strict?: boolean) => boolean;
+export declare const updateFilter: (filter: Filter | undefined, newFilter: Filter | undefined, mode: "add" | "replace") => Filter | undefined;
+export declare const getTypeaheadFilter: (column: string, filterValues: string[], isStartsWithFilter?: boolean) => Filter | undefined;
+export declare const getNumericFilter: (column: string, op?: NumericFilterClauseOp, value?: number) => FilterClause | undefined;
+type FilterClauseList = Array<[string, string]>;
+/**
+ * Restructure a FilterContainerFilter into a list of [column, value] tuples
+ * suitable for display in a text based control.
+ */
+export declare const getFilterClausesForDisplay: (filter?: FilterContainerFilter, columns?: readonly ColumnDescriptor[], clauses?: FilterClauseList) => FilterClauseList;
+/**
+ * Given a list of FilterContainerFilterDescriptors and a FilterContainerFilter,
+ * find filter descriptor from the list with an equal filter. If
+ * none exists, return undefined, otherwise return the matched filter descriptor
+ */
+export declare const findMatchingFilter: (filterDescriptors: FilterContainerFilterDescriptor[], filter: FilterContainerFilter) => FilterContainerFilterDescriptor | undefined;
+export {};

package/types/src/index.d.ts

@@ -0,0 +1,24 @@
+export { ColumnFilter, type ColumnFilterProps, } from "./column-filter/ColumnFilter";
+export * from "./filter-bar";
+export * from "./filter-clause";
+export { ExtendedSingleValueFilterClause } from "./filter-container/ExtendedSingleValueFilterClause";
+export { FilterContainer, FilterContainerColumnFilter, type FilterContainerColumnFilterProps, type FilterContainerProps, } from "./filter-container/FilterContainer";
+export type { FilterAppliedHandler } from "./filter-container/useFilterContainer";
+export { useFilterContextMenu } from "./filter-context-menu/useFilterContextMenu";
+export { FilterDisplay } from "./filter-display/FilterDisplay";
+export * from "./filter-editor";
+export { FilterPanel } from "./filter-panel/FilterPanel";
+export * from "./filter-pill";
+export { type FilterPermissions } from "./filter-pill/FilterMenu";
+export { FilterPillNext, type FilterPillNextProps, } from "./filter-pill/FilterPillNext";
+export { NULL_FILTER, useSavedFilters } from "./filter-provider/FilterContext";
+export { FilterProvider } from "./filter-provider/FilterProvider";
+export * from "./filter-utils";
+export * from "./FilterModel";
+export * from "./inline-filter";
+export * from "./quick-filters";
+export { FilterNamePrompt as SaveFilterConfirmPrompt, type FilterNamePromptProps as SaveFilterConfirmPromptProps, } from "./saved-filters/FilterNamePrompt";
+export { SavedFilterPanel, type SavedFilterPanelProps, } from "./saved-filters/SavedFilterPanel";
+export type { FilterClickHandler } from "./saved-filters/useSavedFilterPanel";
+export { TabbedFilterContainer, type TabbedFilterContainerProps, } from "./tabbed-filter-container/TabbedFilterContainer";
+export { ToggleFilter, type ToggleFilterProps, } from "./toggle-filter/ToggleFilter";

package/types/src/inline-filter/InlineFilter.d.ts

@@ -0,0 +1,12 @@
+import type { TableSchemaTable } from "@vuu-ui/vuu-data-types";
+import type { VuuFilter } from "@vuu-ui/vuu-protocol-types";
+import type { BaseRowProps } from "@vuu-ui/vuu-table-types";
+import type { HTMLAttributes } from "react";
+import type { FilterAppliedHandler } from "../filter-container/useFilterContainer";
+export type FilterValueChangeHandler = (filter: VuuFilter) => void;
+export interface InlineFilterProps extends Partial<BaseRowProps>, Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    onFilterApplied?: FilterAppliedHandler;
+    onFilterCleared?: () => void;
+    table: TableSchemaTable;
+}
+export declare const InlineFilter: ({ ariaRole, onFilterApplied, onFilterCleared, table, ...htmlAttributes }: InlineFilterProps) => import("react").JSX.Element;

package/types/src/inline-filter/index.d.ts

@@ -0,0 +1 @@
+export * from "./InlineFilter";

package/types/src/inline-filter/useInlineFilter.d.ts

@@ -0,0 +1,5 @@
+export declare const useInlineFilter: () => {
+    columns: import("@vuu-ui/vuu-table-types").RuntimeColumnDescriptor[];
+    onKeyDown: import("react").KeyboardEventHandler<HTMLDivElement>;
+    virtualColSpan: number;
+};

package/types/src/quick-filters/QuickFilters.d.ts

@@ -0,0 +1,17 @@
+import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import type { HTMLAttributes } from "react";
+import { FilterBarProps } from "../filter-bar";
+export interface QuickFilterProps extends HTMLAttributes<HTMLDivElement>, Pick<FilterBarProps, "onApplyFilter" | "onClearFilter" | "vuuTable"> {
+    allowAddColumn?: boolean;
+    allowFind?: boolean;
+    availableColumns: readonly ColumnDescriptor[];
+    onChangeQuickFilterColumns?: (columns: string[]) => void;
+    quickFilterColumns?: string[];
+    /**
+     * Render a general 'search' control.
+     * if true, all columns of type 'string' will be included in the search. Otherwise
+     * a list of the columns to include in search can be provided.
+     */
+    showFind?: boolean | string[];
+}
+export declare const QuickFilters: ({ allowAddColumn, allowFind, availableColumns, onApplyFilter, onClearFilter, onChangeQuickFilterColumns, quickFilterColumns, vuuTable, }: QuickFilterProps) => import("react").JSX.Element;

package/types/src/quick-filters/index.d.ts

@@ -0,0 +1 @@
+export * from "./QuickFilters";

package/types/src/quick-filters/useQuickFilters.d.ts

@@ -0,0 +1,12 @@
+import { MultiSelectionHandler } from "@vuu-ui/vuu-ui-controls";
+import { CommitHandler } from "@vuu-ui/vuu-utils";
+import { ChangeEventHandler, RefCallback } from "react";
+import { QuickFilterProps } from "./QuickFilters";
+export type QuickFilterHookProps = Pick<QuickFilterProps, "availableColumns" | "onApplyFilter" | "onClearFilter" | "onChangeQuickFilterColumns" | "quickFilterColumns">;
+export declare const useQuickFilters: ({ availableColumns, onApplyFilter, onClearFilter, onChangeQuickFilterColumns, }: QuickFilterProps) => {
+    availableColumnNames: string[];
+    onChange: ChangeEventHandler<HTMLInputElement>;
+    onColumnsSelectionChange: MultiSelectionHandler;
+    onCommit: CommitHandler<HTMLElement>;
+    rootRef: RefCallback<HTMLDivElement>;
+};

package/types/src/saved-filters/DeleteFilterPrompt.d.ts

@@ -0,0 +1,9 @@
+import { FilterContainerFilterDescriptor } from "@vuu-ui/vuu-filter-types";
+import { PromptProps } from "@vuu-ui/vuu-ui-controls";
+import { HTMLAttributes } from "react";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export interface DeleteFilterPromptProps extends Pick<PromptProps, "onConfirm" | "onClose" | "open">, HTMLAttributes<HTMLDivElement> {
+    columns?: ColumnDescriptor[];
+    filterDescriptor: FilterContainerFilterDescriptor;
+}
+export declare const DeleteFilterPrompt: ({ children, className, columns, filterDescriptor, onClose, onConfirm, open, ...htmlAttributes }: DeleteFilterPromptProps) => import("react").JSX.Element;

package/types/src/saved-filters/FilterNamePrompt.d.ts

@@ -0,0 +1,6 @@
+import { PromptProps } from "@vuu-ui/vuu-ui-controls";
+import { HTMLAttributes } from "react";
+import { FilterNamePromptHookProps } from "./useFilterNamePrompt";
+export interface FilterNamePromptProps extends FilterNamePromptHookProps, Pick<PromptProps, "onClose" | "open" | "title">, Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+}
+export declare const FilterNamePrompt: ({ className, filterName, onClose, onConfirm: onConfirmProp, open, title, filterNameMaxLength, ...htmlAttributes }: FilterNamePromptProps) => import("react").JSX.Element;

package/types/src/saved-filters/SavedFilterPanel.d.ts

@@ -0,0 +1,14 @@
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { HTMLAttributes } from "react";
+import { FilterPermissions } from "../filter-pill/FilterMenu";
+import { FilterContainerProps } from "../filter-container/FilterContainer";
+export interface SavedFilterPanelProps extends HTMLAttributes<HTMLDivElement>, Pick<FilterContainerProps, "filterProviderKey"> {
+    /**
+     * ColumnDescriptors are not required but is passed will be
+     * used to provide labels and correct value formatting for
+     * displayed filters, e.g in tooltips
+     */
+    availableColumns?: ColumnDescriptor[];
+    filterPillPermissions?: FilterPermissions;
+}
+export declare const SavedFilterPanel: ({ availableColumns, className, filterPillPermissions, filterProviderKey, ...htmlAttributes }: SavedFilterPanelProps) => import("react").JSX.Element;

package/types/src/saved-filters/useFilterNamePrompt.d.ts

@@ -0,0 +1,28 @@
+import { ChangeEventHandler } from "react";
+import { CommitHandler, ValueOf } from "@vuu-ui/vuu-utils";
+export interface FilterNamePromptHookProps {
+    filterName?: string;
+    onConfirm: (filterName: string) => void;
+    filterNameMaxLength?: number;
+}
+export declare const Status: {
+    readonly Empty: "empty";
+    readonly Valid: "valid";
+    readonly Invalid: "invalid";
+    readonly DuplicateName: "duplicate-name";
+};
+type Status = ValueOf<typeof Status>;
+export declare const useFilterNamePrompt: ({ filterName, onConfirm, }: FilterNamePromptHookProps) => {
+    confirmButtonProps: {
+        disabled: boolean;
+        label: string;
+        ref: import("react").RefObject<HTMLButtonElement | null>;
+    };
+    nameOfDuplicateFilter: string | undefined;
+    onChange: ChangeEventHandler<HTMLInputElement>;
+    onCommit: CommitHandler;
+    onConfirm: () => void;
+    status: Status;
+    value: string;
+};
+export {};

package/types/src/saved-filters/useSavedFilterPanel.d.ts

@@ -0,0 +1,13 @@
+import { SyntheticEvent } from "react";
+import { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+export type FilterClickHandler = (filterId: string) => void;
+interface SavedFilterPanelProps {
+    availableColumns?: ColumnDescriptor[];
+    filterProviderKey?: string;
+}
+export declare const useSavedFilterPanel: (props?: SavedFilterPanelProps) => {
+    onClickFilter: (e: SyntheticEvent) => void;
+    onFilterMenuAction: (filterId: string, filterAction: import("../filter-pill/FilterMenu").FilterAction) => void;
+    savedFilters: import("@vuu-ui/vuu-filter-types").FilterContainerFilterDescriptorWithFilter[];
+};
+export {};

package/types/src/tabbed-filter-container/TabbedFilterContainer.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import { FilterContainerProps } from "../filter-container/FilterContainer";
+import { SavedFilterPanelProps } from "../saved-filters/SavedFilterPanel";
+export interface TabbedFilterContainerProps extends HTMLAttributes<HTMLDivElement>, Pick<FilterContainerProps, "filter" | "filterProviderKey" | "onFilterApplied" | "onFilterCleared"> {
+    SavedFilterPanelProps?: Pick<SavedFilterPanelProps, "availableColumns" | "filterPillPermissions">;
+    children: ReactNode;
+    filterTabLabel?: string;
+    savedFilterLabel?: string;
+}
+export declare const TabbedFilterContainer: ({ SavedFilterPanelProps, children, className, filter, filterProviderKey, filterTabLabel, onFilterApplied, onFilterCleared, savedFilterLabel, ...htmlAttributes }: TabbedFilterContainerProps) => import("react").JSX.Element;

package/types/src/toggle-filter/ToggleFilter.d.ts

@@ -0,0 +1,17 @@
+import { ToggleButtonGroupProps } from "@salt-ds/core";
+import { CommitHandler } from "@vuu-ui/vuu-utils";
+import { type ToggleFilterHookProps } from "./useToggleFilter";
+/**
+ * ToggleFilter is designed to work with a FilterProvider and
+ * DataSourceProvider. With a DataSourceProvider, values will
+ * be validated against available values from datasource.
+ * With both FilterProvider and a DataSourceProvider, changes to
+ * the currentFilter will also trigger re-evaluation of available
+ * values from dataSource.
+ * With neither of these Providers available, the ToggleFilter is
+ * behaving like a regular ToggleButtonGroup.
+ */
+export interface ToggleFilterProps extends ToggleButtonGroupProps, ToggleFilterHookProps {
+    onCommit: CommitHandler<HTMLElement>;
+}
+export declare const ToggleFilter: import("react").ForwardRefExoticComponent<ToggleFilterProps & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/toggle-filter/useToggleFilter.d.ts

@@ -0,0 +1,11 @@
+import type { TableSchemaTable } from "@vuu-ui/vuu-data-types";
+export interface ToggleFilterHookProps {
+    column: string;
+    /**
+     * table must be provided to enable validation
+     * of values using server data.
+     */
+    table?: TableSchemaTable;
+    values: string[];
+}
+export declare const useToggleFilter: ({ column, table, values, }: ToggleFilterHookProps) => string | undefined;