@turystack/ui 0.0.18 → 0.0.21

package/dist/index.d.ts

@@ -1,8 +1,237 @@
-import { default as default_2 } from 'react';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { ForwardRefExoticComponent } from 'react';
+import { InputHTMLAttributes } from 'react';
 import { JSX } from 'react/jsx-runtime';
+import { LucideIcon } from 'lucide-react';
 import { PropsWithChildren } from 'react';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { TextareaHTMLAttributes } from 'react';
+import { toast } from 'sonner';
+import { Toaster } from 'sonner';
+import { TVReturnType } from 'tailwind-variants';
 
-export declare function Button(props: PropsWithChildren<ButtonProps>): JSX.Element;
+export declare const Accordion: typeof Root & {
+    Content: typeof Content;
+    Item: typeof Item;
+    Trigger: typeof Trigger;
+};
+
+export declare type AccordionConfig = {
+    default?: ComponentConfig<AccordionProps, AccordionSlots>;
+    item?: ComponentConfig<AccordionItem, AccordionItemSlots>;
+    trigger?: ComponentConfig<AccordionTrigger, AccordionTriggerSlots>;
+    content?: ComponentConfig<AccordionContent, AccordionContentSlots>;
+};
+
+export declare type AccordionContent = {};
+
+export declare type AccordionContentSlots = 'root' | 'inner';
+
+export declare type AccordionItem = {
+    value: string;
+    disabled?: boolean;
+};
+
+export declare type AccordionItemSlots = 'root';
+
+export declare type AccordionProps = (BaseAccordionProps & SingleAccordionProps) | (BaseAccordionProps & MultipleAccordionProps);
+
+export declare type AccordionSlots = 'root';
+
+export declare type AccordionTrigger = {};
+
+export declare type AccordionTriggerSlots = 'header' | 'root' | 'icon';
+
+export declare type AccordionType = 'single' | 'multiple';
+
+declare function Action({ children }: PropsWithChildren<AlertActionProps>): JSX.Element;
+
+export declare const Alert: typeof Root_2 & {
+    Action: typeof Action;
+    Content: typeof Content_2;
+    Description: typeof Description;
+    Icon: typeof Icon;
+    Title: typeof Title;
+};
+
+export declare type AlertActionProps = {};
+
+export declare type AlertActionSlots = 'root';
+
+export declare type AlertConfig = {
+    default?: ComponentConfig<AlertProps, AlertSlots>;
+    icon?: ComponentConfig<AlertIconProps, AlertIconSlots>;
+    title?: ComponentConfig<AlertTitleProps, AlertTitleSlots>;
+    description?: ComponentConfig<AlertDescriptionProps, AlertDescriptionSlots>;
+    action?: ComponentConfig<AlertActionProps, AlertActionSlots>;
+};
+
+export declare type AlertDescriptionProps = {};
+
+export declare type AlertDescriptionSlots = 'root';
+
+export declare type AlertIconProps = {};
+
+export declare type AlertIconSlots = 'root';
+
+export declare type AlertProps = {
+    variant?: AlertVariant;
+    closable?: boolean;
+    onClose?: () => void;
+};
+
+export declare type AlertSlots = 'root' | 'close';
+
+export declare type AlertTitleProps = {};
+
+export declare type AlertTitleSlots = 'root';
+
+export declare type AlertVariant = 'default' | 'destructive';
+
+export declare function applyTheme(theme: ThemeProps, isDark: boolean): Record<string, string>;
+
+export declare function Avatar({ src, alt, size, variant, children, }: PropsWithChildren<AvatarProps>): JSX.Element;
+
+export declare type AvatarConfig = ComponentConfig<AvatarProps, AvatarSlots>;
+
+export declare type AvatarProps = {
+    src?: string | null;
+    alt?: string;
+    size?: AvatarSize;
+    variant?: AvatarVariant;
+};
+
+export declare type AvatarSize = 'sm' | 'md' | 'lg';
+
+export declare type AvatarSlots = 'root' | 'image' | 'fallback';
+
+export declare type AvatarVariant = 'circle' | 'square';
+
+export declare function Badge({ variant, align, block, loading, asChild, onClick, children, }: PropsWithChildren<BadgeProps>): JSX.Element;
+
+export declare type BadgeAlign = 'start' | 'center' | 'end';
+
+export declare type BadgeConfig = ComponentConfig<BadgeProps, BadgeSlots>;
+
+export declare type BadgeProps = {
+    variant?: BadgeVariant;
+    align?: BadgeAlign;
+    block?: boolean;
+    loading?: boolean;
+    asChild?: boolean;
+    onClick?: React.MouseEventHandler<HTMLDivElement>;
+};
+
+export declare type BadgeSlots = 'root';
+
+export declare type BadgeVariant = 'default' | 'secondary' | 'destructive' | 'outline';
+
+declare type BaseAccordionProps = {
+    type: AccordionType;
+    bordered?: boolean;
+};
+
+declare type BaseCurrencyInputProps = Omit<InputProps, 'value' | 'defaultValue' | 'onChange'> & {
+    currency?: Currency;
+};
+
+declare type BaseNumberInputProps = Omit<InputProps, 'value' | 'defaultValue' | 'onChange'> & {
+    step?: number;
+};
+
+export declare type BaseSelectProps<T, O> = {
+    options: T[];
+    optionLabel: keyof T | ((option: T) => string);
+    optionValue: keyof T | ((option: T) => O);
+    optionGroup?: keyof T | ((option: T) => string);
+    renderOption?: (option: T) => React.ReactNode;
+    renderValue?: (option: T) => React.ReactNode;
+    placeholder?: string;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    emptySection?: React.ReactNode;
+    leftSection?: React.ReactNode;
+    rightSection?: React.ReactNode;
+    infinite?: SelectInfiniteProps;
+    disabled?: boolean;
+    loading?: boolean;
+    block?: boolean;
+    size?: SelectSize;
+};
+
+declare type BaseSliderProps = {
+    orientation: SliderOrientation;
+    size?: SliderSize;
+};
+
+declare type BaseUploaderProps = {
+    accept?: string;
+    maxFiles?: number;
+    maxFileSize?: number;
+    disabled?: boolean;
+    handler: (fileName: string) => Promise<UploaderHandlerResponse>;
+};
+
+declare function Body_2({ children }: PropsWithChildren<ModalBodyProps>): JSX.Element;
+
+declare function Body_3({ children }: PropsWithChildren<SheetBodyProps>): JSX.Element;
+
+export declare const Breadcrumb: typeof Root_3 & {
+    Ellipsis: typeof Ellipsis;
+    Item: typeof Item_2;
+    Link: typeof Link;
+    List: typeof List;
+    Page: typeof Page;
+    Separator: typeof Separator_2;
+};
+
+export declare type BreadcrumbConfig = {
+    default?: ComponentConfig<BreadcrumbProps, BreadcrumbSlots>;
+    list?: ComponentConfig<BreadcrumbListProps, BreadcrumbListSlots>;
+    item?: ComponentConfig<BreadcrumbItemProps, BreadcrumbItemSlots>;
+    link?: ComponentConfig<BreadcrumbLinkProps, BreadcrumbLinkSlots>;
+    page?: ComponentConfig<BreadcrumbPageProps, BreadcrumbPageSlots>;
+    separator?: ComponentConfig<BreadcrumbSeparatorProps, BreadcrumbSeparatorSlots>;
+    ellipsis?: ComponentConfig<BreadcrumbEllipsisProps, BreadcrumbEllipsisSlots>;
+};
+
+export declare type BreadcrumbEllipsisProps = {};
+
+export declare type BreadcrumbEllipsisSlots = 'root' | 'icon';
+
+export declare type BreadcrumbItemProps = {};
+
+export declare type BreadcrumbItemSlots = 'root';
+
+export declare type BreadcrumbLinkProps = {
+    asChild?: boolean;
+    href?: string;
+};
+
+export declare type BreadcrumbLinkSlots = 'root';
+
+export declare type BreadcrumbListProps = {};
+
+export declare type BreadcrumbListSlots = 'root';
+
+export declare type BreadcrumbPageProps = {};
+
+export declare type BreadcrumbPageSlots = 'root';
+
+export declare type BreadcrumbProps = {};
+
+export declare type BreadcrumbSeparatorProps = {};
+
+export declare type BreadcrumbSeparatorSlots = 'root';
+
+export declare type BreadcrumbSlots = 'root';
+
+export declare const Button: ForwardRefExoticComponent<ButtonProps & {
+children?: ReactNode | undefined;
+} & RefAttributes<HTMLButtonElement>>;
+
+export declare type ButtonConfig = ComponentConfig<ButtonProps, ButtonSlots>;
 
 export declare type ButtonProps = {
     form?: string;
@@ -26,34 +255,1609 @@ export declare type ButtonType = 'button' | 'submit' | 'reset';
 
 export declare type ButtonVariant = 'default' | 'destructive' | 'outline' | 'dashed' | 'secondary' | 'ghost' | 'link';
 
+export declare const Card: typeof Root_4 & {
+    Content: typeof Content_3;
+    Description: typeof Description_2;
+    Footer: typeof Footer;
+    Header: typeof Header;
+    Separator: typeof Separator_3;
+    Title: typeof Title_2;
+};
+
+export declare type CardConfig = {
+    default?: ComponentConfig<CardProps, CardSlots>;
+    header?: ComponentConfig<CardHeaderProps, CardHeaderSlots>;
+    title?: ComponentConfig<CardTitleProps, CardTitleSlots>;
+    description?: ComponentConfig<CardDescriptionProps, CardDescriptionSlots>;
+    content?: ComponentConfig<CardContentProps, CardContentSlots>;
+    footer?: ComponentConfig<CardFooterProps, CardFooterSlots>;
+    separator?: ComponentConfig<CardSeparatorProps, CardSeparatorSlots>;
+};
+
+export declare type CardContentProps = {};
+
+export declare type CardContentSlots = 'root';
+
+export declare type CardDescriptionProps = {};
+
+export declare type CardDescriptionSlots = 'root';
+
+export declare type CardFooterProps = {
+    bordered?: boolean;
+};
+
+export declare type CardFooterSlots = 'root';
+
+export declare type CardHeaderProps = {
+    bordered?: boolean;
+};
+
+export declare type CardHeaderSlots = 'root';
+
+export declare type CardProps = {
+    onClick?: React.MouseEventHandler<HTMLDivElement>;
+};
+
+export declare type CardSeparatorProps = {};
+
+export declare type CardSeparatorSlots = 'root';
+
+export declare type CardSlots = 'root';
+
+export declare type CardTitleProps = {};
+
+export declare type CardTitleSlots = 'root';
+
+export declare const Checkbox: typeof Root_5 & {
+    Group: typeof Group;
+};
+
+export declare type CheckboxConfig = {
+    default?: ComponentConfig<CheckboxProps, CheckboxSlots>;
+    group?: ComponentConfig<CheckboxGroupProps, CheckboxGroupSlots>;
+};
+
+export declare type CheckboxGroupProps = {
+    items: CheckboxItem[];
+    value?: string[];
+    defaultValue?: string[];
+    disabled?: boolean;
+    variant?: CheckboxGroupVariant;
+    onChange?: (value: string[]) => void;
+};
+
+export declare type CheckboxGroupSlots = 'root' | 'item';
+
+export declare type CheckboxGroupVariant = 'vertical' | 'horizontal';
+
+export declare type CheckboxItem = {
+    label: string;
+    value: string;
+    disabled?: boolean;
+};
+
+declare function CheckboxItem_2({ checked, disabled, onCheckedChange, children, }: PropsWithChildren<DropdownMenuCheckboxItemProps>): JSX.Element;
+
+export declare type CheckboxProps = {
+    label?: string;
+    description?: string;
+    value?: string;
+    size?: CheckboxSize;
+    disabled?: boolean;
+    bordered?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+};
+
+export declare type CheckboxSize = 'sm' | 'md' | 'lg';
+
+export declare type CheckboxSlots = 'wrapper' | 'root' | 'indicator' | 'icon' | 'label' | 'description';
+
+declare type ColorScheme = 'light' | 'dark' | 'system';
+
+declare type ColorSchemeContextValue = {
+    colorScheme: ColorScheme;
+    changeColorScheme: (colorScheme: ColorScheme) => void;
+};
+
 declare type ComponentClassNameSlots<T extends string> = Partial<Record<T, string>>;
 
-export declare type ComponentConfig<T extends object, S extends string> = {
+declare type ComponentConfig<T extends object, S extends string> = {
     classNames?: ComponentClassNameSlots<S>;
     defaultProps?: ComponentDefaultProps<T>;
 };
 
 declare type ComponentDefaultProps<T extends object> = Partial<T>;
 
-export declare function Loader({ size }: LoaderProps): JSX.Element;
+export declare function Confirm({ open, title, description, confirmText, cancelText, confirmProps, cancelProps, onConfirm, onCancel, onClose, }: ConfirmProps): JSX.Element;
 
-export declare type LoaderProps = {
-    size?: LoaderSize;
+export declare type ConfirmProps = {
+    open?: boolean;
+    title: string;
+    description: string;
+    confirmText?: string;
+    cancelText?: string;
+    confirmProps?: Omit<ButtonProps, 'loading' | 'onClick'>;
+    cancelProps?: Omit<ButtonProps, 'loading' | 'onClick'>;
+    onConfirm?: () => void;
+    onCancel?: () => void;
+    onClose?: () => void;
 };
 
-export declare type LoaderSize = 'sm' | 'md' | 'lg';
+export declare type ConfirmSlots = 'root' | 'overlay' | 'content' | 'title' | 'description' | 'actions';
 
-export declare type LoaderSlots = 'root';
+declare function Content({ children }: PropsWithChildren<AccordionContent>): JSX.Element;
 
-export declare function TuryStackProvider({ children, ...props }: TuryStackProviderProps & {
-    children: default_2.ReactNode;
-}): JSX.Element;
+declare function Content_2({ children }: PropsWithChildren): JSX.Element;
 
-export declare type TuryStackProviderProps = {
-    components?: {
-        button?: ComponentConfig<ButtonProps, ButtonSlots>;
-        loader?: ComponentConfig<LoaderProps, LoaderSlots>;
-    };
+declare function Content_3({ children }: PropsWithChildren<CardContentProps>): JSX.Element;
+
+declare function Content_4({ side, align, sideOffset, children, }: PropsWithChildren<DropdownMenuContentProps>): JSX.Element;
+
+declare function Content_5({ children }: PropsWithChildren): JSX.Element;
+
+declare function Content_6({ value, children }: PropsWithChildren<TabsContentProps>): JSX.Element;
+
+export declare type Country = {
+    code: string;
+    ddi: string;
+    flag: string;
+    mask: string;
+};
+
+export declare type Currency = 'brl' | 'usd' | 'eur';
+
+export declare const CurrencyInput: ForwardRefExoticComponent<CurrencyInputProps & RefAttributes<HTMLInputElement>>;
+
+export declare type CurrencyInputConfig = ComponentConfig<BaseCurrencyInputProps, CurrencyInputSlots>;
+
+export declare type CurrencyInputProps = BaseCurrencyInputProps & (SingleCurrencyInputProps | RangeCurrencyInputProps);
+
+export declare type CurrencyInputRangeValue = {
+    from?: number | null;
+    to?: number | null;
+};
+
+export declare type CurrencyInputSingleValue = number | null;
+
+export declare type CurrencyInputSlots = 'root' | 'input' | 'leftSection' | 'rightSection' | 'loader';
+
+declare type CursorPaginationProps = {
+    mode: 'cursor';
+    rowsPerPage: number;
+    hasPreviousPage?: boolean;
+    hasNextPage?: boolean;
+    onPreviousPage?: () => void;
+    onNextPage?: () => void;
+    onRowsPerPageChange?: (rowsPerPage: number) => void;
+};
+
+export declare const DateInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "onChange" | "defaultValue"> & {
+value?: Date | null;
+defaultValue?: Date | null;
+onChange?: (date: Date | null) => void;
+} & RefAttributes<HTMLButtonElement>>;
+
+export declare type DateInputConfig = ComponentConfig<DateInputProps, DateInputSlots>;
+
+export declare type DateInputProps = Omit<InputProps, 'value' | 'defaultValue' | 'onChange'> & {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (date: Date | null) => void;
+};
+
+export declare type DateInputSlots = 'root' | 'content' | 'calendar';
+
+export declare type DateRange = {
+    from?: Date;
+    to?: Date;
+};
+
+export declare const DateRangeInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "onChange" | "defaultValue"> & {
+value?: DateRange | null;
+defaultValue?: DateRange | null;
+onChange?: (range: DateRange | null) => void;
+} & RefAttributes<HTMLButtonElement>>;
+
+export declare type DateRangeInputConfig = ComponentConfig<DateRangeInputProps, DateRangeInputSlots>;
+
+export declare type DateRangeInputProps = Omit<InputProps, 'value' | 'defaultValue' | 'onChange'> & {
+    value?: DateRange | null;
+    defaultValue?: DateRange | null;
+    onChange?: (range: DateRange | null) => void;
+};
+
+export declare type DateRangeInputSlots = 'root' | 'content' | 'calendar';
+
+declare function Description({ children }: PropsWithChildren<AlertDescriptionProps>): JSX.Element;
+
+declare function Description_2({ children }: PropsWithChildren<CardDescriptionProps>): JSX.Element;
+
+declare function Description_3({ children }: PropsWithChildren<SheetDescriptionProps>): JSX.Element;
+
+export declare const DocumentInput: ForwardRefExoticComponent<Omit<MaskInputProps, "value" | "mask" | "onChange" | "defaultValue"> & {
+variant: DocumentType_2;
+value?: DocumentValue | null;
+defaultValue?: DocumentValue | null;
+onChange?: (value: DocumentValue | null) => void;
+} & RefAttributes<HTMLInputElement>>;
+
+export declare type DocumentInputConfig = ComponentConfig<object, DocumentInputSlots>;
+
+export declare type DocumentInputProps = Omit<MaskInputProps, 'mask' | 'value' | 'defaultValue' | 'onChange'> & {
+    variant: DocumentType_2;
+    value?: DocumentValue | null;
+    defaultValue?: DocumentValue | null;
+    onChange?: (value: DocumentValue | null) => void;
+};
+
+export declare type DocumentInputSlots = 'root' | 'input' | 'typeSelector' | 'loader';
+
+declare type DocumentType_2 = 'cpf' | 'cnpj' | 'cpf_cnpj';
+export { DocumentType_2 as DocumentType }
+
+export declare type DocumentValue = {
+    type: DocumentType_2;
+    number: string;
+};
+
+export declare const DropdownMenu: typeof Root_6 & {
+    CheckboxItem: typeof CheckboxItem_2;
+    Content: typeof Content_4;
+    Group: typeof Group_2;
+    Item: typeof Item_3;
+    Label: typeof MenuLabel;
+    RadioGroup: typeof RadioGroup;
+    RadioItem: typeof RadioItem_2;
+    Separator: typeof Separator_4;
+    Shortcut: typeof Shortcut;
+    Sub: typeof Sub;
+    SubContent: typeof SubContent;
+    SubTrigger: typeof SubTrigger;
+    Trigger: typeof Trigger_2;
+};
+
+export declare type DropdownMenuAlign = 'start' | 'center' | 'end';
+
+export declare type DropdownMenuCheckboxItemProps = {
+    checked?: boolean;
+    disabled?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+};
+
+export declare type DropdownMenuCheckboxItemSlots = 'root' | 'indicator';
+
+export declare type DropdownMenuConfig = {
+    content?: ComponentConfig<DropdownMenuContentProps, DropdownMenuContentSlots>;
+    item?: ComponentConfig<DropdownMenuItemProps, DropdownMenuItemSlots>;
+    checkboxItem?: ComponentConfig<DropdownMenuCheckboxItemProps, DropdownMenuCheckboxItemSlots>;
+    radioItem?: ComponentConfig<DropdownMenuRadioItemProps, DropdownMenuRadioItemSlots>;
+    label?: ComponentConfig<DropdownMenuLabelProps, DropdownMenuLabelSlots>;
+    separator?: ComponentConfig<DropdownMenuSeparatorProps, DropdownMenuSeparatorSlots>;
+    subTrigger?: ComponentConfig<DropdownMenuSubTriggerProps, DropdownMenuSubTriggerSlots>;
+    subContent?: ComponentConfig<DropdownMenuSubContentProps, DropdownMenuSubContentSlots>;
+    shortcut?: ComponentConfig<DropdownMenuShortcutProps, DropdownMenuShortcutSlots>;
+};
+
+export declare type DropdownMenuContentProps = {
+    side?: DropdownMenuSide;
+    align?: DropdownMenuAlign;
+    sideOffset?: number;
+};
+
+export declare type DropdownMenuContentSlots = 'root';
+
+export declare type DropdownMenuGroupProps = {};
+
+export declare type DropdownMenuGroupSlots = 'root';
+
+export declare type DropdownMenuItemProps = {
+    variant?: DropdownMenuItemVariant;
+    disabled?: boolean;
+    asChild?: boolean;
+    onClick?: React.MouseEventHandler<HTMLDivElement>;
+};
+
+export declare type DropdownMenuItemSlots = 'root' | 'icon';
+
+export declare type DropdownMenuItemVariant = 'default' | 'destructive';
+
+export declare type DropdownMenuLabelProps = {
+    inset?: boolean;
+};
+
+export declare type DropdownMenuLabelSlots = 'root';
+
+export declare type DropdownMenuProps = {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+
+export declare type DropdownMenuRadioGroupProps = {
+    value?: string;
+    onValueChange?: (value: string) => void;
+};
+
+export declare type DropdownMenuRadioGroupSlots = 'root';
+
+export declare type DropdownMenuRadioItemProps = {
+    value: string;
+    disabled?: boolean;
+};
+
+export declare type DropdownMenuRadioItemSlots = 'root' | 'indicator';
+
+export declare type DropdownMenuSeparatorProps = {};
+
+export declare type DropdownMenuSeparatorSlots = 'root';
+
+export declare type DropdownMenuShortcutProps = {};
+
+export declare type DropdownMenuShortcutSlots = 'root';
+
+export declare type DropdownMenuSide = 'top' | 'right' | 'bottom' | 'left';
+
+export declare type DropdownMenuSlots = 'root';
+
+export declare type DropdownMenuSubContentProps = {};
+
+export declare type DropdownMenuSubContentSlots = 'root';
+
+export declare type DropdownMenuSubProps = {};
+
+export declare type DropdownMenuSubSlots = 'root';
+
+export declare type DropdownMenuSubTriggerProps = {
+    inset?: boolean;
+};
+
+export declare type DropdownMenuSubTriggerSlots = 'root' | 'icon';
+
+export declare type DropdownMenuTriggerProps = {
+    asChild?: boolean;
+};
+
+export declare type DropdownMenuTriggerSlots = 'root';
+
+declare function Ellipsis(_props: BreadcrumbEllipsisProps): JSX.Element;
+
+declare function Field({ children, label, name, description, error, }: PropsWithChildren<FormFieldProps>): JSX.Element;
+
+declare function FieldSet({ legend, tooltip, children, }: PropsWithChildren<FormFieldSetProps>): JSX.Element;
+
+export declare function Flex({ direction, justify, align, gap, wrap, inline, children, }: PropsWithChildren<FlexProps>): JSX.Element;
+
+export declare type FlexAlign = 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+
+export declare type FlexDirection = 'row' | 'col' | 'row-reverse' | 'col-reverse';
+
+export declare type FlexGap = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+export declare type FlexJustify = 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly';
+
+export declare type FlexProps = {
+    direction?: FlexDirection;
+    justify?: FlexJustify;
+    align?: FlexAlign;
+    gap?: FlexGap;
+    wrap?: FlexWrap;
+    inline?: boolean;
+};
+
+export declare type FlexSlots = 'root';
+
+export declare type FlexWrap = 'wrap' | 'nowrap' | 'wrap-reverse';
+
+declare function Footer({ bordered, children }: PropsWithChildren<CardFooterProps>): JSX.Element;
+
+declare function Footer_2({ bordered, children }: PropsWithChildren<ModalFooterProps>): JSX.Element;
+
+declare function Footer_3({ bordered, children }: PropsWithChildren<SheetFooterProps>): JSX.Element;
+
+export declare const Form: typeof Root_7 & {
+    Field: typeof Field;
+    FieldSet: typeof FieldSet;
+};
+
+export declare type FormConfig = {
+    default?: ComponentConfig<FormProps, FormSlots>;
+    field?: ComponentConfig<FormFieldProps, FormFieldSlots>;
+    fieldSet?: ComponentConfig<FormFieldSetProps, FormFieldSetSlots>;
+};
+
+export declare type FormFieldLabelInput = string | (LabelProps & {
+    content: string;
+});
+
+export declare type FormFieldLabelProps = {
+    htmlFor?: string;
+    required?: boolean;
+    optional?: boolean;
+    disabled?: boolean;
+    tooltip?: React.ReactNode;
+};
+
+export declare type FormFieldProps = {
+    label?: FormFieldLabelInput;
+    name?: string;
+    description?: React.ReactNode;
+    error?: React.ReactNode;
+};
+
+export declare type FormFieldSetProps = {
+    legend?: string;
+    tooltip?: FormFieldSetTooltip;
+};
+
+export declare type FormFieldSetSlots = 'root' | 'legend';
+
+export declare type FormFieldSetTooltip = string | TooltipProps;
+
+export declare type FormFieldSlots = 'root';
+
+export declare type FormProps = {
+    onSubmit?: React.FormEventHandler<HTMLFormElement>;
+};
+
+export declare type FormSlots = 'root';
+
+export declare function getThemeScript(defaultTheme?: ThemeProps): string;
+
+export declare const Grid: typeof Root_8 & {
+    Item: typeof Item_4;
+};
+
+export declare type GridCols = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+
+export declare type GridGap = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+export declare type GridItemProps = {
+    span?: GridItemSpan;
+};
+
+export declare type GridItemSlots = 'root';
+
+export declare type GridItemSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'full';
+
+export declare type GridProps = {
+    cols?: GridCols;
+    gap?: GridGap;
+};
+
+export declare type GridSlots = 'root';
+
+declare function Group({ items, value, defaultValue, disabled, variant, onChange, }: CheckboxGroupProps): JSX.Element;
+
+declare function Group_2({ children }: PropsWithChildren): JSX.Element;
+
+declare function Group_3({ items, variant, value, defaultValue, disabled, bordered, onChange, }: RadioGroupProps): JSX.Element;
+
+declare function Header({ bordered, children }: PropsWithChildren<CardHeaderProps>): JSX.Element;
+
+declare function Header_2({ bordered, closable, children, }: PropsWithChildren<SheetHeaderProps>): JSX.Element;
+
+export declare function HeaderCenter({ children }: PropsWithChildren): JSX.Element;
+
+export declare namespace HeaderCenter {
+    var displayName: string;
+}
+
+export declare type HeaderConfig = ComponentConfig<LayoutHeaderProps, LayoutHeaderSlots>;
+
+declare function HeaderDescription({ children, }: PropsWithChildren<ModalHeaderDescriptionProps>): JSX.Element;
+
+export declare function HeaderLeft({ children }: PropsWithChildren): JSX.Element;
+
+export declare namespace HeaderLeft {
+    var displayName: string;
+}
+
+export declare function HeaderRight({ children }: PropsWithChildren): JSX.Element;
+
+export declare namespace HeaderRight {
+    var displayName: string;
+}
+
+declare function HeaderRoot({ children, bordered, sticky, size, }: PropsWithChildren<LayoutHeaderProps>): JSX.Element;
+
+declare function HeaderRoot_2({ closable, bordered, children, }: PropsWithChildren<ModalHeaderProps>): JSX.Element;
+
+declare function HeaderTitle({ children }: PropsWithChildren<ModalHeaderTitleProps>): JSX.Element;
+
+declare type I18nTranslations = {
+    select?: {
+        empty?: string;
+        loadingMore?: string;
+    };
+    phoneInput?: {
+        searchCountry?: string;
+        noCountriesFound?: string;
+    };
+    currencyInput?: {
+        from?: string;
+        to?: string;
+        cancel?: string;
+        confirm?: string;
+        selectRange?: string;
+    };
+};
+
+declare function Icon({ children }: PropsWithChildren<AlertIconProps>): JSX.Element;
+
+export declare const Input: ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "type" | "onChange" | "defaultValue"> & {
+type?: InputType;
+value?: string | null;
+defaultValue?: string | null;
+size?: InputSize;
+rootClassName?: string;
+leftSection?: React.ReactNode;
+rightSection?: React.ReactNode;
+debounce?: boolean;
+block?: boolean;
+loading?: boolean;
+onChange?: (value: string | null) => void;
+} & RefAttributes<HTMLInputElement>>;
+
+export declare type InputConfig = ComponentConfig<InputProps, InputSlots>;
+
+export declare type InputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'size' | 'value' | 'defaultValue' | 'type'> & {
+    type?: InputType;
+    value?: string | null;
+    defaultValue?: string | null;
+    size?: InputSize;
+    rootClassName?: string;
+    leftSection?: React.ReactNode;
+    rightSection?: React.ReactNode;
+    debounce?: boolean;
+    block?: boolean;
+    loading?: boolean;
+    onChange?: (value: string | null) => void;
+};
+
+export declare type InputSize = 'sm' | 'md' | 'lg';
+
+export declare type InputSlots = 'root' | 'input' | 'leftSection' | 'rightSection' | 'loader';
+
+export declare type InputType = 'text' | 'password';
+
+declare function Item({ value, disabled, children }: PropsWithChildren<AccordionItem>): JSX.Element;
+
+declare function Item_2({ children }: PropsWithChildren<BreadcrumbItemProps>): JSX.Element;
+
+declare function Item_3({ variant, disabled, asChild, onClick, children, }: PropsWithChildren<DropdownMenuItemProps>): JSX.Element;
+
+declare function Item_4({ span, children }: PropsWithChildren<GridItemProps>): JSX.Element;
+
+export declare function Label({ htmlFor, required, optional, disabled, tooltip, children, }: PropsWithChildren<LabelProps>): JSX.Element;
+
+export declare type LabelProps = {
+    htmlFor?: string;
+    required?: boolean;
+    optional?: boolean;
+    disabled?: boolean;
+    tooltip?: React.ReactNode;
+};
+
+export declare type LabelSlots = 'root' | 'required' | 'optional';
+
+export declare const Layout: typeof LayoutRoot & {
+    Content: typeof LayoutContent;
+    Footer: typeof LayoutFooter;
+    Header: (({ children, bordered, sticky, size, }: PropsWithChildren<LayoutHeaderProps>) => JSX.Element) & {
+        Center: HeaderCenter;
+        Left: HeaderLeft;
+        Right: HeaderRight;
+    };
+    Main: typeof LayoutMain;
+    Nav: typeof LayoutNav;
+    Sidebar: (({ children, bordered, width, paddingHorizontal, paddingVertical, }: PropsWithChildren<LayoutSidebarProps>) => JSX.Element) & {
+        Body: SidebarBody;
+        Footer: SidebarFooter;
+        Header: SidebarHeader;
+        Trigger: SidebarTrigger;
+    };
+};
+
+export declare type LayoutConfig = {
+    default?: ComponentConfig<LayoutProps, LayoutSlots>;
+    main?: ComponentConfig<LayoutMainProps, LayoutMainSlots>;
+    content?: ComponentConfig<LayoutContentProps, LayoutContentSlots>;
+    footer?: ComponentConfig<LayoutFooterProps, LayoutFooterSlots>;
+};
+
+export declare function LayoutContent({ children, padding, paddingHorizontal, paddingVertical, maxWidth, }: PropsWithChildren<LayoutContentProps>): JSX.Element;
+
+export declare type LayoutContentProps = {
+    padding?: 'sm' | 'md' | 'lg';
+    paddingHorizontal?: 'sm' | 'md' | 'lg';
+    paddingVertical?: 'sm' | 'md' | 'lg';
+    maxWidth?: 'sm' | 'md' | 'lg';
+};
+
+export declare type LayoutContentSlots = 'root' | 'inner';
+
+export declare function LayoutFooter({ children, bordered, sticky, size, }: PropsWithChildren<LayoutFooterProps>): JSX.Element;
+
+export declare type LayoutFooterProps = {
+    bordered?: boolean;
+    sticky?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+};
+
+export declare type LayoutFooterSlots = 'root';
+
+export declare const LayoutHeader: typeof HeaderRoot & {
+    Center: typeof HeaderCenter;
+    Left: typeof HeaderLeft;
+    Right: typeof HeaderRight;
+};
+
+export declare type LayoutHeaderProps = {
+    bordered?: boolean;
+    sticky?: boolean;
+    size?: LayoutHeaderSize;
+};
+
+export declare type LayoutHeaderSize = 'sm' | 'md' | 'lg';
+
+export declare type LayoutHeaderSlots = 'root' | 'left' | 'center' | 'right';
+
+export declare function LayoutMain({ children }: PropsWithChildren<LayoutMainProps>): JSX.Element;
+
+export declare type LayoutMainProps = {};
+
+export declare type LayoutMainSlots = 'root';
+
+export declare function LayoutNav({ items }: NavProps): JSX.Element;
+
+export declare type LayoutProps = {};
+
+declare function LayoutRoot({ children }: PropsWithChildren<LayoutProps>): JSX.Element;
+
+export declare const LayoutSidebar: typeof SidebarRoot & {
+    Body: typeof SidebarBody;
+    Footer: typeof SidebarFooter;
+    Header: typeof SidebarHeader;
+    Trigger: typeof SidebarTrigger;
+};
+
+export declare type LayoutSidebarProps = {
+    bordered?: boolean;
+    width?: SidebarWidth;
+    paddingHorizontal?: SidebarPadding;
+    paddingVertical?: SidebarPadding;
+};
+
+export declare type LayoutSlots = 'root';
+
+declare function Link({ asChild, href, children, }: PropsWithChildren<BreadcrumbLinkProps>): JSX.Element;
+
+declare function List({ children }: PropsWithChildren<BreadcrumbListProps>): JSX.Element;
+
+declare function List_2({ children, justified }: PropsWithChildren<TabsListProps>): JSX.Element;
+
+export declare function Loader({ size }: LoaderProps): JSX.Element;
+
+export declare type LoaderConfig = ComponentConfig<LoaderProps, LoaderSlots>;
+
+export declare type LoaderProps = {
+    size?: LoaderSize;
+};
+
+export declare type LoaderSize = 'sm' | 'md' | 'lg';
+
+export declare type LoaderSlots = 'root';
+
+export declare function LoadingOverlay({ visible }: LoadingOverlayProps): JSX.Element;
+
+export declare type LoadingOverlayProps = {
+    visible?: boolean;
+};
+
+export declare type LoadingOverlaySlots = 'root' | 'loader';
+
+export declare const MaskInput: ForwardRefExoticComponent<Omit<InputProps, "type" | "onChange" | "debounce"> & {
+mask: string | string[];
+className?: string;
+onChange?: (value: string | null) => void;
+} & RefAttributes<HTMLInputElement>>;
+
+export declare type MaskInputConfig = ComponentConfig<MaskInputProps, MaskInputSlots>;
+
+export declare type MaskInputProps = Omit<InputProps, 'type' | 'onChange' | 'debounce'> & {
+    mask: string | string[];
+    className?: string;
+    onChange?: (value: string | null) => void;
+};
+
+export declare type MaskInputSlots = 'root' | 'input' | 'leftSection' | 'rightSection' | 'loader';
+
+declare function MenuLabel({ inset, children, }: PropsWithChildren<DropdownMenuLabelProps>): JSX.Element;
+
+export declare const Modal: typeof Root_9 & {
+    Body: typeof Body_2;
+    Close: ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & RefAttributes<HTMLButtonElement>>;
+    Content: typeof Content_5;
+    Footer: typeof Footer_2;
+    Header: typeof HeaderRoot_2 & {
+        Description: typeof HeaderDescription;
+        Title: typeof HeaderTitle;
+    };
+    Trigger: ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & RefAttributes<HTMLButtonElement>>;
+};
+
+export declare type ModalBodyProps = {};
+
+export declare type ModalBodySlots = 'root';
+
+export declare type ModalConfig = {
+    default?: ComponentConfig<ModalProps, ModalSlots>;
+    header?: ComponentConfig<ModalHeaderProps, ModalHeaderSlots>;
+    headerTitle?: ComponentConfig<ModalHeaderTitleProps, ModalHeaderTitleSlots>;
+    headerDescription?: ComponentConfig<ModalHeaderDescriptionProps, ModalHeaderDescriptionSlots>;
+    body?: ComponentConfig<ModalBodyProps, ModalBodySlots>;
+    footer?: ComponentConfig<ModalFooterProps, ModalFooterSlots>;
+};
+
+export declare type ModalFooterProps = {
+    bordered?: boolean;
+};
+
+export declare type ModalFooterSlots = 'root';
+
+export declare type ModalHeaderDescriptionProps = {};
+
+export declare type ModalHeaderDescriptionSlots = 'root';
+
+export declare type ModalHeaderProps = {
+    closable?: boolean;
+    bordered?: boolean;
+};
+
+export declare type ModalHeaderSlots = 'root' | 'title' | 'description';
+
+export declare type ModalHeaderTitleProps = {};
+
+export declare type ModalHeaderTitleSlots = 'root';
+
+export declare type ModalProps = {
+    open?: boolean;
+    onChange?: (open: boolean) => void;
+};
+
+export declare type ModalSlots = 'root' | 'overlay' | 'content' | 'close';
+
+declare type MultipleAccordionProps = {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+};
+
+declare type MultipleUploaderProps = {
+    onUpload?: (response: UploaderHandlerResponse[], index: number) => void;
+};
+
+export declare type NavProps = {
+    items: SidebarNavEntry[];
+};
+
+export declare const NumberInput: ForwardRefExoticComponent<NumberInputProps & RefAttributes<HTMLInputElement>>;
+
+export declare type NumberInputConfig = ComponentConfig<BaseNumberInputProps, NumberInputSlots>;
+
+export declare type NumberInputMode = 'single' | 'range';
+
+export declare type NumberInputProps = BaseNumberInputProps & (SingleNumberInputProps | RangeNumberInputProps);
+
+export declare type NumberInputRangeValue = {
+    from?: number;
+    to?: number;
+};
+
+export declare type NumberInputSingleValue = number;
+
+export declare type NumberInputSlots = 'root' | 'input' | 'increment' | 'decrement';
+
+declare type OffsetPaginationProps = {
+    mode: 'offset';
+    page: number;
+    rowsPerPage: number;
+    total: number;
+    onPageChange: (page: number) => void;
+    onRowsPerPageChange: (rowsPerPage: number) => void;
+};
+
+export declare function OTPInput({ pattern, size, value, defaultValue, onChange, }: OTPInputProps): JSX.Element;
+
+export declare type OTPInputConfig = ComponentConfig<OTPInputProps, OTPInputSlots>;
+
+export declare type OTPInputProps = {
+    pattern?: number[];
+    size?: OTPInputSize;
+    value?: string | null;
+    defaultValue?: string | null;
+    onChange?: (value: string | null) => void;
+};
+
+export declare type OTPInputSize = 'sm' | 'md' | 'lg';
+
+export declare type OTPInputSlots = 'root' | 'cell';
+
+declare function Page({ children }: PropsWithChildren<BreadcrumbPageProps>): JSX.Element;
+
+export declare function Pagination(props: PaginationProps): JSX.Element;
+
+export declare type PaginationConfig = ComponentConfig<PaginationProps, PaginationSlots>;
+
+export declare type PaginationProps = OffsetPaginationProps | CursorPaginationProps;
+
+export declare type PaginationSlots = 'root' | 'actions' | 'rowsPerPage';
+
+export declare const PhoneInput: ForwardRefExoticComponent<Omit<MaskInputProps, "value" | "mask" | "onChange" | "defaultValue" | "leftSection"> & {
+value?: PhoneValue | null;
+defaultValue?: PhoneValue | null;
+onChange?: (value: PhoneValue | null) => void;
+} & RefAttributes<HTMLInputElement>>;
+
+export declare type PhoneInputConfig = ComponentConfig<PhoneInputProps, PhoneInputSlots>;
+
+export declare type PhoneInputProps = Omit<MaskInputProps, 'value' | 'defaultValue' | 'mask' | 'onChange' | 'leftSection'> & {
+    value?: PhoneValue | null;
+    defaultValue?: PhoneValue | null;
+    onChange?: (value: PhoneValue | null) => void;
+};
+
+export declare type PhoneInputSlots = 'root' | 'input' | 'countrySelector' | 'rightSection' | 'loader';
+
+export declare type PhoneValue = {
+    iso: string;
+    number: string;
+    ddi?: string;
+};
+
+export declare function Popover({ content, side, sideOffset, align, children, }: PropsWithChildren<PopoverProps>): JSX.Element;
+
+export declare type PopoverAlign = 'start' | 'center' | 'end';
+
+export declare type PopoverProps = {
+    content: React.ReactNode;
+    side?: PopoverSide;
+    sideOffset?: number;
+    align?: PopoverAlign;
+};
+
+export declare type PopoverSide = 'top' | 'right' | 'bottom' | 'left';
+
+export declare type PopoverSlots = 'root' | 'trigger' | 'content';
+
+export declare function Progress({ label, value, defaultValue, size }: ProgressProps): JSX.Element;
+
+export declare type ProgressProps = WithLabelProps<{
+    value?: number;
+    defaultValue?: number;
+    size?: ProgressSize;
+}>;
+
+export declare type ProgressSize = 'sm' | 'md' | 'lg';
+
+export declare type ProgressSlots = 'root' | 'label';
+
+export declare function Provider({ children, defaultColorScheme, theme, ...props }: PropsWithChildren<ProviderProps>): JSX.Element;
+
+export declare type ProviderProps = {
+    defaultColorScheme?: ColorScheme;
+    theme?: ThemeProps;
+    translations?: I18nTranslations;
+    components?: {
+        accordion?: AccordionConfig;
+        alert?: AlertConfig;
+        avatar?: AvatarConfig;
+        badge?: BadgeConfig;
+        breadcrumb?: BreadcrumbConfig;
+        button?: ButtonConfig;
+        card?: CardConfig;
+        checkbox?: CheckboxConfig;
+        currencyInput?: CurrencyInputConfig;
+        dateInput?: DateInputConfig;
+        dateRangeInput?: DateRangeInputConfig;
+        documentInput?: DocumentInputConfig;
+        dropdownMenu?: DropdownMenuConfig;
+        form?: FormConfig;
+        input?: InputConfig;
+        loader?: LoaderConfig;
+        numberInput?: NumberInputConfig;
+        maskInput?: MaskInputConfig;
+        modal?: ModalConfig;
+        otpInput?: OTPInputConfig;
+        pagination?: PaginationConfig;
+        phoneInput?: PhoneInputConfig;
+        select?: SelectConfig;
+        separator?: SeparatorConfig;
+        sheet?: SheetConfig;
+        skeleton?: SkeletonConfig;
+        table?: TableConfig;
+        tabs?: TabsConfig;
+        tagsInput?: TagsInputConfig;
+        textarea?: TextareaConfig;
+        tooltip?: TooltipConfig;
+        layout?: LayoutConfig & {
+            sidebar?: SidebarConfig;
+            header?: HeaderConfig;
+        };
+    };
+};
+
+export declare const Radio: typeof Root_10 & {
+    Group: typeof Group_3;
+};
+
+declare function RadioGroup({ value, onValueChange, children, }: PropsWithChildren<DropdownMenuRadioGroupProps>): JSX.Element;
+
+export declare type RadioGroupProps = {
+    items: RadioItem[];
+    variant?: RadioGroupVariant;
+    value?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    bordered?: boolean;
+    onChange?: (value: string) => void;
+};
+
+export declare type RadioGroupSlots = 'root' | 'item';
+
+export declare type RadioGroupVariant = 'vertical' | 'horizontal';
+
+export declare type RadioItem = {
+    label: string;
+    value: string;
+    description?: string;
+    disabled?: boolean;
+};
+
+declare function RadioItem_2({ value, disabled, children, }: PropsWithChildren<DropdownMenuRadioItemProps>): JSX.Element;
+
+export declare type RadioProps = {
+    label?: string;
+    description?: string;
+    value?: string;
+    disabled?: boolean;
+    bordered?: boolean;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+};
+
+export declare type RadioSlots = 'root' | 'indicator' | 'label' | 'description';
+
+declare type RangeCurrencyInputProps = {
+    mode: 'range';
+    value?: CurrencyInputRangeValue;
+    defaultValue?: CurrencyInputRangeValue;
+    onChange?: (v: CurrencyInputRangeValue) => void;
+};
+
+declare type RangeNumberInputProps = {
+    mode: 'range';
+    value?: NumberInputRangeValue;
+    defaultValue?: NumberInputRangeValue;
+    onChange?: (value: NumberInputRangeValue) => void;
+};
+
+export declare function resolveTheme(theme: ThemeProps): Omit<ThemeProps, 'style'>;
+
+declare function Root({ children, onChange, ...props }: PropsWithChildren<AccordionProps>): JSX.Element;
+
+declare function Root_10({ label, description, value: radioValue, disabled, bordered, checked, defaultChecked, onChange, }: RadioProps): JSX.Element;
+
+declare function Root_11({ open, side, onChange, children, }: PropsWithChildren<SheetProps>): JSX.Element;
+
+declare function Root_12({ children, onChange, value, defaultValue, orientation, }: PropsWithChildren<TabsProps>): JSX.Element;
+
+declare function Root_2({ variant, closable, onClose, children, }: PropsWithChildren<AlertProps>): JSX.Element | null;
+
+declare function Root_3({ children }: PropsWithChildren<BreadcrumbProps>): JSX.Element;
+
+declare function Root_4({ onClick, children }: PropsWithChildren<CardProps>): JSX.Element;
+
+declare function Root_5({ label, description, value, size, disabled, bordered, checked, defaultChecked, onChange, }: CheckboxProps): JSX.Element;
+
+declare function Root_6({ open, onOpenChange, children, }: PropsWithChildren<DropdownMenuProps>): JSX.Element;
+
+declare function Root_7({ onSubmit, children }: PropsWithChildren<FormProps>): JSX.Element;
+
+declare function Root_8({ cols, gap, children }: PropsWithChildren<GridProps>): JSX.Element;
+
+declare function Root_9({ open, onChange, children }: PropsWithChildren<ModalProps>): JSX.Element;
+
+export declare const Select: <T, I = string, O = I>(props: SelectProps<T, I, O, "single"> | SelectProps<T, I, O, "multiple">) => JSX.Element;
+
+export declare type SelectConfig = ComponentConfig<object, SelectSlots>;
+
+export declare type SelectInfiniteProps = {
+    loadingMoreText?: string;
+    hasMore?: boolean;
+    loadingMore?: boolean;
+    onLoadMore?: () => void;
+};
+
+export declare type SelectMode = 'single' | 'multiple';
+
+export declare type SelectMultipleProps<T, I = string, O = I> = BaseSelectProps<T, O> & {
+    mode: 'multiple';
+    value?: I[];
+    defaultValue?: I[];
+    onChange?: (value: O[]) => void;
+};
+
+export declare type SelectProps<T, I = string, O = I, K extends SelectMode = SelectMode> = K extends 'single' ? SelectSingleProps<T, I, O> : K extends 'multiple' ? SelectMultipleProps<T, I, O> : never;
+
+export declare type SelectSingleProps<T, I = string, O = I> = BaseSelectProps<T, O> & {
+    mode: 'single';
+    value?: I | null;
+    defaultValue?: I | null;
+    onChange?: (value: O | null) => void;
+};
+
+export declare type SelectSize = 'sm' | 'md' | 'lg';
+
+export declare type SelectSlots = 'root' | 'content' | 'option' | 'value' | 'search' | 'empty' | 'loader' | 'leftSection' | 'rightSection';
+
+export declare function Separator({ orientation, decorative }: SeparatorProps): JSX.Element;
+
+declare function Separator_2({ children }: PropsWithChildren<BreadcrumbSeparatorProps>): JSX.Element;
+
+declare function Separator_3({ children }: PropsWithChildren<CardSeparatorProps>): JSX.Element;
+
+declare function Separator_4(): JSX.Element;
+
+export declare type SeparatorConfig = ComponentConfig<SeparatorProps, SeparatorSlots>;
+
+export declare type SeparatorOrientation = 'horizontal' | 'vertical';
+
+export declare type SeparatorProps = {
+    orientation?: SeparatorOrientation;
+    decorative?: boolean;
+};
+
+export declare type SeparatorSlots = 'root';
+
+export declare const Sheet: typeof Root_11 & {
+    Body: typeof Body_3;
+    Close: ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & RefAttributes<HTMLButtonElement>>;
+    Description: typeof Description_3;
+    Footer: typeof Footer_3;
+    Header: typeof Header_2;
+    Title: typeof Title_3;
+    Trigger: ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & RefAttributes<HTMLButtonElement>>;
+};
+
+export declare type SheetBodyProps = {};
+
+export declare type SheetBodySlots = 'root';
+
+export declare type SheetConfig = {
+    default?: ComponentConfig<SheetProps, SheetSlots>;
+    header?: ComponentConfig<SheetHeaderProps, SheetHeaderSlots>;
+    body?: ComponentConfig<SheetBodyProps, SheetBodySlots>;
+    footer?: ComponentConfig<SheetFooterProps, SheetFooterSlots>;
+    title?: ComponentConfig<SheetTitleProps, SheetTitleSlots>;
+    description?: ComponentConfig<SheetDescriptionProps, SheetDescriptionSlots>;
+};
+
+export declare type SheetDescriptionProps = {};
+
+export declare type SheetDescriptionSlots = 'root';
+
+export declare type SheetFooterProps = {
+    bordered?: boolean;
+};
+
+export declare type SheetFooterSlots = 'root';
+
+export declare type SheetHeaderProps = {
+    closable?: boolean;
+    bordered?: boolean;
+};
+
+export declare type SheetHeaderSlots = 'root';
+
+export declare type SheetProps = {
+    open?: boolean;
+    side?: SheetSide;
+    onChange?: (open: boolean) => void;
+};
+
+export declare type SheetSide = 'top' | 'right' | 'bottom' | 'left';
+
+export declare type SheetSlots = 'root' | 'overlay' | 'content' | 'close';
+
+export declare type SheetTitleProps = {};
+
+export declare type SheetTitleSlots = 'root';
+
+declare function Shortcut({ children }: PropsWithChildren): JSX.Element;
+
+export declare function SidebarBody({ children }: PropsWithChildren<SidebarBodyProps>): JSX.Element;
+
+export declare namespace SidebarBody {
+    var displayName: string;
+}
+
+export declare type SidebarBodyProps = {};
+
+export declare type SidebarBodySlots = 'root';
+
+export declare type SidebarConfig = {
+    default?: ComponentConfig<LayoutSidebarProps, SidebarSlots>;
+    header?: ComponentConfig<SidebarHeaderProps, SidebarHeaderSlots>;
+    body?: ComponentConfig<SidebarBodyProps, SidebarBodySlots>;
+    footer?: ComponentConfig<SidebarFooterProps, SidebarFooterSlots>;
+};
+
+declare type SidebarContextValue = {
+    collapsed: boolean;
+    setCollapsed: (v: boolean) => void;
+    toggle: () => void;
+};
+
+export declare function SidebarFooter({ children, bordered, size, }: PropsWithChildren<SidebarFooterProps>): JSX.Element;
+
+export declare namespace SidebarFooter {
+    var displayName: string;
+}
+
+export declare type SidebarFooterProps = {
+    bordered?: boolean;
+    size?: SidebarSize;
+};
+
+export declare type SidebarFooterSlots = 'root';
+
+export declare function SidebarHeader({ children, bordered, size, }: PropsWithChildren<SidebarHeaderProps>): JSX.Element;
+
+export declare namespace SidebarHeader {
+    var displayName: string;
+}
+
+export declare type SidebarHeaderProps = {
+    bordered?: boolean;
+    size?: SidebarSize;
+};
+
+export declare type SidebarHeaderSlots = 'root';
+
+export declare type SidebarNavEntry = {
+    type: 'item';
+    item: SidebarNavItem;
+} | {
+    type: 'divider';
+};
+
+export declare interface SidebarNavItem {
+    label: string;
+    icon?: LucideIcon;
+    href?: string;
+    active?: boolean;
+    children?: SidebarNavSubItem[];
+}
+
+export declare interface SidebarNavSubItem {
+    label: string;
+    icon?: LucideIcon;
+    href?: string;
+    active?: boolean;
+}
+
+export declare type SidebarPadding = 'sm' | 'md' | 'lg';
+
+declare function SidebarRoot({ children, bordered, width, paddingHorizontal, paddingVertical, }: PropsWithChildren<LayoutSidebarProps>): JSX.Element;
+
+export declare type SidebarSize = 'sm' | 'md' | 'lg';
+
+export declare type SidebarSlots = 'root';
+
+export declare function SidebarTrigger(): JSX.Element;
+
+export declare namespace SidebarTrigger {
+    var displayName: string;
+}
+
+export declare type SidebarTriggerSlots = 'root';
+
+export declare type SidebarWidth = 'default' | 'wide';
+
+declare type SingleAccordionProps = {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    collapsible?: boolean;
+    onChange?: (value: string) => void;
+};
+
+declare type SingleCurrencyInputProps = {
+    mode?: 'single';
+    value?: number | null;
+    defaultValue?: number | null;
+    onChange?: (value: number | null) => void;
+};
+
+declare type SingleNumberInputProps = {
+    mode: 'single';
+    value?: NumberInputSingleValue;
+    defaultValue?: NumberInputSingleValue;
+    onChange?: (value: NumberInputSingleValue) => void;
+};
+
+declare type SingleUploaderProps = {
+    onUpload?: (response: UploaderHandlerResponse, index: number) => void;
+};
+
+export declare function Skeleton({ children, className, }: PropsWithChildren<SkeletonProps>): JSX.Element;
+
+export declare type SkeletonConfig = ComponentConfig<SkeletonProps, SkeletonSlots>;
+
+export declare type SkeletonProps = {
+    className?: string;
+};
+
+export declare type SkeletonSlots = 'root';
+
+export declare function Slider(props: SliderProps): JSX.Element;
+
+export declare type SliderOrientation = 'horizontal' | 'vertical';
+
+export declare type SliderProps = BaseSliderProps & (SliderSingleProps | SliderRangeProps);
+
+declare type SliderRangeProps = {
+    mode: 'range';
+    value?: [
+    number,
+    number
+    ];
+    defaultValue?: [
+    number,
+    number
+    ];
+    onValueChange?: (value: [
+    number,
+    number
+    ]) => void;
+};
+
+declare type SliderSingleProps = {
+    mode: 'single';
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+};
+
+export declare type SliderSize = 'sm' | 'md' | 'lg';
+
+export declare type SliderSlots = 'root';
+
+export declare const styles: TVReturnType<    {
+block: {
+true: string;
+};
+size: {
+'icon-lg': string;
+'icon-md': string;
+'icon-sm': string;
+lg: string;
+md: string;
+sm: string;
+};
+variant: {
+dashed: string;
+default: string;
+destructive: string;
+ghost: string;
+link: string;
+outline: string;
+secondary: string;
+};
+}, undefined, "t:relative t:inline-flex t:cursor-pointer t:items-center t:justify-center t:gap-2 t:whitespace-nowrap t:rounded-md t:font-medium t:text-sm t:ring-offset-background t:transition-colors t:focus-visible:outline-none t:focus-visible:ring-2 t:focus-visible:ring-ring t:focus-visible:ring-offset-2 t:disabled:pointer-events-none t:disabled:opacity-50 t:[&_svg]:pointer-events-none t:[&_svg]:size-4 t:[&_svg]:shrink-0", {
+block: {
+true: string;
+};
+size: {
+'icon-lg': string;
+'icon-md': string;
+'icon-sm': string;
+lg: string;
+md: string;
+sm: string;
+};
+variant: {
+dashed: string;
+default: string;
+destructive: string;
+ghost: string;
+link: string;
+outline: string;
+secondary: string;
+};
+}, undefined, TVReturnType<    {
+block: {
+true: string;
+};
+size: {
+'icon-lg': string;
+'icon-md': string;
+'icon-sm': string;
+lg: string;
+md: string;
+sm: string;
+};
+variant: {
+dashed: string;
+default: string;
+destructive: string;
+ghost: string;
+link: string;
+outline: string;
+secondary: string;
+};
+}, undefined, "t:relative t:inline-flex t:cursor-pointer t:items-center t:justify-center t:gap-2 t:whitespace-nowrap t:rounded-md t:font-medium t:text-sm t:ring-offset-background t:transition-colors t:focus-visible:outline-none t:focus-visible:ring-2 t:focus-visible:ring-ring t:focus-visible:ring-offset-2 t:disabled:pointer-events-none t:disabled:opacity-50 t:[&_svg]:pointer-events-none t:[&_svg]:size-4 t:[&_svg]:shrink-0", unknown, unknown, undefined>>;
+
+declare function Sub({ children }: PropsWithChildren): JSX.Element;
+
+declare function SubContent({ children }: PropsWithChildren): JSX.Element;
+
+declare function SubTrigger({ inset, children, }: PropsWithChildren<DropdownMenuSubTriggerProps>): JSX.Element;
+
+export declare function Switch({ label, value, size, description, checked, defaultChecked, disabled, bordered, onCheckedChange, }: SwitchProps): JSX.Element;
+
+export declare type SwitchProps = WithLabelProps<{
+    value?: string;
+    size?: SwitchSize;
+    description?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    bordered?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}>;
+
+export declare type SwitchSize = 'sm' | 'md' | 'lg';
+
+export declare type SwitchSlots = 'root' | 'thumb' | 'label';
+
+export declare function Table<T extends object>({ columns, items, itemKey, selection, selectedKeys: selectedKeysProp, defaultSelectedKeys, pagination, sort, hidePagination, loading, emptySection, onRowClick, onSelectionChange, onSortChange, }: TableProps<T>): JSX.Element;
+
+export declare type TableColumnAlign = 'left' | 'center' | 'right';
+
+export declare type TableColumns<T> = Array<{
+    key: string;
+    label?: string;
+    selector?: (row: T, index: number) => React.ReactNode;
+    align?: TableColumnAlign;
+    width?: number;
+    sorter?: boolean;
+    hide?: boolean;
+}>;
+
+export declare type TableConfig = ComponentConfig<object, TableSlots>;
+
+export declare type TableItems<T> = Array<T>;
+
+export declare type TableProps<T> = {
+    columns: TableColumns<T>;
+    items?: TableItems<T>;
+    itemKey: keyof T;
+    selection?: TableSelection;
+    selectedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    pagination?: PaginationProps;
+    sort?: string;
+    hidePagination?: boolean;
+    loading?: boolean;
+    emptySection?: React.ReactNode;
+    onRowClick?: (row: T) => void;
+    onSelectionChange?: (value: string[]) => void;
+    onSortChange?: (sort?: string) => void;
+};
+
+export declare type TableSelection = 'none' | 'multiple';
+
+export declare type TableSlots = 'root' | 'header' | 'headerCell' | 'body' | 'row' | 'cell' | 'empty' | 'loader' | 'selection';
+
+export declare const Tabs: typeof Root_12 & {
+    Content: typeof Content_6;
+    List: typeof List_2;
+    Trigger: typeof Trigger_3;
+};
+
+export declare type TabsConfig = {
+    default?: ComponentConfig<TabsProps, TabsSlots>;
+    list?: ComponentConfig<TabsListProps, TabsListSlots>;
+    trigger?: ComponentConfig<TabsTriggerProps, TabsTriggerSlots>;
+    content?: ComponentConfig<TabsContentProps, TabsContentSlots>;
+};
+
+export declare type TabsContentProps = {
+    value: string;
+};
+
+export declare type TabsContentSlots = 'root';
+
+export declare type TabsListProps = {
+    justified?: boolean;
+};
+
+export declare type TabsListSlots = 'root';
+
+export declare type TabsOrientation = 'horizontal' | 'vertical';
+
+export declare type TabsProps = {
+    orientation?: TabsOrientation;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+};
+
+export declare type TabsSlots = 'root';
+
+export declare type TabsTriggerProps = {
+    value: string;
+    icon?: React.ReactNode;
+};
+
+export declare type TabsTriggerSlots = 'root';
+
+export declare const TagsInput: ForwardRefExoticComponent<Omit<InputProps, "value" | "onChange" | "defaultValue"> & {
+value?: string[];
+defaultValue?: string[];
+maxTags?: number;
+allowDuplicates?: boolean;
+onChange?: (value: string[]) => void;
+} & RefAttributes<HTMLInputElement>>;
+
+export declare type TagsInputConfig = ComponentConfig<TagsInputProps, TagsInputSlots>;
+
+export declare type TagsInputProps = Omit<InputProps, 'value' | 'defaultValue' | 'onChange'> & {
+    value?: string[];
+    defaultValue?: string[];
+    maxTags?: number;
+    allowDuplicates?: boolean;
+    onChange?: (value: string[]) => void;
+};
+
+export declare type TagsInputSlots = 'root' | 'input' | 'tag' | 'tagRemove';
+
+export declare const Textarea: ForwardRefExoticComponent<Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size" | "value" | "onChange" | "defaultValue"> & {
+value?: string | null;
+defaultValue?: string | null;
+size?: InputSize;
+rootClassName?: string;
+leftSection?: React.ReactNode;
+rightSection?: React.ReactNode;
+block?: boolean;
+onChange?: (value: string | null) => void;
+maxLength?: number;
+} & RefAttributes<HTMLTextAreaElement>>;
+
+export declare type TextareaConfig = ComponentConfig<TextareaProps, TextareaSlots>;
+
+export declare type TextareaProps = Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange' | 'size' | 'value' | 'defaultValue'> & {
+    value?: string | null;
+    defaultValue?: string | null;
+    size?: InputSize;
+    rootClassName?: string;
+    leftSection?: React.ReactNode;
+    rightSection?: React.ReactNode;
+    block?: boolean;
+    onChange?: (value: string | null) => void;
+    maxLength?: number;
+};
+
+export declare type TextareaSlots = 'root' | 'counter';
+
+export declare type ThemeBaseColor = 'neutral' | 'stone' | 'zinc' | 'gray';
+
+declare type ThemeContextValue = {
+    theme: ThemeProps;
+    changeTheme: (theme: Partial<ThemeProps>) => void;
+};
+
+export declare type ThemeFont = 'sans' | 'serif' | 'mono';
+
+export declare type ThemePrimaryColor = 'cyan' | 'green' | 'orange' | 'pink' | 'yellow' | 'purple' | 'red' | 'blue' | 'indigo' | 'violet' | 'fuchsia' | 'rose';
+
+export declare type ThemeProps = {
+    style?: ThemeStyle;
+    baseColor?: ThemeBaseColor;
+    primaryColor?: ThemePrimaryColor;
+    font?: ThemeFont;
+    radius?: ThemeRadius;
+};
+
+export declare type ThemeRadius = 'none' | 'lg' | 'md' | 'sm';
+
+export declare type ThemeStyle = 'vega' | 'nova' | 'maia' | 'lyra' | 'mira';
+
+declare function Title({ children }: PropsWithChildren<AlertTitleProps>): JSX.Element;
+
+declare function Title_2({ children }: PropsWithChildren<CardTitleProps>): JSX.Element;
+
+declare function Title_3({ children }: PropsWithChildren<SheetTitleProps>): JSX.Element;
+
+export { toast }
+
+export declare function ToastContainer({ theme, ...props }: ToasterProps): JSX.Element;
+
+declare type ToasterProps = React.ComponentProps<typeof Toaster>;
+
+export declare type ToastProps = {};
+
+export declare type ToastSlots = 'root' | 'title' | 'description' | 'action' | 'close';
+
+export declare function Tooltip({ content, side, sideOffset, delayDuration, children, }: PropsWithChildren<TooltipProps>): JSX.Element;
+
+export declare type TooltipConfig = ComponentConfig<TooltipProps, TooltipSlots>;
+
+export declare type TooltipProps = {
+    content: React.ReactNode;
+    side?: TooltipSide;
+    sideOffset?: number;
+    delayDuration?: number;
+};
+
+export declare type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
+
+export declare type TooltipSlots = 'root' | 'content';
+
+declare function Trigger({ children }: PropsWithChildren<AccordionTrigger>): JSX.Element;
+
+declare function Trigger_2({ asChild, children, }: PropsWithChildren<{
+    asChild?: boolean;
+}>): JSX.Element;
+
+declare function Trigger_3({ value, children }: PropsWithChildren<TabsTriggerProps>): JSX.Element;
+
+export declare function Typography({ component, size, variant, weight, truncate, children, }: PropsWithChildren<TypographyProps>): JSX.Element;
+
+export declare type TypographyComponent = 'span' | 'p' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'div';
+
+export declare type TypographyProps = {
+    component?: TypographyComponent;
+    size?: TypographySize;
+    variant?: TypographyVariant;
+    weight?: TypographyWeight;
+    truncate?: boolean;
+};
+
+export declare type TypographySize = 'xs' | 'sm' | 'base' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl' | '7xl' | '8xl' | '9xl';
+
+export declare type TypographySlots = 'root';
+
+export declare type TypographyVariant = 'default' | 'muted';
+
+export declare type TypographyWeight = 'thin' | 'extralight' | 'light' | 'normal' | 'medium' | 'semibold' | 'bold' | 'extrabold' | 'black';
+
+export declare function Uploader({ accept, maxFiles, maxFileSize, disabled, handler, onUpload, }: UploaderProps): JSX.Element;
+
+export declare type UploaderHandlerResponse = {
+    fileName: string;
+    fileNameSigned: string;
+};
+
+export declare type UploaderProps = BaseUploaderProps & (SingleUploaderProps | MultipleUploaderProps);
+
+export declare type UploaderSlots = 'root' | 'fileList' | 'fileItem' | 'fileName' | 'progress' | 'remove' | 'icon';
+
+export declare const useColorScheme: () => ColorSchemeContextValue;
+
+export declare function useSidebar(): SidebarContextValue;
+
+export declare const useTheme: () => ThemeContextValue;
+
+export declare type WithLabelProps<T> = T & {
+    label?: string | (LabelProps & {
+        content?: string;
+    });
 };
 
 export { }