@johly/bits-ui 2.18.1

package/dist/bits/filter/components/filter-value.svelte

@@ -0,0 +1,146 @@
+<script
+	lang="ts"
+	generics="TData = unknown, TType extends import('../types.js').ColumnDataType = import('../types.js').ColumnDataType, TContext = any"
+>
+	import { mergeProps } from "svelte-toolbelt";
+	import Root from "../../menu/components/menu.svelte";
+	import Trigger from "../../menu/components/menu-trigger.svelte";
+	import Portal from "../../utilities/portal/portal.svelte";
+	import Content from "../../dropdown-menu/components/dropdown-menu-content.svelte";
+	import type { FilterValueProps } from "../types.js";
+	import {
+		filterAttrs,
+		useFilterActions,
+		useFilterContext,
+		useFilterItemContext,
+	} from "../filter.svelte.js";
+	import {
+		isBooleanColumn,
+		isDateColumn,
+		isMultiOptionColumn,
+		isNumberColumn,
+		isOptionColumn,
+		isTextColumn,
+	} from "../type-guards.js";
+	import FilterValueDisplay from "./filter-value-display.svelte";
+	import FilterTextEditor from "./filter-text-editor.svelte";
+	import FilterNumberEditor from "./filter-number-editor.svelte";
+	import FilterDateEditor from "./filter-date-editor.svelte";
+	import FilterOptionEditor from "./filter-option-editor.svelte";
+	import type { Column, DurationUnit, FilterModel } from "../types.js";
+
+	let {
+		filter: filterProp,
+		column: columnProp,
+		actions: actionsProp,
+		strategy: strategyProp,
+		locale: localeProp,
+		entityName: entityNameProp,
+		children,
+		child: childProp,
+		ref = $bindable(null),
+		type = "button",
+		variant,
+		...restProps
+	}: FilterValueProps<TData, TType, TContext> = $props();
+
+	const context = useFilterContext<TData, TContext>();
+	const itemContext = useFilterItemContext<TData, TType, TContext>();
+	const fallbackActions = useFilterActions<TContext>();
+	const filter = $derived(filterProp ?? itemContext?.filter);
+	const column = $derived(columnProp ?? itemContext?.column);
+	const actions = $derived(actionsProp ?? itemContext?.actions ?? fallbackActions);
+	const strategy = $derived(strategyProp ?? itemContext?.strategy ?? context.strategy);
+	const locale = $derived(localeProp ?? itemContext?.locale ?? context.locale ?? "en");
+	const entityName = $derived(entityNameProp ?? itemContext?.entityName ?? context.entityName);
+	const resolvedVariant = $derived(variant ?? itemContext?.variant ?? context.variant);
+	let open = $state(false);
+	let initialValues = $state<Array<string | number | bigint | boolean | Date>>([]);
+
+	function handleOpenChange(value: boolean) {
+		if (value && filter) {
+			initialValues = [...filter.values];
+		}
+		open = value;
+	}
+
+	const triggerProps = $derived(
+		mergeProps(restProps, {
+			type,
+			"data-column-type": column?.type,
+			"data-variant": resolvedVariant,
+			[filterAttrs.value]: "",
+		})
+	);
+</script>
+
+{#if !filter || !column || !actions || !strategy}
+	{@const _error = (() => {
+		throw new Error(
+			"Filter.Value requires filter/column/actions/strategy props or must be used within Filter.Item"
+		);
+	})()}
+{:else if isBooleanColumn(column)}
+	{#if childProp}
+		{@render childProp({ props: triggerProps })}
+	{:else}
+		<button bind:this={ref} {...triggerProps}>
+			{#if children}
+				{@render children()}
+			{:else}
+				<FilterValueDisplay {filter} {column} {locale} {entityName} />
+			{/if}
+		</button>
+	{/if}
+{:else}
+	<Root bind:open onOpenChange={handleOpenChange}>
+		<Trigger>
+			{#snippet child({ props })}
+				{@const delegatedProps = mergeProps(props, triggerProps)}
+				{#if childProp}
+					{@render childProp({ props: delegatedProps })}
+				{:else}
+					<button bind:this={ref} {...delegatedProps}>
+						{#if children}
+							{@render children()}
+						{:else}
+							<FilterValueDisplay {filter} {column} {locale} {entityName} />
+						{/if}
+					</button>
+				{/if}
+			{/snippet}
+		</Trigger>
+		<Portal>
+			<Content align="start" sideOffset={8}>
+				{#if isTextColumn(column)}
+					<FilterTextEditor column={column as Column<unknown, "text">} {actions} />
+				{:else if isDateColumn(column)}
+					<FilterDateEditor
+						filter={filter as FilterModel<"date">}
+						column={column as Column<unknown, "date">}
+						{actions}
+					/>
+				{:else if isNumberColumn(column)}
+					<FilterNumberEditor
+						column={column as Column<unknown, "number">}
+						{actions}
+						baseUnit={(column.meta as { number?: { unit?: DurationUnit } } | undefined)
+							?.number?.unit}
+					/>
+				{:else if isOptionColumn(column) || isMultiOptionColumn(column)}
+					<FilterOptionEditor
+						column={column as
+							| Column<unknown, "option">
+							| Column<unknown, "multiOption">}
+						{actions}
+						filter={filter as FilterModel<"option"> | FilterModel<"multiOption">}
+						{locale}
+						{strategy}
+						{initialValues}
+						showSeparator
+					/>
+				{/if}
+			</Content>
+		</Portal>
+	</Root>
+{/if}

package/dist/bits/filter/components/filter-value.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { FilterValueProps } from "../types.js";
+declare class __sveltets_Render<TData = unknown, TType extends import('../types.js').ColumnDataType = import('../types.js').ColumnDataType, TContext = any> {
+    props(): FilterValueProps<TData, TType, TContext>;
+    events(): {};
+    slots(): {};
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TData = unknown, TType extends import('../types.js').ColumnDataType = import('../types.js').ColumnDataType, TContext = any>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData, TType, TContext>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData, TType, TContext>['props']>, ReturnType<__sveltets_Render<TData, TType, TContext>['events']>, ReturnType<__sveltets_Render<TData, TType, TContext>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TData, TType, TContext>['bindings']>;
+    } & ReturnType<__sveltets_Render<TData, TType, TContext>['exports']>;
+    <TData = unknown, TType extends import('../types.js').ColumnDataType = import('../types.js').ColumnDataType, TContext = any>(internal: unknown, props: ReturnType<__sveltets_Render<TData, TType, TContext>['props']> & {}): ReturnType<__sveltets_Render<TData, TType, TContext>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any, any>['bindings']>;
+}
+declare const FilterValue: $$IsomorphicComponent;
+type FilterValue<TData = unknown, TType extends import('../types.js').ColumnDataType = import('../types.js').ColumnDataType, TContext = any> = InstanceType<typeof FilterValue<TData, TType, TContext>>;
+export default FilterValue;

package/dist/bits/filter/exports.d.ts

@@ -0,0 +1,25 @@
+export { default as Actions } from "./components/filter-actions.svelte";
+export { default as Item } from "./components/filter-item.svelte";
+export { default as List } from "./components/filter-list.svelte";
+export { default as ListMobileContainer } from "./components/filter-list-mobile-container.svelte";
+export { default as Menu } from "./components/filter-menu.svelte";
+export { default as Operator } from "./components/filter-operator.svelte";
+export { default as Provider } from "./components/filter-provider.svelte";
+export { default as Remove } from "./components/filter-remove.svelte";
+export { default as Root } from "./components/filter-root.svelte";
+export { default as Subject } from "./components/filter-subject.svelte";
+export { default as Trigger } from "./components/filter-trigger.svelte";
+export { default as Value } from "./components/filter-value.svelte";
+export { default as ValueDisplay } from "./components/filter-value-display.svelte";
+export { default as DateEditor } from "./components/filter-date-editor.svelte";
+export { default as NumberEditor } from "./components/filter-number-editor.svelte";
+export { default as OptionEditor } from "./components/filter-option-editor.svelte";
+export { default as TextEditor } from "./components/filter-text-editor.svelte";
+export { createMultiOptionMenu, createNumberFilterItems, createOperatorNodes, createOptionMenu, createTextFilterItems, } from "./menu-nodes.js";
+export { createTypedDataTableFilters, filterAttrs, useDataTableFilters, useFilterActions, useFilterColumn, useFilterContext, useFilterEntityName, useFilterItemContext, useFilterLocale, useFilterStrategy, useFilterVariant, } from "./filter.svelte.js";
+export { createBigIntRange, createDateRange, createNumberRange, getColumn, } from "./helpers.js";
+export { filterOperations } from "./operations.js";
+export { parseNumberInput } from "./units.js";
+export { t } from "./i18n.js";
+export type { FilterActionsProps as ActionsProps, FilterItemContextValue as ItemContextValue, FilterItemProps as ItemProps, FilterListMobileContainerProps as ListMobileContainerProps, FilterListProps as ListProps, FilterMenuProps as MenuProps, FilterOperatorProps as OperatorProps, FilterProviderProps as ProviderProps, FilterRemoveProps as RemoveProps, FilterRootProps as RootProps, FilterSubjectProps as SubjectProps, FilterTriggerProps as TriggerProps, FilterValueDisplayProps as ValueDisplayProps, FilterValueProps as ValueProps, } from "./types.js";
+export type * from "./types.js";

package/dist/bits/filter/exports.js

@@ -0,0 +1,23 @@
+export { default as Actions } from "./components/filter-actions.svelte";
+export { default as Item } from "./components/filter-item.svelte";
+export { default as List } from "./components/filter-list.svelte";
+export { default as ListMobileContainer } from "./components/filter-list-mobile-container.svelte";
+export { default as Menu } from "./components/filter-menu.svelte";
+export { default as Operator } from "./components/filter-operator.svelte";
+export { default as Provider } from "./components/filter-provider.svelte";
+export { default as Remove } from "./components/filter-remove.svelte";
+export { default as Root } from "./components/filter-root.svelte";
+export { default as Subject } from "./components/filter-subject.svelte";
+export { default as Trigger } from "./components/filter-trigger.svelte";
+export { default as Value } from "./components/filter-value.svelte";
+export { default as ValueDisplay } from "./components/filter-value-display.svelte";
+export { default as DateEditor } from "./components/filter-date-editor.svelte";
+export { default as NumberEditor } from "./components/filter-number-editor.svelte";
+export { default as OptionEditor } from "./components/filter-option-editor.svelte";
+export { default as TextEditor } from "./components/filter-text-editor.svelte";
+export { createMultiOptionMenu, createNumberFilterItems, createOperatorNodes, createOptionMenu, createTextFilterItems, } from "./menu-nodes.js";
+export { createTypedDataTableFilters, filterAttrs, useDataTableFilters, useFilterActions, useFilterColumn, useFilterContext, useFilterEntityName, useFilterItemContext, useFilterLocale, useFilterStrategy, useFilterVariant, } from "./filter.svelte.js";
+export { createBigIntRange, createDateRange, createNumberRange, getColumn, } from "./helpers.js";
+export { filterOperations } from "./operations.js";
+export { parseNumberInput } from "./units.js";
+export { t } from "./i18n.js";

package/dist/bits/filter/filter-fns.d.ts

@@ -0,0 +1,21 @@
+import type { FilterModel, FiltersState } from "./types.js";
+export declare function optionFilterFn(inputData: string, filterValue: FilterModel<"option">): boolean;
+export declare function multiOptionFilterFn(inputData: string[], filterValue: FilterModel<"multiOption">): boolean;
+export declare function dateFilterFn(inputData: Date, filterValue: FilterModel<"date">): boolean;
+export declare function textFilterFn(inputData: string, filterValue: FilterModel<"text">): boolean;
+export declare function numberFilterFn(inputData: number, filterValue: FilterModel<"number">): boolean;
+export declare function bigIntFilterFn(inputData: bigint, filterValue: FilterModel<"bigint">): boolean;
+export declare function booleanFilterFn(inputData: boolean, filterValue: FilterModel<"boolean">): boolean;
+export declare function filterRow(row: any, filters: FiltersState): boolean;
+export declare function filterData<TData>(data: TData[], filters: FiltersState): TData[];
+export declare const filterFns: {
+    text: typeof textFilterFn;
+    number: typeof numberFilterFn;
+    bigint: typeof bigIntFilterFn;
+    date: typeof dateFilterFn;
+    boolean: typeof booleanFilterFn;
+    option: typeof optionFilterFn;
+    multiOption: typeof multiOptionFilterFn;
+    row: typeof filterRow;
+    data: typeof filterData;
+};

package/dist/bits/filter/filter-fns.js

@@ -0,0 +1,279 @@
+import { dateFilterOperators } from "./operators.js";
+import { intersection } from "./array.js";
+import { getValidBigInt, getValidNumber, isValidNumber } from "./helpers.js";
+function startOfDay(date) {
+    const value = new Date(date);
+    value.setHours(0, 0, 0, 0);
+    return value;
+}
+function endOfDay(date) {
+    const value = new Date(date);
+    value.setHours(23, 59, 59, 999);
+    return value;
+}
+function isSameDay(a, b) {
+    return (a.getFullYear() === b.getFullYear() &&
+        a.getMonth() === b.getMonth() &&
+        a.getDate() === b.getDate());
+}
+export function optionFilterFn(inputData, filterValue) {
+    if (!inputData)
+        return false;
+    if (filterValue.values.length === 0)
+        return true;
+    const value = inputData.toString().toLowerCase();
+    const found = filterValue.values.some((v) => v.toLowerCase() === value);
+    switch (filterValue.operator) {
+        case "is":
+        case "is any of":
+            return found;
+        case "is not":
+        case "is none of":
+            return !found;
+    }
+}
+export function multiOptionFilterFn(inputData, filterValue) {
+    if (!inputData)
+        return false;
+    if (filterValue.values.length === 0 || !filterValue.values[0])
+        return true;
+    const values = inputData;
+    const filterValues = filterValue.values;
+    switch (filterValue.operator) {
+        case "include":
+        case "include any of":
+            return intersection(values, filterValues).length > 0;
+        case "exclude":
+        case "exclude if any of":
+            return intersection(values, filterValues).length === 0;
+        case "include all of":
+            return intersection(values, filterValues).length === filterValues.length;
+        case "exclude if all":
+            return intersection(values, filterValues).length !== filterValues.length;
+    }
+}
+export function dateFilterFn(inputData, filterValue) {
+    if (!filterValue || filterValue.values.length === 0)
+        return true;
+    if (dateFilterOperators[filterValue.operator].target === "single" &&
+        filterValue.values.length > 1) {
+        throw new Error("Singular operators require at most one filter value");
+    }
+    if ((filterValue.operator === "is between" || filterValue.operator === "is not between") &&
+        filterValue.values.length !== 2) {
+        throw new Error("Plural operators require two filter values");
+    }
+    const d1 = filterValue.values[0];
+    const d2 = filterValue.values[1];
+    const value = inputData;
+    switch (filterValue.operator) {
+        case "is":
+            return isSameDay(value, d1);
+        case "is not":
+            return !isSameDay(value, d1);
+        case "is before":
+            return value.getTime() < startOfDay(d1).getTime();
+        case "is on or after":
+            return isSameDay(value, d1) || value.getTime() > startOfDay(d1).getTime();
+        case "is after":
+            return value.getTime() > startOfDay(d1).getTime();
+        case "is on or before":
+            return isSameDay(value, d1) || value.getTime() < startOfDay(d1).getTime();
+        case "is between":
+            return value.getTime() >= startOfDay(d1).getTime() && value.getTime() <= endOfDay(d2).getTime();
+        case "is not between":
+            return value.getTime() < startOfDay(d1).getTime() || value.getTime() > endOfDay(d2).getTime();
+    }
+}
+export function textFilterFn(inputData, filterValue) {
+    if (!filterValue || filterValue.values.length === 0)
+        return true;
+    const value = inputData.toLowerCase().trim();
+    const filterStr = filterValue.values[0].toLowerCase().trim();
+    if (filterStr === "")
+        return true;
+    const found = value.includes(filterStr);
+    switch (filterValue.operator) {
+        case "contains":
+            return found;
+        case "does not contain":
+            return !found;
+    }
+}
+export function numberFilterFn(inputData, filterValue) {
+    if (!filterValue || !filterValue.values || filterValue.values.length === 0)
+        return true;
+    const value = inputData;
+    const filterVal = getValidNumber(filterValue.values[0]);
+    if (filterVal === undefined)
+        return true;
+    if (!isValidNumber(value))
+        return false;
+    switch (filterValue.operator) {
+        case "is":
+            return value === filterVal;
+        case "is not":
+            return value !== filterVal;
+        case "is greater than":
+            if (filterVal === Number.POSITIVE_INFINITY)
+                return false;
+            if (filterVal === Number.NEGATIVE_INFINITY)
+                return true;
+            return value > filterVal;
+        case "is greater than or equal to":
+            if (filterVal === Number.POSITIVE_INFINITY)
+                return value === Number.POSITIVE_INFINITY;
+            if (filterVal === Number.NEGATIVE_INFINITY)
+                return true;
+            return value >= filterVal;
+        case "is less than":
+            if (filterVal === Number.NEGATIVE_INFINITY)
+                return false;
+            if (filterVal === Number.POSITIVE_INFINITY)
+                return value !== Number.POSITIVE_INFINITY;
+            return value < filterVal;
+        case "is less than or equal to":
+            if (filterVal === Number.NEGATIVE_INFINITY)
+                return value === Number.NEGATIVE_INFINITY;
+            if (filterVal === Number.POSITIVE_INFINITY)
+                return true;
+            return value <= filterVal;
+        case "is between": {
+            const lowerBound = getValidNumber(filterValue.values[0]);
+            const upperBound = getValidNumber(filterValue.values[1]);
+            if (lowerBound === undefined || upperBound === undefined)
+                return true;
+            const actualLower = Math.min(lowerBound, upperBound);
+            const actualUpper = Math.max(lowerBound, upperBound);
+            if (actualLower === Number.NEGATIVE_INFINITY &&
+                actualUpper === Number.POSITIVE_INFINITY) {
+                return true;
+            }
+            if (actualLower === Number.POSITIVE_INFINITY ||
+                actualUpper === Number.NEGATIVE_INFINITY) {
+                return false;
+            }
+            return value >= actualLower && value <= actualUpper;
+        }
+        case "is not between": {
+            const lowerBound = getValidNumber(filterValue.values[0]);
+            const upperBound = getValidNumber(filterValue.values[1]);
+            if (lowerBound === undefined || upperBound === undefined)
+                return true;
+            const actualLower = Math.min(lowerBound, upperBound);
+            const actualUpper = Math.max(lowerBound, upperBound);
+            if (actualLower === Number.NEGATIVE_INFINITY &&
+                actualUpper === Number.POSITIVE_INFINITY) {
+                return false;
+            }
+            if (actualLower === Number.POSITIVE_INFINITY ||
+                actualUpper === Number.NEGATIVE_INFINITY) {
+                return true;
+            }
+            return value < actualLower || value > actualUpper;
+        }
+        default:
+            return true;
+    }
+}
+export function bigIntFilterFn(inputData, filterValue) {
+    if (!filterValue || !filterValue.values || filterValue.values.length === 0)
+        return true;
+    const value = inputData;
+    const filterVal = getValidBigInt(filterValue.values[0]);
+    if (filterVal === undefined)
+        return true;
+    if (typeof value !== "bigint")
+        return false;
+    switch (filterValue.operator) {
+        case "is":
+            return value === filterVal;
+        case "is not":
+            return value !== filterVal;
+        case "is greater than":
+            return value > filterVal;
+        case "is greater than or equal to":
+            return value >= filterVal;
+        case "is less than":
+            return value < filterVal;
+        case "is less than or equal to":
+            return value <= filterVal;
+        case "is between": {
+            const lowerBound = getValidBigInt(filterValue.values[0]);
+            const upperBound = getValidBigInt(filterValue.values[1]);
+            if (lowerBound === undefined || upperBound === undefined)
+                return true;
+            const actualLower = lowerBound < upperBound ? lowerBound : upperBound;
+            const actualUpper = lowerBound < upperBound ? upperBound : lowerBound;
+            return value >= actualLower && value <= actualUpper;
+        }
+        case "is not between": {
+            const lowerBound = getValidBigInt(filterValue.values[0]);
+            const upperBound = getValidBigInt(filterValue.values[1]);
+            if (lowerBound === undefined || upperBound === undefined)
+                return true;
+            const actualLower = lowerBound < upperBound ? lowerBound : upperBound;
+            const actualUpper = lowerBound < upperBound ? upperBound : lowerBound;
+            return value < actualLower || value > actualUpper;
+        }
+        default:
+            return true;
+    }
+}
+export function booleanFilterFn(inputData, filterValue) {
+    if (!filterValue || filterValue.values.length === 0)
+        return true;
+    if (filterValue.values.some((v) => typeof v === "undefined")) {
+        throw new Error("Cannot create boolean filter value from undefined values");
+    }
+    const value = inputData;
+    const filterVal = filterValue.values[0] ?? false;
+    switch (filterValue.operator) {
+        case "is":
+            return value === filterVal;
+        case "is not":
+            return value !== filterVal;
+        default:
+            return true;
+    }
+}
+export function filterRow(row, filters) {
+    for (const filter of filters) {
+        const cell = row[filter.columnId];
+        if (filter.type === "text" && !textFilterFn(cell, filter))
+            return false;
+        if (filter.type === "number" && !numberFilterFn(cell, filter)) {
+            return false;
+        }
+        if (filter.type === "bigint" && !bigIntFilterFn(cell, filter)) {
+            return false;
+        }
+        if (filter.type === "date" && !dateFilterFn(cell, filter))
+            return false;
+        if (filter.type === "boolean" && !booleanFilterFn(cell, filter)) {
+            return false;
+        }
+        if (filter.type === "option" && !optionFilterFn(cell, filter)) {
+            return false;
+        }
+        if (filter.type === "multiOption" &&
+            !multiOptionFilterFn(cell, filter)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function filterData(data, filters) {
+    return data.filter((row) => filterRow(row, filters));
+}
+export const filterFns = {
+    text: textFilterFn,
+    number: numberFilterFn,
+    bigint: bigIntFilterFn,
+    date: dateFilterFn,
+    boolean: booleanFilterFn,
+    option: optionFilterFn,
+    multiOption: multiOptionFilterFn,
+    row: filterRow,
+    data: filterData,
+};

package/dist/bits/filter/filter.svelte.d.ts

@@ -0,0 +1,14 @@
+import type { Column, ColumnConfig, ColumnDataType, DataTableFilterActions, DataTableFiltersInstance, DataTableFiltersOptions, FilterContextValue, FilterItemContextValue, FilterStrategy } from "./types.js";
+export declare const filterAttrs: import("../../internal/attrs.js").CreateBitsAttrsReturn<readonly ["provider", "root", "trigger", "menu", "menu-content", "menu-input", "menu-empty", "menu-caret", "menu-checkbox-indicator", "menu-count", "menu-icon", "menu-shortcut", "date-editor", "date-fields", "date-field", "date-label", "date-field-input", "date-segment", "date-calendar", "date-calendar-header", "date-calendar-nav", "date-calendar-heading", "date-calendar-heading-button", "date-calendar-grid", "date-calendar-head-cell", "date-calendar-cell", "date-calendar-day", "date-calendar-mode-panel", "date-calendar-mode-option", "date-clear", "list", "list-mobile-container", "item", "subject", "subject-icon", "operator", "value", "value-display", "value-icon", "value-editor", "remove", "actions"]>;
+export declare function setFilterContext<TData = unknown, TContext = any>(value: FilterContextValue<TData, TContext>): FilterContextValue<unknown, any>;
+export declare function useFilterContext<TData = unknown, TContext = any>(): FilterContextValue<TData, TContext>;
+export declare function setFilterItemContext<TData = unknown, TType extends ColumnDataType = ColumnDataType, TContext = any>(value: FilterItemContextValue<TData, TType, TContext>): FilterItemContextValue<unknown, ColumnDataType, any>;
+export declare function useFilterItemContext<TData = unknown, TType extends ColumnDataType = ColumnDataType, TContext = any>(): FilterItemContextValue<TData, TType, TContext> | null;
+export declare function useFilterColumn<TData = unknown>(columnId: string): Column<TData> | undefined;
+export declare function useFilterActions<TContext = any>(): DataTableFilterActions<TContext>;
+export declare function useFilterStrategy(): FilterStrategy;
+export declare function useFilterLocale(): import("./types.js").Locale;
+export declare function useFilterEntityName(): string | undefined;
+export declare function useFilterVariant(): import("./types.js").FilterVariant | undefined;
+export declare function useDataTableFilters<TData, TColumns extends ReadonlyArray<ColumnConfig<TData, any, any, any>>, TStrategy extends FilterStrategy, TContext = any>({ strategy, data, columnsConfig, defaultFilters, filters: externalFilters, onFiltersChange, options, faceted, entityName, }: DataTableFiltersOptions<TData, TColumns, TStrategy, TContext>): DataTableFiltersInstance<TData, TStrategy, TContext>;
+export declare function createTypedDataTableFilters<TContext>(): <TData, TColumns extends ReadonlyArray<ColumnConfig<TData, any, any, any>>, TStrategy extends FilterStrategy>(options: DataTableFiltersOptions<TData, TColumns, TStrategy, TContext>) => DataTableFiltersInstance<TData, TStrategy, TContext>;