@capy-vn/ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1391 @@
+import * as React$1 from 'react';
+import { ComponentProps, ReactNode } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import { DayPicker, DateRange } from 'react-day-picker';
+export { DateRange } from 'react-day-picker';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import { Locale } from 'date-fns';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as react_hook_form from 'react-hook-form';
+import { FieldValues, FieldPath, ControllerProps, Control, ControllerRenderProps } from 'react-hook-form';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { Toaster as Toaster$1 } from 'sonner';
+export { toast } from 'sonner';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { LucideIcon } from 'lucide-react';
+import { ColumnDef, Row, SortingState } from '@tanstack/react-table';
+import { ClassValue } from 'clsx';
+
+interface AccordionProps {
+    type?: 'single' | 'multiple';
+    collapsible?: boolean;
+    defaultValue?: string | string[];
+    value?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function Accordion({ type, collapsible, defaultValue, value: controlledValue, onValueChange, children, className, }: AccordionProps): React$1.JSX.Element;
+declare namespace Accordion {
+    var displayName: string;
+}
+interface AccordionItemProps {
+    value: string;
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function AccordionItem({ value, children, className }: AccordionItemProps): React$1.JSX.Element;
+declare namespace AccordionItem {
+    var displayName: string;
+}
+interface AccordionTriggerProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function AccordionTrigger({ children, className }: AccordionTriggerProps): React$1.JSX.Element;
+declare namespace AccordionTrigger {
+    var displayName: string;
+}
+interface AccordionContentProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function AccordionContent({ children, className }: AccordionContentProps): React$1.JSX.Element;
+declare namespace AccordionContent {
+    var displayName: string;
+}
+
+declare const Alert: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | "success" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const AlertDialog: React$1.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React$1.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React$1.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Avatar: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "success" | "warning" | "outline" | "secondary" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): React$1.JSX.Element;
+
+declare const Breadcrumb: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React$1.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React$1.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React$1.ComponentProps<"li">): React$1.JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React$1.ComponentProps<"span">): React$1.JSX.Element;
+    displayName: string;
+};
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    loading?: boolean;
+}
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, locale, ...props }: CalendarProps): React$1.JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+
+declare const Card: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
+
+interface DatePickerProps {
+    value?: Date | undefined;
+    onChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    locale?: Locale;
+    dateFormat?: string;
+}
+declare function DatePicker({ value, onChange, placeholder, disabled, className, locale, dateFormat, }: DatePickerProps): React$1.JSX.Element;
+declare namespace DatePicker {
+    var displayName: string;
+}
+
+interface DateRangePickerProps {
+    value?: DateRange | undefined;
+    onChange?: (range: DateRange | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    locale?: Locale;
+    dateFormat?: string;
+    numberOfMonths?: number;
+    showPresets?: boolean;
+}
+declare function DateRangePicker({ value, onChange, placeholder, disabled, className, locale, dateFormat, numberOfMonths, showPresets, }: DateRangePickerProps): React$1.JSX.Element;
+declare namespace DateRangePicker {
+    var displayName: string;
+}
+
+interface DateTimePickerProps {
+    value?: Date | undefined;
+    onChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    withSeconds?: boolean;
+    locale?: Locale;
+    dateFormat?: string;
+}
+declare function DateTimePicker({ value, onChange, placeholder, disabled, className, withSeconds, locale, dateFormat, }: DateTimePickerProps): React$1.JSX.Element;
+declare namespace DateTimePicker {
+    var displayName: string;
+}
+
+interface DateTimeRange {
+    from: Date | undefined;
+    to: Date | undefined;
+}
+interface DateTimeRangePickerProps {
+    value?: DateTimeRange;
+    onChange?: (range: DateTimeRange | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    withSeconds?: boolean;
+    locale?: Locale;
+    dateFormat?: string;
+    numberOfMonths?: number;
+    showPresets?: boolean;
+}
+declare function DateTimeRangePicker({ value, onChange, placeholder, disabled, className, withSeconds, locale, dateFormat, numberOfMonths, showPresets, }: DateTimeRangePickerProps): React$1.JSX.Element;
+declare namespace DateTimeRangePicker {
+    var displayName: string;
+}
+
+declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare function DropdownMenuShortcut({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): React$1.JSX.Element;
+declare namespace DropdownMenuShortcut {
+    var displayName: string;
+}
+
+interface FileUploadProps {
+    accept?: string;
+    multiple?: boolean;
+    maxSize?: number;
+    value?: File[];
+    onChange?: (files: File[]) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+}
+declare function FileUpload({ accept, multiple, maxSize, value, onChange, disabled, placeholder, className, }: FileUploadProps): React$1.JSX.Element;
+declare namespace FileUpload {
+    var displayName: string;
+}
+
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>({ children, watch, getValues, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, handleSubmit, unregister, control, register, setFocus, subscribe, }: react_hook_form.FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React$1.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => React$1.JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: react_hook_form.FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormItem: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & React$1.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React$1.ForwardRefExoticComponent<Omit<React$1.HTMLAttributes<HTMLElement> & {
+    children?: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLElement>, "ref"> & React$1.RefAttributes<HTMLElement>>;
+declare const FormDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+interface InputProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
+}
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const Label: React$1.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React$1.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLLabelElement>>;
+
+interface MultiSelectOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+interface MultiSelectProps {
+    options: MultiSelectOption[];
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    className?: string;
+    maxDisplay?: number;
+}
+declare function MultiSelect({ options, value, onChange, placeholder, searchPlaceholder, emptyText, disabled, className, maxDisplay, }: MultiSelectProps): React$1.JSX.Element;
+declare namespace MultiSelect {
+    var displayName: string;
+}
+
+declare const notificationVariants: (props?: ({
+    variant?: "default" | "success" | "warning" | "error" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface NotificationProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof notificationVariants> {
+    title: string;
+    description?: string;
+    timestamp?: string;
+    unread?: boolean;
+    icon?: React$1.ReactNode;
+    onDismiss?: () => void;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+declare const Notification: React$1.ForwardRefExoticComponent<NotificationProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface NumberInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    onValueChange?: (value: number) => void;
+}
+declare const NumberInput: React$1.ForwardRefExoticComponent<NumberInputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+interface OtpInputProps {
+    length?: number;
+    value?: string | undefined;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    className?: string;
+    inputClassName?: string;
+}
+declare function OtpInput({ length, value, onChange, disabled, className, inputClassName, }: OtpInputProps): React$1.JSX.Element;
+declare namespace OtpInput {
+    var displayName: string;
+}
+
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Progress: React$1.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+interface SearchSelectOption {
+    value: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+interface SearchSelectProps {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    onSearch: (query: string) => Promise<SearchSelectOption[]>;
+    initialOptions?: SearchSelectOption[];
+    debounceMs?: number;
+    disabled?: boolean;
+    className?: string;
+    emptyText?: string;
+}
+declare function SearchSelect({ value, onValueChange, placeholder, searchPlaceholder, onSearch, initialOptions, debounceMs, disabled, className, emptyText, }: SearchSelectProps): React$1.JSX.Element;
+
+declare const Select: React$1.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React$1.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Sheet: React$1.FC<DialogPrimitive.DialogProps>;
+declare const SheetTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "top" | "right" | "bottom" | "left" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React$1.JSX.Element;
+
+interface SliderProps {
+    value?: number | undefined;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+}
+declare function Slider({ value, defaultValue, onChange, min, max, step, disabled, className, }: SliderProps): React$1.JSX.Element;
+declare namespace Slider {
+    var displayName: string;
+}
+
+declare const Switch: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+interface TextareaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+interface TimePickerProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    withSeconds?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+declare function TimePicker({ value, onChange, withSeconds, disabled, className }: TimePickerProps): React$1.JSX.Element;
+declare namespace TimePicker {
+    var displayName: string;
+}
+
+type ToasterProps = ComponentProps<typeof Toaster$1>;
+declare function Toaster({ ...props }: ToasterProps): React$1.JSX.Element;
+
+declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+type ContainerSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+interface ContainerProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    size?: ContainerSize;
+    center?: boolean;
+}
+declare function Container({ size, center, className, children, ...props }: ContainerProps): React$1.JSX.Element;
+declare namespace Container {
+    var displayName: string;
+}
+
+interface PageLayoutProps {
+    title: string;
+    description?: string;
+    actions?: React$1.ReactNode;
+    children: React$1.ReactNode;
+    breadcrumbs?: {
+        label: string;
+        href?: string;
+    }[];
+}
+declare function PageLayout({ title, description, actions, children, breadcrumbs }: PageLayoutProps): React$1.JSX.Element;
+
+interface SidebarLayoutProps {
+    sidebar: React$1.ReactNode;
+    children: React$1.ReactNode;
+    sidebarWidth?: number;
+    collapsible?: boolean;
+    className?: string;
+}
+declare function SidebarLayout({ sidebar, children, sidebarWidth, collapsible, className, }: SidebarLayoutProps): React$1.JSX.Element;
+
+type Gap = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16;
+type Align = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+type Justify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+type Wrap = 'nowrap' | 'wrap' | 'wrap-reverse';
+interface StackProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    direction?: 'row' | 'column';
+    gap?: Gap;
+    align?: Align;
+    justify?: Justify;
+    wrap?: Wrap;
+}
+declare function Stack({ direction, gap, align, justify, wrap, className, children, ...props }: StackProps): React$1.JSX.Element;
+declare namespace Stack {
+    var displayName: string;
+}
+declare function HStack({ align, ...props }: Omit<StackProps, 'direction'>): React$1.JSX.Element;
+declare namespace HStack {
+    var displayName: string;
+}
+declare function VStack(props: Omit<StackProps, 'direction'>): React$1.JSX.Element;
+declare namespace VStack {
+    var displayName: string;
+}
+
+interface AdminLayoutContextValue {
+    collapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+    toggleCollapsed: () => void;
+    sidebarWidth: number;
+    collapsedWidth: number;
+}
+declare const AdminLayoutContext: React$1.Context<AdminLayoutContextValue | null>;
+declare function useAdminLayout(): AdminLayoutContextValue;
+
+interface AdminLayoutProps {
+    children: React$1.ReactNode;
+    className?: string;
+    defaultCollapsed?: boolean;
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    sidebarWidth?: number;
+    collapsedWidth?: number;
+}
+declare function AdminLayout({ children, className, defaultCollapsed, collapsed: controlledCollapsed, onCollapsedChange, sidebarWidth, collapsedWidth, }: AdminLayoutProps): React$1.JSX.Element;
+
+interface AdminNavBadge {
+    label: string | number;
+    variant?: 'default' | 'destructive' | 'secondary';
+}
+interface AdminNavItem {
+    label: string;
+    href?: string;
+    icon?: LucideIcon;
+    active?: boolean;
+    disabled?: boolean;
+    badge?: AdminNavBadge;
+    onClick?: React$1.MouseEventHandler<HTMLElement>;
+    asChild?: boolean;
+    children?: AdminNavItem[];
+}
+interface AdminNavGroup {
+    label?: string;
+    items: AdminNavItem[];
+}
+interface AdminSidebarProps {
+    groups?: AdminNavGroup[];
+    logo?: React$1.ReactNode;
+    footer?: React$1.ReactNode;
+    className?: string;
+}
+declare function AdminSidebar({ groups, logo, footer, className }: AdminSidebarProps): React$1.JSX.Element;
+
+interface WithClassName {
+    className?: string;
+}
+interface WithChildren {
+    children: ReactNode;
+}
+interface WithOptionalChildren {
+    children?: ReactNode;
+}
+type PropsWithClassName<T = unknown> = T & WithClassName;
+type Size = 'sm' | 'md' | 'lg';
+type Variant = 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
+type Status = 'idle' | 'loading' | 'success' | 'error';
+interface PaginationState {
+    page: number;
+    pageSize: number;
+    total: number;
+}
+interface SelectOption<T = string> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+    description?: string;
+}
+interface BreadcrumbNavItem {
+    label: string;
+    href?: string;
+}
+
+interface AdminUserMenuItem {
+    label: string;
+    icon?: LucideIcon;
+    onClick?: () => void;
+    href?: string;
+    destructive?: boolean;
+    separator?: boolean;
+}
+interface AdminHeaderUser {
+    name: string;
+    email?: string;
+    avatarSrc?: string;
+    avatarFallback?: string;
+}
+interface AdminHeaderProps extends React$1.HTMLAttributes<HTMLElement> {
+    title?: string;
+    breadcrumbs?: BreadcrumbNavItem[];
+    actions?: React$1.ReactNode;
+    sticky?: boolean;
+    showToggle?: boolean;
+    user?: AdminHeaderUser;
+    userMenuItems?: AdminUserMenuItem[];
+}
+declare const AdminHeader: React$1.ForwardRefExoticComponent<AdminHeaderProps & React$1.RefAttributes<HTMLElement>>;
+
+interface AdminFooterProps extends React$1.HTMLAttributes<HTMLElement> {
+}
+declare const AdminFooter: React$1.ForwardRefExoticComponent<AdminFooterProps & React$1.RefAttributes<HTMLElement>>;
+
+interface AdminContentProps extends React$1.HTMLAttributes<HTMLElement> {
+    padded?: boolean;
+}
+declare const AdminContent: React$1.ForwardRefExoticComponent<AdminContentProps & React$1.RefAttributes<HTMLElement>>;
+
+interface PublicLayoutContextValue {
+    mobileMenuOpen: boolean;
+    setMobileMenuOpen: (open: boolean) => void;
+}
+declare const PublicLayoutContext: React$1.Context<PublicLayoutContextValue | null>;
+declare function usePublicLayout(): PublicLayoutContextValue;
+
+interface PublicLayoutProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function PublicLayout({ children, className }: PublicLayoutProps): React$1.JSX.Element;
+
+interface PublicNavLink {
+    label: string;
+    href?: string;
+    active?: boolean;
+    external?: boolean;
+    onClick?: React$1.MouseEventHandler<HTMLElement>;
+    children?: PublicNavLink[];
+}
+interface PublicNavbarProps extends React$1.HTMLAttributes<HTMLElement> {
+    logo?: React$1.ReactNode;
+    links?: PublicNavLink[];
+    cta?: React$1.ReactNode;
+    sticky?: boolean;
+    transparent?: boolean;
+    transparentThreshold?: number;
+    mobileMenuTitle?: string;
+    containerSize?: ContainerSize;
+}
+declare const PublicNavbar: React$1.ForwardRefExoticComponent<PublicNavbarProps & React$1.RefAttributes<HTMLElement>>;
+
+type PublicFooterSocialPlatform = 'facebook' | 'twitter' | 'instagram' | 'linkedin' | 'youtube' | 'github' | 'email' | 'website';
+interface PublicFooterLink {
+    label: string;
+    href: string;
+    external?: boolean;
+}
+interface PublicFooterLinkGroup {
+    heading: string;
+    links: PublicFooterLink[];
+}
+interface PublicFooterSocialLink {
+    platform: PublicFooterSocialPlatform;
+    href: string;
+    label?: string;
+}
+interface PublicFooterProps extends React$1.HTMLAttributes<HTMLElement> {
+    logo?: React$1.ReactNode;
+    tagline?: string;
+    linkGroups?: PublicFooterLinkGroup[];
+    socialLinks?: PublicFooterSocialLink[];
+    copyright?: React$1.ReactNode;
+    newsletter?: React$1.ReactNode;
+    containerSize?: ContainerSize;
+}
+declare const PublicFooter: React$1.ForwardRefExoticComponent<PublicFooterProps & React$1.RefAttributes<HTMLElement>>;
+
+interface PaginationProps {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    showFirstLast?: boolean;
+    siblingCount?: number;
+    className?: string;
+}
+declare function Pagination({ page, totalPages, onPageChange, showFirstLast, siblingCount, className, }: PaginationProps): React$1.JSX.Element | null;
+declare namespace Pagination {
+    var displayName: string;
+}
+
+interface StepperStep {
+    title: string;
+    description?: string;
+}
+interface StepperProps {
+    steps: StepperStep[];
+    activeStep: number;
+    orientation?: 'horizontal' | 'vertical';
+    onStepClick?: (index: number) => void;
+    className?: string;
+}
+declare function Stepper({ steps, activeStep, orientation, onStepClick, className, }: StepperProps): React$1.JSX.Element;
+declare namespace Stepper {
+    var displayName: string;
+}
+
+interface FormCheckboxProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+}
+declare function FormCheckbox<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, disabled, }: FormCheckboxProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormDatePickerProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    locale?: Locale;
+    dateFormat?: string;
+}
+declare function FormDatePicker<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...pickerProps }: FormDatePickerProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormDateRangePickerProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    locale?: Locale;
+    dateFormat?: string;
+    numberOfMonths?: number;
+}
+declare function FormDateRangePicker<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...pickerProps }: FormDateRangePickerProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormDateTimePickerProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    withSeconds?: boolean;
+    locale?: Locale;
+    dateFormat?: string;
+}
+declare function FormDateTimePicker<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...pickerProps }: FormDateTimePickerProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormDateTimeRangePickerProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    withSeconds?: boolean;
+    locale?: Locale;
+    dateFormat?: string;
+    numberOfMonths?: number;
+}
+declare function FormDateTimeRangePicker<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...pickerProps }: FormDateTimeRangePickerProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormFieldWrapperProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    control: Control<TFieldValues>;
+    render: (field: ControllerRenderProps<TFieldValues, TName>) => React$1.ReactNode;
+}
+declare function FormFieldWrapper<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, label, description, required, control, render, }: FormFieldWrapperProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormFileUploadProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    accept?: string;
+    multiple?: boolean;
+    maxSize?: number;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function FormFileUpload<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...uploadProps }: FormFileUploadProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'name' | 'defaultValue'> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+}
+declare function FormInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...inputProps }: FormInputProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormMultiSelectProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    options: MultiSelectOption[];
+    label?: string;
+    description?: string;
+    required?: boolean;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    className?: string;
+    maxDisplay?: number;
+}
+declare function FormMultiSelect<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...selectProps }: FormMultiSelectProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormNumberInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, 'name' | 'defaultValue' | 'type' | 'onChange'> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+}
+declare function FormNumberInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...inputProps }: FormNumberInputProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormOtpInputProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    length?: number;
+    disabled?: boolean;
+    className?: string;
+    inputClassName?: string;
+}
+declare function FormOtpInput<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...inputProps }: FormOtpInputProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormSelectProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    options: SelectOption[];
+    label?: string;
+    description?: string;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+}
+declare function FormSelect<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, options, label, description, placeholder, required, disabled, }: FormSelectProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormSliderProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+}
+declare function FormSlider<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...sliderProps }: FormSliderProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormSwitchProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+}
+declare function FormSwitch<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, disabled, }: FormSwitchProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormTextareaProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> extends Omit<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, 'name' | 'defaultValue'> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+}
+declare function FormTextarea<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...textareaProps }: FormTextareaProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface FormTimePickerProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> {
+    name: TName;
+    control: Control<TFieldValues>;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    withSeconds?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+declare function FormTimePicker<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ name, control, label, description, required, ...pickerProps }: FormTimePickerProps<TFieldValues, TName>): React$1.JSX.Element;
+
+interface DataTablePaginationProps {
+    pageIndex: number;
+    pageSize: number;
+    total: number;
+    onPageChange: (page: number) => void;
+    onPageSizeChange?: (size: number) => void;
+    showFirstLast?: boolean;
+    siblingCount?: number;
+}
+interface DataTableRowAction<TData> {
+    label: string;
+    icon?: React$1.ComponentType<{
+        className?: string;
+    }>;
+    onClick: (row: TData) => void;
+    /** Đổi màu text sang destructive */
+    variant?: 'default' | 'destructive';
+    /** Disable dựa vào dữ liệu của dòng */
+    disabled?: (row: TData) => boolean;
+    /** Hiện separator phía trên item này */
+    separator?: boolean;
+}
+interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    loading?: boolean;
+    pagination?: DataTablePaginationProps;
+    /** Hiện search input, debounce 300ms */
+    searchable?: boolean;
+    onSearch?: (query: string) => void;
+    emptyText?: string;
+    className?: string;
+    /** Checkbox chọn nhiều dòng */
+    enableRowSelection?: boolean;
+    onRowSelectionChange?: (rows: TData[]) => void;
+    /** Slot render bulk-action buttons khi có dòng được chọn */
+    selectionActions?: React$1.ReactNode;
+    /** Render nội dung expand bên dưới mỗi dòng */
+    renderSubRow?: (row: Row<TData>) => React$1.ReactNode;
+    getRowCanExpand?: (row: Row<TData>) => boolean;
+    /** Hiện nút toggle ẩn/hiện cột ở góc phải toolbar */
+    showColumnToggle?: boolean;
+    /** Inject cột "..." cuối mỗi dòng với dropdown actions */
+    rowActions?: DataTableRowAction<TData>[];
+    /** Callback khi sort thay đổi — nếu truyền vào thì dùng manualSorting (server-side) */
+    onSortChange?: (sorting: SortingState) => void;
+}
+declare function DataTable<TData, TValue>({ columns, data, loading, pagination, searchable, onSearch, emptyText, className, enableRowSelection, onRowSelectionChange, selectionActions, renderSubRow, getRowCanExpand, showColumnToggle, rowActions, onSortChange, }: DataTableProps<TData, TValue>): React$1.JSX.Element;
+
+interface DescriptionItem {
+    label: string;
+    value: React$1.ReactNode;
+}
+interface DescriptionListProps {
+    items: DescriptionItem[];
+    layout?: 'horizontal' | 'vertical';
+    striped?: boolean;
+    labelWidth?: string;
+    className?: string;
+}
+declare function DescriptionList({ items, layout, striped, labelWidth, className, }: DescriptionListProps): React$1.JSX.Element;
+declare namespace DescriptionList {
+    var displayName: string;
+}
+
+interface EmptyStateProps {
+    icon?: LucideIcon;
+    title: string;
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    className?: string;
+}
+declare function EmptyState({ icon: Icon, title, description, action, className }: EmptyStateProps): React$1.JSX.Element;
+
+interface StatCardProps {
+    title: string;
+    value: string | number;
+    change?: {
+        value: number;
+        period: string;
+    };
+    icon?: LucideIcon;
+    loading?: boolean;
+    className?: string;
+}
+declare function StatCard({ title, value, change, icon: Icon, loading, className }: StatCardProps): React$1.JSX.Element;
+
+type TimelineStatus = 'default' | 'success' | 'warning' | 'error' | 'pending';
+interface TimelineItem {
+    title: string;
+    description?: React$1.ReactNode;
+    time?: string;
+    icon?: React$1.ReactNode;
+    status?: TimelineStatus;
+}
+interface TimelineProps {
+    items: TimelineItem[];
+    className?: string;
+}
+declare function Timeline({ items, className }: TimelineProps): React$1.JSX.Element;
+declare namespace Timeline {
+    var displayName: string;
+}
+
+interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    variant?: 'destructive' | 'default';
+    onConfirm: () => void | Promise<void>;
+    loading?: boolean;
+}
+declare function ConfirmDialog({ open, onOpenChange, title, description, confirmLabel, cancelLabel, variant, onConfirm, loading, }: ConfirmDialogProps): React$1.JSX.Element;
+
+interface LoadingOverlayProps {
+    open?: boolean;
+    message?: string;
+    blur?: boolean;
+    className?: string;
+}
+declare function LoadingOverlay({ open, message, blur, className }: LoadingOverlayProps): React$1.ReactPortal | null;
+declare namespace LoadingOverlay {
+    var displayName: string;
+}
+
+interface LoadingSpinnerProps {
+    size?: 'sm' | 'md' | 'lg';
+    text?: string;
+    className?: string;
+    fullScreen?: boolean;
+}
+declare function LoadingSpinner({ size, text, className, fullScreen }: LoadingSpinnerProps): React$1.JSX.Element;
+
+type ResultStatus = 'success' | 'error' | 'warning' | 'info';
+interface ResultProps {
+    status?: ResultStatus;
+    icon?: React$1.ReactNode;
+    title: string;
+    description?: React$1.ReactNode;
+    extra?: React$1.ReactNode;
+    className?: string;
+}
+declare function Result({ status, icon, title, description, extra, className, }: ResultProps): React$1.JSX.Element;
+declare namespace Result {
+    var displayName: string;
+}
+
+declare const sectionVariants: (props?: ({
+    padding?: "none" | "sm" | "lg" | "md" | "xl" | null | undefined;
+    background?: "default" | "muted" | "transparent" | "dark" | "primary" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SectionVariantProps = VariantProps<typeof sectionVariants>;
+interface SectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    as?: React$1.ElementType;
+    container?: boolean;
+    containerSize?: ContainerSize;
+}
+declare const Section: React$1.ForwardRefExoticComponent<SectionProps & React$1.RefAttributes<HTMLElement>>;
+
+type SectionHeadingAlign = 'left' | 'center' | 'right';
+interface SectionHeadingProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    eyebrow?: string;
+    eyebrowClassName?: string;
+    heading: string;
+    headingAs?: 'h1' | 'h2' | 'h3' | 'h4';
+    headingClassName?: string;
+    description?: string;
+    descriptionClassName?: string;
+    align?: SectionHeadingAlign;
+    gradient?: boolean;
+}
+declare const SectionHeading: React$1.ForwardRefExoticComponent<SectionHeadingProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface HeroAction {
+    label: string;
+    href?: string;
+    onClick?: React$1.MouseEventHandler<HTMLElement>;
+    variant?: ButtonProps['variant'];
+    size?: ButtonProps['size'];
+    asChild?: boolean;
+    icon?: LucideIcon;
+}
+type HeroMediaPosition = 'right' | 'left' | 'bottom' | 'background';
+type HeroMinHeight = 'screen' | 'half' | 'auto';
+interface HeroSectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    eyebrow?: string;
+    heading: string;
+    description?: string;
+    primaryAction?: HeroAction;
+    secondaryAction?: HeroAction;
+    media?: React$1.ReactNode;
+    mediaPosition?: HeroMediaPosition;
+    align?: 'left' | 'center';
+    minHeight?: HeroMinHeight;
+    containerSize?: ContainerSize;
+}
+declare function HeroSection({ eyebrow, heading, description, primaryAction, secondaryAction, media, mediaPosition, align, minHeight, padding, background, containerSize, className, ...props }: HeroSectionProps): React$1.JSX.Element;
+
+interface FeatureItem {
+    icon?: LucideIcon | React$1.ReactNode;
+    title: string;
+    description: string;
+    href?: string;
+    badge?: string;
+}
+type FeatureVariant = 'card' | 'icon-left' | 'minimal';
+interface FeatureCardProps {
+    item: FeatureItem;
+    variant: FeatureVariant;
+    className?: string;
+}
+declare function FeatureCard({ item, variant, className }: FeatureCardProps): React$1.JSX.Element;
+interface FeatureSectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    eyebrow?: string;
+    heading?: string;
+    description?: string;
+    headingAlign?: SectionHeadingAlign;
+    features: FeatureItem[];
+    columns?: 2 | 3 | 4;
+    variant?: FeatureVariant;
+    containerSize?: ContainerSize;
+}
+declare function FeatureSection({ eyebrow, heading, description, headingAlign, features, columns, variant, padding, background, containerSize, className, ...props }: FeatureSectionProps): React$1.JSX.Element;
+
+interface CTASectionAction {
+    label: string;
+    href?: string;
+    onClick?: React$1.MouseEventHandler<HTMLElement>;
+    variant?: ButtonProps['variant'];
+    size?: ButtonProps['size'];
+    asChild?: boolean;
+}
+type CTASectionVariant = 'simple' | 'split' | 'boxed';
+interface CTASectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    eyebrow?: string;
+    heading: string;
+    description?: string;
+    primaryAction?: CTASectionAction;
+    secondaryAction?: CTASectionAction;
+    align?: 'left' | 'center';
+    variant?: CTASectionVariant;
+    containerSize?: ContainerSize;
+}
+declare function CTASection({ eyebrow, heading, description, primaryAction, secondaryAction, align, variant, padding, background, containerSize, className, ...props }: CTASectionProps): React$1.JSX.Element;
+
+interface StatItem {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: LucideIcon;
+}
+type StatsVariant = 'simple' | 'card' | 'bordered';
+interface StatsSectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    eyebrow?: string;
+    heading?: string;
+    description?: string;
+    headingAlign?: SectionHeadingAlign;
+    stats: StatItem[];
+    columns?: 2 | 3 | 4;
+    variant?: StatsVariant;
+    containerSize?: ContainerSize;
+}
+declare function StatsSection({ eyebrow, heading, description, headingAlign, stats, columns, variant, padding, background, containerSize, className, ...props }: StatsSectionProps): React$1.JSX.Element;
+
+interface TestimonialAuthor {
+    name: string;
+    role?: string;
+    company?: string;
+    avatarSrc?: string;
+    avatarFallback?: string;
+}
+interface TestimonialItem {
+    quote: string;
+    author: TestimonialAuthor;
+    rating?: 1 | 2 | 3 | 4 | 5;
+    featured?: boolean;
+}
+type TestimonialVariant = 'grid' | 'masonry' | 'featured';
+interface TestimonialCardProps {
+    item: TestimonialItem;
+    featured?: boolean;
+    className?: string;
+}
+declare function TestimonialCard({ item, featured, className }: TestimonialCardProps): React$1.JSX.Element;
+interface TestimonialSectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    eyebrow?: string;
+    heading?: string;
+    description?: string;
+    headingAlign?: SectionHeadingAlign;
+    testimonials: TestimonialItem[];
+    columns?: 1 | 2 | 3;
+    variant?: TestimonialVariant;
+    containerSize?: ContainerSize;
+}
+declare function TestimonialSection({ eyebrow, heading, description, headingAlign, testimonials, columns, variant, padding, background, containerSize, className, ...props }: TestimonialSectionProps): React$1.JSX.Element;
+
+interface PricingFeatureItem {
+    label: string;
+    included: boolean | string;
+    tooltip?: string;
+}
+interface PricingPlanPrice {
+    monthly?: string | number;
+    annual?: string | number;
+    currency?: string;
+    unit?: string;
+}
+interface PricingPlanCTA {
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    variant?: ButtonProps['variant'];
+}
+interface PricingPlan {
+    name: string;
+    description?: string;
+    price: PricingPlanPrice;
+    features: PricingFeatureItem[];
+    cta: PricingPlanCTA;
+    highlighted?: boolean;
+    highlightLabel?: string;
+    badge?: string;
+}
+interface PricingBillingToggle {
+    enabled: boolean;
+    defaultPeriod?: 'monthly' | 'annual';
+    annualDiscount?: string;
+}
+type BillingPeriod = 'monthly' | 'annual';
+interface PricingCardProps {
+    plan: PricingPlan;
+    period: BillingPeriod;
+    className?: string;
+}
+declare function PricingCard({ plan, period, className }: PricingCardProps): React$1.JSX.Element;
+interface PricingSectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    eyebrow?: string;
+    heading?: string;
+    description?: string;
+    headingAlign?: SectionHeadingAlign;
+    plans: PricingPlan[];
+    billingToggle?: PricingBillingToggle;
+    columns?: 2 | 3 | 4;
+    containerSize?: ContainerSize;
+}
+declare function PricingSection({ eyebrow, heading, description, headingAlign, plans, billingToggle, columns, padding, background, containerSize, className, ...props }: PricingSectionProps): React$1.JSX.Element;
+
+interface FAQItem {
+    question: string;
+    answer: string | React$1.ReactNode;
+    value?: string;
+}
+type FAQVariant = 'default' | 'card' | 'separated';
+type FAQLayout = 'full' | 'two-column';
+interface FAQSectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    eyebrow?: string;
+    heading?: string;
+    description?: string;
+    headingAlign?: SectionHeadingAlign;
+    items: FAQItem[];
+    type?: 'single' | 'multiple';
+    collapsible?: boolean;
+    variant?: FAQVariant;
+    layout?: FAQLayout;
+    containerSize?: ContainerSize;
+    contactCta?: {
+        heading?: string;
+        label: string;
+        href?: string;
+        onClick?: () => void;
+    };
+}
+declare function FAQSection({ eyebrow, heading, description, headingAlign, items, type, collapsible, variant, layout, padding, background, containerSize, contactCta, className, ...props }: FAQSectionProps): React$1.JSX.Element;
+
+type TeamSocialPlatform = 'linkedin' | 'twitter' | 'github' | 'email' | 'website';
+interface TeamSocialLink {
+    platform: TeamSocialPlatform;
+    href: string;
+    label?: string;
+}
+interface TeamMember {
+    name: string;
+    role: string;
+    bio?: string;
+    avatarSrc?: string;
+    avatarFallback?: string;
+    socials?: TeamSocialLink[];
+    badge?: string;
+}
+type TeamVariant = 'card' | 'minimal' | 'horizontal';
+type TeamAvatarSize = 'sm' | 'md' | 'lg';
+interface TeamMemberCardProps {
+    member: TeamMember;
+    variant: TeamVariant;
+    avatarSize?: TeamAvatarSize;
+    className?: string;
+}
+declare function TeamMemberCard({ member, variant, avatarSize, className, }: TeamMemberCardProps): React$1.JSX.Element;
+interface TeamSectionProps extends React$1.HTMLAttributes<HTMLElement>, SectionVariantProps {
+    eyebrow?: string;
+    heading?: string;
+    description?: string;
+    headingAlign?: SectionHeadingAlign;
+    members: TeamMember[];
+    variant?: TeamVariant;
+    columns?: 2 | 3 | 4 | 5;
+    avatarSize?: TeamAvatarSize;
+    containerSize?: ContainerSize;
+}
+declare function TeamSection({ eyebrow, heading, description, headingAlign, members, variant, columns, avatarSize, padding, background, containerSize, className, ...props }: TeamSectionProps): React$1.JSX.Element;
+
+declare function useDebounce<T>(value: T, delay: number): T;
+
+interface UseDisclosureReturn {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    onOpenChange: (open: boolean) => void;
+}
+declare function useDisclosure(defaultOpen?: boolean): UseDisclosureReturn;
+
+declare function useLocalStorage<T>(key: string, defaultValue: T): [T, (value: T) => void];
+
+interface UsePaginationOptions {
+    total: number;
+    defaultPageSize?: number;
+    defaultPage?: number;
+}
+interface UsePaginationReturn {
+    page: number;
+    pageSize: number;
+    offset: number;
+    totalPages: number;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+}
+declare function usePagination({ total, defaultPageSize, defaultPage, }: UsePaginationOptions): UsePaginationReturn;
+
+declare function cn(...inputs: ClassValue[]): string;
+declare function formatCurrency(value: number, currency?: string, locale?: string): string;
+declare function formatNumber(value: number, locale?: string): string;
+declare function formatDate(date: Date | string | number, options?: Intl.DateTimeFormatOptions, locale?: string): string;
+declare function slugify(text: string): string;
+declare function truncate(text: string, maxLength: number): string;
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, AdminContent, type AdminContentProps, AdminFooter, type AdminFooterProps, AdminHeader, type AdminHeaderProps, type AdminHeaderUser, AdminLayout, AdminLayoutContext, type AdminLayoutContextValue, type AdminLayoutProps, type AdminNavBadge, type AdminNavGroup, type AdminNavItem, AdminSidebar, type AdminSidebarProps, type AdminUserMenuItem, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, type BillingPeriod, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, type BreadcrumbNavItem, BreadcrumbPage, BreadcrumbSeparator, Button, type ButtonProps, CTASection, type CTASectionAction, type CTASectionProps, type CTASectionVariant, Calendar, type CalendarProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, ConfirmDialog, type ConfirmDialogProps, Container, type ContainerProps, type ContainerSize, DataTable, type DataTablePaginationProps, type DataTableProps, type DataTableRowAction, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, DateTimePicker, type DateTimePickerProps, type DateTimeRange, DateTimeRangePicker, type DateTimeRangePickerProps, type DescriptionItem, DescriptionList, type DescriptionListProps, 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, EmptyState, type EmptyStateProps, type FAQItem, type FAQLayout, FAQSection, type FAQSectionProps, type FAQVariant, FeatureCard, type FeatureCardProps, type FeatureItem, FeatureSection, type FeatureSectionProps, type FeatureVariant, FileUpload, type FileUploadProps, Form, FormCheckbox, type FormCheckboxProps, FormControl, FormDatePicker, type FormDatePickerProps, FormDateRangePicker, type FormDateRangePickerProps, FormDateTimePicker, type FormDateTimePickerProps, FormDateTimeRangePicker, type FormDateTimeRangePickerProps, FormDescription, FormField, FormFieldWrapper, type FormFieldWrapperProps, FormFileUpload, type FormFileUploadProps, FormInput, type FormInputProps, FormItem, FormLabel, FormMessage, FormMultiSelect, type FormMultiSelectProps, FormNumberInput, type FormNumberInputProps, FormOtpInput, type FormOtpInputProps, FormSelect, type FormSelectProps, FormSlider, type FormSliderProps, FormSwitch, type FormSwitchProps, FormTextarea, type FormTextareaProps, FormTimePicker, type FormTimePickerProps, HStack, type HeroAction, type HeroMediaPosition, type HeroMinHeight, HeroSection, type HeroSectionProps, Input, type InputProps, Label, LoadingOverlay, type LoadingOverlayProps, LoadingSpinner, type LoadingSpinnerProps, MultiSelect, type MultiSelectOption, type MultiSelectProps, Notification, type NotificationProps, NumberInput, type NumberInputProps, OtpInput, type OtpInputProps, PageLayout, type PageLayoutProps, Pagination, type PaginationProps, type PaginationState, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, type PricingBillingToggle, PricingCard, type PricingCardProps, type PricingFeatureItem, type PricingPlan, type PricingPlanCTA, type PricingPlanPrice, PricingSection, type PricingSectionProps, Progress, type PropsWithClassName, PublicFooter, type PublicFooterLink, type PublicFooterLinkGroup, type PublicFooterProps, type PublicFooterSocialLink, type PublicFooterSocialPlatform, PublicLayout, PublicLayoutContext, type PublicLayoutContextValue, type PublicLayoutProps, type PublicNavLink, PublicNavbar, type PublicNavbarProps, RadioGroup, RadioGroupItem, Result, type ResultProps, type ResultStatus, ScrollArea, ScrollBar, SearchSelect, type SearchSelectOption, type SearchSelectProps, Section, SectionHeading, type SectionHeadingAlign, type SectionHeadingProps, type SectionProps, type SectionVariantProps, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, type SelectOption, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, SidebarLayout, type SidebarLayoutProps, type Size, Skeleton, Slider, type SliderProps, Stack, type StackProps, StatCard, type StatCardProps, type StatItem, StatsSection, type StatsSectionProps, type StatsVariant, type Status, Stepper, type StepperProps, type StepperStep, Switch, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, type TeamAvatarSize, type TeamMember, TeamMemberCard, type TeamMemberCardProps, TeamSection, type TeamSectionProps, type TeamSocialLink, type TeamSocialPlatform, type TeamVariant, type TestimonialAuthor, TestimonialCard, type TestimonialCardProps, type TestimonialItem, TestimonialSection, type TestimonialSectionProps, type TestimonialVariant, Textarea, type TextareaProps, TimePicker, type TimePickerProps, Timeline, type TimelineItem, type TimelineProps, type TimelineStatus, Toaster, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type UseDisclosureReturn, type UsePaginationOptions, type UsePaginationReturn, VStack, type Variant, type WithChildren, type WithClassName, type WithOptionalChildren, badgeVariants, buttonVariants, cn, formatCurrency, formatDate, formatNumber, notificationVariants, sectionVariants, slugify, truncate, useAdminLayout, useDebounce, useDisclosure, useFormField, useLocalStorage, usePagination, usePublicLayout };