import * as React$1 from 'react';
import React__default, { ChangeEventHandler, ReactNode, FC, MutableRefObject, ComponentType, ErrorInfo, ReactElement } from 'react';
import * as AccordionPrimitive from '@radix-ui/react-accordion';
import * as class_variance_authority_types from 'class-variance-authority/types';
import { ComponentWithAs, HTMLTailwindStyledComponentProps, OptionType } from '@paalan/react-shared/types';
import { VariantProps } from 'class-variance-authority';
import { B as BoxProps, H as HeadingProps, T as TextProps } from '../Text-DNZ3-pK9.js';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import { AllColorVariant, ColorVariant } from '@paalan/react-shared/system';
import { DayPicker, DayPickerBase, DateRange } from 'react-day-picker';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import * as _radix_ui_react_dialog from '@radix-ui/react-dialog';
import { DialogProps as DialogProps$1 } from '@radix-ui/react-dialog';
import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
import { Table as Table$1, Column, ColumnDef, Row, SortingState, Cell, Header } from '@tanstack/react-table';
import z from 'zod';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import { DropdownMenuProps as DropdownMenuProps$1 } from '@radix-ui/react-dropdown-menu';
import { ErrorBoundaryProps as ErrorBoundaryProps$1 } from 'react-error-boundary';
import * as axios from 'axios';
import { HttpError } from '@paalan/react-shared/lib';
import * as react_hook_form from 'react-hook-form';
import { FieldValues, Path, ControllerRenderProps, UseFormReturn, SubmitHandler, SubmitErrorHandler, UseFormReset, FieldPath, ControllerProps } from 'react-hook-form';
import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as _radix_ui_react_slot from '@radix-ui/react-slot';
import * as LabelPrimitive from '@radix-ui/react-label';
import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
import * as input_otp from 'input-otp';
import { LoadingIcon } from '@paalan/react-icons';
import * as _radix_ui_react_context from '@radix-ui/react-context';
import * as MenubarPrimitive from '@radix-ui/react-menubar';
import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
import { UsePaginationParams } from '@paalan/react-hooks';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as ProgressPrimitive from '@radix-ui/react-progress';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import * as SliderPrimitive from '@radix-ui/react-slider';
import * as SwitchPrimitives from '@radix-ui/react-switch';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import * as TogglePrimitive from '@radix-ui/react-toggle';
import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import * as recharts_types_util_payload_getUniqPayload from 'recharts/types/util/payload/getUniqPayload';
import * as recharts_types_component_Tooltip from 'recharts/types/component/Tooltip';
import * as recharts_types_util_types from 'recharts/types/util/types';
import * as recharts_types_component_DefaultTooltipContent from 'recharts/types/component/DefaultTooltipContent';
import * as RechartsPrimitive from 'recharts';
import { Drawer as Drawer$1 } from 'vaul';
import { LucideIcon } from 'lucide-react';

declare const AccordionRoot: React$1.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React$1.RefAttributes<HTMLDivElement>>;
declare const AccordionTrigger: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const AccordionContent: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const AccordionItem: React$1.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
/**
 * Represents an item in the Accordion component.
 */
interface AccordionItem {
    /** The value associated with the Accordion item. */
    value: string;
    /** The title of the Accordion item. */
    title: React$1.ReactNode;
    /** The content of the Accordion item. */
    content: React$1.ReactNode;
}
/**
 * Props for the Accordion component.
 */
type AccordionProps = React$1.ComponentProps<typeof AccordionRoot> & {
    /** The items to render in the Accordion. */
    items: AccordionItem[];
    /**
     * The type of Accordion. Defaults to `single`.
     * @default 'single'
     */
    type: 'single' | 'multiple';
    /**
     * Whether an accordion item can be collapsed after it has been opened.
     * @default false
     */
    collapsible?: boolean;
};
/**
 * Renders an accordion component with the given items.
 */
declare const Accordion: React$1.FC<AccordionProps>;

declare const AlertRoot: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
    colorVariant?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | "default" | null | undefined;
    softBackground?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | null | undefined;
    solidBackground?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string> & BoxProps & React$1.RefAttributes<HTMLDivElement>>;
declare const AlertTitle: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLHeadingElement> & BoxProps & React$1.RefAttributes<HTMLParagraphElement>>;
declare const AlertDescription: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLParagraphElement> & BoxProps & React$1.RefAttributes<HTMLParagraphElement>>;
interface AlertProps extends Omit<React$1.ComponentPropsWithoutRef<typeof AlertRoot>, 'children'> {
    /** Title for the alert */
    title?: string;
    /** Description for the alert */
    description?: string;
    /**
     * Icon for the alert
     */
    icon?: React$1.ReactNode;
    /**
     * Whether the alert is dismissible or not
     */
    dismissible?: boolean;
    /** onDismiss functions call when the alert is dismissed */
    onDismiss?: () => void;
}
/**
 * Alerts are used to communicate a state that affects a system, feature, or page.
 */
declare const Alert: ComponentWithAs<'div', AlertProps>;

declare const AlertDialogRoot: React$1.FC<AlertDialogPrimitive.AlertDialogProps>;
declare const AlertDialogTrigger: React$1.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
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_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const AlertDialogFooter: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.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"> & VariantProps<(props?: ({
    variant?: "primary" | "secondary" | "info" | "success" | "warning" | "danger" | "default" | "outline" | "ghost" | null | undefined;
    rounded?: "none" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | null | undefined;
    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
declare const AlertDialogCancel: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
    variant?: "primary" | "secondary" | "info" | "success" | "warning" | "danger" | "default" | "outline" | "ghost" | null | undefined;
    rounded?: "none" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | null | undefined;
    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;
interface AlertDialogProps extends React$1.ComponentPropsWithoutRef<typeof AlertDialogRoot> {
    /**
     * The trigger element. Must be a `Button` or `IconButton`.
     */
    trigger?: React$1.ReactNode;
    /**
     * The icon of the alert dialog.
     */
    icon?: React$1.ReactNode;
    /**
     * The class name for the icon.
     */
    iconClassName?: string;
    /**
     * The header of the alert dialog.
     */
    header?: {
        /**
         * The title of the alert dialog.
         */
        title?: React$1.ReactNode;
        /**
         * The description of the alert dialog.
         */
        description?: React$1.ReactNode;
        /**
         * The class name for the header.
         */
        className?: string;
    };
    /**
     * The footer class name.
     */
    footerClassName?: string;
    /**
     * The cancel button text.
     */
    cancelButtonText?: string;
    /**
     * The confirm button text.
     */
    confirmButtonText?: string;
    /**
     * The cancel button click handler.
     */
    onCancel?: (e: React$1.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * The confirm button click handler.
     */
    onConfirm?: (e: React$1.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * The props for the cancel button.
     */
    cancelButtonProps?: React$1.ComponentPropsWithoutRef<typeof AlertDialogCancel>;
    /**
     * The props for the confirm button.
     */
    confirmButtonProps?: React$1.ComponentPropsWithoutRef<typeof AlertDialogAction>;
}
declare const AlertDialog: React$1.FC<AlertDialogProps>;

declare const AspectRatio: React$1.ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & React$1.RefAttributes<HTMLDivElement>>;

declare const AvatarRoot: 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>>;
interface AvatarProps extends Omit<React$1.ComponentPropsWithoutRef<typeof AvatarRoot>, 'children'> {
    /**
     * The image source to use for the avatar.
     */
    src?: string;
    /**
     * The fallback content to use when the `src` is not available.
     */
    fallback?: React$1.ReactNode;
    /**
     * The alternate text to use for the avatar image.
     */
    alt?: string;
    /**
     * Props to pass to the `AvatarImage` component.
     */
    avatarImageProps?: React$1.ComponentPropsWithoutRef<typeof AvatarImage>;
    /**
     * Props to pass to the `AvatarFallback` component.
     */
    avatarFallbackProps?: React$1.ComponentPropsWithoutRef<typeof AvatarFallback>;
}
declare const Avatar: React$1.ForwardRefExoticComponent<AvatarProps & React$1.RefAttributes<HTMLSpanElement>>;

interface InputProps extends HTMLTailwindStyledComponentProps<'input'> {
    /**
     * whether the input is invalid
     */
    isInvalid?: boolean;
    /**
     * label for the input
     */
    label?: string;
    /**
     * inline input or not
     */
    inline?: boolean;
    /**
     * input class name for styling
     */
    inputClassName?: string;
    /**
     * Optional value change handler for the number input
     */
    onValueChange?: (value: string) => void;
    /**
     * The error message for the checkbox
     */
    errorMessage?: string;
    /**
     * max length of the input
     */
    maxLength?: number;
}
declare const Input: ComponentWithAs<'input', InputProps>;

interface AvatarUploadProps {
    /**
     * The src of the avatar image.
     */
    src: string;
    /**
     * onChange event handler for the input element.
     */
    onChange?: ChangeEventHandler<HTMLInputElement>;
    /**
     * If defined, this function will be called when the user selects a new avatar image.
     * @param file file object
     * @param blobUrl blob url of the file
     */
    onAvatarChange?: (file: File, blobUrl: string) => void;
    /**
     * If `true`, the component will be in a loading state.
     */
    isLoading?: boolean;
    /**
     * The class name to apply to the root element.
     */
    className?: string;
    /**
     * The class name to apply to the loading element.
     */
    loadingClassName?: string;
    /**
     * The element to use as the avatar image.
     * @example <Image src="https://bit.ly/uchiha-itachi" width={160} height={160} />
     */
    avatarImage?: ReactNode;
    /**
     * The element to use as the fallback icon.
     * @example <User2Icon className="size-1/2" />
     */
    avatarFallbackIcon?: ReactNode;
    /**
     * The props to apply to the input element.
     */
    inputProps?: InputProps;
}

declare const AvatarUpload: React$1.ForwardRefExoticComponent<AvatarUploadProps & React$1.RefAttributes<HTMLInputElement>>;

declare const badgeVariants: (props?: ({
    variant?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | "outline" | null | undefined;
    size?: "sm" | "md" | "lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface BadgeProps extends VariantProps<typeof badgeVariants>, Omit<BoxProps, 'size'> {
    /**
     * Optional label for the badge
     */
    label?: string;
}
/**
 *  Displays a badge or a component that looks like a badge.
 */
declare const Badge: ComponentWithAs<'div', BadgeProps>;

declare const BUTTON_VARIANTS: readonly ["solid", "surface", "outline", "soft", "ghost", "link"];
type ButtonVariant = (typeof BUTTON_VARIANTS)[number];

declare const buttonVariants: (props?: ({
    variant?: "primary" | "secondary" | "info" | "success" | "warning" | "danger" | "default" | "outline" | "ghost" | null | undefined;
    rounded?: "none" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | null | undefined;
    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface ButtonProps extends Omit<BoxProps, 'size' | 'rounded'>, Omit<VariantProps<typeof buttonVariants>, 'variant'> {
    asChild?: boolean;
    /**
     * Optional click handler
     */
    onClick?: (e: React$1.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
    /**
     * Optional label for the button
     */
    label?: string;
    /**
     * Optional variant for the button (solid, outline, ghost, soft, link).
     * @default solid
     */
    variant?: ButtonVariant;
    /**
     * Optional color for the button,
     * @default primary
     */
    color?: AllColorVariant;
    /**
     * Optional left icon for the button
     */
    leftIcon?: React$1.ReactNode;
    /**
     * Optional right icon for the button
     */
    rightIcon?: React$1.ReactNode;
    /**
     * Optional loading for the button
     */
    isLoading?: boolean;
    /**
     * Optional loading text for the button
     */
    loadingText?: React$1.ReactNode;
    /**
     * Optional wrapper class name for the button and icons (if any)
     */
    wrapperClassName?: string;
    /**
     * Optional unstyled button
     */
    unstyled?: boolean;
}
/**
 * Primary UI component for user interaction
 */
declare const Button: ComponentWithAs<'button', ButtonProps>;

type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
declare const Calendar: React$1.FC<CalendarProps>;

type OmitColorFromHTMLAttributes = Omit<React$1.HTMLAttributes<HTMLDivElement>, 'color'>;
type OmitColorAndChildrenFromHTMLAttributes = Omit<React$1.HTMLAttributes<HTMLParagraphElement>, 'children' | 'color'>;
declare const CardRoot: ComponentWithAs<'div', OmitColorFromHTMLAttributes>;
declare const CardHeader: ComponentWithAs<'div', OmitColorFromHTMLAttributes>;
declare const CardTitle: ComponentWithAs<'h3', HeadingProps>;
declare const CardDescription: ComponentWithAs<'p', OmitColorAndChildrenFromHTMLAttributes>;
declare const CardContent: ComponentWithAs<'div', OmitColorFromHTMLAttributes>;
declare const CardFooter: ComponentWithAs<'div', OmitColorFromHTMLAttributes>;
type CardCustomHeaderProps = {
    /**
     * Optional title for the card header
     */
    title: React$1.ReactNode;
    /**
     * Optional class name for the card header title
     */
    titleClassName?: string;
    /**
     * Optional description for the card header
     */
    description?: React$1.ReactNode;
    /**
     * Optional class name for the card header description
     */
    descriptionClassName?: string;
};
type CardProps = React$1.ComponentPropsWithoutRef<typeof CardRoot> & {
    /**
     * content for the card
     */
    children: React$1.ReactNode;
    /**
     * Optional header for the card
     */
    header?: CardCustomHeaderProps | React$1.ReactNode;
    /**
     * Optional class name for the card header
     */
    headerClassName?: string;
    /**
     * Optional class name for the card content
     */
    contentClassName?: string;
    /**
     * Optional footer for the card
     */
    footer?: React$1.ReactNode;
    /**
     * Optional class name for the card footer
     */
    footerClassName?: string;
};
declare const Card: ComponentWithAs<'div', CardProps>;

declare const checkboxVariants: (props?: ({
    variant?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | "accent" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare const CheckboxRoot: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
    variant?: CheckboxProps['variant'];
    indeterminate?: boolean | undefined;
} & React$1.RefAttributes<HTMLButtonElement>>;
interface CheckboxProps extends React$1.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root> {
    /** Label for the checkbox */
    label?: React$1.ReactNode;
    /** Whether the checkbox is checked or not */
    checked?: boolean;
    /** Whether the checkbox is disabled or not */
    disabled?: boolean;
    /** Callback when the checkbox value changes */
    onCheckedChange?: (checked: boolean) => void;
    /** Variant of the checkbox */
    variant?: VariantProps<typeof checkboxVariants>['variant'];
    /**
     * Whether the checkbox is swapped to the right or not
     */
    swapRight?: boolean;
    /**
     * The class name for the checkbox label
     */
    labelClassName?: string;
    /**
     * Whether the checkbox is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the checkbox is invalid
     */
    isInvalid?: boolean;
    /**
     * The error message for the checkbox
     */
    errorMessage?: string;
    /**
     * Whether the checkbox is indeterminate or not
     */
    indeterminate?: boolean;
    /**
     * The class name for the checkbox root container
     */
    rootClassName?: string;
}
declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLButtonElement>>;

interface CheckboxGroupProps {
    /** options for the checkbox group */
    options: Array<OptionType | string | number>;
    /** selectedValues for the checkbox group */
    selectedValues: string[] | undefined;
    /** Callback when the checkbox value changes */
    onSelectedValueChange: (selectedValues: string[]) => void;
    /** Label for the checkbox */
    label?: ReactNode;
    /**
     * The class name for the label
     */
    labelClassName?: string;
    /**
     * Whether the checkbox group is inline or not
     */
    inline?: boolean;
    /** Variant of the checkbox */
    variant?: CheckboxProps['variant'];
    /**
     * Whether the checkbox is swapped to the right or not
     */
    swapRight?: boolean;
    /**
     * The class name for the checkbox group
     */
    className?: string;
    /**
     * Whether the checkbox group is required
     */
    required?: boolean;
    /**
     * Whether the checkbox group is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the checkbox group is invalid
     */
    isInvalid?: boolean;
    /**
     * The error message for the checkbox
     */
    errorMessage?: string;
}
declare const CheckboxGroup: React__default.ForwardRefExoticComponent<CheckboxGroupProps & React__default.RefAttributes<HTMLDivElement>>;

interface CheckboxInputProps extends Omit<HTMLTailwindStyledComponentProps<'input'>, 'as' | 'children'> {
    /** Label for the checkbox */
    label?: string;
    /** Whether the checkbox is checked or not */
    checked?: boolean;
    /** Whether the checkbox is disabled or not */
    disabled?: boolean;
    /** Callback when the checkbox value changes */
    onCheckedChange?: (checked: boolean) => void;
    /**
     * Whether the checkbox is swapped to the right or not
     */
    swapRight?: boolean;
    /**
     * The class name for the checkbox label
     */
    labelClassName?: string;
    /**
     * Whether the checkbox is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the checkbox is invalid
     */
    isInvalid?: boolean;
    /**
     * The error message for the checkbox
     */
    errorMessage?: string;
    /**
     * The parent class name for the checkbox
     */
    parentClassName?: string;
}
declare const CheckboxInput: React__default.ForwardRefExoticComponent<CheckboxInputProps & React__default.RefAttributes<HTMLInputElement>>;

/**
 * An interactive component which expands/collapses a panel.
 */
declare const Collapsible: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>>;
declare const CollapsibleTrigger: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const CollapsibleContent: React$1.ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>>;

interface CommandGroupItem {
    /**
     * Optional icon to display for the command item
     */
    icon?: React.ReactNode;
    /**
     * The label for the command item
     */
    label: string;
    /**
     * Optional shortcut to display for the command item
     */
    shortcut?: string;
    /**
     * Optional click handler
     */
    onClick?: () => void;
    /**
     * Optional id for the command item
     */
    className?: string;
}
interface CommandGroupList {
    /**
     * The heading for the command group
     */
    heading: string;
    /**
     * The items for the command group
     */
    items: CommandGroupItem[];
    /**
     * Optional className for the command group
     */
    className?: string;
}
interface CommandNoResultFoundProps {
    /**
     * The number of options in the popover list
     */
    optionsLength: number;
    /**
     * Optional message to display when no results are found
     * @default 'No results found for "{search}".''
     * */
    emptyOptionMessage?: string;
    /**
     * Optional content to display when no results are found
     */
    emptyOptionContent?: ReactNode;
    /**
     * Optional search value
     */
    searchValue: string;
    /**
     * Optional initial search content when the search value is empty
     */
    initialSearchContent?: ReactNode;
}

interface PopoverModalContentProps extends Omit<CommandNoResultFoundProps, 'optionsLength' | 'searchValue'> {
    /**
     * List of items to be displayed in the combobox
     */
    options: OptionType[];
    /**
     * Optional placeholder for the search input
     * @default Search...
     * */
    searchPlaceholder?: string;
    /**
     * Optional value for the combobox
     */
    value?: string;
    /**
     *
     * @param value the value to set
     * @returns void
     */
    onValueChange?: (value: string) => void;
    /**
     * Optional commandClassName for the combobox
     */
    commandClassName?: string;
    /**
     * Optional className for the CommandInput
     */
    commandInputClassName?: string;
    /**
     * Optional className for the CommandGroup
     */
    commandGroupClassName?: string;
    /**
     * Optional className for the CommandItem
     */
    commandItemClassName?: string;
    /**
     * Optional className for the CheckIcon
     */
    checkIconClassName?: (value: string) => string | string;
    /**
     * @param option  the option to filter
     * @param value  the value to filter by
     * @param index  the index of the option
     * @returns  boolean whether the option should be displayed
     */
    filter?: (option: OptionType, value: string, index: number) => boolean;
    /**
     * filterBy the option to filter by label, value, both, metadata or all
     * - "label" will filter by label key in the option
     * - "value" will filter by value key in the option
     * - "metadata" will filter by the metadata key in the option
     * - "all" will filter by label, value and metadata keys in the option
     * - "both" will filter by label and value keys in the option
     * @default label
     */
    filterBy?: 'label' | 'value' | 'both' | 'metadata' | 'all';
    /**
     * Whether the combobox is multi
     */
    isMulti?: boolean;
    /**
     * Whether the combobox is loading
     */
    isLoading?: boolean;
    /**
     * Optional loading message for the combobox
     * @default 'Loading...'
     */
    loadingText?: ReactNode;
    /**
     * Optional search value for the combobox
     */
    searchValue?: string;
    /**
     *
     * @param search the search value to set
     * @returns void
     */
    onSearchValueChange?: (search: string) => void;
    /**
     * Optional whether to show the check icon
     * @default true
     */
    showCheckIcon?: boolean;
}
declare const PopoverModalContent: FC<PopoverModalContentProps>;

interface ComboboxProps extends Omit<PopoverModalContentProps, 'options'> {
    /**
     * List of items to be displayed in the combobox
     */
    options: Array<OptionType | string | number>;
    /**
     * Whether the combobox is open
     */
    open?: boolean;
    /**
     *
     * @param open whether the combobox is open
     * @returns void
     */
    onOpenChange?: (open: boolean) => void;
    /**
     * Optional label for the combobox
     */
    label?: React__default.ReactNode;
    /**
     * Optional placeholder for the combobox
     * @default Select...
     * */
    placeholder?: string;
    /**
     * Whether the combobox is required
     */
    required?: boolean;
    /**
     * Optional disabled for the combobox
     */
    disabled?: boolean;
    /**
     * Optional selectedValues for the combobox
     */
    value?: string;
    /**
     * Optional onValueChange handler for the combobox
     */
    onValueChange?: (value: string) => void;
    /**
     * Optional onBlur handler for the combobox
     */
    onBlur?: () => void;
    /**
     * Whether the select is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the select is invalid
     */
    isInvalid?: boolean;
    /**
     * Optional inline for the combobox
     */
    inline?: boolean;
    /**
     * Optional triggerClassName for the combobox
     */
    triggerClassName?: string;
    /**
     * Optional contentClassName for the combobox
     */
    contentClassName?: string;
    /**
     * Optional className for the combobox
     */
    className?: string;
    /**
     * Optional id for the combobox
     */
    id?: string;
    /**
     * The error message for the combobox
     */
    errorMessage?: string;
    /**
     * onClear handler for the combobox to clear the value
     */
    onClear?: () => void;
    /**
     * Whether the combobox is a render within body container or not
     * @default true
     */
    modal?: boolean;
}
/**
 * Autocomplete input and command palette with a list of suggestions.
 */
declare const Combobox: React__default.ForwardRefExoticComponent<ComboboxProps & React__default.RefAttributes<HTMLButtonElement>>;

declare const CommandModal: React$1.ForwardRefExoticComponent<Omit<{
    children?: React$1.ReactNode;
} & React$1.HTMLAttributes<HTMLDivElement> & {
    label?: string | undefined;
    shouldFilter?: boolean | undefined;
    filter?: ((value: string, search: string) => number) | undefined;
    defaultValue?: string | undefined;
    value?: string | undefined;
    onValueChange?: ((value: string) => void) | undefined;
    loop?: boolean | undefined;
    vimBindings?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
interface CommandDialogProps extends DialogProps$1 {
}
declare const CommandDialog: React$1.FC<CommandDialogProps>;
declare const CommandInput: React$1.ForwardRefExoticComponent<Omit<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "type" | "value"> & {
    value?: string | undefined;
    onValueChange?: ((search: string) => void) | undefined;
} & React$1.RefAttributes<HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
declare const CommandList: React$1.ForwardRefExoticComponent<Omit<{
    children?: React$1.ReactNode;
} & React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandEmpty: React$1.ForwardRefExoticComponent<Omit<{
    children?: React$1.ReactNode;
} & React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandGroup: React$1.ForwardRefExoticComponent<Omit<{
    children?: React$1.ReactNode;
} & Omit<React$1.HTMLAttributes<HTMLDivElement>, "heading" | "value"> & {
    heading?: React$1.ReactNode;
    value?: string | undefined;
    forceMount?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandSeparator: React$1.ForwardRefExoticComponent<Omit<React$1.HTMLAttributes<HTMLDivElement> & {
    alwaysRender?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandLoading: React$1.ForwardRefExoticComponent<Omit<{
    children?: React$1.ReactNode;
} & React$1.HTMLAttributes<HTMLDivElement> & {
    progress?: number | undefined;
} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandItem: React$1.ForwardRefExoticComponent<Omit<{
    children?: React$1.ReactNode;
} & Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect" | "value" | "disabled"> & {
    disabled?: boolean | undefined;
    onSelect?: ((value: string) => void) | undefined;
    value?: string | undefined;
    forceMount?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const CommandShortcut: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
interface CommandProps extends Omit<React$1.ComponentPropsWithoutRef<typeof CommandDialog>, 'children'> {
    /**
     * Optional input options for the command input field
     */
    inputOptions?: React$1.ComponentPropsWithoutRef<typeof CommandInput>;
    /**
     * Optional content to display when no results are found
     */
    emptyResultContent?: React$1.ReactNode;
    /**
     * Optional groups to display in the command dialog
     */
    groups: CommandGroupList[];
}
declare const Command: React$1.FC<CommandProps>;
declare const CommandNoResultFound: React$1.FC<CommandNoResultFoundProps>;

declare const ContextMenu: React$1.FC<ContextMenuPrimitive.ContextMenuProps>;
declare const ContextMenuTrigger: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React$1.RefAttributes<HTMLSpanElement>>;
declare const ContextMenuGroup: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuPortal: React$1.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
declare const ContextMenuSub: React$1.FC<ContextMenuPrimitive.ContextMenuSubProps>;
declare const ContextMenuRadioGroup: React$1.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuSubContent: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuContent: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuLabel: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuSeparator: React$1.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const ContextMenuShortcut: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

type DataTableInstance<TRow> = Table$1<TRow>;
interface DataTableFacetFilterOption {
    label: string;
    value: string;
    icon?: React.ComponentType<{
        className?: string;
    }>;
}
interface DataTableFacetFilterProps<TData, TValue> {
    options: DataTableFacetFilterOption[];
    title: ReactNode;
    column?: Column<TData, TValue>;
    emptyResultMessage?: ReactNode;
    className?: string;
    searchPlaceholder?: string;
}
interface DataTableFacetFilterColumn<TData, TValue = unknown> extends DataTableFacetFilterProps<TData, TValue> {
    accessorKey: string;
}
interface DataTableActionItem extends DataTableFacetFilterOption {
    label: string;
    value: string;
    onClick?: (value: string, e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
    subLabels?: DataTableFacetFilterOption[];
}
interface DataTablePaginationType {
    enabled: boolean;
    currentPage?: number;
    pageSize?: number;
    sizes?: number[];
}
interface DataTableSearchFilter {
    enabled: boolean;
    accessorKey: string;
    placeholder?: string;
    className?: string;
}
interface DataTableCustomSearchFilter {
    enabled: boolean;
    customInput: ReactNode;
}
type DataTableSearchFilterColumn = DataTableSearchFilter | DataTableCustomSearchFilter;
type DataTableColumnDef<TData, TValue = unknown> = ColumnDef<TData, TValue>;
type DataTableRow<TData> = Row<TData>;

interface DataTableProps<TRow, TValue = unknown> {
    /**
     * provide the columns to render in the table
     */
    columns: DataTableColumnDef<TRow, TValue>[];
    /**
     * provide the data to render in the table
     */
    rows: TRow[];
    /**
     * enable the selectable checkbox input in the table header
     */
    enableSelectableTable?: boolean;
    /**
     * provide the column accessorKey value to search the table
     */
    search?: DataTableSearchFilterColumn;
    /**
     * provide the column accessorKey value to filter the table
     */
    facetFilterColumns?: DataTableFacetFilterColumn<TRow, TValue>[];
    /**
     * show the table toolbar
     */
    showTableConfigure?: boolean;
    /**
     * provide the pagination options
     */
    pagination?: DataTablePaginationType;
    /**
     * additional class name to apply to the component
     */
    className?: string;
    /**
     * additional class name to apply to the table container
     */
    tableContainerClassName?: string;
    /**
     * provide the message to display when no results are found in the table
     * @default 'No results.'
     * @type React.ReactNode
     * @example <DataTable noResultsMessage="No tasks found." />
     * @example <DataTable noResultsMessage={<span>No tasks found.</span>} />
     */
    noResultsMessage?: ReactNode;
    /**
     * ref to the table instance
     */
    tableInstanceRef?: MutableRefObject<DataTableInstance<TRow> | undefined>;
    /**
     * additional content to render on the right side of the table
     */
    toolbarRightSideContent?: ReactNode;
    /**
     * provide the sorting columns state
     */
    sortingColumns?: SortingState;
    /**
     *
     * @param cell single cell of the table
     * @returns classname
     */
    getCellClassName?: (cell: Cell<TRow, TValue>) => string | undefined;
    /**
     *
     * @param header single header of the table
     * @returns classname
     */
    getHeadClassName?: (header: Header<TRow, unknown>) => string | undefined;
}
/**
 * The DataTable component is used to display data in a tabular format.
 * It is a wrapper around the react-table component.
 */
declare const DataTable: <TRow, TValue>({ columns, rows, enableSelectableTable, search, facetFilterColumns, showTableConfigure, pagination, className, tableContainerClassName, noResultsMessage, tableInstanceRef, toolbarRightSideContent, sortingColumns, getCellClassName, getHeadClassName, }: DataTableProps<TRow, TValue>) => react_jsx_runtime.JSX.Element;

interface DataTableColumnHeaderProps<TData, TValue> extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
    column: Column<TData, TValue>;
    title: ReactNode;
    isSimpleSort?: boolean;
}
declare const DataTableColumnHeader: <TData, TValue>({ column, title, className, isSimpleSort, }: DataTableColumnHeaderProps<TData, TValue>) => react_jsx_runtime.JSX.Element;

declare const DataTableFacetedFilter: <TData, TValue>({ column, title, options, emptyResultMessage, className, searchPlaceholder, }: DataTableFacetFilterProps<TData, TValue>) => react_jsx_runtime.JSX.Element;

interface DataTablePaginationProps<TData> {
    table: Table$1<TData>;
    pagination?: DataTablePaginationType;
    enableSelectableTable?: boolean;
}
declare function DataTablePagination<TData>({ table, pagination, enableSelectableTable, }: DataTablePaginationProps<TData>): react_jsx_runtime.JSX.Element;

interface DataTableRowActionsProps<TData> {
    row: DataTableRow<TData>;
    rowSchema: z.AnyZodObject;
    actionItems: DataTableActionItem[];
}
declare const DataTableRowActions: <TData>({ row, rowSchema, actionItems }: DataTableRowActionsProps<TData>) => react_jsx_runtime.JSX.Element;

interface DataTableToolbarProps<TData> {
    /**
     * provide the table instance
     */
    table: Table$1<TData>;
    /**
     * provide the column accessorKey value to search the table
     */
    search?: DataTableSearchFilterColumn;
    /**
     * provide the column accessorKey value to filter the table
     */
    facetFilterColumns?: DataTableFacetFilterColumn<TData>[];
    /**
     * show the table toolbar
     */
    showTableConfigure?: boolean;
    /**
     * provide the right side content for the toolbar
     */
    toolbarRightSideContent?: React.ReactNode;
}
declare function DataTableToolbar<TData>({ table, search, facetFilterColumns, showTableConfigure, toolbarRightSideContent, }: DataTableToolbarProps<TData>): react_jsx_runtime.JSX.Element | null;

interface DataTableViewOptionsProps<TData> {
    table: Table$1<TData>;
}
declare function DataTableViewOptions<TData>({ table }: DataTableViewOptionsProps<TData>): react_jsx_runtime.JSX.Element;

declare const getSelectColumn: <TData>() => DataTableColumnDef<TData>;

interface DatePickerProps {
    /**
     * The selected date.
     */
    date?: Date | string;
    /**
     * Callback when the selected date changes.
     */
    onDateChange?: (date: Date | undefined) => void;
    /**
     * Additional class names to apply to the date picker.
     */
    className?: string;
    /**
     * Label for the date picker.
     */
    label?: string;
    /**
     * Placeholder text for the date picker.
     */
    placeholder?: string;
    /**
     * Date format to use
     */
    dateFormat?: string;
    /**
     * Placeholder text for the presets.
     */
    presetPlaceholder?: string;
    /**
     * Preset values to show.
     * value is the number of days to add to the current date.
     */
    presets?: {
        label: string;
        value: number;
    }[];
    /**
     * required or not
     */
    required?: boolean;
    /**
     * Whether the checkbox is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the checkbox is invalid
     */
    isInvalid?: boolean;
    /**
     *  id for the date picker
     */
    id?: string;
    /**
     * The error message for the checkbox
     */
    errorMessage?: string;
    /**
     * Parent class name for the date picker
     */
    parentClassName?: string;
    /**
     * Whether the date picker is disabled or not
     */
    disabled?: boolean;
    /**
     * Additional props for the calendar component.
     */
    calendarProps?: DayPickerBase;
}
/**
 *  A date picker component with range and presets.
 */
declare const DatePicker: React__default.ForwardRefExoticComponent<DatePickerProps & React__default.RefAttributes<HTMLButtonElement>>;

type DateRangePreset = {
    /**
     * Label for the preset picker.
     */
    label: string;
    /**
     * an integer, when added to today, represents start of date range
     */
    from: number;
    /**
     * an integer, when added to today, represents end of date range
     */
    to: number;
};
interface DateRangePickerProps {
    /**
     * The selected date.
     */
    dateRange?: DateRange;
    /**
     * Callback when the selected date changes.
     */
    onDateRangeChange?: (date: DateRange | undefined) => void;
    /**
     * Additional class names to apply to the date picker.
     */
    className?: string;
    /**
     * Label for the date picker.
     */
    label?: string;
    /**
     * Placeholder text for the date picker.
     */
    placeholder?: string;
    /**
     * Number of months to show in the calendar
     */
    numberOfMonths?: number;
    /**
     * Date format to use
     */
    dateFormat?: string;
    /**
     * Placeholder text for the presets.
     */
    presetPlaceholder?: string;
    /**
     * Preset values to show.
     * value is the number of days to add to the current date.
     */
    presets?: DateRangePreset[];
    /**
     * required or not
     */
    required?: boolean;
    /**
     * Whether the checkbox is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the checkbox is invalid
     */
    isInvalid?: boolean;
    /**
     *  id for the date picker
     */
    id?: string;
    /**
     * The error message for the checkbox
     */
    errorMessage?: string;
    /**
     * Parent class name for the date range picker
     */
    parentClassName?: string;
    /**
     * Whether the date range picker is disabled or not
     */
    disabled?: boolean;
    /**
     * Additional props for the calendar component.
     */
    calendarProps?: DayPickerBase;
}
/**
 *  A date picker component with range and presets.
 */
declare const DateRangePicker: React$1.ForwardRefExoticComponent<DateRangePickerProps & React$1.RefAttributes<HTMLButtonElement>>;

/**
 * A window overlaid on either the primary window or another dialog window, rendering the content underneath inert.
 */
declare const DialogRoot: React$1.FC<_radix_ui_react_dialog.DialogProps>;
declare const DialogTrigger: React$1.ForwardRefExoticComponent<_radix_ui_react_dialog.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const DialogContent: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_dialog.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    /**
     * onClose event handler for the close button.
     */
    onClose?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
    /**
     * hideCloseButton to hide the close button.
     * @default false
     */
    hideCloseButton?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const DialogHeader: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DialogFooter: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DialogTitle: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_dialog.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const DialogDescription: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_dialog.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
interface DialogProps extends React$1.ComponentPropsWithoutRef<typeof _radix_ui_react_dialog.Root> {
    /**
     * The trigger content of the dialog that will open the dialog when clicked. (Optional)
     */
    trigger?: React$1.ReactNode;
    /**
     * The trigger className of the dialog.
     */
    triggerClassName?: string;
    /**
     * The content of the dialog. (Optional)
     */
    content?: React$1.ReactNode;
    /**
     * The content of the dialog.
     */
    contentClassName?: string;
    /**
     * The header content of the dialog.
     */
    header?: {
        /**
         * The title content of the dialog.
         */
        title?: React$1.ReactNode;
        /**
         * The description content of the dialog.
         */
        description?: React$1.ReactNode;
        /**
         * The className of the header content. (Optional)
         */
        className?: string;
    };
    /**
     * The footer content of the dialog.
     */
    footer?: {
        /**
         * The content of the footer.
         */
        content: React$1.ReactNode;
        /**
         * The className of the footer content. (Optional)
         */
        className?: string;
    };
    /**
     * The props for the dialog content.
     */
    dialogContentProps?: React$1.ComponentPropsWithoutRef<typeof DialogContent>;
    /**
     * The props for the dialog header.
     */
    dialogHeaderProps?: React$1.ComponentPropsWithoutRef<typeof DialogHeader>;
    /**
     * The props for the dialog footer.
     */
    dialogFooterProps?: React$1.ComponentPropsWithoutRef<typeof DialogFooter>;
}
declare const Dialog: React$1.FC<DialogProps>;

interface CustomDropdownMenuItem extends React.ComponentPropsWithoutRef<typeof DropdownMenuItem> {
    /**
     * The label to display for the item.
     */
    label?: React.ReactNode;
    /**
     * The shortcut to display for the item.
     */
    shortcut?: React.ReactNode;
    /**
     * Whether the item is disabled.
     */
    disabled?: boolean;
    /**
     * Whether the item is a separator.
     */
    separator?: boolean;
}
interface CustomDropdownMenuItemWithSubItem extends CustomDropdownMenuItem {
    /**
     * The sub items to display for the item.
     */
    label: React.ReactNode;
    /**
     * The sub items to display for the item.
     */
    subItems: CustomDropdownMenuItem[];
}
interface DropdownMenuProps extends DropdownMenuProps$1 {
    /**
     * The trigger element that will open the dropdown menu.
     */
    trigger: React.ReactNode;
    /**
     * The items to display in the dropdown menu.
     */
    items: Array<CustomDropdownMenuItem | CustomDropdownMenuItemWithSubItem>;
    /**
     * The title heading for the dropdown menu.
     */
    title?: React.ReactNode;
    /**
     * The dropdown menu content props.
     */
    contentProps?: React.ComponentPropsWithoutRef<typeof DropdownMenuContent>;
    /**
     * The class name for the trigger of the dropdown menu.
     */
    triggerClassName?: string;
}

/**
 * Displays a menu to the user — such as a set of actions or functions — triggered by a button.
 */
declare const DropdownMenuRoot: 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 | undefined;
} & 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 | undefined;
} & 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 | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DropdownMenuShortcut: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DropdownMenu: React$1.FC<DropdownMenuProps>;

interface FallbackProps<ErrorType> {
    error: ErrorType;
    resetErrorBoundary: (...args: unknown[]) => void;
}
type ErrorFallback<ErrorType> = ComponentType<FallbackProps<ErrorType>>;
type ErrorBoundaryProps<ErrorType> = ErrorBoundaryProps$1 & {
    onError?: (error: ErrorType, info: ErrorInfo) => void;
    FallbackComponent?: ErrorFallback<ErrorType>;
    resetKeys?: unknown[];
};
type IErrorBoundaryProps<ErrorType> = ErrorBoundaryProps<ErrorType> & {
    children: ReactNode;
};
declare const ErrorBoundary: <ErrorType extends Error>({ children, ...props }: IErrorBoundaryProps<ErrorType>) => react_jsx_runtime.JSX.Element;

interface ErrorLayoutProps {
    /**
     * Heading of the error content
     */
    heading?: ReactNode;
    /**
     * Subheading of the error content
     */
    subHeading?: ReactNode;
    /**
     * Children of the error content
     */
    children: ReactNode;
    /**
     * Icon of the error content
     */
    icon?: React.ReactElement;
    /**
     * Show icon of the error content
     */
    showIcon?: boolean;
    /**
     * Classname of the error content
     */
    className?: string;
    /**
     * Classname of the heading of the error content
     */
    headingClassName?: string;
    /**
     * Classname of the subheading of the error content
     */
    subHeadingClassName?: string;
    /**
     * Error object
     */
    error?: Error;
}
declare const ErrorLayout: FC<ErrorLayoutProps>;

interface ErrorEmptyResponseProps extends Partial<ErrorLayoutProps> {
}
declare const ErrorEmptyResponse: FC<ErrorEmptyResponseProps>;

interface ErrorResponseImpl {
    data: string;
    error: Error;
    internal: boolean;
    status: number;
    statusText: string;
}
declare const isInternalErrorResponse: (error: unknown) => error is ErrorResponseImpl;
interface ErrorInternalResponseProps extends Partial<ErrorLayoutProps> {
}
declare const ErrorInternalResponse: FC<ErrorInternalResponseProps>;

interface ErrorInternalServerResponseProps extends Partial<ErrorLayoutProps> {
}
declare const ErrorInternalServerResponse: FC<ErrorInternalServerResponseProps>;

interface ErrorNotFoundResponseProps extends Partial<ErrorLayoutProps> {
}
declare const ErrorNotFoundResponse: FC<ErrorNotFoundResponseProps>;

interface IProps<Response extends HttpError['response'] = never> {
    error?: Response;
}
declare const ErrorReactRouterBoundary: <Response_1 extends axios.AxiosResponse<unknown, any> | undefined = never>(props: IProps<Response_1>) => react_jsx_runtime.JSX.Element | null;

interface ErrorReactRouterComponentProps {
    error: Error;
    heading?: ReactNode;
    className?: string;
}
declare const ErrorReactRouterComponent: FC<ErrorReactRouterComponentProps>;

interface ErrorInternalServerProps<ErrorType extends Error = Error> {
    /**
     * Error object
     */
    error: ErrorType;
    /**
     * Status code of the error
     */
    statusCode?: number;
    /**
     * Status text of the error
     */
    statusText?: string;
    /**
     * Whether to show the error message
     */
    showErrorMessage?: boolean;
    /**
     *  @param onRefresh refresh the page
     * @returns void
     */
    onRefresh?: () => void;
    /**
     *  @param onGoBack go back to the previous page
     * @returns void
     */
    onGoBack?: () => void;
    /**
     * Text for the go back button
     */
    goBackText?: React.ReactNode;
    /**
     * Text for the refresh button
     */
    refreshText?: React.ReactNode;
    /**
     * Whether to show the error in the console
     */
    showErrorInConsole?: boolean;
}
/**
 * Error page for internal server errors
 */
declare const ErrorInternalServer: <ErrorType extends Error = Error>({ error, statusCode, statusText, showErrorMessage, showErrorInConsole, goBackText, refreshText, onRefresh, onGoBack, }: ErrorInternalServerProps<ErrorType>) => react_jsx_runtime.JSX.Element;

interface ErrorMessageProps extends Omit<TextProps, 'children'> {
    /**
     * The error message to display.
     */
    message?: React.ReactNode;
    /**
     * Additional class names to apply to the error message.
     */
    className?: string;
    /**
     * Optional label for the error message to be displayed.
     * this label will be suffix with "is required"
     */
    label?: string;
}
declare const ErrorMessage: FC<ErrorMessageProps>;

interface MultiSelectProps extends Omit<ComboboxProps, 'value' | 'onValueChange'> {
    /**
     * List of selected values
     */
    selectedValues: string[] | undefined;
    /**
     * onChange handler for the multiselect
     */
    onSelectedValueChange: (selectedValues: string[]) => void;
    /**
     * id for the multiselect
     */
    id?: string;
}
declare const MultiSelect: React$1.ForwardRefExoticComponent<MultiSelectProps & React$1.RefAttributes<HTMLButtonElement>>;

interface NumberInputProps extends Omit<InputProps, 'onValueChange' | 'value' | 'defaultValue'> {
    /**
     * value of number input
     */
    value?: string | number | null;
    /**
     * default value of number input(when uncontrolled)
     */
    defaultValue?: string | number | null;
    /**
     * zero will be treated as empty string
     */
    zeroAsEmptyString?: boolean;
    /**
     * If true, only positive integer is allowed
     */
    isPositiveInteger?: boolean;
    /**
     * If true, only positive float is allowed
     */
    isPositiveFloat?: boolean;
    /**
     * If true, only positive integer is allowed and starts with zero
     * @default false
     */
    isPositiveIntegerStartsWithZero?: boolean;
    /**
     * if true, only positive float is allowed and starts with zero
     * @default false
     */
    isPositiveFloatStartsWithZero?: boolean;
    /**
     *
     * @param value current value of the input
     */
    onValueChange?: (value: number) => void;
}
declare const NumberInput: ComponentWithAs<'input', NumberInputProps>;

declare const radioGroupVariants: (props?: ({
    variant?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare const RadioGroupRoot: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const RadioGroupRootItem: React$1.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
    variant?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | undefined;
} & React$1.RefAttributes<HTMLButtonElement>>;
interface RadioGroupProps extends React$1.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> {
    /** Array of options to render */
    options: Array<OptionType | string | number>;
    /** The selected value */
    value?: string;
    /** Callback when the selected value changes */
    onValueChange?: (value: string) => void;
    /** Label for the radio group */
    label?: string;
    /** Whether the radio group is inline or not */
    inline?: boolean;
    /**
     * Whether the radio group is swap to right or not
     */
    swapRight?: boolean;
    /**
     * The class name for the label
     */
    labelClassName?: string;
    /**
     * The variant of the radio group
     */
    variant?: ColorVariant;
    /**
     * required or not
     */
    required?: boolean;
    /**
     * Whether the checkbox group is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the checkbox group is invalid
     */
    isInvalid?: boolean;
    /**
     * The error message for the checkbox
     */
    errorMessage?: string;
}
declare const RadioGroup: React$1.ForwardRefExoticComponent<RadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;

interface SelectOptionGroupType {
    label?: string;
    options: OptionType[];
}
type SelectOption = OptionType | SelectOptionGroupType | string | number;

declare const SelectRoot: React$1.FC<SelectPrimitive.SelectProps>;
declare const SelectPortal: React$1.FC<SelectPrimitive.SelectPortalProps>;
declare const SelectIcon: React$1.ForwardRefExoticComponent<SelectPrimitive.SelectIconProps & React$1.RefAttributes<HTMLSpanElement>>;
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 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>>;
interface SelectProps extends Omit<React$1.ComponentProps<typeof SelectRoot>, 'children'> {
    /**
     * The groups of options to display in the select.
     */
    options: SelectOption[];
    /**
     * The placeholder text to display when no option is selected.
     */
    placeholder?: React$1.ReactNode;
    /**
     * The label for the select.
     */
    label?: React$1.ReactNode;
    /**
     * The class name for the select.
     */
    className?: string;
    /**
     * The class name for the trigger select.
     */
    triggerClassName?: string;
    /**
     * The class name for the content select.
     */
    contentClassName?: string;
    /**
     * The id for the select.
     */
    id?: string;
    /**
     * Whether the select is required.
     */
    required?: boolean;
    /**
     * Whether the select is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the select is invalid
     */
    isInvalid?: boolean;
    /**
     * blur event handler
     */
    onBlur?: () => void;
    /**
     * Optional inline for the select
     */
    inline?: boolean;
    /**
     * The error message for the checkbox
     */
    errorMessage?: string;
    /**
     * If options are not found, display this message.
     * @default 'No option found.'
     */
    noOptionsMessage?: React$1.ReactNode;
}
/**
 * Displays a list of options for the user to pick from—triggered by a button.
 */
declare const Select: React$1.ForwardRefExoticComponent<SelectProps & React$1.RefAttributes<HTMLButtonElement>>;

interface TextareaProps extends Omit<HTMLTailwindStyledComponentProps<'textarea'>, 'color'> {
    /**
     * whether the textarea is invalid
     */
    isInvalid?: boolean;
    /**
     * label for the input
     */
    label?: string;
    /**
     * inline input or not
     */
    inline?: boolean;
    /**
     * textarea class name for styling
     */
    className?: string;
    /**
     * parent class name for styling
     */
    parentClassName?: string;
    /**
     * error message for the textarea
     */
    errorMessage?: string;
    /**
     * value for the textarea
     */
    value?: string;
    /**
     * on value change callback
     */
    onValueChange?: (value: string) => void;
}
declare const Textarea: ComponentWithAs<'textarea', TextareaProps>;

interface CommonFormFieldItem<TData> {
    name: Path<TData>;
    label?: ReactNode;
    labelDescription?: ReactNode;
    description?: ReactNode;
    required?: boolean;
    placeholder?: string;
    disabled?: boolean;
    className?: string;
    inline?: boolean;
    formItemClassName?: string;
    formLabelClassName?: string;
}
type FormInputProps = Omit<InputProps, 'inline' | 'label' | 'className' | 'disabled' | 'placeholder' | 'name' | 'required' | 'type'>;
interface FormFieldInputItem<TData> extends CommonFormFieldItem<TData>, Partial<Pick<FormInputProps, 'onValueChange' | 'onChange'>> {
    type: 'input';
    autoComplete?: 'off' | 'on';
    inputType?: React.ComponentPropsWithoutRef<'input'>['type'];
    inputProps?: Omit<FormInputProps, 'onValueChange' | 'onChange'>;
}
interface FormFieldNumberInputItem<TData> extends CommonFormFieldItem<TData>, Partial<Pick<NumberInputProps, 'onValueChange'>> {
    type: 'number';
    autoComplete?: 'off' | 'on';
    numberInputProps?: Omit<NumberInputProps, 'label' | 'value' | 'onValueChange'>;
}
interface FormFieldTextAreaItem<TData> extends CommonFormFieldItem<TData>, Partial<Pick<TextareaProps, 'onValueChange' | 'onChange'>> {
    type: 'textarea';
    autoComplete?: 'off' | 'on';
    textareaProps?: Omit<TextareaProps, 'label' | 'name' | 'onValueChange' | 'onChange'>;
}
interface FormFieldSelectItem<TData> extends CommonFormFieldItem<TData>, Partial<Pick<SelectProps, 'onValueChange'>> {
    type: 'select';
    options: SelectOption[];
    triggerClassName?: string;
    contentClassName?: string;
    selectProps?: Omit<SelectProps, 'label' | 'placeholder' | 'name' | 'onValueChange'>;
}
interface FormFieldCheckboxItem<TData> extends Omit<CommonFormFieldItem<TData>, 'placeholder'>, Partial<Pick<CheckboxProps, 'onChange' | 'onCheckedChange'>> {
    type: 'checkbox';
    variant?: ColorVariant;
    checkboxProps?: Omit<CheckboxProps, 'label' | 'name' | 'type' | 'onCheckedChange' | 'onChange'>;
}
interface FormFieldCheckboxGroupItem<TData> extends Omit<CommonFormFieldItem<TData>, 'placeholder'>, Partial<Pick<CheckboxGroupProps, 'onSelectedValueChange'>> {
    type: 'checkbox-group';
    options: CheckboxGroupProps['options'];
    checkboxInline?: boolean;
    labelClassName?: string;
    swapRight?: boolean;
    variant?: ColorVariant;
    checkboxGroupProps?: Omit<CheckboxGroupProps, 'label' | 'name' | 'selectedValues' | 'onSelectedValueChange'>;
}
interface FormFieldRadioGroupItem<TData> extends Omit<CommonFormFieldItem<TData>, 'placeholder'>, Partial<Pick<RadioGroupProps, 'onChange' | 'onValueChange'>> {
    type: 'radio-group';
    options: RadioGroupProps['options'];
    radioInline?: boolean;
    labelClassName?: string;
    swapRight?: boolean;
    variant?: ColorVariant;
    radioGroupProps?: Omit<RadioGroupProps, 'label' | 'name' | 'onValueChange' | 'onChange'>;
}
interface FormFieldComboboxItem<TData> extends CommonFormFieldItem<TData>, Partial<Pick<ComboboxProps, 'onValueChange'>> {
    type: 'combobox';
    options: ComboboxProps['options'];
    comboboxProps?: Omit<ComboboxProps, 'label' | 'onValueChange'>;
}
interface FormFieldMultiSelectItem<TData> extends CommonFormFieldItem<TData>, Partial<Pick<MultiSelectProps, 'onSelectedValueChange'>> {
    type: 'multi-select';
    options: MultiSelectProps['options'];
    triggerClassName?: MultiSelectProps['triggerClassName'];
    contentClassName?: MultiSelectProps['contentClassName'];
    commandClassName?: MultiSelectProps['commandClassName'];
    multiSelectProps?: Omit<MultiSelectProps, 'label' | 'selectedValues' | 'onSelectedValueChange'>;
}
interface FormFieldDatePickerItem<TData> extends CommonFormFieldItem<TData>, Partial<Pick<DatePickerProps, 'onDateChange'>> {
    type: 'date-picker';
    datePickerProps?: Omit<DatePickerProps, 'label' | 'onDateChange'>;
}
interface FormFieldDateRangePickerItem<TData> extends CommonFormFieldItem<TData>, Partial<Pick<DateRangePickerProps, 'onDateRangeChange'>> {
    type: 'date-range-picker';
    dateRangePickerProps?: Omit<DateRangePickerProps, 'label' | 'onDateRangeChange'>;
}
interface FormFieldCustomItem<TData extends FieldValues> extends CommonFormFieldItem<TData> {
    type: 'custom';
    render: <TName extends Path<TData>>(props: {
        field: ControllerRenderProps<TData, TName>;
    }) => ReactNode;
}
type FormFieldItem<TData extends FieldValues> = FormFieldInputItem<TData> | FormFieldNumberInputItem<TData> | FormFieldTextAreaItem<TData> | FormFieldSelectItem<TData> | FormFieldCheckboxItem<TData> | FormFieldMultiSelectItem<TData> | FormFieldRadioGroupItem<TData> | FormFieldCheckboxGroupItem<TData> | FormFieldComboboxItem<TData> | FormFieldDatePickerItem<TData> | FormFieldDateRangePickerItem<TData> | FormFieldCustomItem<TData>;
interface FormComponentProps<TData extends FieldValues> extends React.PropsWithChildren {
    /**
     * The form object from react-hook-form
     */
    form: UseFormReturn<TData>;
    /**
     * The fields to render
     */
    fields: FormFieldItem<TData>[];
    /**
     * The callback will fired when the form is submitted
     */
    onSubmit?: SubmitHandler<TData>;
    /**
     * The callback will fired when the form is submitted with error
     */
    onSubmitError?: SubmitErrorHandler<TData> | undefined;
    /**
     * The text to display on the submit button
     */
    submitText?: React.ReactNode;
    /**
     * The submit button component
     */
    SubmitButton?: React.ComponentType<{
        /**
         * Whether the form is submitting or not
         */
        isSubmitting: boolean;
        /**
         * You have to call this function to submit the form, If you do that then the form will be submitted and onSubmit callback will be called if there is no error
         * Only use this function when you want to submit the form manually or <Button type="button" />
         * @param e Event
         * @example <Button type="button" isLoading={isSubmitting} onClick={onFormSubmit}>Submit</Button>
         */
        onFormSubmit?: React.FormEventHandler<HTMLFormElement>;
    }>;
    /**
     * The submit button variant
     */
    submitButtonVariant?: ButtonProps['variant'];
    /**
     * The submit button color
     */
    submitButtonColor?: ButtonProps['color'];
    /**
     * The class name for the submit button
     */
    submitClassName?: string;
    /**
     * Whether the form is submitting or not
     */
    isSubmitting?: boolean;
    /**
     * The callback will fired when the form is reset
     */
    onReset?: () => void;
    /**
     * The text to display on the reset button
     */
    resetText?: React.ReactNode;
    /**
     * The reset button component
     */
    ResetButton?: React.ComponentType<{
        onFormReset: UseFormReset<TData>;
    }>;
    /**
     * The reset button variant
     */
    resetButtonVariant?: ButtonProps['variant'];
    /**
     * The reset button color
     */
    resetButtonColor?: ButtonProps['color'];
    /**
     * The class name for the reset button
     */
    resetClassName?: string;
    /**
     * Whether the form is resetting or not
     */
    isResetting?: boolean;
    /**
     * The class name for the form element
     */
    className?: string;
    /**
     * The parent class name for reset and submit buttons
     */
    actionClassName?: string;
    /**
     * Whether to hide the reset button
     */
    hideResetButton?: boolean;
    /**
     * Whether to hide the submit button
     */
    hideSubmitButton?: boolean;
    /**
     * Whether to display the form inline
     */
    inline?: boolean;
    /**
     * The ref for the form element
     */
    formRef?: React.MutableRefObject<HTMLFormElement | null>;
    /**
     * The id for the form element
     */
    id?: string;
    /**
     * Whether support the browser native form validation or not (default is true)
     */
    noValidate?: boolean;
}

/**
 * Form component
 */
declare const Form: {
    <TData extends FieldValues>({ form, onSubmit, onSubmitError, fields, className, submitText, SubmitButton, submitButtonVariant, submitButtonColor, submitClassName, resetText, ResetButton, resetButtonVariant, resetButtonColor, resetClassName, actionClassName, hideResetButton, hideSubmitButton, noValidate, inline: formInline, formRef, id, isSubmitting: isFormSubmitting, isResetting, onReset, children, }: FormComponentProps<TData>): react_jsx_runtime.JSX.Element;
    displayName: string;
};

declare const labelVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
interface LabelProps extends React$1.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>, VariantProps<typeof labelVariants> {
    /**
     * if required, adds a red asterisk to the label
     */
    required?: boolean;
    /**
     *
     */
    text?: React$1.ReactNode;
    /**
     * if true, show the label in red color
     */
    isInvalid?: boolean;
    /**
     * if true, disable the label
     */
    disabled?: boolean;
    /**
     * Description of the label
     */
    labelDescription?: React$1.ReactNode;
}
declare const Label: React$1.ForwardRefExoticComponent<LabelProps & React$1.RefAttributes<HTMLLabelElement>>;

declare const FormRoot: <TFieldValues extends FieldValues, TContext = any, TTransformedValues extends FieldValues | undefined = undefined>(props: 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_jsx_runtime.JSX.Element;
declare const useFormField: () => {
    invalid: boolean;
    isDirty: boolean;
    isTouched: boolean;
    isValidating: boolean;
    error?: react_hook_form.FieldError | undefined;
    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<LabelProps & React$1.RefAttributes<HTMLLabelElement>>;
declare const FormControl: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_slot.SlotProps & 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>>;

type FormFieldItemsProps<TData extends FieldValues> = Pick<FormComponentProps<TData>, 'fields' | 'inline'> & {
    control: FormComponentProps<TData>['form']['control'];
};
declare const FormFieldItems: <TData extends FieldValues>({ fields, ...props }: FormFieldItemsProps<TData>) => react_jsx_runtime.JSX.Element;

type FormFieldItemProps<TData extends FieldValues> = Pick<FormComponentProps<TData>, 'inline'> & {
    control: FormComponentProps<TData>['form']['control'];
    field: FormFieldItem<TData>;
};
declare const FormFieldItemComponent: <TData extends FieldValues>({ inline: formInline, control, field: parentField, }: FormFieldItemProps<TData>) => react_jsx_runtime.JSX.Element;

declare const HoverCard: React$1.FC<HoverCardPrimitive.HoverCardProps>;
declare const HoverCardTrigger: React$1.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React$1.RefAttributes<HTMLAnchorElement>>;
declare const HoverCardContent: React$1.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

type IconButtonProps = BoxProps & {
    icon?: React__default.ReactNode;
    /**
     * Additional class names to apply to the icon button.
     */
    className?: string;
    /**
     * Whether the icon button is disabled.
     */
    disabled?: boolean;
    /**
     * The rounded variant of the icon button.
     */
    outline?: boolean;
} & ({
    /**
     * The icon to display.
     */
    icon: React__default.ReactNode;
} | {
    /**
     * The icon to display.
     */
    children: React__default.ReactNode;
});
/**
 * Icon button component.
 */
declare const IconButton: ComponentWithAs<'button', IconButtonProps>;

declare const InputOTP: React$1.ForwardRefExoticComponent<(Omit<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "maxLength" | "containerClassName" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "noScriptCSSFallback"> & {
    value?: string | undefined;
    onChange?: ((newValue: string) => unknown) | undefined;
    maxLength: number;
    textAlign?: "center" | "right" | "left" | undefined;
    onComplete?: ((...args: any[]) => unknown) | undefined;
    pushPasswordManagerStrategy?: "none" | "increase-width" | undefined;
    containerClassName?: string | undefined;
    noScriptCSSFallback?: string | null | undefined;
} & {
    render: (props: input_otp.RenderProps) => React$1.ReactNode;
    children?: undefined;
} & React$1.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "maxLength" | "containerClassName" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "noScriptCSSFallback"> & {
    value?: string | undefined;
    onChange?: ((newValue: string) => unknown) | undefined;
    maxLength: number;
    textAlign?: "center" | "right" | "left" | undefined;
    onComplete?: ((...args: any[]) => unknown) | undefined;
    pushPasswordManagerStrategy?: "none" | "increase-width" | undefined;
    containerClassName?: string | undefined;
    noScriptCSSFallback?: string | null | undefined;
} & {
    render?: undefined;
    children: React$1.ReactNode;
} & React$1.RefAttributes<HTMLInputElement>, "ref">) & React$1.RefAttributes<HTMLInputElement>>;
declare const InputOTPGroup: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const InputOTPSlot: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
    index: number;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const InputOTPSeparator: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

interface LabelInputProps extends InputProps {
    label: string;
}
declare const LabelInput: ComponentWithAs<'input', LabelInputProps>;

type LoadingProps = React__default.ComponentPropsWithoutRef<typeof LoadingIcon> & {
    /**
     * Optional spin for the Loading
     * @default true
     */
    spin?: boolean;
    /**
     * Optional className for the Loading parent element
     */
    parentClassName?: string;
    /**
     * Optional content to display next to the Loading
     */
    content?: React__default.ReactNode;
};
declare const Loading: React__default.FC<LoadingProps>;

interface MenubarMenuItemProps extends React.ComponentPropsWithoutRef<typeof MenubarItem> {
    label: React.ReactNode;
    shortcut?: string;
    subMenus?: MenubarMenuList[];
}
interface MenubarMenuCheckboxItemProps extends React.ComponentPropsWithoutRef<typeof MenubarCheckboxItem> {
    type: 'checkbox';
    label: React.ReactNode;
}
interface MenubarMenuRadioItemProps extends React.ComponentPropsWithoutRef<typeof MenubarRadioItem> {
    type: 'radio';
    value: string;
    options: {
        label: string;
        value: string;
    }[];
}
interface MenubarMenuSeparatorProps extends React.ComponentPropsWithoutRef<typeof MenubarSeparator> {
    separator: boolean;
}
type MenubarMenuItemsProps = MenubarMenuItemProps | MenubarMenuSeparatorProps | MenubarMenuCheckboxItemProps | MenubarMenuRadioItemProps;
interface MenubarMenuList {
    label: React.ReactNode;
    items: MenubarMenuItemsProps[];
}
interface MenubarProps extends Omit<React.ComponentPropsWithoutRef<typeof MenubarRoot>, 'children' | 'asChild'> {
    menus: MenubarMenuList[];
}

declare const MenubarMenu: {
    (props: MenubarPrimitive.MenubarMenuProps & {
        __scopeMenubar?: _radix_ui_react_context.Scope;
    }): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const MenubarGroup: React$1.ForwardRefExoticComponent<MenubarPrimitive.MenubarGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarPortal: React$1.FC<MenubarPrimitive.MenubarPortalProps>;
declare const MenubarSub: React$1.FC<MenubarPrimitive.MenubarSubProps>;
declare const MenubarRadioGroup: React$1.ForwardRefExoticComponent<MenubarPrimitive.MenubarRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarRoot: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarTrigger: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const MenubarSubTrigger: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarSubContent: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarContent: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarCheckboxItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarRadioItem: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarLabel: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarSeparator: React$1.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const MenubarShortcut: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
    displayname: string;
};
declare const MenubarMenuCheckboxItem: React$1.FC<MenubarMenuCheckboxItemProps>;
declare const MenubarMenuRadioItem: React$1.FC<MenubarMenuRadioItemProps>;
declare const MenubarMenuItem: React$1.FC<MenubarMenuItemProps>;
declare const MenubarMenuItems: React$1.FC<MenubarMenuItemsProps>;
declare const Menubar: React$1.ForwardRefExoticComponent<MenubarProps & React$1.RefAttributes<HTMLDivElement>>;

declare const isMenubarMenuSeparator: (menu: unknown) => menu is MenubarMenuSeparatorProps;
declare const isMenubarMenuCheckbox: (menu: unknown) => menu is MenubarMenuCheckboxItemProps;
declare const isMenubarMenuRadio: (menu: unknown) => menu is MenubarMenuRadioItemProps;

declare const NavigationMenu: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React$1.RefAttributes<HTMLElement>, "ref"> & React$1.RefAttributes<HTMLElement>>;
declare const NavigationMenuList: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React$1.RefAttributes<HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
declare const NavigationMenuItem: React$1.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React$1.RefAttributes<HTMLLIElement>>;
declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
declare const NavigationMenuTrigger: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
declare const NavigationMenuContent: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const NavigationMenuLink: React$1.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
declare const NavigationMenuViewport: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const NavigationMenuIndicator: React$1.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const NavigationMenuListItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & React$1.RefAttributes<HTMLAnchorElement>>;

declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
interface PaginationProps extends BoxProps, Omit<UsePaginationParams, 'onChange' | 'page'> {
    /**
     * The total number of items.
     */
    total: number;
    /**
     * The current page number.
     */
    currentPage?: number;
    /**
     * The total number of items per page.
     * @default 10
     */
    pageSize?: number;
    /**
     *
     * @param pageSize page size number
     * @returns void
     */
    onPageSizeChange?: (pageSize: number) => void;
    /**
     * pageSizeOptions for the pagination
     */
    pageSizeOptions?: number[];
    /**
     * pageSizeText for the pagination
     * @default "items per page"
     */
    pageSizeText?: ReactNode;
    /**
     * showPageSizeOptions for the pagination
     * @default false
     */
    showPageSizeOptions?: boolean;
    /**
     *
     * @param page page number
     * @returns void
     */
    onPageChange?: (page: number) => void;
    /**
     * hide the total result description or not
     */
    showTotalResults?: boolean;
    /**
     * show only the next and previous buttons or not
     */
    showOnlyNextAndPrevious?: boolean;
    /**
     * Additional class names to apply to the pagination.
     */
    className?: string;
    /**
     * Show pagination only if total is greater than page size
     * @default true
     */
    showOnlyIfTotalGreaterThanPageSize?: boolean;
}
/**
 * Pagination component.
 */
declare const Pagination: React__default.ForwardRefExoticComponent<PaginationProps & React__default.RefAttributes<HTMLDivElement>>;

interface NextAndPrevPaginationProps {
    onNext: () => void;
    onPrev: () => void;
    isDisabledNext: boolean;
    isDisabledPrev: boolean;
}
declare const NextAndPrevPagination: FC<NextAndPrevPaginationProps>;

interface PaginationSizeOptionProps {
    pageSize: number;
    setPageSize: (pageSize: number) => void;
    isDisabled: boolean;
    options: number[];
    text?: ReactNode;
}
declare const PaginationSizeOption: FC<PaginationSizeOptionProps>;

declare const PopoverRoot: React$1.FC<PopoverPrimitive.PopoverProps>;
declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
interface PopoverProps extends Omit<React$1.ComponentPropsWithoutRef<typeof PopoverRoot>, 'children'> {
    /**
     * The trigger element for the popover.
     */
    trigger: React$1.ReactNode;
    /**
     * The content element for the popover.
     */
    content: React$1.ReactNode;
    /**
     * The className for the trigger element.
     */
    triggerClassName?: string;
    /**
     * The className for the content element.
     */
    contentClassName?: string;
}
declare const Popover: React$1.FC<PopoverProps>;

declare const progressRootVariants: (props?: ({
    variant?: "primary" | "secondary" | "info" | "success" | "warning" | "danger" | "default" | "accent" | "dark" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare const progressIndicatorVariants: (props?: ({
    variant?: "primary" | "secondary" | "info" | "success" | "warning" | "danger" | "default" | "accent" | "dark" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface ProgressProps extends React$1.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>, VariantProps<typeof progressRootVariants> {
    /**
     * The value of the progress bar. Should be between 0 and 100.
     */
    value?: number;
}
declare const Progress: React$1.ForwardRefExoticComponent<ProgressProps & React$1.RefAttributes<HTMLDivElement>>;

interface RadioInputProps extends Omit<HTMLTailwindStyledComponentProps<'input'>, 'as' | 'children'> {
    /** Label for the radio */
    label?: React__default.ReactNode;
    /** Whether the radio is checked or not */
    checked?: boolean;
    /** Whether the radio is disabled or not */
    disabled?: boolean;
    /** Callback when the radio value changes */
    onCheckedChange?: (checked: boolean) => void;
    /**
     * Whether the radio is swapped to the right or not
     */
    swapRight?: boolean;
    /**
     * The class name for the radio label
     */
    labelClassName?: string;
    /**
     * Whether the radio is invalid.
     */
    'aria-invalid'?: boolean;
    /**
     * whether the radio is invalid
     */
    isInvalid?: boolean;
    /**
     * The error message for the radio
     */
    errorMessage?: string;
    /**
     * The parent class name for the radio
     */
    parentClassName?: string;
}
declare const RadioInput: React__default.ForwardRefExoticComponent<RadioInputProps & React__default.RefAttributes<HTMLInputElement>>;

interface RadioInputGroupProps extends RadioInputProps {
    /**
     * The options for the radio input group
     */
    options: OptionType[];
    /**
     * The default value for the radio input group
     */
    defaultValue?: string;
    /**
     * The default value for the radio input group
     */
    value?: string;
    /**
     * The label for the radio input group
     */
    label?: string;
    /**
     * The class name for the radio input group label
     */
    labelClassName?: string;
    /**
     * Whether the radio input group is vertical or horizontal.
     */
    inline?: boolean;
}
declare const RadioInputGroup: ComponentWithAs<'label', RadioInputGroupProps>;

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>>;

declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

declare const SheetRoot: React$1.FC<_radix_ui_react_dialog.DialogProps>;
declare const SheetTrigger: React$1.ForwardRefExoticComponent<_radix_ui_react_dialog.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const SheetClose: React$1.ForwardRefExoticComponent<_radix_ui_react_dialog.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
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 _radix_ui_react_dialog.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_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const SheetFooter: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const SheetTitle: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_dialog.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const SheetDescription: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_dialog.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
interface SheetProps extends React$1.ComponentProps<typeof SheetRoot> {
    /**
     * The trigger element that will open the sheet
     */
    trigger: React$1.ReactNode;
    /**
     * The header of the sheet, title represents the main title and description is optional
     */
    header: {
        title: React$1.ReactNode;
        description?: React$1.ReactNode;
    };
    /**
     * The content of the sheet (usually a form or a list)
     */
    children?: React$1.ReactNode;
    /**
     * The footer of the sheet, primaryAction is the main action and secondaryAction is optional
     * primaryAction is usually a submit button
     * secondaryAction is usually a cancel button
     */
    footer?: {
        primaryAction?: React$1.ReactNode;
        secondaryAction?: React$1.ReactNode;
    };
    /**
     * The side of the screen the sheet will be displayed
     */
    side?: 'top' | 'bottom' | 'left' | 'right';
    /**
     * The className of the sheet content, useful for adding padding
     */
    className?: string;
}
declare const Sheet: React$1.FC<SheetProps>;

interface TableProps extends BoxProps {
}
declare const Table: ComponentWithAs<'table', TableProps>;
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>>;

interface SimpleTableProps<TRow extends Record<string, unknown> = Record<string, unknown>> extends TableProps {
    /**
     * An array of objects that define the table headers.
     */
    columns: SimpleTableColumn<TRow>[];
    /**
     * An array of objects that define the table rows.
     */
    rows: TRow[];
    /**
     * The primary key of the table rows.
     */
    primaryKey: string;
    /**
     * The table caption.
     */
    caption?: React.ReactNode;
    /**
     * className is the class name of the table row. it is apply for all rows.
     */
    rowClassName?: string;
    /**
     * rowCellClassName is the class name of the table cell. it is apply for all cells.
     */
    rowCellClassName?: string;
    /**
     * columnClassName is the class name of the table header. it is apply for all headers.
     */
    columnClassName?: string;
    /**
     * className is the class name of the table.
     */
    className?: string;
    /**
     * enablePagination is the flag to enable the pagination.
     */
    enablePagination?: boolean;
    /**
     * paginationProps is the props of the pagination.
     */
    paginationProps?: Partial<PaginationProps>;
    /**
     * emptyTableContent is the content to display when the table is empty.
     * @default 'No data available'
     */
    emptyTableContent?: ReactNode;
    /**
     * emptyTableContentClassName is the class name of the empty table content.
     */
    emptyTableContentClassName?: string;
    /**
     * CustomTableRowComponent is the custom table row component.
     */
    CustomTableRowComponent?: React.ComponentType<{
        className?: string;
        row: TRow;
        index: number;
        primaryKey: string;
        children: React.ReactNode;
    }>;
    /**
     * theadClassName is the class name of the table head.
     */
    theadClassName?: string;
    /**
     * tbodyClassName is the class name of the table body.
     */
    tbodyClassName?: string;
}
interface SimpleTableColumn<TRow extends Record<string, unknown> = Record<string, unknown>> {
    /**
     * accessorKey is the key of the row object.
     */
    accessorKey: string;
    /**
     * The header content.
     */
    title: ReactNode;
    /**
     * className is the class name of the table header.
     */
    className?: string;
    /**
     * rowCellClassName is the class name of the table cell.
     */
    rowCellClassName?: string;
    /**
     * rowEmptyValue is the value to display when the row value is empty.
     * @default '-'
     */
    rowEmptyValue?: ReactNode;
    /**
     *
     * @param props is the value of the row object and the column object.
     * @returns rowRender returns the row content.
     */
    render?: (props: {
        value: unknown;
        column: SimpleTableColumn<TRow>;
        row: TRow;
        index: number;
    }) => ReactNode;
    /**
     * @param props is the column object and the index of the column.
     * @returns headerRender returns the header content.
     */
    renderHeader?: (props: {
        column: SimpleTableColumn<TRow>;
        index: number;
    }) => ReactNode;
}

type ForwardRefFn<R> = <TRow extends Record<string, unknown>>(p: SimpleTableProps<TRow> & {
    ref?: React.Ref<R> | undefined | ((instance: R) => ReactElement | null);
}) => ReactElement;
declare const SimpleTable: ForwardRefFn<HTMLTableElement>;

interface SkeletonProps extends Omit<HTMLTailwindStyledComponentProps<'div'>, 'as' | 'children'> {
}
declare const Skeleton: FC<SkeletonProps>;

interface SkeletonContainerProps extends Omit<HTMLTailwindStyledComponentProps<'div'>, 'as' | 'children'> {
    /**
     * If true, the skeleton will be a circle.
     */
    circle?: boolean;
    /**
     * The number of skeleton items to render.
     */
    count?: number;
    /**
     * The class name to apply to each skeleton item.
     */
    className?: string;
    /**
     * If true, the skeleton will be full width.
     */
    isFullWidth?: boolean;
    /**
     * The class name to apply to the container.
     */
    containerClassName?: string;
}
/**
 * A skeleton is a component used to represent a loading state.
 */
declare const SkeletonContainer: FC<SkeletonContainerProps>;

declare const sliderVariant: Record<ColorVariant, {
    track: string;
    range: string;
    thumb: string;
}>;
interface SliderProps extends React$1.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> {
    /**
     * The variant of the slider
     */
    variant?: ColorVariant;
}
/**
 * An input where the user selects a value from within a given range.
 */
declare const Slider: React$1.ForwardRefExoticComponent<SliderProps & React$1.RefAttributes<HTMLSpanElement>>;

declare const Switch: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;

interface TabOption {
    label: React__default.ReactNode;
    value: string;
    content?: React__default.ReactNode;
    triggerClassName?: string;
    contentClassName?: string;
}

declare const TabsRoot: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
declare const TabsList: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    strip?: boolean | undefined;
} & React$1.RefAttributes<HTMLDivElement>>;
declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
    strip?: boolean | undefined;
} & React$1.RefAttributes<HTMLButtonElement>>;
declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
interface TabsProps extends React$1.ComponentPropsWithoutRef<typeof TabsRoot> {
    /**
     * The tabs to render in the component
     */
    tabs: Array<TabOption>;
    /**
     * The active tab
     */
    activeTab: string;
    /**
     * Optional handler for when the tab changes
     */
    onTabChange?: (tab: string) => void;
    /**
     * The tabs to render in the component
     * label: The label for the tab
     * value: The value for the tab
     * content: The content to render for the tab
     * triggerClassName: Optional class name for the tab trigger
     * contentClassName: Optional class name for the tab content
     */
    /**
     * Optional class name for the all tab trigger
     */
    triggerClassName?: string;
    /**
     * Optional class name for the all tab content
     */
    contentClassName?: string;
    /**
     * Optional class name for the tab list
     */
    tabListClassName?: string;
    /**
     * Optional flag to strip the default styles from the component
     * @default true
     */
    strip?: boolean;
}
/**
 * A set of layered sections of content—known as tab panels—that are displayed one at a time.
 */
declare const Tabs: React$1.ForwardRefExoticComponent<TabsProps & React$1.RefAttributes<HTMLDivElement>>;

type ToastTypes = 'normal' | 'action' | 'success' | 'error' | 'warning' | 'info' | 'default' | 'loading';
type PromiseT<Data = unknown> = Promise<Data> | (() => Promise<Data>);
type PromiseData<ToastData> = ExternalToast & {
    loading?: string | React__default.ReactNode;
    success?: string | React__default.ReactNode | ((data: ToastData) => React__default.ReactNode | string);
    error?: string | React__default.ReactNode | ((error: unknown) => React__default.ReactNode | string);
    finally?: () => void | Promise<void>;
};
/**
 * Represents the properties of a toast notification.
 */
interface ToastT {
    /**
     * The id of the toast.
     */
    id: number | string;
    /**
     * The title of the toast.
     */
    title?: string | React__default.ReactNode;
    /**
     * The type of the toast.
     */
    type?: ToastTypes;
    /**
     * The icon of the toast.
     */
    icon?: React__default.ReactNode;
    /**
     * The JSX content of the toast.
     */
    jsx?: React__default.ReactNode;
    /**
     * Whether to invert the toast colors.
     */
    invert?: boolean;
    /**
     * Whether the toast is dismissible.
     */
    dismissible?: boolean;
    /**
     * The description of the toast.
     */
    description?: React__default.ReactNode;
    /**
     * The duration of the toast in milliseconds.
     */
    duration?: number;
    /**
     * Whether to show a delete button for the toast.
     */
    delete?: boolean;
    /**
     * Whether the toast is important.
     */
    important?: boolean;
    /**
     * The action button of the toast.
     */
    action?: {
        label: string;
        onClick: (event: React__default.MouseEvent<HTMLButtonElement>) => void;
        className?: string;
    };
    /**
     * The cancel button of the toast.
     */
    cancel?: {
        label: string;
        onClick?: () => void;
        className?: string;
    };
    /**
     * The callback function to be called when the toast is dismissed.
     */
    onDismiss?: (toast: ToastT) => void;
    /**
     * The callback function to be called when the toast is auto-closed.
     */
    onAutoClose?: (toast: ToastT) => void;
    /**
     * The promise associated with the toast.
     */
    promise?: PromiseT;
    /**
     * The class name for the cancel button.
     */
    cancelButtonClassName?: string;
    /**
     * The class name for the action button.
     */
    actionButtonClassName?: string;
    /**
     * The style of the toast.
     */
    style?: React__default.CSSProperties;
    /**
     * Whether to apply no styles to the toast.
     */
    unstyled?: boolean;
    /**
     * The class name for the toast.
     */
    className?: string;
    /**
     * The class name for the description of the toast.
     */
    descriptionClassName?: string;
    /**
     * The position of the toast. Can be 'top-left', 'top-right', 'bottom-left', 'bottom-right', 'top-center', or 'bottom-center'.
     */
    position?: Position;
}
type Position = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center';
interface HeightT {
    height: number;
    toastId: number | string;
}
/**
 * Options for configuring a Toast component.
 */
interface ToastOptions {
    /**
     * className for the toast.
     */
    className?: string;
    /**
     * className for the toast description.
     */
    descriptionClassName?: string;
    /**
     * Style object for the toast.
     */
    style?: React__default.CSSProperties;
    /**
     * className for the cancel button.
     */
    cancelButtonClassName?: string;
    /**
     * className for the action button.
     */
    actionButtonClassName?: string;
    /**
     * Duration in milliseconds for which the toast should be displayed.
     */
    duration?: number;
    /**
     * Whether to apply default styles to the toast.
     */
    unstyled?: boolean;
}
/**
 * Props for the Toaster component.
 */
interface ToasterProps {
    /**
     * Whether to invert the theme.
     */
    invert?: boolean;
    /**
     * The theme to use. Can be 'light', 'dark', or 'system'.
     */
    theme?: 'light' | 'dark' | 'system';
    /**
     * The position of the toaster on the screen.
     */
    position?: Position;
    /**
     * The hotkey to trigger the toaster.
     */
    hotkey?: string[];
    /**
     * Whether to use rich colors.
     */
    richColors?: boolean;
    /**
     * Whether to expand the toaster to full width.
     */
    expand?: boolean;
    /**
     * The duration of each toast in milliseconds.
     */
    duration?: number;
    /**
     * The gap between toasts in pixels.
     */
    gap?: number;
    /**
     * The maximum number of visible toasts.
     */
    visibleToasts?: number;
    /**
     * Whether to show a close button on each toast.
     */
    closeButton?: boolean;
    /**
     * Additional options for each toast.
     * @summary See {@link ToastOptions}.
     */
    toastOptions?: ToastOptions;
    /**
     * The class name for the toaster.
     */
    className?: string;
    /**
     * The style object for the toaster.
     */
    style?: React__default.CSSProperties;
    /**
     * The offset of the toaster from the edge of the screen.
     */
    offset?: string | number;
    /**
     * The direction of the toaster.
     */
    dir?: 'rtl' | 'ltr' | 'auto';
    /**
     * The loading icon to show while the toaster is loading.
     */
    loadingIcon?: React__default.ReactNode;
}
declare enum SwipeStateTypes {
    SwipedOut = "SwipedOut",
    SwipedBack = "SwipedBack",
    NotSwiped = "NotSwiped"
}
type ToastTheme = 'light' | 'dark';
interface ToastToDismiss {
    id: number | string;
    dismiss: boolean;
}
type ExternalToast = Omit<ToastT, 'id' | 'type' | 'title' | 'jsx' | 'delete' | 'promise'> & {
    id?: number | string;
};
interface ToastProps {
    toast: ToastT;
    toasts: ToastT[];
    index: number;
    expanded: boolean;
    invert: boolean;
    heights: HeightT[];
    setHeights: React__default.Dispatch<React__default.SetStateAction<HeightT[]>>;
    removeToast: (toast: ToastT) => void;
    gap?: number;
    position: Position;
    visibleToasts: number;
    expandByDefault: boolean;
    closeButton: boolean;
    interacting: boolean;
    style?: React__default.CSSProperties;
    cancelButtonClassName?: string;
    actionButtonClassName?: string;
    duration?: number;
    className?: string;
    unstyled?: boolean;
    descriptionClassName?: string;
    loadingIcon?: React__default.ReactNode;
}

declare const useToast: () => ((message: React$1.ReactNode, data?: ExternalToast | undefined) => string | number) & {
    success: (message: React$1.ReactNode, data?: ExternalToast | undefined) => string | number;
    error: (message: React$1.ReactNode, data?: ExternalToast | undefined) => string | number;
    warning: (message: React$1.ReactNode, data?: ExternalToast | undefined) => string | number;
    info: (message: React$1.ReactNode, data?: ExternalToast | undefined) => string | number;
    show: (message: React$1.ReactNode, { description, ...data }?: ExternalToast) => void;
    custom: (jsx: (id: string | number) => React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>, data?: ExternalToast | undefined) => void;
    message: (message: React$1.ReactNode, data?: ExternalToast | undefined) => string | number;
    promise: <ToastData>(promise: PromiseT<ToastData>, data?: PromiseData<ToastData> | undefined) => string | number | undefined;
    dismiss: (id?: string | number | undefined) => string | number | undefined;
    loading: (message: React$1.ReactNode, data?: ExternalToast | undefined) => string | number;
};

declare const toast: ((message: string | React__default.ReactNode, data?: ExternalToast) => string | number) & {
    success: (message: string | React__default.ReactNode, data?: ExternalToast) => string | number;
    error: (message: string | React__default.ReactNode, data?: ExternalToast) => string | number;
    warning: (message: string | React__default.ReactNode, data?: ExternalToast) => string | number;
    info: (message: string | React__default.ReactNode, data?: ExternalToast) => string | number;
    show: (message: string | React__default.ReactNode, { description, ...data }?: ExternalToast) => void;
    custom: (jsx: (id: number | string) => React__default.ReactElement, data?: ExternalToast) => void;
    message: (message: string | React__default.ReactNode, data?: ExternalToast) => string | number;
    promise: <ToastData>(promise: PromiseT<ToastData>, data?: PromiseData<ToastData> | undefined) => string | number | undefined;
    dismiss: (id?: number | string) => string | number | undefined;
    loading: (message: string | React__default.ReactNode, data?: ExternalToast) => string | number;
};

declare const Toaster: FC<ToasterProps>;

declare const toggleVariants: (props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "sm" | "lg" | "default" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
/**
 * A two-state button that can be either on or off.
 */
declare const Toggle: React$1.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "sm" | "lg" | "default" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string> & React$1.RefAttributes<HTMLButtonElement>>;

declare const toggleGroupItemVariants: (props?: ({
    color?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | null | undefined;
    size?: "sm" | "md" | "lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
declare const ToggleGroupRoot: React__default.ForwardRefExoticComponent<(ToggleGroupPrimitive.ToggleGroupSingleProps | ToggleGroupPrimitive.ToggleGroupMultipleProps) & React__default.RefAttributes<HTMLDivElement>>;
declare const ToggleGroupItem: React__default.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React__default.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
    color?: "primary" | "secondary" | "tertiary" | "info" | "success" | "warning" | "danger" | null | undefined;
    size?: "sm" | "md" | "lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string> & React__default.RefAttributes<HTMLButtonElement>>;
type ToggleGroupProps = React__default.ComponentPropsWithoutRef<typeof ToggleGroupRoot> & VariantProps<typeof toggleGroupItemVariants> & {
    items: (Omit<React__default.ComponentPropsWithoutRef<typeof ToggleGroupItem>, 'children' | 'color' | 'size'> & {
        content: React__default.ReactNode;
    })[];
    /**
     * Optional label for the ToggleGroup
     */
    label?: ReactNode;
    /**
     * Optional color for the ToggleGroup (primary).
     * @default primary
     */
    color?: 'primary';
    /**
     * Optional size for the ToggleGroup (sm, md, lg).
     * @default md
     */
    size?: 'sm' | 'md' | 'lg';
    /**
     * Optional orientation for the ToggleGroup (vertical, horizontal).
     */
    inline?: boolean;
};
declare const ToggleGroup: React__default.ForwardRefExoticComponent<ToggleGroupProps & React__default.RefAttributes<HTMLDivElement>>;

declare const TooltipProvider: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
declare const TooltipRoot: React$1.FC<TooltipPrimitive.TooltipProps>;
declare const TooltipTrigger: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const TooltipPortal: React$1.FC<TooltipPrimitive.TooltipPortalProps>;
declare const TooltipContent: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
interface TooltipProps extends Omit<React$1.ComponentPropsWithoutRef<typeof TooltipContent>, 'content' | 'children'> {
    /**
     * Tooltip trigger content
     *
     */
    trigger: React$1.ReactNode;
    /**
     * Tooltip body content
     *
     */
    content: React$1.ReactNode;
    /**
     * Tooltip side
     *
     * @default top
     */
    side?: 'top' | 'right' | 'bottom' | 'left';
    /**
     * Tooltip align
     *
     * @default center
     */
    align?: 'start' | 'center' | 'end';
    /**
     * Tooltip as portal (render tooltip in separate DOM node)
     *
     * @default false
     */
    asPortal?: boolean;
    /**
     * Tooltip open state
     *
     * @default false
     */
    open?: boolean;
    /**
     * Tooltip default open state
     *
     * @default false
     */
    defaultOpen?: boolean;
    /**
     * Tooltip on open state change handler
     *
     */
    onOpenChange?: (open: boolean) => void;
}
declare const Tooltip: React$1.ForwardRefExoticComponent<TooltipProps & React$1.RefAttributes<HTMLDivElement>>;

declare const THEMES: {
    readonly light: "";
    readonly dark: ".dark";
};
type ChartConfig = {
    [k in string]: {
        label?: React$1.ReactNode;
        icon?: React$1.ComponentType;
    } & ({
        color?: string;
        theme?: never;
    } | {
        color?: never;
        theme: Record<keyof typeof THEMES, string>;
    });
};
declare const ChartContainer: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
    config: ChartConfig;
    children: React$1.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>['children'];
}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const ChartStyle: ({ id, config }: {
    id: string;
    config: ChartConfig;
}) => react_jsx_runtime.JSX.Element | null;
declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
declare const ChartTooltipContent: React$1.ForwardRefExoticComponent<Omit<RechartsPrimitive.DefaultTooltipContentProps<recharts_types_component_DefaultTooltipContent.ValueType, recharts_types_component_DefaultTooltipContent.NameType> & {
    accessibilityLayer?: boolean | undefined;
    active?: boolean | undefined;
    includeHidden?: boolean | undefined;
    allowEscapeViewBox?: recharts_types_util_types.AllowInDimension | undefined;
    animationDuration?: number | undefined;
    animationEasing?: recharts_types_util_types.AnimationTiming | undefined;
    content?: recharts_types_component_Tooltip.ContentType<recharts_types_component_DefaultTooltipContent.ValueType, recharts_types_component_DefaultTooltipContent.NameType> | undefined;
    coordinate?: Partial<recharts_types_util_types.Coordinate> | undefined;
    cursor?: boolean | React$1.SVGProps<SVGElement> | React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>> | undefined;
    filterNull?: boolean | undefined;
    defaultIndex?: number | undefined;
    isAnimationActive?: boolean | undefined;
    offset?: number | undefined;
    payloadUniqBy?: recharts_types_util_payload_getUniqPayload.UniqueOption<recharts_types_component_DefaultTooltipContent.Payload<recharts_types_component_DefaultTooltipContent.ValueType, recharts_types_component_DefaultTooltipContent.NameType>> | undefined;
    position?: Partial<recharts_types_util_types.Coordinate> | undefined;
    reverseDirection?: recharts_types_util_types.AllowInDimension | undefined;
    shared?: boolean | undefined;
    trigger?: "hover" | "click" | undefined;
    useTranslate3d?: boolean | undefined;
    viewBox?: recharts_types_util_types.CartesianViewBox | undefined;
    wrapperStyle?: React$1.CSSProperties | undefined;
} & React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
    hideLabel?: boolean | undefined;
    hideIndicator?: boolean | undefined;
    indicator?: "line" | "dashed" | "dot" | undefined;
    nameKey?: string | undefined;
    labelKey?: string | undefined;
}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const ChartLegend: typeof RechartsPrimitive.Legend;
declare const ChartLegendContent: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
    hideIcon?: boolean | undefined;
    nameKey?: string | undefined;
}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;

declare const BreadcrumbRoot: 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 | undefined;
} & 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_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const BreadcrumbEllipsis: {
    ({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
interface BreadcrumbProps extends Omit<React$1.ComponentPropsWithoutRef<typeof BreadcrumbRoot>, 'children'> {
    /**
     * The items to display in the breadcrumb.
     */
    items: {
        label: React$1.ReactNode;
        href?: string;
    }[];
    /**
     * The link component to use for the breadcrumb items.
     * @example <Breadcrumb items={items} Link={Link} />
     * @example <Breadcrumb items={items} Link={NextLink} />
     */
    Link: React$1.ComponentType<{
        href: string;
        children: React$1.ReactNode;
        className?: string;
    }>;
    /**
     * The number of items to display in the breadcrumb.
     * @default 3
     */
    itemsToDisplay?: number;
    /**
     * If true, the breadcrumb will be open.
     */
    open?: boolean;
    /**
     *
     * @param open it is the open state of the breadcrumb
     * @returns  void
     */
    onOpenChange?: (open: boolean) => void;
    /**
     * The props for the breadcrumb list.
     */
    breadcrumbListProps?: Omit<React$1.ComponentPropsWithoutRef<typeof BreadcrumbList>, 'children'>;
    /**
     * The props for the breadcrumb item.
     */
    breadcrumbItemProps?: Omit<React$1.ComponentPropsWithoutRef<typeof BreadcrumbItem>, 'children'>;
    /**
     *  The props for the breadcrumb separator.
     */
    breadcrumbSeparatorProps?: React$1.ComponentPropsWithoutRef<typeof BreadcrumbSeparator>;
    /**
     * The props for the breadcrumb ellipsis.
     */
    breadcrumbEllipsisProps?: React$1.ComponentPropsWithoutRef<typeof BreadcrumbEllipsis>;
}
/**
 * Breadcrumbs are a navigational aid that helps users keep track of their location within a website or application.
 */
declare const Breadcrumb: React$1.ForwardRefExoticComponent<BreadcrumbProps & React$1.RefAttributes<HTMLElement>>;

declare const DrawerRoot: {
    ({ shouldScaleBackground, ...props }: React$1.ComponentProps<typeof Drawer$1.Root>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DrawerTrigger: React$1.ForwardRefExoticComponent<_radix_ui_react_dialog.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const DrawerPortal: React$1.FC<_radix_ui_react_dialog.DialogPortalProps>;
declare const DrawerClose: React$1.ForwardRefExoticComponent<_radix_ui_react_dialog.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
declare const DrawerOverlay: React$1.ForwardRefExoticComponent<Omit<Omit<_radix_ui_react_dialog.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DrawerContent: React$1.ForwardRefExoticComponent<Omit<Omit<_radix_ui_react_dialog.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
    onAnimationEnd?: ((open: boolean) => void) | undefined;
} & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
declare const DrawerHeader: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DrawerFooter: {
    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
    displayName: string;
};
declare const DrawerTitle: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_dialog.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
declare const DrawerDescription: React$1.ForwardRefExoticComponent<Omit<_radix_ui_react_dialog.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
type DrawerProps = React$1.ComponentPropsWithoutRef<typeof DrawerRoot> & {
    /**
     * The trigger element for the drawer.
     */
    trigger: React$1.ReactNode;
    /**
     * The content element for the drawer.
     */
    content?: React$1.ReactNode;
    /**
     * The className for the trigger element.
     */
    triggerClassName?: string;
    /**
     * The className for the content element.
     */
    contentClassName?: string;
    /**
     * The header content of the drawer.
     */
    header?: {
        /**
         * The title content of the drawer.
         */
        title?: React$1.ReactNode;
        /**
         * The description content of the drawer.
         */
        description?: React$1.ReactNode;
        /**
         * The className of the header content. (Optional)
         */
        className?: string;
    };
    /**
     * The footer content of the drawer.
     */
    footer?: {
        /**
         * The content of the footer.
         */
        content: React$1.ReactNode;
        /**
         * The className of the footer content. (Optional)
         */
        className?: string;
    };
    /**
     * The drawer close button element.
     * @example <Button variant="outline">Close</Button>
     */
    drawerCloseButton?: React$1.ReactNode;
    /**
     * The className for the drawer close button element. this className will be applied to the parent of the drawer close button.
     * @default 'pt-2'
     */
    drawerCloseButtonClassName?: string;
};
declare const Drawer: React$1.FC<DrawerProps>;

type IconType = LucideIcon | React.ComponentType<unknown> | undefined;
type StepItem = {
    id?: string;
    label?: string;
    description?: string;
    icon?: IconType;
    optional?: boolean;
};
interface TimelineStepProps {
    /**
     * Whether to display the steps as a timeline
     */
    timeline?: boolean;
    /**
     * Class name for the timeline container
     */
    timelineContainerClassName?: string;
    /**
     * Class name for the timeline content
     */
    timelineContentClassName?: string;
}
interface StepOptions {
    orientation?: 'vertical' | 'horizontal';
    state?: 'loading' | 'error';
    responsive?: boolean;
    checkIcon?: IconType;
    errorIcon?: IconType;
    onClickStep?: (step: number, setStep: (step: number) => void) => void;
    mobileBreakpoint?: string;
    variant?: 'circle' | 'circle-alt' | 'line';
    expandVerticalSteps?: boolean;
    size?: 'sm' | 'md' | 'lg';
    styles?: {
        /** Styles for the main container */
        'main-container'?: string;
        /** Styles for the horizontal step */
        'horizontal-step'?: string;
        /** Styles for the horizontal step container (button and labels) */
        'horizontal-step-container'?: string;
        /** Styles for the vertical step */
        'vertical-step'?: string;
        /** Styles for the vertical step container (button and labels) */
        'vertical-step-container'?: string;
        /** Styles for the vertical step content */
        'vertical-step-content'?: string;
        /** Styles for the step button container */
        'step-button-container'?: string;
        /** Styles for the label and description container */
        'step-label-container'?: string;
        /** Styles for the step label */
        'step-label'?: string;
        /** Styles for the step description */
        'step-description'?: string;
    };
    variables?: {
        '--step-icon-size'?: string;
        '--step-gap'?: string;
    };
    scrollTracking?: boolean;
}
interface StepperProps extends StepOptions, TimelineStepProps {
    children?: React.ReactNode;
    className?: string;
    initialStep: number;
    steps: StepItem[];
}
interface StepProps extends React.HTMLAttributes<HTMLLIElement> {
    label?: string | React.ReactNode;
    description?: string;
    icon?: IconType;
    state?: 'loading' | 'error';
    checkIcon?: IconType;
    errorIcon?: IconType;
    isCompletedStep?: boolean;
    isKeepError?: boolean;
    onClickStep?: (step: number, setStep: (step: number) => void) => void;
}
interface StepSharedProps extends StepProps {
    isLastStep?: boolean;
    isCurrentStep?: boolean;
    index?: number;
    hasVisited: boolean | undefined;
    isError?: boolean;
    isLoading?: boolean;
}

declare const Step: React$1.ForwardRefExoticComponent<StepProps & React$1.RefAttributes<HTMLDivElement>>;

declare function useStepper(): {
    isLastStep: boolean;
    hasCompletedAllSteps: boolean;
    isOptionalStep: boolean;
    isDisabledStep: boolean;
    currentStep: StepItem;
    previousActiveStep: number | undefined;
    clickable?: boolean | undefined;
    isError?: boolean | undefined;
    isLoading?: boolean | undefined;
    isVertical?: boolean | undefined;
    isVerticalTimeline?: boolean | undefined;
    stepCount?: number | undefined;
    expandVerticalSteps?: boolean | undefined;
    activeStep: number;
    initialStep: number;
    steps: StepItem[];
    orientation?: "horizontal" | "vertical" | undefined;
    state?: "loading" | "error" | undefined;
    responsive?: boolean | undefined;
    checkIcon?: IconType;
    errorIcon?: IconType;
    onClickStep?: ((step: number, setStep: (step: number) => void) => void) | undefined;
    mobileBreakpoint?: string | undefined;
    variant?: "circle" | "line" | "circle-alt" | undefined;
    size?: "sm" | "md" | "lg" | undefined;
    styles?: {
        'main-container'?: string | undefined;
        'horizontal-step'?: string | undefined;
        'horizontal-step-container'?: string | undefined;
        'vertical-step'?: string | undefined;
        'vertical-step-container'?: string | undefined;
        'vertical-step-content'?: string | undefined;
        'step-button-container'?: string | undefined;
        'step-label-container'?: string | undefined;
        'step-label'?: string | undefined;
        'step-description'?: string | undefined;
    } | undefined;
    variables?: {
        '--step-icon-size'?: string | undefined;
        '--step-gap'?: string | undefined;
    } | undefined;
    scrollTracking?: boolean | undefined;
    timeline?: boolean | undefined;
    timelineContainerClassName?: string | undefined;
    timelineContentClassName?: string | undefined;
    nextStep: () => void;
    prevStep: () => void;
    resetSteps: () => void;
    setStep: (step: number) => void;
};

declare const Stepper: React$1.ForwardRefExoticComponent<StepperProps & React$1.RefAttributes<HTMLDivElement>>;

export { Accordion, AccordionContent, AccordionItem, AccordionRoot, AccordionTrigger, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogRoot, AlertDialogTitle, AlertDialogTrigger, type AlertProps, AlertRoot, AlertTitle, AspectRatio, Avatar, AvatarFallback, AvatarImage, type AvatarProps, AvatarRoot, AvatarUpload, type AvatarUploadProps, Badge, type BadgeProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, type BreadcrumbProps, BreadcrumbRoot, BreadcrumbSeparator, Button, type ButtonProps, Calendar, type CalendarProps, Card, CardContent, type CardCustomHeaderProps, CardDescription, CardFooter, CardHeader, type CardProps, CardRoot, CardTitle, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Checkbox, CheckboxGroup, type CheckboxGroupProps, CheckboxInput, type CheckboxInputProps, type CheckboxProps, CheckboxRoot, Collapsible, CollapsibleContent, CollapsibleTrigger, Combobox, type ComboboxProps, Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, type CommandGroupItem, type CommandGroupList, CommandInput, CommandItem, CommandList, CommandLoading, CommandModal, CommandNoResultFound, type CommandNoResultFoundProps, type CommandProps, CommandSeparator, CommandShortcut, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, type CustomDropdownMenuItem, type CustomDropdownMenuItemWithSubItem, DEFAULT_PAGE_SIZE_OPTIONS, DataTable, type DataTableActionItem, type DataTableColumnDef, DataTableColumnHeader, type DataTableCustomSearchFilter, type DataTableFacetFilterColumn, type DataTableFacetFilterOption, type DataTableFacetFilterProps, DataTableFacetedFilter, type DataTableInstance, DataTablePagination, type DataTablePaginationType, type DataTableProps, type DataTableRow, DataTableRowActions, type DataTableSearchFilter, type DataTableSearchFilterColumn, DataTableToolbar, DataTableViewOptions, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, type DateRangePreset, Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, type DialogProps, DialogRoot, DialogTitle, DialogTrigger, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, type DrawerProps, DrawerRoot, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, type DropdownMenuProps, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuRoot, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, ErrorBoundary, ErrorEmptyResponse, type ErrorFallback, ErrorInternalResponse, ErrorInternalServer, type ErrorInternalServerProps, ErrorInternalServerResponse, ErrorLayout, type ErrorLayoutProps, ErrorMessage, ErrorNotFoundResponse, ErrorReactRouterBoundary, ErrorReactRouterComponent, type ErrorResponseImpl, type ExternalToast, type FallbackProps, Form, type FormComponentProps, FormControl, FormDescription, FormField, type FormFieldCheckboxGroupItem, type FormFieldCheckboxItem, type FormFieldComboboxItem, type FormFieldCustomItem, type FormFieldDatePickerItem, type FormFieldDateRangePickerItem, type FormFieldInputItem, type FormFieldItem, FormFieldItemComponent, type FormFieldItemProps, FormFieldItems, type FormFieldItemsProps, type FormFieldMultiSelectItem, type FormFieldNumberInputItem, type FormFieldRadioGroupItem, type FormFieldSelectItem, type FormFieldTextAreaItem, type FormInputProps, FormItem, FormLabel, FormMessage, FormRoot, type HeightT, HoverCard, HoverCardContent, HoverCardTrigger, type IErrorBoundaryProps, IconButton, type IconButtonProps, type IconType, Input, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, type InputProps, Label, LabelInput, type LabelProps, Loading, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarMenuCheckboxItem, type MenubarMenuCheckboxItemProps, MenubarMenuItem, type MenubarMenuItemProps, MenubarMenuItems, type MenubarMenuItemsProps, type MenubarMenuList, MenubarMenuRadioItem, type MenubarMenuRadioItemProps, type MenubarMenuSeparatorProps, MenubarPortal, type MenubarProps, MenubarRadioGroup, MenubarRadioItem, MenubarRoot, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, MultiSelect, type MultiSelectProps, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuListItem, NavigationMenuTrigger, NavigationMenuViewport, NextAndPrevPagination, type NextAndPrevPaginationProps, NumberInput, type NumberInputProps, Pagination, type PaginationProps, PaginationSizeOption, type PaginationSizeOptionProps, Popover, PopoverContent, PopoverModalContent, type PopoverModalContentProps, type PopoverProps, PopoverRoot, PopoverTrigger, type Position, Progress, type PromiseData, type PromiseT, RadioGroup, type RadioGroupProps, RadioGroupRoot, RadioGroupRootItem, RadioInput, RadioInputGroup, type RadioInputGroupProps, type RadioInputProps, ScrollArea, ScrollBar, Select, SelectContent, SelectGroup, SelectIcon, SelectItem, SelectLabel, type SelectOption, type SelectOptionGroupType, SelectPortal, type SelectProps, SelectRoot, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetRoot, SheetTitle, SheetTrigger, SimpleTable, type SimpleTableColumn, type SimpleTableProps, Skeleton, SkeletonContainer, type SkeletonContainerProps, type SkeletonProps, Slider, Step, type StepItem, type StepOptions, type StepProps, type StepSharedProps, Stepper, type StepperProps, SwipeStateTypes, Switch, type TabOption, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, type TableProps, TableRow, Tabs, TabsContent, TabsList, type TabsProps, TabsRoot, TabsTrigger, Textarea, type TextareaProps, type ToastProps, type ToastT, type ToastTheme, type ToastToDismiss, type ToastTypes, Toaster, type ToasterProps, Toggle, ToggleGroup, ToggleGroupItem, type ToggleGroupProps, ToggleGroupRoot, Tooltip, TooltipContent, TooltipPortal, TooltipProvider, TooltipRoot, TooltipTrigger, badgeVariants, buttonVariants, getSelectColumn, isInternalErrorResponse, isMenubarMenuCheckbox, isMenubarMenuRadio, isMenubarMenuSeparator, navigationMenuTriggerStyle, progressIndicatorVariants, progressRootVariants, radioGroupVariants, sliderVariant, toast, toggleGroupItemVariants, toggleVariants, useFormField, useStepper, useToast };