@bizapps/design-system-testing 0.4.3 → 1.0.1

package/dist/main.d.cts

@@ -1,15 +1,1940 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as class_variance_authority_types from 'class-variance-authority/types';
-import * as React from 'react';
+import * as class_variance_authority from 'class-variance-authority';
 import { VariantProps } from 'class-variance-authority';
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, ComponentProps, ButtonHTMLAttributes, MouseEventHandler, SVGAttributes } from 'react';
+import { Avatar as Avatar$1, Toggle as Toggle$1, ToggleGroup as ToggleGroup$1, Select as Select$1, Separator as Separator$1, Progress as Progress$1, Slider as Slider$1, Switch as Switch$1, Tabs as Tabs$1, Tooltip as Tooltip$1, Popover as Popover$1, Dialog as Dialog$1, AlertDialog as AlertDialog$1, Accordion as Accordion$1, DropdownMenu as DropdownMenu$1, RadioGroup as RadioGroup$1, NavigationMenu as NavigationMenu$1, Checkbox as Checkbox$1 } from 'radix-ui';
+import { DayPicker, DayButton, Locale, DateRange } from 'react-day-picker';
+export { DateRange } from 'react-day-picker';
+import useEmblaCarousel, { UseEmblaCarouselType } from 'embla-carousel-react';
+import { DropzoneOptions, FileRejection, DropEvent } from 'react-dropzone';
+import Color from 'color';
+import * as react_hook_form from 'react-hook-form';
+import { UseFormProps, FieldValues } from 'react-hook-form';
+export { Controller, useFieldArray } from 'react-hook-form';
+import { ZodType, z } from 'zod';
+import { ColumnDef, SortingState, ColumnFiltersState, Row, RowSelectionState, Table as Table$1, VisibilityState, ColumnSizingState, Header, Updater, Column } from '@tanstack/react-table';
+export { Column, ColumnDef, ColumnFiltersState, Row, SortingState, Table as TanStackTableType, createColumnHelper } from '@tanstack/react-table';
 
-declare const buttonVariants: (props?: ({
-    variant?: "primary" | "secondary" | "cancel" | "outline" | "ghost" | null | undefined;
+declare const alertVariants: (props?: ({
+    variant?: "default" | "info" | "success" | "warning" | "error" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AlertProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+    icon?: ReactNode;
+    onDismiss?: () => void;
+}
+type AlertTitleProps = HTMLAttributes<HTMLHeadingElement>;
+type AlertDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+declare function Alert({ className, variant, icon, onDismiss, children, ...props }: AlertProps): react_jsx_runtime.JSX.Element;
+declare function AlertTitle({ className, ...props }: AlertTitleProps): react_jsx_runtime.JSX.Element;
+declare function AlertDescription({ className, ...props }: AlertDescriptionProps): react_jsx_runtime.JSX.Element;
+
+declare const avatarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Avatar({ className, size, ...props }: ComponentProps<typeof Avatar$1.Root> & VariantProps<typeof avatarVariants>): react_jsx_runtime.JSX.Element;
+declare function AvatarImage({ className, ...props }: ComponentProps<typeof Avatar$1.Image>): react_jsx_runtime.JSX.Element;
+declare function AvatarFallback({ className, ...props }: ComponentProps<typeof Avatar$1.Fallback>): react_jsx_runtime.JSX.Element;
+declare function AvatarBadge({ className, ...props }: ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+declare function AvatarGroup({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function AvatarGroupCount({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+declare const badgeVariants$1: (props?: ({
+    variant?: "default" | "link" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Badge$1({ className, variant, asChild, ...props }: ComponentProps<'span'> & VariantProps<typeof badgeVariants$1> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+type StatusProps = ComponentProps<typeof Badge$1> & {
+    status: 'online' | 'offline' | 'maintenance' | 'degraded';
+};
+declare const Status: ({ className, status, ...props }: StatusProps) => react_jsx_runtime.JSX.Element;
+type StatusIndicatorProps = HTMLAttributes<HTMLSpanElement>;
+declare const StatusIndicator: ({ className, ...props }: StatusIndicatorProps) => react_jsx_runtime.JSX.Element;
+type StatusLabelProps = HTMLAttributes<HTMLSpanElement>;
+declare const StatusLabel: ({ className, children, ...props }: StatusLabelProps) => react_jsx_runtime.JSX.Element;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "link" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Badge({ className, variant, size, asChild, ...props }: ComponentProps<'span'> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Root landmark for a breadcrumb trail. Renders a `<nav aria-label="breadcrumb">`
+ * and wraps a single {@link BreadcrumbList}.
+ */
+declare function Breadcrumb({ className, ...props }: ComponentProps<'nav'>): react_jsx_runtime.JSX.Element;
+/**
+ * Ordered list (`<ol>`) holding the trail. Lays the items out in a wrapping,
+ * gapped flex row and sets the default `text-main-grey` color and `text-sm` scale.
+ */
+declare function BreadcrumbList({ className, ...props }: ComponentProps<'ol'>): react_jsx_runtime.JSX.Element;
+/**
+ * A single segment (`<li>`) of the trail. Wraps a {@link BreadcrumbLink},
+ * {@link BreadcrumbPage}, or {@link BreadcrumbEllipsis}.
+ */
+declare function BreadcrumbItem({ className, ...props }: ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
+/**
+ * Navigable ancestor in the trail. Renders an `<a>` by default; pass `asChild`
+ * to delegate to a router link (e.g. React Router / Next.js `Link`) while keeping
+ * the hover and focus styles.
+ *
+ * @param asChild - Render the child element instead of an `<a>` (Radix `Slot`).
+ */
+declare function BreadcrumbLink({ asChild, className, ...props }: ComponentProps<'a'> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * The current page — the last, non-interactive segment. Renders a `<span>` with
+ * `aria-current="page"` and emphasized `text-main-blue-primary` color.
+ */
+declare function BreadcrumbPage({ className, ...props }: ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+/**
+ * Visual divider between items. Defaults to a `ChevronRight` icon; pass any node
+ * as children to override it. Always `aria-hidden`, so overrides never reach
+ * assistive tech.
+ */
+declare function BreadcrumbSeparator({ children, className, ...props }: ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
+/**
+ * Truncation marker (`…`) that collapses hidden middle segments of a long trail.
+ * Pair it with a `DropdownMenu` to make the collapsed segments navigable.
+ */
+declare function BreadcrumbEllipsis({ className, ...props }: ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants$1: (props?: ({
+    variant?: "secondary" | "outline" | "ghost" | "cancel" | "primary" | "cancelGhost" | null | undefined;
     size?: "sm" | "md" | "lg" | "icon-sm" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function Button({ className, variant, size, asChild, isLoading, children, ...props }: React.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+/**
+ * Interactive button with 6 variants and 4 sizes. Use `asChild` to render as any element via Radix Slot.
+ * When `isLoading` is true, a spinner is shown and clicks are blocked while keeping the not-allowed cursor.
+ */
+declare function Button$1({ className, variant, size, asChild, isLoading, children, onClick, ...props }: ComponentProps<'button'> & VariantProps<typeof buttonVariants$1> & {
     asChild?: boolean;
     isLoading?: boolean;
 }): react_jsx_runtime.JSX.Element;
 
-export { Button, buttonVariants };
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, locale, formatters, components, fromYear, toYear, ...props }: ComponentProps<typeof DayPicker> & {
+    buttonVariant?: ComponentProps<typeof Button$1>['variant'];
+    fromYear?: number;
+    toYear?: number;
+}): react_jsx_runtime.JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, locale, ...props }: ComponentProps<typeof DayButton> & {
+    locale?: Partial<Locale>;
+}): react_jsx_runtime.JSX.Element;
+
+type MiniCalendarProps = HTMLAttributes<HTMLDivElement> & {
+    value?: Date;
+    defaultValue?: Date;
+    onValueChange?: (date: Date | undefined) => void;
+    startDate?: Date;
+    defaultStartDate?: Date;
+    onStartDateChange?: (date: Date | undefined) => void;
+    days?: number;
+};
+declare const MiniCalendar: ({ value, defaultValue, onValueChange, startDate, defaultStartDate, onStartDateChange, days, className, children, ...props }: MiniCalendarProps) => react_jsx_runtime.JSX.Element;
+type MiniCalendarNavigationProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    direction: 'prev' | 'next';
+    asChild?: boolean;
+};
+declare const MiniCalendarNavigation: ({ direction, asChild, children, onClick, ...props }: MiniCalendarNavigationProps) => react_jsx_runtime.JSX.Element;
+type MiniCalendarDaysProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
+    children: (date: Date) => ReactNode;
+};
+declare const MiniCalendarDays: ({ className, children, ...props }: MiniCalendarDaysProps) => react_jsx_runtime.JSX.Element;
+type MiniCalendarDayProps = ComponentProps<typeof Button$1> & {
+    date: Date;
+};
+declare const MiniCalendarDay: ({ date, className, ...props }: MiniCalendarDayProps) => react_jsx_runtime.JSX.Element;
+
+declare function Card({ className, size, ...props }: ComponentProps<'div'> & {
+    size?: 'default' | 'sm';
+}): react_jsx_runtime.JSX.Element;
+declare function CardHeader({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardTitle({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardDescription({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardAction({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardContent({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function CardFooter({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: 'horizontal' | 'vertical';
+    setApi?: (api: CarouselApi) => void;
+};
+type CarouselContextProps = {
+    carouselRef: ReturnType<typeof useEmblaCarousel>[0];
+    api: ReturnType<typeof useEmblaCarousel>[1];
+    scrollPrev: () => void;
+    scrollNext: () => void;
+    canScrollPrev: boolean;
+    canScrollNext: boolean;
+} & CarouselProps;
+declare function useCarousel(): CarouselContextProps;
+/**
+ * Carousel root. Wraps Embla Carousel with keyboard navigation, scroll state, and context.
+ * Use `orientation` for vertical mode and `opts` to pass Embla options directly.
+ */
+declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: ComponentProps<'div'> & CarouselProps): react_jsx_runtime.JSX.Element;
+/**
+ * Scrollable track wrapper. Direct child of `Carousel`. Wraps `CarouselItem` children.
+ */
+declare function CarouselContent({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+/**
+ * Individual slide. Use `className` with `basis-*` utilities to control how many slides are visible.
+ */
+declare function CarouselItem({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+/**
+ * Previous-slide button. Positioned absolutely to the left (horizontal) or top (vertical).
+ * Disabled automatically when there are no previous slides.
+ */
+declare function CarouselPrevious({ className, variant, size, ...props }: ComponentProps<typeof Button$1>): react_jsx_runtime.JSX.Element;
+/**
+ * Next-slide button. Positioned absolutely to the right (horizontal) or bottom (vertical).
+ * Disabled automatically when there are no next slides.
+ */
+declare function CarouselNext({ className, variant, size, ...props }: ComponentProps<typeof Button$1>): react_jsx_runtime.JSX.Element;
+
+declare function Field({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function FieldLabel({ className, ...props }: ComponentProps<'label'>): react_jsx_runtime.JSX.Element;
+declare function FieldDescription({ className, ...props }: ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
+declare function FieldError({ errors, className }: {
+    errors?: unknown[];
+    className?: string;
+}): react_jsx_runtime.JSX.Element | null;
+declare function FieldGroup({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+declare function Input({ className, type, ...props }: ComponentProps<'input'>): react_jsx_runtime.JSX.Element;
+
+declare const linkVariants: (props?: ({
+    variant?: "underlined" | "plain" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Link({ className, variant, size, asChild, disabled, target, rel, href, truncate, children, onClick, ...props }: Omit<ComponentProps<'a'>, 'onClick'> & VariantProps<typeof linkVariants> & {
+    asChild?: boolean;
+    disabled?: boolean;
+    truncate?: boolean;
+    onClick?: MouseEventHandler<HTMLElement>;
+}): react_jsx_runtime.JSX.Element;
+
+interface PinInputProps {
+    length?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    invalid?: boolean;
+    mask?: boolean;
+    className?: string;
+    inputClassName?: string;
+}
+declare function PinInput({ length, value, onChange, disabled, invalid, mask, className, inputClassName, }: PinInputProps): react_jsx_runtime.JSX.Element;
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Toggle({ className, variant, size, ...props }: ComponentProps<typeof Toggle$1.Root> & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
+
+type SegmentedControlSingleProps = {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+};
+type SegmentedControlMultipleProps = {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+};
+type SegmentedControlProps = (SegmentedControlSingleProps | SegmentedControlMultipleProps) & VariantProps<typeof toggleVariants> & {
+    disabled?: boolean;
+    className?: string;
+    children?: ReactNode;
+};
+declare function SegmentedControl({ className, size, children, ...props }: SegmentedControlProps): react_jsx_runtime.JSX.Element;
+declare function SegmentedControlItem({ className, children, value, ...props }: ComponentProps<typeof ToggleGroup$1.Item> & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
+
+declare function Select({ ...props }: ComponentProps<typeof Select$1.Root>): react_jsx_runtime.JSX.Element;
+declare function SelectTrigger$1({ className, children, ...props }: ComponentProps<typeof Select$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function SelectContent({ className, children, position, ...props }: ComponentProps<typeof Select$1.Content>): react_jsx_runtime.JSX.Element;
+declare function SelectItem({ className, children, ...props }: ComponentProps<typeof Select$1.Item>): react_jsx_runtime.JSX.Element;
+declare function SelectLabel({ className, ...props }: ComponentProps<typeof Select$1.Label>): react_jsx_runtime.JSX.Element;
+declare function SelectSeparator({ className, ...props }: ComponentProps<typeof Select$1.Separator>): react_jsx_runtime.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: ComponentProps<typeof Select$1.ScrollUpButton>): react_jsx_runtime.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: ComponentProps<typeof Select$1.ScrollDownButton>): react_jsx_runtime.JSX.Element;
+declare function SelectValue({ ...props }: ComponentProps<typeof Select$1.Value>): react_jsx_runtime.JSX.Element;
+declare function SelectGroup({ ...props }: ComponentProps<typeof Select$1.Group>): react_jsx_runtime.JSX.Element;
+
+declare function Separator({ className, orientation, decorative, ...props }: ComponentProps<typeof Separator$1.Root>): react_jsx_runtime.JSX.Element;
+
+declare const progressVariants: (props?: ({
+    variant?: "default" | "success" | "warning" | "danger" | "orange" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const progressIndicatorVariants: (props?: ({
+    variant?: "default" | "success" | "warning" | "danger" | "orange" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ProgressProps extends ComponentProps<typeof Progress$1.Root>, VariantProps<typeof progressVariants> {
+}
+declare function Progress({ className, value, variant, size, ...props }: ProgressProps): react_jsx_runtime.JSX.Element;
+
+declare const skeletonVariants: (props?: ({
+    variant?: "default" | "text" | "avatar" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Skeleton({ className, variant, ...props }: ComponentProps<'div'> & VariantProps<typeof skeletonVariants>): react_jsx_runtime.JSX.Element;
+
+declare function Slider({ className, defaultValue, value, min, max, ...props }: ComponentProps<typeof Slider$1.Root>): react_jsx_runtime.JSX.Element;
+
+declare function Switch({ className, size, ...props }: ComponentProps<typeof Switch$1.Root> & {
+    size?: 'sm' | 'default';
+}): react_jsx_runtime.JSX.Element;
+
+declare function Tabs({ defaultValue, value: controlledValue, onValueChange, ...props }: ComponentProps<typeof Tabs$1.Root>): react_jsx_runtime.JSX.Element;
+declare function TabsList({ className, ...props }: ComponentProps<typeof Tabs$1.List>): react_jsx_runtime.JSX.Element;
+declare function TabsTrigger({ className, value, children, ...props }: ComponentProps<typeof Tabs$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ className, value, children, ...props }: ComponentProps<typeof Tabs$1.Content>): react_jsx_runtime.JSX.Element;
+
+type ToastType = 'default' | 'success' | 'error' | 'warning' | 'info' | 'loading';
+interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+interface ToastItem {
+    id: string;
+    type: ToastType;
+    title: string;
+    description?: string;
+    duration: number;
+    action?: ToastAction;
+}
+type ToastOptions = Partial<Omit<ToastItem, 'id' | 'title' | 'type'>> & {
+    id?: string;
+};
+interface PromiseMessages<T> {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((err: unknown) => string);
+}
+declare function useToast(): ((title: string, options?: ToastOptions) => string) & {
+    success: (title: string, options?: ToastOptions) => string;
+    error: (title: string, options?: ToastOptions) => string;
+    warning: (title: string, options?: ToastOptions) => string;
+    info: (title: string, options?: ToastOptions) => string;
+    loading: (title: string, options?: ToastOptions) => string;
+    dismiss: (id: string) => void;
+    promise: <T>(promise: Promise<T>, messages: PromiseMessages<T>) => string;
+};
+type ToasterPosition = 'top-right' | 'top-left' | 'top-center' | 'bottom-right' | 'bottom-left' | 'bottom-center';
+interface ToasterProps {
+    position?: ToasterPosition;
+    richColors?: boolean;
+    closeButton?: boolean;
+    duration?: number;
+    children?: ReactNode;
+}
+declare function Toaster({ position, children }: ToasterProps): react_jsx_runtime.JSX.Element;
+
+declare function ToggleGroup({ className, variant, size, spacing, orientation, children, ...props }: ComponentProps<typeof ToggleGroup$1.Root> & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+    orientation?: 'horizontal' | 'vertical';
+}): react_jsx_runtime.JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: ComponentProps<typeof ToggleGroup$1.Item> & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
+
+declare const tooltipContentVariants: (props?: ({
+    variant?: "default" | "primary" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function TooltipProvider({ delayDuration, ...props }: ComponentProps<typeof Tooltip$1.Provider>): react_jsx_runtime.JSX.Element;
+declare function Tooltip({ ...props }: ComponentProps<typeof Tooltip$1.Root>): react_jsx_runtime.JSX.Element;
+declare function TooltipTrigger({ ...props }: ComponentProps<typeof Tooltip$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function TooltipContent({ className, sideOffset, variant, size, children, ...props }: ComponentProps<typeof Tooltip$1.Content> & VariantProps<typeof tooltipContentVariants>): react_jsx_runtime.JSX.Element;
+
+declare function Popover({ ...props }: ComponentProps<typeof Popover$1.Root>): react_jsx_runtime.JSX.Element;
+declare function PopoverTrigger({ ...props }: ComponentProps<typeof Popover$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: ComponentProps<typeof Popover$1.Content>): react_jsx_runtime.JSX.Element;
+declare function PopoverAnchor({ ...props }: ComponentProps<typeof Popover$1.Anchor>): react_jsx_runtime.JSX.Element;
+declare function PopoverHeader({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function PopoverTitle({ className, ...props }: ComponentProps<'h2'>): react_jsx_runtime.JSX.Element;
+declare function PopoverDescription({ className, ...props }: ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
+
+declare const TEXT_SIZES: readonly [12, 14, 16, 18, 20, 24, 28, 32, 40, 48];
+declare const TEXT_WEIGHTS: readonly [100, 200, 300, 400, 500, 700, 800, 900];
+type TextSize = (typeof TEXT_SIZES)[number];
+type TextWeight = (typeof TEXT_WEIGHTS)[number];
+type TextAs = 'p' | 'span' | 'label' | 'small' | 'strong' | 'em';
+interface TextProps extends Omit<HTMLAttributes<HTMLElement>, 'color'> {
+    /** HTML element to render */
+    as?: TextAs;
+    /** Font size in pixels */
+    size?: TextSize;
+    /** Font weight */
+    weight?: TextWeight;
+    /** Italic style */
+    italic?: boolean;
+    /** Optional CSS color value */
+    color?: string;
+    /** Text content */
+    children: ReactNode;
+}
+declare function Text({ as: Tag, size, weight, italic, color, className, style, children, ...props }: TextProps): react_jsx_runtime.JSX.Element;
+
+declare function Dialog({ children, ...props }: ComponentProps<typeof Dialog$1.Root>): react_jsx_runtime.JSX.Element;
+declare function DialogTrigger({ ...props }: ComponentProps<typeof Dialog$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DialogPortal({ children, ...props }: ComponentProps<typeof Dialog$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function DialogClose({ ...props }: ComponentProps<typeof Dialog$1.Close>): react_jsx_runtime.JSX.Element;
+declare function DialogOverlay({ className, ...props }: ComponentProps<typeof Dialog$1.Overlay>): react_jsx_runtime.JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, ...props }: ComponentProps<typeof Dialog$1.Content> & {
+    showCloseButton?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DialogHeader({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function DialogFooter({ className, showCloseButton, children, ...props }: ComponentProps<'div'> & {
+    showCloseButton?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DialogTitle({ className, ...props }: ComponentProps<typeof Dialog$1.Title>): react_jsx_runtime.JSX.Element;
+declare function DialogDescription({ className, ...props }: ComponentProps<typeof Dialog$1.Description>): react_jsx_runtime.JSX.Element;
+
+declare function AlertDialog({ children, ...props }: ComponentProps<typeof AlertDialog$1.Root>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogTrigger({ ...props }: ComponentProps<typeof AlertDialog$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogPortal({ children, ...props }: ComponentProps<typeof AlertDialog$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: ComponentProps<typeof AlertDialog$1.Overlay>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogContent({ className, size, variant, showClose, children, ...props }: ComponentProps<typeof AlertDialog$1.Content> & {
+    size?: 'default' | 'sm';
+    variant?: 'default' | 'dark-glass';
+    showClose?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogMedia({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: ComponentProps<typeof AlertDialog$1.Title>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: ComponentProps<typeof AlertDialog$1.Description>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogAction({ className, variant, size, children, ...props }: ComponentProps<typeof AlertDialog$1.Action> & Pick<ComponentProps<typeof Button$1>, 'variant' | 'size'>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogCancel({ className, variant, size, children, ...props }: ComponentProps<typeof AlertDialog$1.Cancel> & Pick<ComponentProps<typeof Button$1>, 'variant' | 'size'>): react_jsx_runtime.JSX.Element;
+
+declare function Accordion({ className, ...props }: ComponentProps<typeof Accordion$1.Root>): react_jsx_runtime.JSX.Element;
+declare function AccordionItem({ className, ...props }: ComponentProps<typeof Accordion$1.Item>): react_jsx_runtime.JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: ComponentProps<typeof Accordion$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function AccordionContent({ className, children, ...props }: ComponentProps<typeof Accordion$1.Content>): react_jsx_runtime.JSX.Element;
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface ComboboxProps {
+    options: ComboboxOption[];
+    value?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function Combobox({ options, value, onValueChange, placeholder, searchPlaceholder, emptyMessage, disabled, className, }: ComboboxProps): react_jsx_runtime.JSX.Element;
+
+declare function DropdownMenu({ ...props }: ComponentProps<typeof DropdownMenu$1.Root>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: ComponentProps<typeof DropdownMenu$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: ComponentProps<typeof DropdownMenu$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuContent({ className, align, sideOffset, ...props }: ComponentProps<typeof DropdownMenu$1.Content>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: ComponentProps<typeof DropdownMenu$1.Group>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: ComponentProps<typeof DropdownMenu$1.Item> & {
+    inset?: boolean;
+    variant?: 'default' | 'destructive';
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, inset, ...props }: ComponentProps<typeof DropdownMenu$1.CheckboxItem> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: ComponentProps<typeof DropdownMenu$1.RadioGroup>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, inset, ...props }: ComponentProps<typeof DropdownMenu$1.RadioItem> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: ComponentProps<typeof DropdownMenu$1.Label> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: ComponentProps<typeof DropdownMenu$1.Separator>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSub({ ...props }: ComponentProps<typeof DropdownMenu$1.Sub>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: ComponentProps<typeof DropdownMenu$1.SubTrigger> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: ComponentProps<typeof DropdownMenu$1.SubContent>): react_jsx_runtime.JSX.Element;
+
+type DropzoneProps = Omit<DropzoneOptions, 'onDrop'> & {
+    src?: File[];
+    className?: string;
+    border?: 'default' | 'dashed';
+    onDrop?: (acceptedFiles: File[], fileRejections: FileRejection[], event: DropEvent) => void;
+    children?: ReactNode;
+};
+declare const Dropzone: ({ accept, maxFiles, maxSize, minSize, onDrop, onError, disabled, src, className, children, border, ...props }: DropzoneProps) => react_jsx_runtime.JSX.Element;
+interface DropzoneContentProps {
+    children?: ReactNode;
+    className?: string;
+}
+declare const DropzoneContent: ({ children, className }: DropzoneContentProps) => string | number | bigint | true | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null;
+interface DropzoneEmptyStateProps {
+    children?: ReactNode;
+    className?: string;
+}
+declare const DropzoneEmptyState: ({ children, className }: DropzoneEmptyStateProps) => string | number | bigint | true | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null;
+
+declare function Empty({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function EmptyHeader({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function EmptyMedia({ className, variant, ...props }: React.ComponentProps<'div'> & VariantProps<typeof emptyMediaVariants>): react_jsx_runtime.JSX.Element;
+declare function EmptyTitle({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function EmptyDescription({ className, ...props }: React.ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
+declare function EmptyContent({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+declare function ItemGroup({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function ItemSeparator({ className, ...props }: ComponentProps<typeof Separator>): react_jsx_runtime.JSX.Element;
+declare const itemVariants: (props?: ({
+    variant?: "default" | "outline" | "muted" | "highlighted" | null | undefined;
+    size?: "default" | "sm" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Item({ className, variant, size, asChild, ...props }: ComponentProps<'div'> & VariantProps<typeof itemVariants> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare const itemMediaVariants: (props?: ({
+    variant?: "default" | "icon" | "image" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function ItemMedia({ className, variant, ...props }: ComponentProps<'div'> & VariantProps<typeof itemMediaVariants>): react_jsx_runtime.JSX.Element;
+declare function ItemContent({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function ItemTitle({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function ItemDescription({ className, ...props }: ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
+declare function ItemActions({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function ItemHeader({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function ItemFooter({ className, ...props }: ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+declare function RadioGroup({ className, ...props }: ComponentProps<typeof RadioGroup$1.Root>): react_jsx_runtime.JSX.Element;
+declare function RadioGroupItem({ className, ...props }: ComponentProps<typeof RadioGroup$1.Item>): react_jsx_runtime.JSX.Element;
+
+declare const spinnerVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    color?: "current" | "destructive" | "primary" | "white" | "muted" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SpinnerProps extends Omit<ComponentProps<'svg'>, 'color'>, VariantProps<typeof spinnerVariants> {
+}
+declare function Spinner({ className, size, color, ...props }: SpinnerProps): react_jsx_runtime.JSX.Element;
+declare const spinnerLoaderVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    color?: "current" | "destructive" | "primary" | "white" | "muted" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SpinnerLoaderProps extends Omit<ComponentProps<'svg'>, 'color'>, VariantProps<typeof spinnerLoaderVariants> {
+}
+declare function SpinnerLoader({ className, size, color, ...props }: SpinnerLoaderProps): react_jsx_runtime.JSX.Element;
+declare const spinnerDotsVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    color?: "current" | "destructive" | "primary" | "white" | "muted" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SpinnerDotsProps extends VariantProps<typeof spinnerDotsVariants> {
+    className?: string;
+}
+declare function SpinnerDots({ className, size, color }: SpinnerDotsProps): react_jsx_runtime.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | "icon-sm" | "xs" | "icon-xs" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+
+declare function SelectTrigger({ className, size, children, ...props }: ComponentProps<typeof Select$1.Trigger> & {
+    size?: 'sm' | 'default';
+}): react_jsx_runtime.JSX.Element;
+
+interface ColorPickerContextValue {
+    hue: number;
+    saturation: number;
+    lightness: number;
+    alpha: number;
+    mode: string;
+    setHue: (hue: number) => void;
+    setSaturation: (saturation: number) => void;
+    setLightness: (lightness: number) => void;
+    setAlpha: (alpha: number) => void;
+    setMode: (mode: string) => void;
+}
+declare const useColorPicker: () => ColorPickerContextValue;
+type ColorPickerProps = Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> & {
+    value?: Parameters<typeof Color>[0];
+    defaultValue?: Parameters<typeof Color>[0];
+    onChange?: (value: [number, number, number, number]) => void;
+};
+declare const ColorPicker: ({ value, defaultValue, onChange, className, ...props }: ColorPickerProps) => react_jsx_runtime.JSX.Element;
+type ColorPickerSelectionProps = HTMLAttributes<HTMLDivElement>;
+declare const ColorPickerSelection: react.MemoExoticComponent<({ className, ...props }: ColorPickerSelectionProps) => react_jsx_runtime.JSX.Element>;
+type ColorPickerHueProps = ComponentProps<typeof Slider$1.Root>;
+declare const ColorPickerHue: ({ className, ...props }: ColorPickerHueProps) => react_jsx_runtime.JSX.Element;
+type ColorPickerAlphaProps = ComponentProps<typeof Slider$1.Root>;
+declare const ColorPickerAlpha: ({ className, ...props }: ColorPickerAlphaProps) => react_jsx_runtime.JSX.Element;
+type ColorPickerEyeDropperProps = ComponentProps<typeof Button>;
+declare const ColorPickerEyeDropper: ({ className, ...props }: ColorPickerEyeDropperProps) => react_jsx_runtime.JSX.Element;
+type ColorPickerOutputProps = ComponentProps<typeof SelectTrigger>;
+declare const ColorPickerOutput: ({ ...props }: ColorPickerOutputProps) => react_jsx_runtime.JSX.Element;
+type ColorPickerFormatProps = HTMLAttributes<HTMLDivElement>;
+declare const ColorPickerFormat: ({ className, ...props }: ColorPickerFormatProps) => react_jsx_runtime.JSX.Element | null;
+type ColorPickerPresetsProps = HTMLAttributes<HTMLDivElement> & {
+    colors: string[];
+};
+declare const ColorPickerPresets: {
+    ({ colors, className, ...props }: ColorPickerPresetsProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+interface DatePickerSingleProps {
+    mode?: 'single';
+    selected?: Date;
+    onSelect?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    fromDate?: Date;
+    toDate?: Date;
+}
+interface DatePickerRangeProps {
+    mode: 'range';
+    selected?: DateRange;
+    onSelect?: (range: DateRange | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    fromDate?: Date;
+    toDate?: Date;
+}
+interface DatePickerProps {
+    mode?: 'single' | 'range';
+    selected?: Date | DateRange;
+    onSelect?: ((date: Date | undefined) => void) | ((range: DateRange | undefined) => void);
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    fromDate?: Date;
+    toDate?: Date;
+}
+declare function DatePicker({ mode, selected, onSelect, placeholder, disabled, className, fromDate, toDate, }: DatePickerProps): react_jsx_runtime.JSX.Element;
+
+interface NavbarDropdownItem {
+    href: string;
+    label: string;
+    icon?: ReactNode;
+}
+interface NavbarNavLink {
+    href: string;
+    label: string;
+    active?: boolean;
+    icon?: ReactNode;
+    /** If provided, hovering this link shows a dropdown */
+    dropdownItems?: NavbarDropdownItem[];
+}
+interface NavbarUtilityLink {
+    href: string;
+    label: string;
+}
+interface NavbarProps extends HTMLAttributes<HTMLElement> {
+    logo?: ReactNode;
+    brandName?: string;
+    utilityLinks?: NavbarUtilityLink[];
+    navigationLinks?: NavbarNavLink[];
+    notificationCount?: number;
+    onNavLinkClick?: (href: string) => void;
+    onSearchClick?: () => void;
+    onHelpClick?: () => void;
+}
+declare const Logo: (props: SVGAttributes<SVGElement>) => react_jsx_runtime.JSX.Element;
+declare const Navbar: react.ForwardRefExoticComponent<NavbarProps & react.RefAttributes<HTMLElement>>;
+
+declare function NavigationMenu({ className, children, viewport, ...props }: ComponentProps<typeof NavigationMenu$1.Root> & {
+    viewport?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuList({ className, ...props }: ComponentProps<typeof NavigationMenu$1.List>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuItem({ className, ...props }: ComponentProps<typeof NavigationMenu$1.Item>): react_jsx_runtime.JSX.Element;
+declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare function NavigationMenuTrigger({ className, children, ...props }: ComponentProps<typeof NavigationMenu$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuContent({ className, ...props }: ComponentProps<typeof NavigationMenu$1.Content>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuViewport({ className, ...props }: ComponentProps<typeof NavigationMenu$1.Viewport>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuLink({ className, ...props }: ComponentProps<typeof NavigationMenu$1.Link>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuIndicator({ className, ...props }: ComponentProps<typeof NavigationMenu$1.Indicator>): react_jsx_runtime.JSX.Element;
+
+interface SidebarProviderProps extends HTMLAttributes<HTMLDivElement> {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare const SidebarProvider: react.ForwardRefExoticComponent<SidebarProviderProps & react.RefAttributes<HTMLDivElement>>;
+declare const SidebarTrigger: react.ForwardRefExoticComponent<Omit<react.ClassAttributes<HTMLButtonElement> & ButtonHTMLAttributes<HTMLButtonElement> & class_variance_authority.VariantProps<(props?: ({
+    variant?: "secondary" | "outline" | "ghost" | "cancel" | "primary" | "cancelGhost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon-sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    asChild?: boolean;
+    isLoading?: boolean;
+}, "ref"> & react.RefAttributes<HTMLButtonElement>>;
+
+interface SideBarItem {
+    label: string;
+    icon?: React.ReactNode;
+    active?: boolean;
+    onClick?: () => void;
+}
+interface SideBarProps {
+    items?: SideBarItem[];
+    activeItem?: string;
+    onItemClick?: (label: string) => void;
+    brandName?: string;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare function SideBar({ items, activeItem, onItemClick, brandName, className, children, }: SideBarProps): react_jsx_runtime.JSX.Element;
+
+declare function Textarea({ className, ...props }: ComponentProps<'textarea'>): react_jsx_runtime.JSX.Element;
+
+interface CalendarEvent {
+    id: string | number;
+    title: string;
+    /** ISO format: "YYYY-MM-DD HH:mm" for timed events, "YYYY-MM-DD" for all-day */
+    start: string;
+    /** ISO format: "YYYY-MM-DD HH:mm" for timed events, "YYYY-MM-DD" for all-day */
+    end: string;
+    color?: 'default' | 'primary' | 'success' | 'warning' | 'danger';
+    description?: string;
+    [key: string]: unknown;
+}
+type CalendarView = 'month' | 'week' | 'day' | 'agenda';
+interface EventCreateRange {
+    /** "YYYY-MM-DD HH:mm" for timed slot, "YYYY-MM-DD" for all-day slot */
+    start: string;
+    end: string;
+}
+interface EventCalendarProps {
+    events: CalendarEvent[];
+    /**
+     * Initial view. @schedule-x owns view state — use `key` prop to force reset.
+     * @default 'month'
+     */
+    defaultView?: CalendarView;
+    /** Fired whenever the user switches views inside the calendar. */
+    onViewChange?: (view: CalendarView) => void;
+    /**
+     * Initial selected date in "YYYY-MM-DD" format.
+     * @default today
+     */
+    defaultDate?: string;
+    /** Fired when the user clicks an existing event. */
+    onEventClick?: (event: CalendarEvent) => void;
+    /** Fired when the user double-clicks an empty slot. Use this to open a create-event dialog. */
+    onEventCreate?: (range: EventCreateRange) => void;
+    /**
+     * BCP 47 locale string for calendar labels.
+     * @default 'en-US'
+     */
+    locale?: string;
+    className?: string;
+}
+
+declare function EventCalendar({ events, defaultView, onViewChange, defaultDate, onEventClick, onEventCreate, locale, className, }: EventCalendarProps): react_jsx_runtime.JSX.Element;
+
+declare const duration: {
+    readonly instant: 0.1;
+    readonly fast: 0.15;
+    readonly normal: 0.25;
+    readonly slow: 0.4;
+};
+declare const ease: {
+    readonly smooth: readonly [0.4, 0, 0.2, 1];
+    readonly enter: readonly [0, 0, 0.2, 1];
+    readonly exit: readonly [0.4, 0, 1, 1];
+    readonly linear: readonly [0, 0, 1, 1];
+};
+declare const spring: {
+    readonly gentle: {
+        readonly type: "spring";
+        readonly stiffness: 260;
+        readonly damping: 28;
+    };
+    readonly snappy: {
+        readonly type: "spring";
+        readonly stiffness: 400;
+        readonly damping: 30;
+    };
+};
+declare const transition: {
+    readonly button: {
+        readonly duration: 0.1;
+        readonly ease: readonly [0.4, 0, 0.2, 1];
+    };
+    readonly toggle: {
+        readonly type: "spring";
+        readonly stiffness: 400;
+        readonly damping: 30;
+    };
+    readonly input: {
+        readonly duration: 0.15;
+        readonly ease: readonly [0.4, 0, 0.2, 1];
+    };
+    readonly dropdown: {
+        readonly duration: 0.15;
+        readonly ease: readonly [0, 0, 0.2, 1];
+    };
+    readonly toast: {
+        readonly duration: 0.15;
+        readonly ease: readonly [0.4, 0, 0.2, 1];
+    };
+    readonly modal: {
+        readonly type: "spring";
+        readonly stiffness: 260;
+        readonly damping: 28;
+    };
+    readonly sidebar: {
+        readonly duration: 0.4;
+        readonly ease: readonly [0.4, 0, 0.2, 1];
+    };
+    readonly card: {
+        readonly duration: 0.15;
+        readonly ease: readonly [0.4, 0, 0.2, 1];
+    };
+};
+declare const fadeIn: {
+    readonly hidden: {
+        readonly opacity: 0;
+    };
+    readonly visible: {
+        readonly opacity: 1;
+        readonly transition: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0, 0, 0.2, 1];
+        };
+    };
+    readonly exit: {
+        readonly opacity: 0;
+        readonly transition: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0.4, 0, 1, 1];
+        };
+    };
+};
+declare const slideUp: {
+    readonly hidden: {
+        readonly opacity: 0;
+        readonly y: 8;
+    };
+    readonly visible: {
+        readonly opacity: 1;
+        readonly y: 0;
+        readonly transition: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0, 0, 0.2, 1];
+        };
+    };
+    readonly exit: {
+        readonly opacity: 0;
+        readonly y: 4;
+        readonly transition: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0.4, 0, 1, 1];
+        };
+    };
+};
+declare const slideRight: {
+    readonly hidden: {
+        readonly opacity: 0;
+        readonly x: -12;
+    };
+    readonly visible: {
+        readonly opacity: 1;
+        readonly x: 0;
+        readonly transition: {
+            readonly duration: 0.4;
+            readonly ease: readonly [0.4, 0, 0.2, 1];
+        };
+    };
+    readonly exit: {
+        readonly opacity: 0;
+        readonly x: -12;
+        readonly transition: {
+            readonly duration: 0.25;
+            readonly ease: readonly [0.4, 0, 1, 1];
+        };
+    };
+};
+declare const scaleIn: {
+    readonly hidden: {
+        readonly opacity: 0;
+        readonly scale: 0.97;
+    };
+    readonly visible: {
+        readonly opacity: 1;
+        readonly scale: 1;
+        readonly transition: {
+            readonly type: "spring";
+            readonly stiffness: 260;
+            readonly damping: 28;
+        };
+    };
+    readonly exit: {
+        readonly opacity: 0;
+        readonly scale: 0.97;
+        readonly transition: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0.4, 0, 1, 1];
+        };
+    };
+};
+declare const stagger: {
+    readonly container: {
+        readonly hidden: {};
+        readonly visible: {
+            readonly transition: {
+                readonly staggerChildren: 0.06;
+                readonly delayChildren: 0.05;
+            };
+        };
+    };
+    readonly item: {
+        readonly hidden: {
+            readonly opacity: 0;
+            readonly y: 6;
+        };
+        readonly visible: {
+            readonly opacity: 1;
+            readonly y: 0;
+            readonly transition: {
+                readonly duration: 0.15;
+                readonly ease: readonly [0.4, 0, 0.2, 1];
+            };
+        };
+    };
+};
+declare const animation: {
+    readonly duration: {
+        readonly instant: 0.1;
+        readonly fast: 0.15;
+        readonly normal: 0.25;
+        readonly slow: 0.4;
+    };
+    readonly ease: {
+        readonly smooth: readonly [0.4, 0, 0.2, 1];
+        readonly enter: readonly [0, 0, 0.2, 1];
+        readonly exit: readonly [0.4, 0, 1, 1];
+        readonly linear: readonly [0, 0, 1, 1];
+    };
+    readonly spring: {
+        readonly gentle: {
+            readonly type: "spring";
+            readonly stiffness: 260;
+            readonly damping: 28;
+        };
+        readonly snappy: {
+            readonly type: "spring";
+            readonly stiffness: 400;
+            readonly damping: 30;
+        };
+    };
+    readonly transition: {
+        readonly button: {
+            readonly duration: 0.1;
+            readonly ease: readonly [0.4, 0, 0.2, 1];
+        };
+        readonly toggle: {
+            readonly type: "spring";
+            readonly stiffness: 400;
+            readonly damping: 30;
+        };
+        readonly input: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0.4, 0, 0.2, 1];
+        };
+        readonly dropdown: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0, 0, 0.2, 1];
+        };
+        readonly toast: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0.4, 0, 0.2, 1];
+        };
+        readonly modal: {
+            readonly type: "spring";
+            readonly stiffness: 260;
+            readonly damping: 28;
+        };
+        readonly sidebar: {
+            readonly duration: 0.4;
+            readonly ease: readonly [0.4, 0, 0.2, 1];
+        };
+        readonly card: {
+            readonly duration: 0.15;
+            readonly ease: readonly [0.4, 0, 0.2, 1];
+        };
+    };
+    readonly variants: {
+        readonly fadeIn: {
+            readonly hidden: {
+                readonly opacity: 0;
+            };
+            readonly visible: {
+                readonly opacity: 1;
+                readonly transition: {
+                    readonly duration: 0.15;
+                    readonly ease: readonly [0, 0, 0.2, 1];
+                };
+            };
+            readonly exit: {
+                readonly opacity: 0;
+                readonly transition: {
+                    readonly duration: 0.15;
+                    readonly ease: readonly [0.4, 0, 1, 1];
+                };
+            };
+        };
+        readonly slideUp: {
+            readonly hidden: {
+                readonly opacity: 0;
+                readonly y: 8;
+            };
+            readonly visible: {
+                readonly opacity: 1;
+                readonly y: 0;
+                readonly transition: {
+                    readonly duration: 0.15;
+                    readonly ease: readonly [0, 0, 0.2, 1];
+                };
+            };
+            readonly exit: {
+                readonly opacity: 0;
+                readonly y: 4;
+                readonly transition: {
+                    readonly duration: 0.15;
+                    readonly ease: readonly [0.4, 0, 1, 1];
+                };
+            };
+        };
+        readonly slideRight: {
+            readonly hidden: {
+                readonly opacity: 0;
+                readonly x: -12;
+            };
+            readonly visible: {
+                readonly opacity: 1;
+                readonly x: 0;
+                readonly transition: {
+                    readonly duration: 0.4;
+                    readonly ease: readonly [0.4, 0, 0.2, 1];
+                };
+            };
+            readonly exit: {
+                readonly opacity: 0;
+                readonly x: -12;
+                readonly transition: {
+                    readonly duration: 0.25;
+                    readonly ease: readonly [0.4, 0, 1, 1];
+                };
+            };
+        };
+        readonly scaleIn: {
+            readonly hidden: {
+                readonly opacity: 0;
+                readonly scale: 0.97;
+            };
+            readonly visible: {
+                readonly opacity: 1;
+                readonly scale: 1;
+                readonly transition: {
+                    readonly type: "spring";
+                    readonly stiffness: 260;
+                    readonly damping: 28;
+                };
+            };
+            readonly exit: {
+                readonly opacity: 0;
+                readonly scale: 0.97;
+                readonly transition: {
+                    readonly duration: 0.15;
+                    readonly ease: readonly [0.4, 0, 1, 1];
+                };
+            };
+        };
+        readonly stagger: {
+            readonly container: {
+                readonly hidden: {};
+                readonly visible: {
+                    readonly transition: {
+                        readonly staggerChildren: 0.06;
+                        readonly delayChildren: 0.05;
+                    };
+                };
+            };
+            readonly item: {
+                readonly hidden: {
+                    readonly opacity: 0;
+                    readonly y: 6;
+                };
+                readonly visible: {
+                    readonly opacity: 1;
+                    readonly y: 0;
+                    readonly transition: {
+                        readonly duration: 0.15;
+                        readonly ease: readonly [0.4, 0, 0.2, 1];
+                    };
+                };
+            };
+        };
+    };
+};
+type AnimationTokens = typeof animation;
+
+declare function useAppForm<T extends ZodType>(schema: T, options?: Omit<UseFormProps<z.infer<T> & FieldValues>, 'resolver'>): react_hook_form.UseFormReturn<z.core.output<T> & FieldValues, any, z.core.output<T> & FieldValues>;
+
+declare const logos: {
+    readonly color: "https://dibt9vplwriap.cloudfront.net/logos/Logo_Total_Color.webp";
+    readonly colorAna: "https://dibt9vplwriap.cloudfront.net/logos/Logo_Total_Color-ANA.webp";
+    readonly colorAnaa: "https://dibt9vplwriap.cloudfront.net/logos/Logo_Total_Color-ANAA.webp";
+    readonly negative: "https://dibt9vplwriap.cloudfront.net/logos/Logo_Total_Negative.webp";
+    readonly positive: "https://dibt9vplwriap.cloudfront.net/logos/Logo_Total_Positive.webp";
+    readonly grayScale: "https://dibt9vplwriap.cloudfront.net/logos/Logo_Total_gray_scale.webp";
+    readonly monochBlack: "https://dibt9vplwriap.cloudfront.net/logos/Logo_Total_monochB.webp";
+    readonly monochOrange: "https://dibt9vplwriap.cloudfront.net/logos/Logo_Total_monochO.webp";
+};
+type LogoKey = keyof typeof logos;
+
+declare function Table({ className, containerClassName, ...props }: ComponentProps<'table'> & {
+    /**
+     * Classes for the scroll container that wraps the table. Defaults to
+     * `overflow-x-auto` for horizontal scrolling. Pass `overflow-visible` when an
+     * outer element already owns scrolling (e.g. a sticky-header data table) —
+     * a nested scroll container would otherwise trap `position: sticky` cells.
+     */
+    containerClassName?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function TableHeader({ className, ...props }: ComponentProps<'thead'>): react_jsx_runtime.JSX.Element;
+declare function TableBody({ className, ...props }: ComponentProps<'tbody'>): react_jsx_runtime.JSX.Element;
+declare function TableFooter({ className, ...props }: ComponentProps<'tfoot'>): react_jsx_runtime.JSX.Element;
+declare function TableRow({ className, ...props }: ComponentProps<'tr'>): react_jsx_runtime.JSX.Element;
+declare function TableHead({ className, ...props }: ComponentProps<'th'>): react_jsx_runtime.JSX.Element;
+declare function TableCell({ className, ...props }: ComponentProps<'td'>): react_jsx_runtime.JSX.Element;
+declare function TableCaption({ className, ...props }: ComponentProps<'caption'>): react_jsx_runtime.JSX.Element;
+
+declare function Checkbox({ className, checked, ...props }: ComponentProps<typeof Checkbox$1.Root>): react_jsx_runtime.JSX.Element;
+
+type TableCellSize = 'sm' | 'md' | 'lg';
+type TableVariant = 'default' | 'striped';
+type SortDirection = 'asc' | 'desc' | false;
+type CellAlignment = 'left' | 'center' | 'right';
+interface ColumnMeta {
+    align?: CellAlignment;
+    size?: TableCellSize;
+    sortable?: boolean;
+    filterable?: boolean;
+    ellipsis?: boolean;
+    variant?: 'default' | 'numeric';
+    width?: string | number;
+    className?: string;
+    pinned?: 'left' | 'right' | false;
+    /** Override the field label shown in mobile card view. Uses column header string by default. */
+    cardLabel?: string;
+    /** Exclude this column from the mobile card view entirely. Default: false */
+    hideInCard?: boolean;
+    /** Disable resize handle for this column. Only relevant when DataTable has enableColumnResizing=true. Default: true */
+    resizable?: boolean;
+}
+type TableColumnDef<T> = ColumnDef<T, unknown> & {
+    meta?: ColumnMeta;
+};
+interface TableClassNames<T> {
+    wrapper?: string;
+    table?: string;
+    header?: string;
+    body?: string;
+    row?: string | ((row: Row<T>) => string);
+    cell?: string | ((row: Row<T>) => string);
+}
+interface DataTableProps<T = unknown> {
+    data: T[];
+    columns: TableColumnDef<T>[];
+    size?: TableCellSize;
+    variant?: TableVariant;
+    isLoading?: boolean;
+    stickyHeader?: boolean;
+    maxHeight?: string | number;
+    sorting?: SortingState;
+    defaultSorting?: SortingState;
+    onSortingChange?: (state: SortingState) => void;
+    enableSorting?: boolean;
+    manualSorting?: boolean;
+    columnFilters?: ColumnFiltersState;
+    defaultColumnFilters?: ColumnFiltersState;
+    onColumnFiltersChange?: (state: ColumnFiltersState) => void;
+    enableFiltering?: boolean;
+    manualFiltering?: boolean;
+    onRowClick?: (row: T) => void;
+    classNames?: TableClassNames<T>;
+    getUniqueValues?: (columnId: string) => string[];
+    /** Custom content rendered when data is empty and not loading. Default: "No results found". */
+    emptyState?: ReactNode;
+    rowSelection?: RowSelectionState;
+    defaultRowSelection?: RowSelectionState;
+    onRowSelectionChange?: (state: RowSelectionState) => void;
+    enableRowSelection?: boolean;
+    /** Called with the original row objects whenever selection changes */
+    onSelectedRowsChange?: (rows: T[]) => void;
+    /** Media query below which card layout renders. Default: "(max-width: 767px)" */
+    responsiveBreakpoint?: string;
+    /** Set true to disable auto-responsive behaviour. Default: false */
+    disableResponsive?: boolean;
+    /** Number of skeleton rows shown in card view while loading. Default: 5 */
+    skeletonRowCount?: number;
+    /** Called once on mount with the TanStack Table instance — pass to DataTableToolbar */
+    onTableReady?: (table: Table$1<T>) => void;
+    /**
+     * Rendered inside the DataTable context provider, above the table wrapper.
+     * Use this to place DataTableToolbar and DataTableSearch so they have full
+     * access to context (globalFilter, size, columnVisibility, etc.).
+     */
+    toolbar?: ReactNode;
+    tableId?: string;
+    globalFilter?: string;
+    defaultGlobalFilter?: string;
+    onGlobalFilterChange?: (value: string) => void;
+    columnVisibility?: VisibilityState;
+    defaultColumnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: (state: VisibilityState) => void;
+    columnSizing?: ColumnSizingState;
+    defaultColumnSizing?: ColumnSizingState;
+    onColumnSizingChange?: (state: ColumnSizingState) => void;
+    /** Enable column resize handles. Default: false */
+    enableColumnResizing?: boolean;
+    /** Called when the user changes density from the toolbar */
+    onSizeChange?: (size: TableCellSize) => void;
+}
+interface TableContextType<T = unknown> {
+    size: TableCellSize;
+    variant: TableVariant;
+    sorting: SortingState;
+    setSorting: (state: SortingState) => void;
+    columnFilters: ColumnFiltersState;
+    setColumnFilters: (state: ColumnFiltersState) => void;
+    getUniqueValues?: (columnId: string) => string[];
+    onRowClick?: (row: T) => void;
+    rowSelection: RowSelectionState;
+    setRowSelection: (state: RowSelectionState) => void;
+    globalFilter: string;
+    setGlobalFilter: (value: string) => void;
+    columnVisibility: VisibilityState;
+    setColumnVisibility: (state: VisibilityState) => void;
+    columnSizing: ColumnSizingState;
+    setColumnSizing: (state: ColumnSizingState) => void;
+    setSize: (size: TableCellSize) => void;
+    /** The underlying TanStack Table instance — available inside the DataTable context. */
+    table: Table$1<T>;
+}
+interface TablePaginationProps {
+    page: number;
+    totalPages: number;
+    perPage: number;
+    totalRecords?: number;
+    rowsPerPageOptions?: number[];
+    onPageChange: (newPage: number) => void;
+    onPerPageChange: (newPerPage: number) => void;
+}
+
+declare function Pagination({ className, ...props }: ComponentProps<'nav'>): react_jsx_runtime.JSX.Element;
+declare function PaginationContent({ className, ...props }: ComponentProps<'ul'>): react_jsx_runtime.JSX.Element;
+declare function PaginationItem({ ...props }: ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ComponentProps<typeof Button$1>, 'size'> & ComponentProps<'a'>;
+declare function PaginationLink({ className, isActive, size, ...props }: PaginationLinkProps): react_jsx_runtime.JSX.Element;
+declare function PaginationPrevious({ className, text, ...props }: ComponentProps<typeof PaginationLink> & {
+    text?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function PaginationNext({ className, text, ...props }: ComponentProps<typeof PaginationLink> & {
+    text?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+declare function TablePaginationBase({ page, totalPages, perPage, totalRecords, rowsPerPageOptions, onPageChange, onPerPageChange, }: TablePaginationProps): react_jsx_runtime.JSX.Element;
+declare const TablePagination: react.MemoExoticComponent<typeof TablePaginationBase>;
+
+declare function useTableContext<T = unknown>(): TableContextType<T>;
+
+declare function DataTable<T>({ data, columns, size, variant, isLoading, stickyHeader, maxHeight, sorting, defaultSorting, onSortingChange, enableSorting, manualSorting, columnFilters, defaultColumnFilters, onColumnFiltersChange, enableFiltering, manualFiltering, onRowClick, classNames, getUniqueValues, emptyState, rowSelection, defaultRowSelection, onRowSelectionChange, enableRowSelection, onSelectedRowsChange, responsiveBreakpoint, disableResponsive, skeletonRowCount, onTableReady, tableId, globalFilter, defaultGlobalFilter, onGlobalFilterChange, columnVisibility, defaultColumnVisibility, onColumnVisibilityChange, columnSizing, defaultColumnSizing, onColumnSizingChange, enableColumnResizing, onSizeChange, toolbar, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+
+interface FilterOptionProps {
+    value: string;
+    checked: boolean;
+    onChange: (value: string, checked: boolean) => void;
+}
+declare const FilterOption: react.NamedExoticComponent<FilterOptionProps>;
+interface DataTableColumnFilterProps {
+    options: string[];
+    selectedValues: string[];
+    onChange: (values: string[]) => void;
+    searchPlaceholder?: string;
+    /** Human-readable column name used to build accessible labels. */
+    columnLabel?: string;
+}
+declare function DataTableColumnFilter({ options, selectedValues, onChange, searchPlaceholder, columnLabel, }: DataTableColumnFilterProps): react_jsx_runtime.JSX.Element;
+
+interface DataTableSkeletonProps {
+    columnCount: number;
+    rowCount?: number;
+    size?: TableCellSize;
+}
+declare function DataTableSkeleton({ columnCount, rowCount, size }: DataTableSkeletonProps): react_jsx_runtime.JSX.Element;
+
+interface DataTableHeaderCellProps<T> {
+    header: Header<T, unknown>;
+}
+declare function DataTableHeaderCell<T>({ header }: DataTableHeaderCellProps<T>): react_jsx_runtime.JSX.Element;
+
+interface UseTableSortingProps {
+    /**
+     * Controlled sorting state (optional)
+     * If provided, the component operates in controlled mode
+     */
+    sorting?: SortingState;
+    /**
+     * Default sorting state for uncontrolled mode
+     * @default []
+     */
+    defaultSorting?: SortingState;
+    /**
+     * Callback fired when sorting changes
+     * Required for controlled mode, optional for uncontrolled
+     */
+    onSortingChange?: (sorting: SortingState) => void;
+}
+interface UseTableSortingReturn {
+    /**
+     * Current sorting state (controlled or internal)
+     */
+    sortingState: SortingState;
+    /**
+     * Handler for TanStack Table's onSortingChange
+     */
+    handleSortingChange: (updater: Updater<SortingState>) => void;
+    /**
+     * Whether the component is in controlled mode
+     */
+    isControlled: boolean;
+    /**
+     * Manual setter for uncontrolled mode (useful for imperative actions)
+     */
+    setSorting: (sorting: SortingState) => void;
+}
+/**
+ * Hook to manage table sorting state (controlled or uncontrolled)
+ *
+ * @example Uncontrolled mode
+ * ```tsx
+ * const { sortingState, handleSortingChange } = useTableSorting({
+ *   defaultSorting: [{ id: 'name', desc: false }],
+ *   onSortingChange: (state) => console.log(state)
+ * });
+ * ```
+ *
+ * @example Controlled mode
+ * ```tsx
+ * const [sorting, setSorting] = useState<SortingState>([]);
+ * const { sortingState, handleSortingChange } = useTableSorting({
+ *   sorting,
+ *   onSortingChange: setSorting
+ * });
+ * ```
+ */
+declare function useTableSorting({ sorting: controlledSorting, defaultSorting, onSortingChange, }: UseTableSortingProps): UseTableSortingReturn;
+
+interface UseTableFilteringProps {
+    /**
+     * Controlled column filters state (optional)
+     * If provided, the component operates in controlled mode
+     */
+    columnFilters?: ColumnFiltersState;
+    /**
+     * Default column filters state for uncontrolled mode
+     * @default []
+     */
+    defaultColumnFilters?: ColumnFiltersState;
+    /**
+     * Callback fired when column filters change
+     * Required for controlled mode, optional for uncontrolled
+     */
+    onColumnFiltersChange?: (columnFilters: ColumnFiltersState) => void;
+}
+interface UseTableFilteringReturn {
+    /**
+     * Current column filters state (controlled or internal)
+     */
+    columnFiltersState: ColumnFiltersState;
+    /**
+     * Handler for TanStack Table's onColumnFiltersChange
+     */
+    handleColumnFiltersChange: (updater: Updater<ColumnFiltersState>) => void;
+    /**
+     * Whether the component is in controlled mode
+     */
+    isControlled: boolean;
+    /**
+     * Manual setter for uncontrolled mode (useful for imperative actions)
+     */
+    setColumnFilters: (columnFilters: ColumnFiltersState) => void;
+}
+/**
+ * Hook to manage table column filtering state (controlled or uncontrolled)
+ *
+ * @example Uncontrolled mode
+ * ```tsx
+ * const { columnFiltersState, handleColumnFiltersChange } = useTableFiltering({
+ *   defaultColumnFilters: [{ id: 'status', value: ['Active'] }],
+ *   onColumnFiltersChange: (state) => console.log(state)
+ * });
+ * ```
+ *
+ * @example Controlled mode
+ * ```tsx
+ * const [filters, setFilters] = useState<ColumnFiltersState>([]);
+ * const { columnFiltersState, handleColumnFiltersChange } = useTableFiltering({
+ *   columnFilters: filters,
+ *   onColumnFiltersChange: setFilters
+ * });
+ * ```
+ */
+declare function useTableFiltering({ columnFilters: controlledFilters, defaultColumnFilters, onColumnFiltersChange, }: UseTableFilteringProps): UseTableFilteringReturn;
+
+declare function useColumnFilter(columnId: string): {
+    selectedValues: string[];
+    handleChange: (values: string[]) => void;
+};
+
+interface UseTableDataProps<T> {
+    data: T[];
+    columns: ColumnDef<T, unknown>[];
+    initialPage?: number;
+    initialPerPage?: number;
+    initialSorting?: SortingState;
+    initialColumnFilters?: ColumnFiltersState;
+}
+interface UseTableDataReturn<T> {
+    paginatedData: T[];
+    processedData: T[];
+    page: number;
+    perPage: number;
+    totalPages: number;
+    totalRecords: number;
+    filteredRecords: number;
+    setPage: (page: number) => void;
+    setPerPage: (perPage: number) => void;
+    sorting: SortingState;
+    setSorting: (sorting: SortingState) => void;
+    columnFilters: ColumnFiltersState;
+    setColumnFilters: (filters: ColumnFiltersState) => void;
+    getUniqueValues: (columnId: string) => string[];
+}
+declare function useTableData<T extends Record<string, unknown>>({ data, columns, initialPage, initialPerPage, initialSorting, initialColumnFilters, }: UseTableDataProps<T>): UseTableDataReturn<T>;
+
+/**
+ * Extracts unique values from a column in the dataset
+ * @param data - The array of data objects
+ * @param columnId - The column identifier
+ * @param accessor - Optional accessor function to get the value from a row
+ * @returns Array of unique string values, sorted alphabetically
+ */
+declare function getUniqueColumnValues<T>(data: T[], columnId: string, accessor?: (row: T, index: number) => unknown): string[];
+/**
+ * Custom filter function for TanStack Table multi-select filtering
+ * Checks if the row's value is included in the array of selected filter values
+ * @param row - The row being filtered
+ * @param columnId - The column identifier
+ * @param filterValue - Array of selected filter values
+ * @returns true if the row should be included in filtered results
+ */
+declare function multiSelectFilter<T>(row: Row<T>, columnId: string, filterValue: unknown): boolean;
+/**
+ * Searches for a term within an array of items (case-insensitive)
+ * @param items - Array of items to search through
+ * @param searchTerm - The search term
+ * @returns Filtered array of items matching the search term
+ */
+declare function searchInArray(items: string[], searchTerm: string): string[];
+/**
+ * Gets the count of rows for each unique value in a column
+ * Useful for showing counts next to filter options (e.g., "Active (5)")
+ * @param data - The array of data objects
+ * @param columnId - The column identifier
+ * @param accessor - Optional accessor function to get the value from a row
+ * @returns Object mapping values to their counts
+ */
+declare function getColumnValueCounts<T>(data: T[], columnId: string, accessor?: (row: T, index: number) => unknown): Record<string, number>;
+/**
+ * Checks if a column has active filters
+ * @param columnFilters - Current column filters state
+ * @param columnId - The column identifier
+ * @returns true if the column has active filters
+ */
+declare function hasActiveFilters(columnFilters: ColumnFiltersState, columnId: string): boolean;
+/**
+ * Gets the active filter values for a specific column
+ * @param columnFilters - Current column filters state
+ * @param columnId - The column identifier
+ * @returns Array of active filter values for the column
+ */
+declare function getActiveFilterValues(columnFilters: ColumnFiltersState, columnId: string): string[];
+/**
+ * Gets the count of active filters across all columns
+ * @param columnFilters - Current column filters state
+ * @returns Total number of active filter values
+ */
+declare function getActiveFilterCount(columnFilters: ColumnFiltersState): number;
+
+/**
+ * Backend sorting format - object representation
+ * Example: { name: 'asc', created_at: 'desc' }
+ */
+type SortRecord = Record<string, 'asc' | 'desc'>;
+/**
+ * Converts TanStack Table SortingState to backend-friendly record format
+ *
+ * @param sortingState - TanStack sorting state array
+ * @returns Object with field names as keys and 'asc'/'desc' as values
+ *
+ * @example
+ * ```ts
+ * const sortingState = [
+ *   { id: 'name', desc: false },
+ *   { id: 'created_at', desc: true }
+ * ];
+ *
+ * const sortRecord = sortingStateToRecord(sortingState);
+ * // Result: { name: 'asc', created_at: 'desc' }
+ * ```
+ */
+declare function sortingStateToRecord(sortingState: SortingState): SortRecord;
+/**
+ * Converts backend sort record to TanStack Table SortingState
+ * Useful for initializing sorting state from backend response
+ *
+ * @param sortRecord - Object with field names and sort directions
+ * @returns TanStack sorting state array
+ *
+ * @example
+ * ```ts
+ * const sortRecord = { name: 'asc', created_at: 'desc' };
+ *
+ * const sortingState = sortRecordToSortingState(sortRecord);
+ * // Result: [
+ * //   { id: 'name', desc: false },
+ * //   { id: 'created_at', desc: true }
+ * // ]
+ * ```
+ */
+declare function sortRecordToSortingState(sortRecord: SortRecord): SortingState;
+/**
+ * Converts SortingState to JSON string ready to send to Laravel backend
+ * This is a convenience function for API calls
+ *
+ * @param sortingState - TanStack sorting state array
+ * @returns JSON string representation of sort record
+ *
+ * @example
+ * ```ts
+ * const sortingState = [{ id: 'name', desc: false }];
+ * const sortsParam = sortingStateToJsonString(sortingState);
+ * // Result: '{"name":"asc"}'
+ *
+ * // Use in API call:
+ * fetch(`/api/users?sorts=${sortsParam}`);
+ * ```
+ */
+declare function sortingStateToJsonString(sortingState: SortingState): string;
+/**
+ * Creates URLSearchParams for backend pagination with sorting
+ * Compatible with Laravel PaginateHelper
+ *
+ * @param options - Pagination and sorting options
+ * @returns URLSearchParams ready to append to API request
+ *
+ * @example
+ * ```ts
+ * const params = createBackendParams({
+ *   sorting: [{ id: 'name', desc: false }],
+ *   perPage: 20,
+ *   genericSearch: 'john',
+ *   filters: { role: 'admin', status: 'active' }
+ * });
+ *
+ * fetch(`/api/users?${params.toString()}`);
+ * // Result: /api/users?sorts={"name":"asc"}&perPage=20&genericSearch=john&filters={"role":"admin","status":"active"}
+ * ```
+ */
+declare function createBackendParams(options: {
+    sorting?: SortingState;
+    perPage?: number;
+    genericSearch?: string;
+    filters?: Record<string, unknown>;
+}): URLSearchParams;
+
+/**
+ * Converts ColumnFiltersState to a simple object format
+ * Example: [{ id: 'status', value: ['Active', 'Pending'] }]
+ * => { status: ['Active', 'Pending'] }
+ *
+ * @param filters - The column filters state from TanStack Table
+ * @returns Object with columnId as keys and filter values as values
+ */
+declare function columnFiltersToRecord(filters: ColumnFiltersState): Record<string, string[]>;
+/**
+ * Converts ColumnFiltersState to a JSON string
+ * Useful for API calls that expect JSON format
+ *
+ * @param filters - The column filters state from TanStack Table
+ * @returns JSON string representation of filters
+ */
+declare function columnFiltersToJsonString(filters: ColumnFiltersState): string;
+/**
+ * Converts ColumnFiltersState to URL query params format
+ * Example: [{ id: 'status', value: ['Active', 'Pending'] }]
+ * => 'filter[status]=Active,Pending'
+ *
+ * @param filters - The column filters state from TanStack Table
+ * @param separator - Separator for multiple values (default: ',')
+ * @returns Object suitable for URLSearchParams
+ */
+declare function columnFiltersToQueryParams(filters: ColumnFiltersState, separator?: string): Record<string, string>;
+/**
+ * Converts ColumnFiltersState to individual query params per value
+ * Example: [{ id: 'status', value: ['Active', 'Pending'] }]
+ * => 'filter[status][]=Active&filter[status][]=Pending'
+ *
+ * @param filters - The column filters state from TanStack Table
+ * @returns Object suitable for URLSearchParams with array notation
+ */
+declare function columnFiltersToArrayQueryParams(filters: ColumnFiltersState): Record<string, string[]>;
+/**
+ * Creates complete backend request params with filters, sorting, and pagination
+ * Combines filtering with other table features
+ *
+ * @param options - Configuration object
+ * @param options.filters - Column filters state
+ * @param options.sorts - Optional sorting state
+ * @param options.page - Optional page number
+ * @param options.perPage - Optional items per page
+ * @returns Complete params object for API requests
+ */
+declare function createBackendParamsWithFilters({ filters, sorts, page, perPage, }: {
+    filters: ColumnFiltersState;
+    sorts?: Array<{
+        id: string;
+        desc: boolean;
+    }>;
+    page?: number;
+    perPage?: number;
+}): Record<string, string | number>;
+/**
+ * Parses URL query params back to ColumnFiltersState
+ * Useful for restoring filters from URL
+ *
+ * @param params - URLSearchParams or query string
+ * @param separator - Separator used in the query params (default: ',')
+ * @returns ColumnFiltersState
+ */
+declare function parseQueryParamsToFilters(params: URLSearchParams | string, separator?: string): ColumnFiltersState;
+/**
+ * Parses JSON string back to ColumnFiltersState
+ *
+ * @param jsonString - JSON string representation of filters
+ * @returns ColumnFiltersState
+ */
+declare function parseJsonToFilters(jsonString: string): ColumnFiltersState;
+/**
+ * Merges multiple filter states, with later filters overriding earlier ones
+ *
+ * @param filterStates - Multiple ColumnFiltersState arrays to merge
+ * @returns Merged ColumnFiltersState
+ */
+declare function mergeFilters(...filterStates: ColumnFiltersState[]): ColumnFiltersState;
+
+interface RowAction<T> {
+    label: string;
+    onClick: (row: T) => void;
+    /** Renders a separator above this item */
+    separator?: boolean;
+    disabled?: boolean | ((row: T) => boolean);
+    /** Renders item in destructive (red) style */
+    destructive?: boolean;
+}
+interface DataTableRowActionsProps<T> {
+    row: T;
+    actions: RowAction<T>[];
+    /** Screen-reader label for the trigger button. Default: "Open actions" */
+    label?: string;
+}
+declare function DataTableRowActions<T>({ row, actions, label, }: DataTableRowActionsProps<T>): react_jsx_runtime.JSX.Element;
+
+interface DataTableFooterProps {
+    pagination: TablePaginationProps;
+    /** Selected row count — renders "N row(s) selected" on the left */
+    selectedCount?: number;
+    className?: string;
+}
+declare function DataTableFooter({ pagination, selectedCount, className }: DataTableFooterProps): react_jsx_runtime.JSX.Element;
+
+interface DataTableCardViewProps<T> {
+    rows: Row<T>[];
+    columns: Column<T, unknown>[];
+    size?: TableCellSize;
+    variant?: TableVariant;
+    onRowClick?: (row: T) => void;
+    isLoading?: boolean;
+    skeletonRowCount?: number;
+    emptyState?: ReactNode;
+}
+declare function DataTableCardView<T>({ rows, columns, size, variant, onRowClick, isLoading, skeletonRowCount, emptyState, }: DataTableCardViewProps<T>): react_jsx_runtime.JSX.Element;
+
+interface DataTableToolbarProps<T> {
+    /** TanStack Table instance. Optional when toolbar is rendered inside DataTable's toolbar prop (context available). */
+    table?: Table$1<T>;
+    /** Slot rendered on the left — e.g. search input, bulk-action buttons */
+    leading?: ReactNode;
+    /** Slot rendered on the right alongside the Columns button */
+    trailing?: ReactNode;
+    className?: string;
+    /** Hide the built-in Columns visibility toggle. Default: false */
+    hideColumnsToggle?: boolean;
+    /** Hide the density toggle. Default: false */
+    hideDensityToggle?: boolean;
+    /**
+     * Pass columnFilters directly if Toolbar is rendered outside DataTable's
+     * context provider. When inside a DataTable, this is read from context.
+     */
+    columnFilters?: ColumnFiltersState;
+}
+declare function DataTableToolbar<T>({ table: tableProp, leading, trailing, className, hideColumnsToggle, hideDensityToggle, columnFilters: columnFiltersProp, }: DataTableToolbarProps<T>): react_jsx_runtime.JSX.Element;
+
+interface DataTableSearchProps {
+    placeholder?: string;
+    className?: string;
+    /** Debounce delay in ms before committing to context. Default: 300 */
+    debounce?: number;
+}
+declare function DataTableSearch({ placeholder, className, debounce, }: DataTableSearchProps): react_jsx_runtime.JSX.Element;
+
+interface UseTableGlobalFilterProps {
+    /**
+     * Controlled global filter state (optional)
+     * If provided, the component operates in controlled mode
+     */
+    globalFilter?: string;
+    /**
+     * Default global filter state for uncontrolled mode
+     * @default ''
+     */
+    defaultGlobalFilter?: string;
+    /**
+     * Callback fired when global filter changes
+     * Required for controlled mode, optional for uncontrolled
+     */
+    onGlobalFilterChange?: (value: string) => void;
+}
+interface UseTableGlobalFilterReturn {
+    /**
+     * Current global filter state (controlled or internal)
+     */
+    globalFilterState: string;
+    /**
+     * Handler for global filter changes
+     */
+    handleGlobalFilterChange: (value: string) => void;
+    /**
+     * Whether the component is in controlled mode
+     */
+    isControlled: boolean;
+    /**
+     * Manual setter for uncontrolled mode (useful for imperative actions)
+     */
+    setGlobalFilter: (value: string) => void;
+}
+/**
+ * Hook to manage table global filter state (controlled or uncontrolled)
+ *
+ * @example Uncontrolled mode
+ * ```tsx
+ * const { globalFilterState, handleGlobalFilterChange } = useTableGlobalFilter({
+ *   defaultGlobalFilter: '',
+ *   onGlobalFilterChange: (state) => console.log(state)
+ * });
+ * ```
+ *
+ * @example Controlled mode
+ * ```tsx
+ * const [globalFilter, setGlobalFilter] = useState<string>('');
+ * const { globalFilterState, handleGlobalFilterChange } = useTableGlobalFilter({
+ *   globalFilter,
+ *   onGlobalFilterChange: setGlobalFilter
+ * });
+ * ```
+ */
+declare function useTableGlobalFilter({ globalFilter: controlledFilter, defaultGlobalFilter, onGlobalFilterChange, }: UseTableGlobalFilterProps): UseTableGlobalFilterReturn;
+
+interface UseTableVisibilityProps {
+    /**
+     * Controlled column visibility state (optional)
+     * If provided, the component operates in controlled mode
+     */
+    columnVisibility?: VisibilityState;
+    /**
+     * Default column visibility state for uncontrolled mode
+     * @default {}
+     */
+    defaultColumnVisibility?: VisibilityState;
+    /**
+     * Callback fired when column visibility changes
+     * Required for controlled mode, optional for uncontrolled
+     */
+    onColumnVisibilityChange?: (state: VisibilityState) => void;
+}
+interface UseTableVisibilityReturn {
+    /**
+     * Current column visibility state (controlled or internal)
+     */
+    columnVisibilityState: VisibilityState;
+    /**
+     * Handler for TanStack Table's onColumnVisibilityChange
+     */
+    handleColumnVisibilityChange: (updater: Updater<VisibilityState>) => void;
+    /**
+     * Whether the component is in controlled mode
+     */
+    isControlled: boolean;
+    /**
+     * Manual setter for uncontrolled mode (useful for imperative actions)
+     */
+    setColumnVisibility: (state: VisibilityState) => void;
+}
+/**
+ * Hook to manage table column visibility state (controlled or uncontrolled)
+ *
+ * @example Uncontrolled mode
+ * ```tsx
+ * const { columnVisibilityState, handleColumnVisibilityChange } = useTableVisibility({
+ *   defaultColumnVisibility: { email: false },
+ *   onColumnVisibilityChange: (state) => console.log(state)
+ * });
+ * ```
+ *
+ * @example Controlled mode
+ * ```tsx
+ * const [visibility, setVisibility] = useState<VisibilityState>({});
+ * const { columnVisibilityState, handleColumnVisibilityChange } = useTableVisibility({
+ *   columnVisibility: visibility,
+ *   onColumnVisibilityChange: setVisibility
+ * });
+ * ```
+ */
+declare function useTableVisibility({ columnVisibility: controlledVisibility, defaultColumnVisibility, onColumnVisibilityChange, }: UseTableVisibilityProps): UseTableVisibilityReturn;
+
+interface UseTableSizingProps {
+    /**
+     * Controlled column sizing state (optional)
+     * If provided, the component operates in controlled mode
+     */
+    columnSizing?: ColumnSizingState;
+    /**
+     * Default column sizing state for uncontrolled mode
+     * @default {}
+     */
+    defaultColumnSizing?: ColumnSizingState;
+    /**
+     * Callback fired when column sizing changes
+     * Required for controlled mode, optional for uncontrolled
+     */
+    onColumnSizingChange?: (state: ColumnSizingState) => void;
+}
+interface UseTableSizingReturn {
+    /**
+     * Current column sizing state (controlled or internal)
+     */
+    columnSizingState: ColumnSizingState;
+    /**
+     * Handler for TanStack Table's onColumnSizingChange
+     */
+    handleColumnSizingChange: (updater: Updater<ColumnSizingState>) => void;
+    /**
+     * Whether the component is in controlled mode
+     */
+    isControlled: boolean;
+    /**
+     * Manual setter for uncontrolled mode (useful for imperative actions)
+     */
+    setColumnSizing: (state: ColumnSizingState) => void;
+}
+/**
+ * Hook to manage table column sizing state (controlled or uncontrolled)
+ *
+ * @example Uncontrolled mode
+ * ```tsx
+ * const { columnSizingState, handleColumnSizingChange } = useTableSizing({
+ *   defaultColumnSizing: { name: 150, email: 200 },
+ *   onColumnSizingChange: (state) => console.log(state)
+ * });
+ * ```
+ *
+ * @example Controlled mode
+ * ```tsx
+ * const [sizing, setSizing] = useState<ColumnSizingState>({});
+ * const { columnSizingState, handleColumnSizingChange } = useTableSizing({
+ *   columnSizing: sizing,
+ *   onColumnSizingChange: setSizing
+ * });
+ * ```
+ */
+declare function useTableSizing({ columnSizing: controlledSizing, defaultColumnSizing, onColumnSizingChange, }: UseTableSizingProps): UseTableSizingReturn;
+
+interface CanProps {
+    permission: string | string[];
+    mode?: 'any' | 'all';
+    negate?: boolean;
+    fallback?: ReactNode;
+    children: ReactNode | ((allowed: boolean) => ReactNode);
+}
+type CanNotProps = Omit<CanProps, 'negate'>;
+/** Renders children when the user has the required permission(s). Requires `AbilityProvider` in the tree. */
+declare function Can({ permission, mode, negate, fallback, children }: CanProps): react_jsx_runtime.JSX.Element;
+declare namespace Can {
+    var displayName: string;
+}
+/** Renders children when the user does NOT have the required permission(s). Alias for `<Can negate />`. Requires `AbilityProvider` in the tree. */
+declare function CanNot({ permission, mode, fallback, children }: CanNotProps): react_jsx_runtime.JSX.Element;
+declare namespace CanNot {
+    var displayName: string;
+}
+
+interface AbilityContextValue {
+    can: (permissions: string | string[], mode?: 'any' | 'all') => boolean;
+    setAbilities: (permissions: string[]) => void;
+    clearAbilities: () => void;
+}
+interface AbilityProviderProps {
+    children: ReactNode;
+    permissions?: string[];
+}
+/**
+ * @param pattern - an entry from the user's grant set (may contain `*` as a segment wildcard)
+ * @param permission - the permission being requested (from `Can.perform`)
+ */
+declare function matchPermission(pattern: string, permission: string): boolean;
+declare function AbilityProvider({ children, permissions }: AbilityProviderProps): react_jsx_runtime.JSX.Element;
+declare function useAbility(): AbilityContextValue;
+declare function useCan(permissions: string | string[], mode?: 'any' | 'all'): boolean;
+
+export { type AbilityContextValue, AbilityProvider, type AbilityProviderProps, Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogMedia, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, type AnimationTokens, Avatar, AvatarBadge, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarImage, Badge, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button$1 as Button, Calendar, CalendarDayButton, type CalendarEvent, type CalendarView, Can, CanNot, type CanNotProps, type CanProps, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, type CellAlignment, Checkbox, ColorPicker, ColorPickerAlpha, type ColorPickerAlphaProps, ColorPickerEyeDropper, type ColorPickerEyeDropperProps, ColorPickerFormat, type ColorPickerFormatProps, ColorPickerHue, type ColorPickerHueProps, ColorPickerOutput, type ColorPickerOutputProps, ColorPickerPresets, type ColorPickerPresetsProps, type ColorPickerProps, ColorPickerSelection, type ColorPickerSelectionProps, type ColumnMeta, Combobox, type ComboboxOption, type ComboboxProps, DataTable, DataTableCardView, type DataTableCardViewProps, DataTableColumnFilter, type DataTableColumnFilterProps, DataTableFooter, type DataTableFooterProps, DataTableHeaderCell, type DataTableHeaderCellProps, type DataTableProps, DataTableRowActions, type DataTableRowActionsProps, DataTableSearch, type DataTableSearchProps, DataTableSkeleton, type DataTableSkeletonProps, DataTableToolbar, type DataTableToolbarProps, DatePicker, type DatePickerProps, type DatePickerRangeProps, type DatePickerSingleProps, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, Dropzone, DropzoneContent, type DropzoneContentProps, DropzoneEmptyState, type DropzoneEmptyStateProps, type DropzoneProps, Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle, EventCalendar, type EventCalendarProps, type EventCreateRange, Field, FieldDescription, FieldError, FieldGroup, FieldLabel, FilterOption, type FilterOptionProps, Input, Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle, Link, Logo, type LogoKey, MiniCalendar, MiniCalendarDay, type MiniCalendarDayProps, MiniCalendarDays, type MiniCalendarDaysProps, MiniCalendarNavigation, type MiniCalendarNavigationProps, type MiniCalendarProps, Navbar, type NavbarDropdownItem, type NavbarNavLink, type NavbarProps, type NavbarUtilityLink, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, PinInput, type PinInputProps, Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, Progress, type ProgressProps, RadioGroup, RadioGroupItem, type RowAction, SegmentedControl, SegmentedControlItem, type SegmentedControlProps, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger$1 as SelectTrigger, SelectValue, Separator, SideBar, type SideBarItem, type SideBarProps, SidebarProvider, SidebarTrigger, Skeleton, Slider, type SortDirection, type SortRecord, Spinner, SpinnerDots, type SpinnerDotsProps, SpinnerLoader, type SpinnerLoaderProps, type SpinnerProps, Status, StatusIndicator, type StatusIndicatorProps, StatusLabel, type StatusLabelProps, type StatusProps, Switch, TEXT_SIZES, TEXT_WEIGHTS, Table, TableBody, TableCaption, TableCell, type TableCellSize, type TableClassNames, type TableColumnDef, type TableContextType, TableFooter, TableHead, TableHeader, TablePagination, type TablePaginationProps, TableRow, type TableVariant, Tabs, TabsContent, TabsList, TabsTrigger, Text, type TextAs, type TextProps, type TextSize, type TextWeight, Textarea, type ToastAction, type ToastItem, type ToastType, Toaster, type ToasterPosition, type ToasterProps, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type UseTableDataProps, type UseTableDataReturn, type UseTableFilteringProps, type UseTableFilteringReturn, type UseTableGlobalFilterProps, type UseTableGlobalFilterReturn, type UseTableSizingProps, type UseTableSizingReturn, type UseTableSortingProps, type UseTableSortingReturn, type UseTableVisibilityProps, type UseTableVisibilityReturn, alertVariants, animation, avatarVariants, badgeVariants, buttonVariants$1 as buttonVariants, columnFiltersToArrayQueryParams, columnFiltersToJsonString, columnFiltersToQueryParams, columnFiltersToRecord, createBackendParams, createBackendParamsWithFilters, duration, ease, fadeIn, getActiveFilterCount, getActiveFilterValues, getColumnValueCounts, getUniqueColumnValues, hasActiveFilters, linkVariants, logos, matchPermission, mergeFilters, multiSelectFilter, navigationMenuTriggerStyle, parseJsonToFilters, parseQueryParamsToFilters, progressIndicatorVariants, progressVariants, scaleIn, searchInArray, skeletonVariants, slideRight, slideUp, sortRecordToSortingState, sortingStateToJsonString, sortingStateToRecord, spinnerDotsVariants, spinnerLoaderVariants, spinnerVariants, spring, stagger, toggleVariants, tooltipContentVariants, transition, useAbility, useAppForm, useCan, useCarousel, useColorPicker, useColumnFilter, useTableContext, useTableData, useTableFiltering, useTableGlobalFilter, useTableSizing, useTableSorting, useTableVisibility, useToast };