@crimson_/altarev 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,527 @@
+import { ClassValue } from 'clsx';
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, ReactElement } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { DayPickerProps, DateRange } from 'react-day-picker';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+type ContainerProps = HTMLAttributes<HTMLDivElement>;
+declare function Container({ className, ...props }: ContainerProps): react.JSX.Element;
+
+declare const accordion: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AccordionProps extends VariantProps<typeof accordion>, Omit<React.DetailsHTMLAttributes<HTMLDetailsElement>, "title"> {
+    title: ReactNode;
+    leading?: ReactNode;
+    children: ReactNode;
+}
+declare function Accordion({ size, title, leading, children, className, ...props }: AccordionProps): react.JSX.Element;
+
+declare const alert: (props?: ({
+    status?: "success" | "error" | "warning" | "info" | null | undefined;
+    styleVariant?: "colourful" | "outline" | "generic" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AlertProps extends Omit<VariantProps<typeof alert>, "styleVariant">, React.HTMLAttributes<HTMLDivElement> {
+    variant?: NonNullable<VariantProps<typeof alert>["styleVariant"]>;
+    icon?: ReactNode;
+    trailing?: ReactNode;
+    children: ReactNode;
+}
+declare function Alert({ status, variant, icon, trailing, children, className, ...props }: AlertProps): react.JSX.Element;
+
+interface EmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+}
+declare function EmptyState({ icon, title, description, children, className, ...props }: EmptyStateProps): react.JSX.Element;
+
+declare const avatar: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | "2xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const badgeCorner: {
+    readonly tr: "top-0 right-0";
+    readonly tl: "top-0 left-0";
+    readonly br: "bottom-0 right-0";
+    readonly bl: "bottom-0 left-0";
+};
+interface AvatarProps extends VariantProps<typeof avatar>, Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> {
+    src?: string;
+    alt?: string;
+    children?: ReactNode;
+    badge?: keyof typeof badgeCorner;
+    badgeColor?: string;
+}
+declare function Avatar({ size, src, alt, children, badge, badgeColor, className, ...props }: AvatarProps): react.JSX.Element;
+
+interface AuthCodeProps {
+    value: string;
+    onChange: (code: string) => void;
+    length?: number;
+    error?: boolean | string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function AuthCode({ value, onChange, length, error, disabled, className, }: AuthCodeProps): react.JSX.Element;
+
+interface BreadcrumbItem {
+    label: ReactNode;
+    href?: string;
+}
+interface BreadcrumbsProps extends Omit<React.HTMLAttributes<HTMLElement>, "children"> {
+    items: BreadcrumbItem[];
+    separator?: ReactNode;
+    maxItems?: number;
+}
+declare function Breadcrumbs({ items, separator, maxItems, className, ...props }: BreadcrumbsProps): react.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "fill" | "text" | "outline" | "ghost" | null | undefined;
+    color?: "success" | "error" | "warning" | "info" | "primary" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    iconOnly?: boolean | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends Omit<VariantProps<typeof buttonVariants>, "iconOnly">, Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "color"> {
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+}
+declare function Button({ variant, color, size, fullWidth, leftIcon, rightIcon, className, children, ...props }: ButtonProps): react.JSX.Element;
+
+interface CarouselProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    children: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    seeAllHref?: string;
+    arrows?: boolean;
+    indicators?: boolean;
+    autoSlide?: boolean;
+    interval?: number;
+    loop?: boolean;
+    gap?: number;
+}
+declare function Carousel({ children, title, description, seeAllHref, arrows, indicators, autoSlide, interval, loop, gap, className, ...props }: CarouselProps): react.JSX.Element;
+
+interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> {
+    label?: ReactNode;
+    indeterminate?: boolean;
+}
+declare function Checkbox({ label, indeterminate, className, disabled, ...props }: CheckboxProps): react.JSX.Element;
+
+declare const chip: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ChipProps extends VariantProps<typeof chip>, React.HTMLAttributes<HTMLSpanElement> {
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    onDismiss?: () => void;
+}
+declare function Chip({ size, leading, trailing, onDismiss, className, children, ...props }: ChipProps): react.JSX.Element;
+
+declare const tag: (props?: ({
+    size?: "xs" | "2xs" | null | undefined;
+    uppercase?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TagProps extends VariantProps<typeof tag>, React.HTMLAttributes<HTMLSpanElement> {
+    leading?: ReactNode;
+    trailing?: ReactNode;
+}
+declare function Tag({ size, uppercase, leading, trailing, className, children, ...props }: TagProps): react.JSX.Element;
+
+interface RadioProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type"> {
+    label?: ReactNode;
+}
+declare function Radio({ label, className, disabled, ...props }: RadioProps): react.JSX.Element;
+
+interface SearchProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "results"> {
+    value: string;
+    onValueChange: (value: string) => void;
+    results?: ReactNode;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    resultsTitle?: ReactNode;
+    shortcut?: string;
+    mobile?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function Search({ value, onValueChange, results, loading, emptyState, resultsTitle, shortcut, mobile, open: controlledOpen, onOpenChange, placeholder, className, ...props }: SearchProps): react.JSX.Element;
+
+declare const container: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SegmentedItem {
+    value: string;
+    label?: ReactNode;
+    icon?: ReactNode;
+}
+interface SegmentedControlProps extends VariantProps<typeof container>, Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    items: SegmentedItem[];
+    value: string;
+    onChange: (value: string) => void;
+}
+declare function SegmentedControl({ items, value, onChange, size, className, ...props }: SegmentedControlProps): react.JSX.Element;
+
+type TabsType = "default" | "pill" | "underline";
+interface TabsProps {
+    value: string;
+    onValueChange: (value: string) => void;
+    type?: TabsType;
+    size?: "sm" | "md";
+    children: ReactNode;
+    className?: string;
+}
+declare function Tabs({ value, onValueChange, type, size, children, className, }: TabsProps): react.JSX.Element;
+declare function TabList({ children, className, }: {
+    children: ReactNode;
+    className?: string;
+}): react.JSX.Element;
+interface TabProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "value"> {
+    value: string;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+}
+declare function Tab({ value, leading, trailing, children, className, ...props }: TabProps): react.JSX.Element;
+declare function TabPanel({ value, children, className, }: {
+    value: string;
+    children: ReactNode;
+    className?: string;
+}): react.JSX.Element | null;
+
+declare const field$2: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    invalid?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SelectProps extends VariantProps<typeof field$2>, Omit<React.SelectHTMLAttributes<HTMLSelectElement>, "size"> {
+    label?: ReactNode;
+    leadingIcon?: ReactNode;
+    error?: ReactNode;
+    helperText?: ReactNode;
+}
+declare function Select({ size, invalid, label, leadingIcon, error, helperText, className, id, disabled, children, ...props }: SelectProps): react.JSX.Element;
+
+declare const field$1: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    invalid?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextInputProps extends VariantProps<typeof field$1>, Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    label?: ReactNode;
+    leadingIcon?: ReactNode;
+    trailingIcon?: ReactNode;
+    error?: ReactNode;
+    helperText?: ReactNode;
+    floatingLabel?: boolean;
+}
+declare function TextInput({ size, invalid, label, leadingIcon, trailingIcon, error, helperText, floatingLabel, className, id, disabled, placeholder, ...props }: TextInputProps): react.JSX.Element;
+
+type Direction = "vertical" | "horizontal";
+interface GroupFieldProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    select?: boolean;
+    invalid?: boolean;
+    children?: ReactNode;
+}
+declare function GroupField({ select, invalid, className, children, ...props }: GroupFieldProps): react.JSX.Element;
+interface TextInputGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    direction?: Direction;
+    errors?: ReactNode[];
+    children: ReactNode;
+}
+declare function TextInputGroup({ direction, errors, className, children, ...props }: TextInputGroupProps): react.JSX.Element;
+
+declare const field: (props?: ({
+    invalid?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextareaProps extends VariantProps<typeof field>, React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: ReactNode;
+    error?: ReactNode;
+    helperText?: ReactNode;
+    autoResize?: boolean;
+}
+declare function Textarea({ invalid, label, error, helperText, autoResize, className, id, disabled, value, onChange, rows, ...props }: TextareaProps): react.JSX.Element;
+
+declare const track: (props?: ({
+    size?: "sm" | "xs" | "2xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SwitchProps extends VariantProps<typeof track>, Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    label?: ReactNode;
+}
+declare function Switch({ size, label, className, disabled, ...props }: SwitchProps): react.JSX.Element;
+
+declare const cell: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | "2xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Table({ className, ...props }: React.TableHTMLAttributes<HTMLTableElement>): react.JSX.Element;
+declare function TableHead({ className, ...props }: React.HTMLAttributes<HTMLTableSectionElement>): react.JSX.Element;
+declare function TableBody(props: React.HTMLAttributes<HTMLTableSectionElement>): react.JSX.Element;
+interface TableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    zebra?: boolean;
+    hover?: boolean;
+    selected?: boolean;
+}
+declare function TableRow({ zebra, hover, selected, className, ...props }: TableRowProps): react.JSX.Element;
+interface TableCellProps extends VariantProps<typeof cell>, React.TdHTMLAttributes<HTMLTableCellElement> {
+    header?: boolean;
+}
+declare function TableCell({ size, header, className, ...props }: TableCellProps): react.JSX.Element;
+interface TableColumn<T> {
+    key: string;
+    header: ReactNode;
+    cell: (row: T) => ReactNode;
+}
+declare function selectionState(selectedCount: number, total: number): {
+    checked: boolean;
+    indeterminate: boolean;
+};
+interface DataTableProps<T> extends VariantProps<typeof cell> {
+    columns: TableColumn<T>[];
+    data: T[];
+    rowKey: (row: T) => string;
+    zebra?: boolean;
+    selectable?: boolean;
+    selected?: string[];
+    onSelectedChange?: (keys: string[]) => void;
+    className?: string;
+}
+declare function DataTable<T>({ columns, data, rowKey, size, zebra, selectable, selected, onSelectedChange, className, }: DataTableProps<T>): react.JSX.Element;
+
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+interface ToastOptions {
+    message: ReactNode;
+    icon?: ReactNode;
+    duration?: number;
+    closable?: boolean;
+}
+interface ToastContextValue {
+    toast: (options: ToastOptions) => number;
+    dismiss: (id: number) => void;
+}
+declare function useToast(): ToastContextValue;
+interface ToastProviderProps {
+    children: ReactNode;
+    position?: ToastPosition;
+    defaultDuration?: number;
+}
+declare function ToastProvider({ children, position, defaultDuration, }: ToastProviderProps): react.JSX.Element;
+interface SnackbarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    icon?: ReactNode;
+    onClose?: () => void;
+    children: ReactNode;
+}
+declare function Snackbar({ icon, onClose, children, className, ...props }: SnackbarProps): react.JSX.Element;
+
+interface PopoverProps {
+    trigger: ReactElement<{
+        ref?: React.Ref<HTMLElement>;
+        onClick?: (e: React.MouseEvent) => void;
+        "aria-expanded"?: boolean;
+        "aria-haspopup"?: boolean;
+    }>;
+    children: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    align?: "start" | "end";
+    className?: string;
+}
+declare function Popover({ trigger, children, open: controlledOpen, onOpenChange, align, className, }: PopoverProps): react.JSX.Element;
+
+declare const bubble: (props?: ({
+    placement?: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | null | undefined;
+    shadow?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TooltipProps extends VariantProps<typeof bubble> {
+    content: ReactNode;
+    pointer?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+declare function Tooltip({ content, placement, shadow, pointer, children, className, }: TooltipProps): react.JSX.Element;
+
+interface SidebarProps extends React.HTMLAttributes<HTMLElement> {
+    collapsed?: boolean;
+    children: ReactNode;
+}
+declare function Sidebar({ collapsed, className, children, ...props }: SidebarProps): react.JSX.Element;
+interface SidebarSectionProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    title?: ReactNode;
+    divider?: boolean;
+    children: ReactNode;
+}
+declare function SidebarSection({ title, divider, className, children, ...props }: SidebarSectionProps): react.JSX.Element;
+interface SidebarItemProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "title"> {
+    icon?: ReactNode;
+    active?: boolean;
+    label: ReactNode;
+}
+declare function SidebarItem({ icon, active, label, href, className, ...props }: SidebarItemProps): react.JSX.Element;
+
+type CalendarProps = DayPickerProps & {
+    className?: string;
+};
+declare function Calendar({ className, classNames, ...props }: CalendarProps): react.JSX.Element;
+
+interface TimePickerProps {
+    value?: {
+        hours: number;
+        minutes: number;
+    };
+    onChange?: (value: {
+        hours: number;
+        minutes: number;
+    }) => void;
+    minuteStep?: number;
+    className?: string;
+}
+declare function TimePicker({ value, onChange, minuteStep, className, }: TimePickerProps): react.JSX.Element;
+
+interface DateRangePreset {
+    label: ReactNode;
+    range: () => DateRange;
+}
+interface DateRangePickerProps {
+    value?: DateRange;
+    onApply?: (range: DateRange | undefined) => void;
+    presets?: DateRangePreset[];
+    numberOfMonths?: number;
+    className?: string;
+}
+interface PresetRanges {
+    today: DateRange;
+    yesterday: DateRange;
+    thisWeek: DateRange;
+    lastWeek: DateRange;
+    thisMonth: DateRange;
+    lastMonth: DateRange;
+}
+declare function presetRanges(now: Date): PresetRanges;
+declare const defaultPresets: DateRangePreset[];
+declare function DateRangePicker({ value, onApply, presets, numberOfMonths, className, }: DateRangePickerProps): react.JSX.Element;
+
+interface QuarterValue {
+    year: number;
+    quarter: 1 | 2 | 3 | 4;
+}
+interface QuarterPickerProps {
+    value?: QuarterValue;
+    onChange?: (value: QuarterValue) => void;
+    year?: number;
+    onYearChange?: (year: number) => void;
+    className?: string;
+}
+declare function QuarterPicker({ value, onChange, year, onYearChange, className, }: QuarterPickerProps): react.JSX.Element;
+
+declare const drawer: (props?: ({
+    side?: "bottom" | "left" | "right" | "top" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface DrawerProps extends VariantProps<typeof drawer>, Omit<React.DialogHTMLAttributes<HTMLDialogElement>, "open"> {
+    open: boolean;
+    onClose?: () => void;
+    children: ReactNode;
+}
+declare function Drawer({ open, onClose, side, className, children, ...props }: DrawerProps): react.JSX.Element;
+
+declare const loader: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | "2xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface LoaderProps extends VariantProps<typeof loader>, Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> {
+    label?: string;
+}
+declare function Loader({ size, label, className, ...props }: LoaderProps): react.JSX.Element;
+
+declare const modal: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ModalProps extends VariantProps<typeof modal>, Omit<React.DialogHTMLAttributes<HTMLDialogElement>, "open" | "title"> {
+    open: boolean;
+    onClose?: () => void;
+    title?: ReactNode;
+    children: ReactNode;
+}
+declare function Modal({ open, onClose, size, title, className, children, ...props }: ModalProps): react.JSX.Element;
+
+declare const DOTS = "\u2026";
+declare function paginationRange(current: number, total: number, siblings?: number): (number | typeof DOTS)[];
+interface PaginationProps extends Omit<React.HTMLAttributes<HTMLElement>, "onChange"> {
+    page: number;
+    total: number;
+    siblings?: number;
+    onPageChange: (page: number) => void;
+}
+declare function Pagination({ page, total, siblings, onPageChange, className, ...props }: PaginationProps): react.JSX.Element;
+
+declare function clampPercent(value: number): number;
+declare const LINEAR_THICKNESS: {
+    readonly "6xs": "h-0.5";
+    readonly "5xs": "h-1";
+    readonly "4xs": "h-2";
+    readonly "3xs": "h-3";
+    readonly "2xs": "h-4";
+};
+declare const CIRCULAR_SIZE: {
+    readonly "2xs": 16;
+    readonly xs: 24;
+    readonly sm: 32;
+    readonly md: 40;
+    readonly lg: 48;
+};
+interface CommonProps {
+    value: number;
+    className?: string;
+    label?: string;
+}
+type ProgressProps = CommonProps & ({
+    variant?: "linear";
+    size?: keyof typeof LINEAR_THICKNESS;
+} | {
+    variant: "circular";
+    size?: keyof typeof CIRCULAR_SIZE;
+});
+declare function Progress({ value, className, label, ...rest }: ProgressProps): react.JSX.Element;
+
+interface DropdownProps {
+    trigger: ReactElement<{
+        ref?: React.Ref<HTMLElement>;
+        onClick?: (e: React.MouseEvent) => void;
+        "aria-expanded"?: boolean;
+        "aria-haspopup"?: boolean;
+    }>;
+    children: ReactNode;
+    align?: "start" | "end";
+    className?: string;
+}
+declare function Dropdown({ trigger, children, align, className, }: DropdownProps): react.JSX.Element;
+interface DropdownItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    description?: ReactNode;
+    selected?: boolean;
+}
+declare function DropdownItem({ leading, trailing, description, selected, children, className, onClick, disabled, ...props }: DropdownItemProps): react.JSX.Element;
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+}
+declare function filterOptions(options: ComboboxOption[], query: string): ComboboxOption[];
+interface BaseProps {
+    options: ComboboxOption[];
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    emptyMessage?: ReactNode;
+}
+type ComboboxProps = (BaseProps & {
+    multiple?: false;
+    value: string | null;
+    onChange: (value: string | null) => void;
+}) | (BaseProps & {
+    multiple: true;
+    value: string[];
+    onChange: (value: string[]) => void;
+});
+declare function Combobox(props: ComboboxProps): react.JSX.Element;
+
+export { Accordion, type AccordionProps, Alert, type AlertProps, AuthCode, type AuthCodeProps, Avatar, type AvatarProps, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, Button, type ButtonProps, Calendar, type CalendarProps, Carousel, type CarouselProps, Checkbox, type CheckboxProps, Chip, type ChipProps, Combobox, type ComboboxOption, type ComboboxProps, Container, type ContainerProps, DataTable, type DataTableProps, DateRangePicker, type DateRangePickerProps, type DateRangePreset, Drawer, type DrawerProps, Dropdown, DropdownItem, type DropdownItemProps, type DropdownProps, EmptyState, type EmptyStateProps, GroupField, type GroupFieldProps, Loader, type LoaderProps, Modal, type ModalProps, Pagination, type PaginationProps, Popover, type PopoverProps, type PresetRanges, Progress, type ProgressProps, QuarterPicker, type QuarterPickerProps, type QuarterValue, Radio, type RadioProps, Search, type SearchProps, SegmentedControl, type SegmentedControlProps, type SegmentedItem, Select, type SelectProps, Sidebar, SidebarItem, type SidebarItemProps, type SidebarProps, SidebarSection, type SidebarSectionProps, Snackbar, type SnackbarProps, Switch, type SwitchProps, Tab, TabList, TabPanel, type TabProps, Table, TableBody, TableCell, type TableCellProps, type TableColumn, TableHead, TableRow, type TableRowProps, Tabs, type TabsProps, Tag, type TagProps, TextInput, TextInputGroup, type TextInputGroupProps, type TextInputProps, Textarea, type TextareaProps, TimePicker, type TimePickerProps, type ToastOptions, type ToastPosition, ToastProvider, type ToastProviderProps, Tooltip, type TooltipProps, buttonVariants, clampPercent, cn, defaultPresets, filterOptions, paginationRange, presetRanges, selectionState, useToast };