import * as AccordionPrimitive from '@radix-ui/react-accordion';
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 { ButtonProps as ButtonProps_2 } from './button';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import { ClassProp } from 'class-variance-authority/types';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import { ColumnDef } from '@tanstack/react-table';
import { Command as Command_2 } from 'cmdk';
import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
import { ControllerProps } from 'react-hook-form';
import { DayPicker } from 'react-day-picker';
import { default as default_2 } from 'embla-carousel-react';
import { default as default_3 } from 'react';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import { Drawer as Drawer_2 } from 'vaul';
import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
import { FieldError } from 'react-hook-form';
import { FieldPath } from 'react-hook-form';
import { FieldValues } from 'react-hook-form';
import { FormProviderProps } from 'react-hook-form';
import { ForwardRefExoticComponent } from 'react';
import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
import { HTMLAttributes } from 'react';
import { InputProps as InputProps_2 } from './input';
import { JSX } from 'react/jsx-runtime';
import * as LabelPrimitive from '@radix-ui/react-label';
import * as LucideIcons from 'lucide-react';
import * as MenubarPrimitive from '@radix-ui/react-menubar';
import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
import { OnChangeFn } from '@tanstack/react-table';
import { OTPInput } from 'input-otp';
import * as PopoverPrimitive from '@radix-ui/react-popover';
import * as ProgressPrimitive from '@radix-ui/react-progress';
import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
import * as React_2 from 'react';
import { ReactElement } from 'react';
import { ReactNode } from 'react';
import * as RechartsPrimitive from 'recharts';
import { RefAttributes } from 'react';
import { RefObject } from 'react';
import * as ResizablePrimitive from 'react-resizable-panels';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import { SeparatorProps } from '@radix-ui/react-separator';
import { SetStateAction } from 'react';
import * as SliderPrimitive from '@radix-ui/react-slider';
import { Slot } from '@radix-ui/react-slot';
import * as SwitchPrimitive from '@radix-ui/react-switch';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import { Toaster as Toaster_2 } from 'sonner';
import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
import * as TogglePrimitive from '@radix-ui/react-toggle';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { UseEmblaCarouselType } from 'embla-carousel-react';
import { VariantProps } from 'class-variance-authority';

export declare function Accordion({ ...props }: AccordionProps): JSX.Element;

export declare function AccordionContent({ className, children, ...props }: AccordionContentProps): JSX.Element;

declare type AccordionContentProps = React_2.ComponentProps<typeof AccordionPrimitive.Content>;

export declare function AccordionItem({ className, ...props }: AccordionItemProps): JSX.Element;

declare type AccordionItemProps = React_2.ComponentProps<typeof AccordionPrimitive.Item>;

declare type AccordionProps = React_2.ComponentProps<typeof AccordionPrimitive.Root>;

export declare function AccordionTrigger({ className, children, ...props }: AccordionTriggerProps): JSX.Element;

declare type AccordionTriggerProps = React_2.ComponentProps<typeof AccordionPrimitive.Trigger>;

declare type AdditionalMessageOptions = Omit<ChatMessageProps, keyof Message>;

export declare function Alert({ className, variant, ...props }: AlertProps): JSX.Element;

export declare function AlertDescription({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function AlertDialog({ ...props }: AlertDialogProps): JSX.Element;

export declare function AlertDialogAction({ className, ...props }: AlertDialogActionProps): JSX.Element;

declare type AlertDialogActionProps = React_2.ComponentProps<typeof AlertDialogPrimitive.Action>;

export declare function AlertDialogCancel({ className, ...props }: AlertDialogCancelProps): JSX.Element;

declare type AlertDialogCancelProps = React_2.ComponentProps<typeof AlertDialogPrimitive.Cancel>;

export declare function AlertDialogContent({ className, ...props }: AlertDialogContentProps): JSX.Element;

declare type AlertDialogContentProps = React_2.ComponentProps<typeof AlertDialogPrimitive.Content>;

export declare function AlertDialogDescription({ className, ...props }: AlertDialogDescriptionProps): JSX.Element;

declare type AlertDialogDescriptionProps = React_2.ComponentProps<typeof AlertDialogPrimitive.Description>;

export declare function AlertDialogFooter({ className, ...props }: AlertDialogFooterProps): JSX.Element;

declare type AlertDialogFooterProps = React_2.ComponentProps<"div">;

export declare function AlertDialogHeader({ className, ...props }: AlertDialogHeaderProps): JSX.Element;

declare type AlertDialogHeaderProps = React_2.ComponentProps<"div">;

declare type AlertDialogProps = React_2.ComponentProps<typeof AlertDialogPrimitive.Root>;

export declare function AlertDialogTitle({ className, ...props }: AlertDialogTitleProps): JSX.Element;

declare type AlertDialogTitleProps = React_2.ComponentProps<typeof AlertDialogPrimitive.Title>;

export declare function AlertDialogTrigger({ ...props }: AlertDialogTriggerProps): JSX.Element;

declare type AlertDialogTriggerProps = React_2.ComponentProps<typeof AlertDialogPrimitive.Trigger>;

declare type AlertProps = React_2.ComponentProps<"div"> & VariantProps<typeof alertVariants>;

export declare function AlertTitle({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

declare const alertVariants: (props?: ({
    variant?: "default" | "destructive" | null | undefined;
} & ClassProp) | undefined) => string;

declare type Animation_2 = VariantProps<typeof chatBubbleVariants>["animation"];

export declare function AppMultipleSelectDropdown({ options, value, onChange, placeholder, disabled, size, label, labelClassName, emptyMessage, className, filterPlaceholder, filterable, cancelLabel, cancelButtonLabel, maxSelectedItems, }: MultipleSelectDropdownProps): JSX.Element;

export declare interface AppMultipleSelectOption {
    value: string;
    label: string;
    disabled?: boolean;
}

export declare function AppSelect<T = AppSelectOption>({ options, placeholder, children, label, className, labelKey, valueKey, descriptionKey, isOptionDisabled, ...props }: AppSelectProps<T>): JSX.Element;

export declare interface AppSelectOption {
    value: string | number;
    label: string | React_2.ReactNode;
    disabled?: boolean;
}

export declare interface AppSelectProps<T = AppSelectOption> extends React_2.ComponentProps<typeof Select> {
    options: T[];
    placeholder?: string;
    className?: string;
    labelKey?: keyof T;
    valueKey?: keyof T;
    descriptionKey?: keyof T;
    isOptionDisabled?: (option: T) => boolean;
}

export declare function AppSidebar({ navigation, navigationFooter, versions, defaultVersion, headerContent, footerContent, showRail, linkComponent: LinkComponent, linkProps, ...props }: AppSidebarProps): JSX.Element;

declare interface AppSidebarProps extends React_2.ComponentProps<typeof Sidebar> {
    navigation: NavGroup[];
    navigationFooter?: NavGroup[];
    versions?: string[];
    defaultVersion?: string;
    headerContent?: React_2.ReactNode;
    footerContent?: React_2.ReactNode;
    showRail?: boolean;
    linkComponent?: React_2.ComponentType<any>;
    linkProps?: Record<string, any>;
}

export declare function AspectRatio({ ...props }: AspectRatioProps): JSX.Element;

declare type AspectRatioProps = React.ComponentProps<typeof AspectRatioPrimitive.Root>;

export declare function AsyncSelect<T>({ fetcher, preload, filterFn, renderOption, getOptionValue, getDisplayValue, notFound, loadingSkeleton, label, labelClassName, placeholder, value, onChange, disabled, width, className, triggerClassName, noResultsMessage, clearable, size, }: AsyncSelectProps<T>): JSX.Element;

declare interface AsyncSelectProps<T> extends VariantProps<typeof asyncSelectTriggerVariants> {
    fetcher: (query?: string) => Promise<T[]>;
    preload?: boolean;
    filterFn?: (option: T, query: string) => boolean;
    renderOption: (option: T) => React_2.ReactNode;
    getOptionValue: (option: T) => string;
    getDisplayValue: (option: T) => React_2.ReactNode;
    notFound?: React_2.ReactNode;
    loadingSkeleton?: React_2.ReactNode;
    value: string;
    onChange: (value: string) => void;
    label?: string | React_2.ReactNode;
    labelClassName?: string;
    placeholder?: string;
    disabled?: boolean;
    width?: string | number;
    className?: string;
    triggerClassName?: string;
    noResultsMessage?: string;
    clearable?: boolean;
}

declare const asyncSelectTriggerVariants: (props?: ({
    size?: "default" | "sm" | "lg" | null | undefined;
} & ClassProp) | undefined) => string;

declare interface Attachment {
    name?: string;
    contentType?: string;
    url: string;
}

export declare function AudioVisualizer({ stream, isRecording, onClick, }: AudioVisualizerProps): JSX.Element;

declare interface AudioVisualizerProps {
    stream: MediaStream | null;
    isRecording: boolean;
    onClick: () => void;
}

export declare function Avatar({ className, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Root>): JSX.Element;

export declare function AvatarFallback({ className, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Fallback>): JSX.Element;

export declare function AvatarImage({ className, ...props }: React_2.ComponentProps<typeof AvatarPrimitive.Image>): JSX.Element;

export declare interface AvatarItem {
    src: string;
    alt?: string;
}

export declare function Badge({ className, variant, asChild, ...props }: React_2.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
    asChild?: boolean;
}): JSX.Element;

export declare const badgeVariants: (props?: ({
    variant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
} & ClassProp) | undefined) => string;

declare type BarItemDataType = RepeatDataType | NoRepeatDataType;

export declare function Breadcrumb({ ...props }: React_2.ComponentProps<"nav">): JSX.Element;

export declare function BreadcrumbEllipsis({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;

export declare function BreadcrumbItem({ className, ...props }: React_2.ComponentProps<"li">): JSX.Element;

export declare function BreadcrumbLink({ asChild, className, ...props }: React_2.ComponentProps<"a"> & {
    asChild?: boolean;
}): JSX.Element;

export declare function BreadcrumbList({ className, ...props }: React_2.ComponentProps<"ol">): JSX.Element;

export declare function BreadcrumbPage({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;

export declare function BreadcrumbSeparator({ children, className, ...props }: React_2.ComponentProps<"li">): JSX.Element;

export declare function Button({ className, variant, size, asChild, iconLeft, iconRight, isLoading, ...props }: ButtonProps): JSX.Element;

export declare interface ButtonProps extends React_2.ComponentProps<"button">, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
    iconLeft?: IconName;
    iconRight?: IconName;
    isLoading?: boolean;
}

export declare const buttonVariants: (props?: ({
    variant?: "link" | "default" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Calendar({ className, classNames, showOutsideDays, ...props }: React_2.ComponentProps<typeof DayPicker>): JSX.Element;

export declare function Card({ className, size, ...props }: CardProps): JSX.Element;

export declare function CardContent({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function CardDescription({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function CardFooter({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function CardHeader({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare interface CardProps extends React_2.ComponentProps<"div"> {
    size?: CardSize;
}

declare type CardSize = "default" | "sm" | "lg" | "none";

export declare function CardTitle({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: React_2.ComponentProps<"div"> & CarouselProps): JSX.Element;

declare type CarouselApi = UseEmblaCarouselType[1];

export declare function CarouselContent({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function CarouselItem({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function CarouselNext({ className, variant, size, ...props }: React_2.ComponentProps<typeof Button>): JSX.Element;

declare type CarouselOptions = UseCarouselParameters[0];

declare type CarouselPlugin = UseCarouselParameters[1];

export declare function CarouselPrevious({ className, variant, size, ...props }: React_2.ComponentProps<typeof Button>): JSX.Element;

declare type CarouselProps = {
    opts?: CarouselOptions;
    plugins?: CarouselPlugin;
    orientation?: "horizontal" | "vertical";
    setApi?: (api: CarouselApi) => void;
};

declare const Chart: default_3.FC<ChartProps>;

export declare type ChartConfig = {
    [k in string]: {
        label?: React_2.ReactNode;
        icon?: React_2.ComponentType;
    } & ({
        color?: string;
        theme?: never;
    } | {
        color?: never;
        theme: Record<keyof typeof THEMES, string>;
    });
};

export declare function ChartContainer({ id, className, children, config, ...props }: React_2.ComponentProps<"div"> & {
    config: ChartConfig;
    children: React_2.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
}): JSX.Element;

export declare const ChartLegend: typeof RechartsPrimitive.Legend;

export declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: React_2.ComponentProps<"div"> & Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
    hideIcon?: boolean;
    nameKey?: string;
}): JSX.Element | null;

declare interface ChartProps {
    data: GanttDataType[];
    className?: string;
    onBarDoubleClick?: OnBarDoubleClickType;
    onBarChange?: OnBarChangeType;
    treeTitle?: string;
}

export declare const ChartStyle: ({ id, config }: {
    id: string;
    config: ChartConfig;
}) => JSX.Element | null;

export declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;

export declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: React_2.ComponentProps<typeof RechartsPrimitive.Tooltip> & React_2.ComponentProps<"div"> & {
    hideLabel?: boolean;
    hideIndicator?: boolean;
    indicator?: "line" | "dot" | "dashed";
    nameKey?: string;
    labelKey?: string;
}): JSX.Element | null;

export declare function Chat({ messages, handleSubmit, input, handleInputChange, stop, isGenerating, append, suggestions, className, onRateResponse, setMessages, transcribeAudio, }: ChatProps): JSX.Element;

export declare namespace Chat {
    var displayName: string;
}

declare const chatBubbleVariants: (props?: ({
    isUser?: boolean | null | undefined;
    animation?: "none" | "scale" | "slide" | "fade" | null | undefined;
} & ClassProp) | undefined) => string;

export declare const ChatContainer: ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;

export declare const ChatForm: ForwardRefExoticComponent<ChatFormProps & RefAttributes<HTMLFormElement>>;

declare interface ChatFormProps {
    className?: string;
    isPending: boolean;
    handleSubmit: (event?: {
        preventDefault?: () => void;
    }, options?: {
        experimental_attachments?: FileList;
    }) => void;
    children: (props: {
        files: File[] | null;
        setFiles: React.Dispatch<React.SetStateAction<File[] | null>>;
    }) => ReactElement;
}

export declare const ChatMessage: default_3.FC<ChatMessageProps>;

export declare interface ChatMessageProps extends Message {
    showTimeStamp?: boolean;
    animation?: Animation_2;
    actions?: default_3.ReactNode;
}

export declare function ChatMessages({ messages, children, }: React.PropsWithChildren<{
    messages: Message[];
}>): JSX.Element;

declare type ChatProps = ChatPropsWithoutSuggestions | ChatPropsWithSuggestions;

declare interface ChatPropsBase {
    handleSubmit: (event?: {
        preventDefault?: () => void;
    }, options?: {
        experimental_attachments?: FileList;
    }) => void;
    messages: Array<Message>;
    input: string;
    className?: string;
    handleInputChange: React.ChangeEventHandler<HTMLTextAreaElement>;
    isGenerating: boolean;
    stop?: () => void;
    onRateResponse?: (messageId: string, rating: "thumbs-up" | "thumbs-down") => void;
    setMessages?: (messages: any[]) => void;
    transcribeAudio?: (blob: Blob) => Promise<string>;
}

declare interface ChatPropsWithoutSuggestions extends ChatPropsBase {
    append?: never;
    suggestions?: never;
}

declare interface ChatPropsWithSuggestions extends ChatPropsBase {
    append: (message: {
        role: "user";
        content: string;
    }) => void;
    suggestions: string[];
}

export declare function Checkbox({ className, ...props }: React_2.ComponentProps<typeof CheckboxPrimitive.Root>): JSX.Element;

export declare function CircularProgress({ value, renderLabel, className, progressClassName, labelClassName, showLabel, shape, size, strokeWidth, circleStrokeWidth, progressStrokeWidth, }: CircularProgressProps): JSX.Element;

declare interface CircularProgressProps {
    value: number;
    renderLabel?: (progress: number) => number | string;
    size?: number;
    strokeWidth?: number;
    circleStrokeWidth?: number;
    progressStrokeWidth?: number;
    shape?: "square" | "round";
    className?: string;
    progressClassName?: string;
    labelClassName?: string;
    showLabel?: boolean;
}

export declare function Collapsible({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Root>): JSX.Element;

export declare function CollapsibleContent({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>): JSX.Element;

export declare function CollapsibleTrigger({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>): JSX.Element;

export declare function Command({ className, ...props }: React_2.ComponentProps<typeof Command_2>): JSX.Element;

export declare function CommandDialog({ title, description, children, ...props }: React_2.ComponentProps<typeof Dialog> & {
    title?: string;
    description?: string;
}): JSX.Element;

export declare function CommandEmpty({ ...props }: React_2.ComponentProps<typeof Command_2.Empty>): JSX.Element;

export declare function CommandGroup({ className, ...props }: React_2.ComponentProps<typeof Command_2.Group>): JSX.Element;

export declare function CommandInput({ className, ...props }: React_2.ComponentProps<typeof Command_2.Input>): JSX.Element;

export declare function CommandItem({ className, ...props }: React_2.ComponentProps<typeof Command_2.Item>): JSX.Element;

export declare function CommandList({ className, ...props }: React_2.ComponentProps<typeof Command_2.List>): JSX.Element;

export declare function CommandSeparator({ className, ...props }: React_2.ComponentProps<typeof Command_2.Separator>): JSX.Element;

export declare function CommandShortcut({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;

declare const confirm_2: (payload: ConfirmOptions) => Promise<boolean>;
export { confirm_2 as confirm }

export declare interface ConfirmedCell {
    fromId: string;
    toId: string;
    id?: string;
    value: any;
}

export declare interface ConfirmedCellsData {
    editedCells: ConfirmedCell[];
    toDefaultCells: ConfirmedCell[];
}

export declare const Confirmer: () => JSX.Element;

declare interface ConfirmOptions {
    title?: React.ReactNode;
    description?: React.ReactNode;
    cancelText?: React.ReactNode;
    actionText?: React.ReactNode;
    CancelProps?: React.ComponentProps<typeof AlertDialogCancel>;
    ActionProps?: React.ComponentProps<typeof Button>;
}

export declare function ContextMenu({ ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Root>): JSX.Element;

export declare function ContextMenuCheckboxItem({ className, children, checked, ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>): JSX.Element;

export declare function ContextMenuContent({ className, ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Content>): JSX.Element;

export declare function ContextMenuGroup({ ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Group>): JSX.Element;

export declare function ContextMenuItem({ className, inset, variant, ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Item> & {
    inset?: boolean;
    variant?: "default" | "destructive";
}): JSX.Element;

export declare function ContextMenuLabel({ className, inset, ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Label> & {
    inset?: boolean;
}): JSX.Element;

export declare function ContextMenuPortal({ ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Portal>): JSX.Element;

export declare function ContextMenuRadioGroup({ ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>): JSX.Element;

export declare function ContextMenuRadioItem({ className, children, ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.RadioItem>): JSX.Element;

export declare function ContextMenuSeparator({ className, ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Separator>): JSX.Element;

export declare function ContextMenuShortcut({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;

export declare function ContextMenuSub({ ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Sub>): JSX.Element;

export declare function ContextMenuSubContent({ className, ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.SubContent>): JSX.Element;

export declare function ContextMenuSubTrigger({ className, inset, children, ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
    inset?: boolean;
}): JSX.Element;

export declare function ContextMenuTrigger({ ...props }: React_2.ComponentProps<typeof ContextMenuPrimitive.Trigger>): JSX.Element;

declare const Controls: default_3.FC<ControlsProps>;

declare interface ControlsProps {
    className?: string;
}

export declare function CopyButton({ content, copyMessage }: CopyButtonProps): JSX.Element;

declare type CopyButtonProps = {
    content: string;
    copyMessage?: string;
};

export declare interface CrossTableCell {
    render?: (fromId: string, toId: string, id?: string) => ReactNode;
    value?: number | string | null;
    bgColor?: string;
    textColor?: string;
    fromId: string;
    toId: string;
    id?: string;
    editable?: boolean;
}

export declare interface CrossTableData {
    headerTop: CrossTableHeader[];
    headerLeft: CrossTableHeader[];
    data: (CrossTableCell | null)[][];
}

export declare interface CrossTableHeader {
    id: string;
    label: string;
}

export declare function DataCrossTable({ crossTableData, filterable, loading, emptyComponent, className, notFoundMessage, cornerHeaderFrom, cornerHeaderTo, minWidthCell, editable, editMode, onEditModeChange, onSelectedRow, selectedRow, rowSortAsc, }: DataCrossTableProps): JSX.Element;

export declare const DataCrossTableButtonsGroup: default_3.FC<DataCrossTableButtonsGroupProps>;

export declare interface DataCrossTableButtonsGroupProps {
    className?: string;
}

declare interface DataCrossTableContextType {
    editedCells: Record<string, {
        value: any;
        cell: CrossTableCell;
    }>;
    setEditedCells: default_3.Dispatch<default_3.SetStateAction<Record<string, {
        value: any;
        cell: CrossTableCell;
    }>>>;
    toDefaultCells: Record<string, {
        value: any;
        cell: CrossTableCell;
    }>;
    setToDefaultCells: default_3.Dispatch<default_3.SetStateAction<Record<string, {
        value: any;
        cell: CrossTableCell;
    }>>>;
    editMode: boolean;
    setEditMode: (mode: boolean) => void;
    onConfirmedCells?: (data: ConfirmedCellsData) => void;
    editConfirmLabel: string;
    editCancelLabel: string;
    editRestoreDefaultLabel: string;
    showDefaultActionButton: boolean;
    cellEditTitleLabel: string;
    cellEditModifiedLabel: string;
    cellConfirmButtonLabel: string;
    cellCancelButtonLabel: string;
    cellResetButtonLabel: string;
}

export declare interface DataCrossTableProps {
    crossTableData: CrossTableData;
    filterable?: boolean;
    loading?: boolean;
    emptyComponent?: ReactNode;
    className?: string;
    notFoundMessage?: string;
    cornerHeaderFrom?: string;
    cornerHeaderTo?: string;
    minWidthCell?: number;
    showFreezeControls?: boolean;
    editable?: boolean;
    editMode?: boolean;
    editConfirmLabel?: string;
    editCancelLabel?: string;
    onConfirmedCells?: (cells: ConfirmedCellsData) => void;
    onEditModeChange?: (editMode: boolean) => void;
    onSelectedRow?: (row: CrossTableHeader) => void;
    selectedRow?: CrossTableHeader;
    rowSortAsc?: boolean;
}

export declare const DataCrossTableProvider: default_3.FC<DataCrossTableProviderProps>;

export declare interface DataCrossTableProviderProps {
    children: ReactNode | ((context: DataCrossTableContextType) => ReactNode);
    onConfirmedCells?: (data: ConfirmedCellsData) => void;
    editConfirmLabel?: string;
    editCancelLabel?: string;
    editRestoreDefaultLabel?: string;
    initialEditMode?: boolean;
    showDefaultActionButton?: boolean;
    cellEditTitleLabel?: string;
    cellEditModifiedLabel?: string;
    cellConfirmButtonLabel?: string;
    cellCancelButtonLabel?: string;
    cellResetButtonLabel?: string;
}

export declare enum DataRepeatTypes {
    DAY = "DAY",
    WEEK = "WEEK",
    MONTH = "MONTH"
}

export declare function DataTable<TData, TValue>({ columns, data, loading, emptyComponent, className, rowSelection, onRowSelectionChange, checkable, onCheckedRowsChange, notFoundMessage, searchBar, dropdownFilters, totalItems, datatableSizes, paginationPlaceholders, serverOptions, setServerOptions, }: DataTableProps<TData, TValue>): JSX.Element;

export declare interface DataTableProps<TData, TValue> {
    columns: ColumnDef<TData, TValue>[];
    data: TData[];
    loading?: boolean;
    emptyComponent?: ReactNode;
    className?: string;
    rowSelection?: Record<string, boolean>;
    onRowSelectionChange?: OnChangeFn<Record<string, boolean>>;
    checkable?: boolean;
    onCheckedRowsChange?: (checkedRows: TData[]) => void;
    notFoundMessage?: string;
    searchBar?: ISearchBarProps;
    dropdownFilters?: IDropdownFilterProp[];
    totalItems?: number;
    datatableSizes?: IDatatableSizes;
    paginationPlaceholders?: IDatatablePaginationPlaceholders;
    serverOptions?: IServerOptionsProps;
    setServerOptions?: (value: SetStateAction<IServerOptionsProps>) => void;
}

export declare function DatePicker({ value, onChange, placeholder, dateFormat, className, buttonVariant, disabled, size, }: DatePickerProps): JSX.Element;

declare interface DatePickerProps {
    value?: Date;
    onChange?: (date: Date | undefined) => void;
    placeholder?: string;
    dateFormat?: string;
    className?: string;
    buttonVariant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
    disabled?: boolean;
    size?: "sm" | "default" | "lg";
}

export declare function Dialog({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Root>): JSX.Element;

export declare function DialogContent({ className, children, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Content>): JSX.Element;

export declare function DialogDescription({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Description>): JSX.Element;

export declare function DialogFooter({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function DialogHeader({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function DialogTitle({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Title>): JSX.Element;

export declare function DialogTrigger({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Trigger>): JSX.Element;

export declare enum DragStepSizes {
    FIVE_MIN = "FIVE_MIN",
    TEN_MIN = "TEN_MIN",
    FIFTEEN_MIN = "FIFTEEN_MIN",
    TWENTY_MIN = "TWENTY_MIN",
    THIRTY_MIN = "THIRTY_MIN",
    ONE_HOUR = "ONE_HOUR",
    EIGHT_HOURS = "EIGHT_HOURS",
    TWELVE_HOURS = "TWELVE_HOURS",
    ONE_DAY = "ONE_DAY"
}

export declare function Drawer({ ...props }: React_2.ComponentProps<typeof Drawer_2.Root>): JSX.Element;

export declare function DrawerContent({ className, children, ...props }: React_2.ComponentProps<typeof Drawer_2.Content>): JSX.Element;

export declare function DrawerDescription({ className, ...props }: React_2.ComponentProps<typeof Drawer_2.Description>): JSX.Element;

export declare function DrawerFooter({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function DrawerHeader({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function DrawerTitle({ className, ...props }: React_2.ComponentProps<typeof Drawer_2.Title>): JSX.Element;

export declare function DrawerTrigger({ ...props }: React_2.ComponentProps<typeof Drawer_2.Trigger>): JSX.Element;

export declare const DropdownMenu: React_2.FC<DropdownMenuPrimitive.DropdownMenuProps>;

export declare const DropdownMenuContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuLabel: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuSeparator: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuTrigger: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare enum ELogicalFilterOperator {
    AND = "AND",
    OR = "OR"
}

export declare const FilePreview: default_3.ForwardRefExoticComponent<FilePreviewProps & default_3.RefAttributes<HTMLDivElement>>;

declare interface FilePreviewProps {
    file: File;
    onRemove?: () => void;
}

export declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React_2.JSX.Element;

export declare function FormControl({ ...props }: React_2.ComponentProps<typeof Slot>): JSX.Element;

export declare function FormDescription({ className, ...props }: React_2.ComponentProps<"p">): JSX.Element;

export declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => JSX.Element;

export declare function FormItem({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function FormLabel({ className, ...props }: React_2.ComponentProps<typeof LabelPrimitive.Root>): JSX.Element;

export declare function FormMessage({ className, ...props }: React_2.ComponentProps<"p">): JSX.Element | null;

export declare const Gantt: default_3.FC<GanttProps> & {
    Chart: typeof Chart;
    Controls: typeof Controls;
};

export declare const GanttConsts: {
    ROW_HEIGHT: number;
    HEADER_HEIGHT: number;
    TREE_WIDTH: number;
    LEAF_TITLE_PADDING_LEFT: number;
    LEAF_CHILDREN_PADDING_LEFT: number;
    SCALE_STEP_DEFAULT_WIDTH: number;
    SECONDS_IN_HOUR: number;
    SECONDS_IN_DAY: number;
    HOURS_IN_DAY: number;
    MIN_SCROLL_OFFSET: number;
    SCALE_STEP_RATIO: number;
};

declare type GanttDataType<T = Record<string, unknown>> = RawGanttDataType<T> & {
    [P in keyof T]: T[P];
};

export declare enum GanttDimensions {
    HOUR = "hour",
    TWO_HOURS = "twoHours",
    THREE_HOURS = "threeHours",
    FOUR_HOURS = "fourHours",
    SIX_HOURS = "sixHours",
    EIGHT_HOURS = "eightHours",
    TWELVE_HOURS = "twelveHours",
    DAY = "day"
}

declare type GanttItemDataType<T = Record<string, unknown>> = TransformedDataType<GanttDataType<T>> & {
    /**
     * Tree level of gantt item
     */
    level: number;
    /**
     * Parents keys of gantt item
     */
    parentsKeys: string[];
    /**
     * Color of gantt item
     */
    color: string;
    /**
     * Is gantt item expanded?
     */
    expanded?: boolean;
} & T;

declare type GanttProps = {
    children: ReactNode | ReactNode[];
    draggable?: boolean;
    /**
     * Dimensione predefinita per il controllo dello zoom (1h, 1g, ecc.)
     * @default GanttDimensions.HOUR
     */
    defaultDimension?: GanttDimensions;
    /**
     * Step size predefinito per il drag delle attività
     * @default DragStepSizes.THIRTY_MIN
     */
    defaultDragStepSize?: DragStepSizes;
    /**
     * Titolo personalizzato per la colonna dell'albero
     * @default "Attività"
     */
    treeTitle?: string;
};

export declare function HoverCard({ ...props }: React_2.ComponentProps<typeof HoverCardPrimitive.Root>): JSX.Element;

export declare function HoverCardContent({ className, align, sideOffset, ...props }: React_2.ComponentProps<typeof HoverCardPrimitive.Content>): JSX.Element;

export declare function HoverCardTrigger({ ...props }: React_2.ComponentProps<typeof HoverCardPrimitive.Trigger>): JSX.Element;

export declare type IColumnDefWithSticky<TData, TValue = unknown> = ColumnDef<TData, TValue> & {
    sticky?: boolean;
};

/**
 * Componente Icon che renderizza un'icona da lucide-react
 *
 * @example
 * ```tsx
 * <Icon name="Check" size="md" />
 * <Icon name="AlertCircle" size="lg" className="text-d-destructive" />
 * <Icon name="ArrowRight" size="sm" color="#FF0000" />
 * ```
 */
export declare function Icon({ name, size, className, color, ...props }: IconProps): JSX.Element | null;

export declare type IconName = keyof typeof LucideIcons;

declare interface IconProps {
    name: IconName;
    /** Dimensione dell'icona (xs, sm, md, lg, xl) */
    size?: IconSize;
    /** Classe CSS personalizzata */
    className?: string;
    /** Colore dell'icona (sovrascrive la classe) */
    color?: string;
    /** Attributi aggiuntivi */
    [key: string]: any;
}

declare type IconSize = keyof typeof sizeMap;

export declare interface IDatatablePaginationPlaceholders {
    rows?: string;
    pages?: string;
    first?: string;
    previous?: string;
    next?: string;
    last?: string;
}

export declare interface IDatatableSizes {
    rowHeight?: number;
    headerHeight?: number;
    containerHeight?: number;
}

export declare interface IDropdownFilterItem {
    label: string;
    value: string;
}

export declare interface IDropdownFilterProp {
    column: string;
    placeholder: string;
    label?: string;
    innerFiltersMode?: ELogicalFilterOperator;
    items: IDropdownFilterItem[];
    filterFn?: (rowValue: unknown, filterValue: string[]) => boolean;
}

export declare const Input: React_2.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React_2.RefAttributes<HTMLInputElement>>;

export declare function InputOTP({ className, containerClassName, ...props }: React_2.ComponentProps<typeof OTPInput> & {
    containerClassName?: string;
}): JSX.Element;

export declare function InputOTPGroup({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function InputOTPSlot({ index, className, ...props }: React_2.ComponentProps<"div"> & {
    index: number;
}): JSX.Element;

declare interface InputProps extends Omit<React_2.ComponentProps<"input">, "label" | "size">, VariantProps<typeof inputVariants> {
    label?: string | React_2.ReactNode;
    labelClassName?: string;
    iconLeft?: IconName;
    iconRight?: IconName;
}

export declare function InputSelector({ value, onChange, min, max, className, buttonClassName, counterClassName, }: InputSelectorProps): JSX.Element;

export declare interface InputSelectorProps {
    value: number;
    onChange?: (value: number) => void;
    min?: number;
    max?: number;
    className?: string;
    buttonClassName?: string;
    counterClassName?: string;
}

declare const inputVariants: (props?: ({
    size?: "default" | "sm" | "lg" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function InterruptPrompt({ isOpen, close }: InterruptPromptProps): JSX.Element;

declare interface InterruptPromptProps {
    isOpen: boolean;
    close: () => void;
}

export declare interface IPaginationProps {
    pageIndex: number;
    pageSize: number;
}

export declare interface ISearchBarProps {
    placeholder?: string;
    columns: string[];
}

export declare interface IServerFilterProps {
    searchbarFilters?: {
        value: string;
        columns: string[];
    };
    dropdownFilters?: {
        [column: string]: {
            logic: ELogicalFilterOperator;
            value: string[];
            column: string;
        };
    };
}

export declare interface IServerOptionsProps {
    pagination: IPaginationProps;
    filters?: IServerFilterProps;
}

export declare function Label({ className, ...props }: React_2.ComponentProps<typeof LabelPrimitive.Root>): JSX.Element;

export declare function MarkdownRenderer({ children }: MarkdownRendererProps): JSX.Element;

declare interface MarkdownRendererProps {
    children: string;
}

export declare function Menubar({ className, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Root>): JSX.Element;

export declare function MenubarCheckboxItem({ className, children, checked, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.CheckboxItem>): JSX.Element;

export declare function MenubarContent({ className, align, alignOffset, sideOffset, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Content>): JSX.Element;

export declare function MenubarGroup({ ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Group>): JSX.Element;

export declare function MenubarItem({ className, inset, variant, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Item> & {
    inset?: boolean;
    variant?: "default" | "destructive";
}): JSX.Element;

export declare function MenubarLabel({ className, inset, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Label> & {
    inset?: boolean;
}): JSX.Element;

export declare function MenubarMenu({ ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Menu>): JSX.Element;

export declare function MenubarPortal({ ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Portal>): JSX.Element;

export declare function MenubarRadioGroup({ ...props }: React_2.ComponentProps<typeof MenubarPrimitive.RadioGroup>): JSX.Element;

export declare function MenubarRadioItem({ className, children, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.RadioItem>): JSX.Element;

export declare function MenubarSeparator({ className, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Separator>): JSX.Element;

export declare function MenubarShortcut({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;

export declare function MenubarSub({ ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Sub>): JSX.Element;

export declare function MenubarSubContent({ className, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.SubContent>): JSX.Element;

export declare function MenubarSubTrigger({ className, inset, children, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.SubTrigger> & {
    inset?: boolean;
}): JSX.Element;

export declare function MenubarTrigger({ className, ...props }: React_2.ComponentProps<typeof MenubarPrimitive.Trigger>): JSX.Element;

export declare interface Message {
    id: string;
    role: "user" | "assistant" | (string & {});
    content: string;
    createdAt?: Date;
    experimental_attachments?: Attachment[];
    toolInvocations?: ToolInvocation[];
    parts?: MessagePart[];
}

export declare function MessageInput({ placeholder, className, onKeyDown: onKeyDownProp, submitOnEnter, stop, isGenerating, enableInterrupt, transcribeAudio, ...props }: MessageInputProps): JSX.Element;

export declare namespace MessageInput {
    var displayName: string;
}

declare interface MessageInputBaseProps extends default_3.TextareaHTMLAttributes<HTMLTextAreaElement> {
    value: string;
    submitOnEnter?: boolean;
    stop?: () => void;
    isGenerating: boolean;
    enableInterrupt?: boolean;
    transcribeAudio?: (blob: Blob) => Promise<string>;
}

declare type MessageInputProps = MessageInputWithoutAttachmentProps | MessageInputWithAttachmentsProps;

declare interface MessageInputWithAttachmentsProps extends MessageInputBaseProps {
    allowAttachments: true;
    files: File[] | null;
    setFiles: default_3.Dispatch<default_3.SetStateAction<File[] | null>>;
}

declare interface MessageInputWithoutAttachmentProps extends MessageInputBaseProps {
    allowAttachments?: false;
}

export declare function MessageList({ messages, showTimeStamps, isTyping, messageOptions, }: MessageListProps): JSX.Element;

declare interface MessageListProps {
    messages: Message[];
    showTimeStamps?: boolean;
    isTyping?: boolean;
    messageOptions?: AdditionalMessageOptions | ((message: Message) => AdditionalMessageOptions);
}

declare type MessagePart = TextPart | ReasoningPart | ToolInvocationPart | SourcePart;

declare interface MultipleSelectDropdownProps {
    options: AppMultipleSelectOption[];
    value: string[];
    onChange: (value: string[]) => void;
    placeholder?: string;
    disabled?: boolean;
    size?: MultipleSelectSizeType;
    label?: string | React_2.ReactNode;
    labelClassName?: string;
    emptyMessage?: string;
    className?: string;
    filterPlaceholder?: string;
    filterable?: boolean;
    maxSelectedItems?: number;
    cancelLabel?: string;
    cancelButtonLabel?: string;
}

export declare const MultipleSelector: React_2.ForwardRefExoticComponent<MultipleSelectorProps & React_2.RefAttributes<MultipleSelectorRef>>;

declare interface MultipleSelectorProps {
    value?: Option_2[];
    defaultOptions?: Option_2[];
    /** manually controlled options */
    options?: Option_2[];
    placeholder?: string;
    /** Loading component. */
    loadingIndicator?: React_2.ReactNode;
    /** Empty component. */
    emptyIndicator?: React_2.ReactNode;
    /** Debounce time for async search. Only work with `onSearch`. */
    delay?: number;
    /**
     * Only work with `onSearch` prop. Trigger search when `onFocus`.
     * For example, when user click on the input, it will trigger the search to get initial options.
     **/
    triggerSearchOnFocus?: boolean;
    /** async search */
    onSearch?: (value: string) => Promise<Option_2[]>;
    /**
     * sync search. This search will not showing loadingIndicator.
     * The rest props are the same as async search.
     * i.e.: creatable, groupBy, delay.
     **/
    onSearchSync?: (value: string) => Option_2[];
    onChange?: (options: Option_2[]) => void;
    /** Limit the maximum number of selected options. */
    maxSelected?: number;
    /** When the number of selected options exceeds the limit, the onMaxSelected will be called. */
    onMaxSelected?: (maxLimit: number) => void;
    /** Hide the placeholder when there are options selected. */
    hidePlaceholderWhenSelected?: boolean;
    disabled?: boolean;
    /** Group the options base on provided key. */
    groupBy?: string;
    className?: string;
    badgeClassName?: string;
    /**
     * First item selected is a default behavior by cmdk. That is why the default is true.
     * This is a workaround solution by add a dummy item.
     *
     * @reference: https://github.com/pacocoursey/cmdk/issues/171
     */
    selectFirstItem?: boolean;
    /** Allow user to create option when there is no option matched. */
    creatable?: boolean;
    /** Props of `Command` */
    commandProps?: React_2.ComponentPropsWithoutRef<typeof Command>;
    /** Props of `CommandInput` */
    inputProps?: Omit<React_2.ComponentPropsWithoutRef<typeof Command_2.Input>, "value" | "placeholder" | "disabled">;
    label?: string | React_2.ReactNode;
    /** hide the clear all button. */
    hideClearAllButton?: boolean;
}

export declare interface MultipleSelectorRef {
    selectedValue: Option_2[];
    input: HTMLInputElement;
    focus: () => void;
    reset: () => void;
}

declare type MultipleSelectSizeType = "sm" | "default" | "lg";

export declare interface NavGroup {
    title: string;
    url?: string;
    items: NavItem[];
}

export declare function NavigationMenu({ className, children, viewport, ...props }: React_2.ComponentProps<typeof NavigationMenuPrimitive.Root> & {
    viewport?: boolean;
}): JSX.Element;

export declare function NavigationMenuContent({ className, ...props }: React_2.ComponentProps<typeof NavigationMenuPrimitive.Content>): JSX.Element;

export declare function NavigationMenuIndicator({ className, ...props }: React_2.ComponentProps<typeof NavigationMenuPrimitive.Indicator>): JSX.Element;

export declare function NavigationMenuItem({ className, ...props }: React_2.ComponentProps<typeof NavigationMenuPrimitive.Item>): JSX.Element;

export declare function NavigationMenuLink({ className, ...props }: React_2.ComponentProps<typeof NavigationMenuPrimitive.Link>): JSX.Element;

export declare function NavigationMenuList({ className, ...props }: React_2.ComponentProps<typeof NavigationMenuPrimitive.List>): JSX.Element;

export declare function NavigationMenuTrigger({ className, children, ...props }: React_2.ComponentProps<typeof NavigationMenuPrimitive.Trigger>): JSX.Element;

export declare function NavigationMenuViewport({ className, ...props }: React_2.ComponentProps<typeof NavigationMenuPrimitive.Viewport>): JSX.Element;

export declare interface NavItem {
    title: string;
    url: string;
    isActive?: boolean;
    iconName?: IconName;
    subItems?: NavSubItem[];
}

export declare interface NavSubItem {
    title: string;
    url: string;
    isActive?: boolean;
    iconName?: IconName;
}

declare type NoRepeatDataType = {
    /**
     * Start date and time of unrepeatable bar item
     */
    startDate: string;
    /**
     * End date and time of unrepeatable bar item
     */
    endDate: string;
    fromTime?: never;
    toTime?: never;
    fromDate?: never;
    toDate?: never;
    repeatType?: never;
    weekdays?: never;
    monthdays?: never;
};

declare type OnBarChangeType<T extends Record<string, unknown> = any> = (barData: GanttItemDataType<T>, data: (GanttItemDataType<T> & T)[]) => any;

declare type OnBarDoubleClickType<T extends Record<string, unknown> = any> = (barData: GanttItemDataType<T>) => any;

declare interface Option_2 {
    value: string;
    label: string;
    disable?: boolean;
    /** fixed option that can't be removed. */
    fixed?: boolean;
    /** Group the options by providing key. */
    [key: string]: string | boolean | undefined;
}

export declare function Pagination({ className, ...props }: React_2.ComponentProps<"nav">): JSX.Element;

export declare function PaginationContent({ className, ...props }: React_2.ComponentProps<"ul">): JSX.Element;

export declare function PaginationEllipsis({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;

export declare function PaginationItem({ ...props }: React_2.ComponentProps<"li">): JSX.Element;

export declare function PaginationLink({ className, isActive, isDisabled, size, ...props }: PaginationLinkProps): JSX.Element;

declare type PaginationLinkProps = {
    isActive?: boolean;
    isDisabled?: boolean;
    label?: string;
} & Pick<React_2.ComponentProps<typeof Button>, "size"> & React_2.ComponentProps<"a">;

export declare function PaginationNext({ className, label, ...props }: React_2.ComponentProps<typeof PaginationLink>): JSX.Element;

export declare function PaginationPrevious({ className, label, ...props }: React_2.ComponentProps<typeof PaginationLink>): JSX.Element;

declare interface PartialToolCall {
    state: "partial-call";
    toolName: string;
}

export declare function Popover({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Root>): JSX.Element;

export declare function PopoverContent({ className, align, sideOffset, ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Content>): JSX.Element;

export declare function PopoverTrigger({ ...props }: React_2.ComponentProps<typeof PopoverPrimitive.Trigger>): JSX.Element;

export declare function Progress({ className, value, ...props }: React_2.ComponentProps<typeof ProgressPrimitive.Root>): JSX.Element;

export declare function PromptSuggestions({ label, append, suggestions, }: PromptSuggestionsProps): JSX.Element;

declare interface PromptSuggestionsProps {
    label: string;
    append: (message: {
        role: "user";
        content: string;
    }) => void;
    suggestions: string[];
}

export declare function RadioGroup({ className, ...props }: React_2.ComponentProps<typeof RadioGroupPrimitive.Root>): JSX.Element;

export declare function RadioGroupItem({ className, ...props }: React_2.ComponentProps<typeof RadioGroupPrimitive.Item>): JSX.Element;

declare type RawGanttDataType<T = Record<string, unknown>> = {
    /**
     * Title of gantt item
     */
    title: string;
    /**
     * Unique gantt item key
     */
    key: string;
    /**
     * Color of gantt item
     */
    color?: string;
    /**
     * Data to render gantt item on the chart
     */
    data?: BarItemDataType;
    /**
     * Nested gantt items
     */
    children?: GanttDataType<T>[];
    /**
     * Custom component to render on the left side of the title
     * Può essere un ReactNode o una funzione che riceve i dati della barra e restituisce un ReactNode
     */
    leftRender?: React.ReactNode | ((barData: RawGanttDataType) => React.ReactNode);
};

declare interface ReasoningPart {
    type: "reasoning";
    reasoning: string;
}

declare type RepeatDataType = {
    /**
     * Type of repeatable gantt item
     */
    repeatType: DataRepeatTypes;
    /**
     * Repeatable gantt item start time in seconds (0-86400)
     */
    fromTime: number;
    /**
     * Repeatable gantt item end time in seconds (0-86400)
     */
    toTime: number;
    /**
     * Start date of repeatable gantt items
     */
    fromDate?: string;
    /**
     * End date of Repeatable gantt items
     */
    toDate?: string;
    /**
     * Numbers of weekdays for repeating (0-6)
     */
    weekdays?: number[];
    /**
     * Numbers of monthdays for repeating (0-31)
     */
    monthdays?: number[];
    startDate?: never;
    endDate?: never;
};

export declare function ResizableHandle({ withHandle, className, ...props }: React_2.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
    withHandle?: boolean;
}): JSX.Element;

export declare function ResizablePanel({ ...props }: React_2.ComponentProps<typeof ResizablePrimitive.Panel>): JSX.Element;

export declare function ResizablePanelGroup({ className, ...props }: React_2.ComponentProps<typeof ResizablePrimitive.PanelGroup>): JSX.Element;

export declare function ScrollArea({ className, children, ...props }: React_2.ComponentProps<typeof ScrollAreaPrimitive.Root>): JSX.Element;

export declare function ScrollBar({ className, orientation, ...props }: React_2.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): JSX.Element;

export declare function Select({ size, label, className, labelClassName, ...props }: SelectProps): JSX.Element;

export declare function SelectContent({ className, children, position, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Content>): JSX.Element;

export declare function SelectGroup({ ...props }: React_2.ComponentProps<typeof SelectPrimitive.Group>): JSX.Element;

export declare function SelectItem({ className, children, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Item>): JSX.Element;

export declare function SelectLabel({ className, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Label>): JSX.Element;

declare interface SelectProps extends React_2.ComponentProps<typeof SelectPrimitive.Root> {
    size?: SelectSizeType;
    label?: string | React_2.ReactNode;
    className?: string;
    labelClassName?: string;
}

export declare function SelectSeparator({ className, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Separator>): JSX.Element;

declare type SelectSizeType = "sm" | "default" | "lg";

export declare function SelectTrigger({ className, size: sizeProp, children, ...props }: React_2.ComponentProps<typeof SelectPrimitive.Trigger> & {
    size?: SelectSizeType;
}): JSX.Element;

export declare function SelectValue({ ...props }: React_2.ComponentProps<typeof SelectPrimitive.Value>): JSX.Element;

export declare function Separator({ className, orientation, decorative, ...props }: React_2.ComponentProps<typeof SeparatorPrimitive.Root>): JSX.Element;

export declare function Sheet({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Root>): JSX.Element;

export declare function SheetContent({ className, children, side, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Content> & {
    side?: "top" | "right" | "bottom" | "left";
}): JSX.Element;

export declare function SheetDescription({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Description>): JSX.Element;

export declare function SheetFooter({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function SheetHeader({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;

export declare function SheetTitle({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Title>): JSX.Element;

export declare function SheetTrigger({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Trigger>): JSX.Element;

export declare const Sidebar: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
    side?: "left" | "right";
    variant?: "sidebar" | "floating" | "inset";
    collapsible?: "offcanvas" | "icon" | "none";
}, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarContent: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

declare type SidebarContextProps = {
    state: "expanded" | "collapsed";
    open: boolean;
    setOpen: (open: boolean) => void;
    openMobile: boolean;
    setOpenMobile: (open: boolean) => void;
    isMobile: boolean;
    toggleSidebar: () => void;
};

export declare const SidebarFooter: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarGroup: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarGroupAction: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLButtonElement> & React_2.ButtonHTMLAttributes<HTMLButtonElement> & {
    asChild?: boolean;
}, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const SidebarGroupContent: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarGroupLabel: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
    asChild?: boolean;
}, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarHeader: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarInput: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<InputProps_2, "ref"> & React_2.RefAttributes<HTMLInputElement>, "ref">, "ref"> & React_2.RefAttributes<HTMLInputElement>>;

export declare const SidebarInset: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarMenu: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React_2.RefAttributes<HTMLUListElement>>;

export declare const SidebarMenuAction: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLButtonElement> & React_2.ButtonHTMLAttributes<HTMLButtonElement> & {
    asChild?: boolean;
    showOnHover?: boolean;
}, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const SidebarMenuBadge: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarMenuButton: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLButtonElement> & React_2.ButtonHTMLAttributes<HTMLButtonElement> & {
    asChild?: boolean;
    isActive?: boolean;
    tooltip?: string | React_2.ComponentProps<typeof TooltipContent>;
} & VariantProps<(props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & ClassProp) | undefined) => string>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const SidebarMenuItem: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React_2.RefAttributes<HTMLLIElement>>;

export declare const SidebarMenuSkeleton: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
    showIcon?: boolean;
}, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarMenuSub: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React_2.RefAttributes<HTMLUListElement>>;

export declare const SidebarMenuSubButton: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLAnchorElement> & React_2.AnchorHTMLAttributes<HTMLAnchorElement> & {
    asChild?: boolean;
    size?: "sm" | "md";
    isActive?: boolean;
}, "ref"> & React_2.RefAttributes<HTMLAnchorElement>>;

export declare const SidebarMenuSubItem: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React_2.RefAttributes<HTMLLIElement>>;

export declare const SidebarProvider: React_2.ForwardRefExoticComponent<Omit<React_2.ClassAttributes<HTMLDivElement> & React_2.HTMLAttributes<HTMLDivElement> & {
    defaultOpen?: boolean;
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
}, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarRail: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const SidebarSeparator: React_2.ForwardRefExoticComponent<Omit<SeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

export declare const SidebarTrigger: React_2.ForwardRefExoticComponent<Omit<ButtonProps_2, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

declare const sizeMap: {
    xs: number;
    sm: number;
    md: number;
    lg: number;
    xl: number;
};

export declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): JSX.Element;

export declare const Slider: React_2.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & VariantProps<(props?: ({
    size?: "base" | "large" | "medium" | null | undefined;
} & ClassProp) | undefined) => string> & {
    formatValue?: (value: number) => string;
    showValues?: boolean;
    showStickyLabel?: boolean;
    stickyLabelSuffix?: string;
    fillOffset?: boolean;
    offsetValue?: number;
    /**
     * Valori predefiniti per la selezione a step
     * Es: [0, 25, 50, 75, 100]
     */
    steps?: number[];
    showStepMarkers?: boolean;
} & React_2.RefAttributes<HTMLSpanElement>>;

declare interface SourcePart {
    type: "source";
}

export declare function Switch({ className, ...props }: React_2.ComponentProps<typeof SwitchPrimitive.Root>): JSX.Element;

export declare function Table({ className, ...props }: React_2.ComponentProps<"table">): JSX.Element;

export declare function TableBody({ className, ...props }: React_2.ComponentProps<"tbody">): JSX.Element;

export declare function TableCaption({ className, ...props }: React_2.ComponentProps<"caption">): JSX.Element;

export declare function TableCell({ className, ...props }: React_2.ComponentProps<"td">): JSX.Element;

export declare function TableFooter({ className, ...props }: React_2.ComponentProps<"tfoot">): JSX.Element;

export declare function TableHead({ className, ...props }: React_2.ComponentProps<"th">): JSX.Element;

export declare function TableHeader({ className, ...props }: React_2.ComponentProps<"thead">): JSX.Element;

export declare function TableRow({ className, ...props }: React_2.ComponentProps<"tr">): JSX.Element;

export declare function Tabs({ className, ...props }: React_2.ComponentProps<typeof TabsPrimitive.Root>): JSX.Element;

export declare function TabsContent({ className, ...props }: React_2.ComponentProps<typeof TabsPrimitive.Content>): JSX.Element;

export declare function TabsList({ className, ...props }: React_2.ComponentProps<typeof TabsPrimitive.List>): JSX.Element;

export declare function TabsTrigger({ className, ...props }: React_2.ComponentProps<typeof TabsPrimitive.Trigger>): JSX.Element;

export declare function Textarea({ className, ...props }: React_2.ComponentProps<"textarea">): JSX.Element;

declare interface TextPart {
    type: "text";
    text: string;
}

declare const THEMES: {
    readonly light: "";
    readonly dark: ".dark";
};

export declare const ThemeSwitcher: ({ value, onChange, defaultValue, className, }: ThemeSwitcherProps) => JSX.Element | null;

declare type ThemeSwitcherProps = {
    value?: "light" | "dark" | "system";
    onChange?: (theme: "light" | "dark" | "system") => void;
    defaultValue?: "light" | "dark" | "system";
    className?: string;
};

export declare const Toaster: ({ ...props }: ToasterProps) => JSX.Element;

declare type ToasterProps = React.ComponentProps<typeof Toaster_2>;

export declare function Toggle({ className, variant, size, ...props }: React_2.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): JSX.Element;

export declare function ToggleGroup({ className, variant, size, children, ...props }: React_2.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants>): JSX.Element;

export declare function ToggleGroupItem({ className, children, variant, size, ...props }: React_2.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): JSX.Element;

export declare const toggleVariants: (props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & ClassProp) | undefined) => string;

declare function ToolCall({ toolInvocations, }: Pick<ChatMessageProps, "toolInvocations">): JSX.Element | null;

declare interface ToolCall {
    state: "call";
    toolName: string;
}

declare type ToolInvocation = PartialToolCall | ToolCall | ToolResult;

declare interface ToolInvocationPart {
    type: "tool-invocation";
    toolInvocation: ToolInvocation;
}

declare interface ToolResult {
    state: "result";
    toolName: string;
    result: {
        __cancelled?: boolean;
        [key: string]: any;
    };
}

export declare function Tooltip({ ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Root>): JSX.Element;

export declare function TooltipContent({ className, sideOffset, children, ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Content>): JSX.Element;

export declare function TooltipProvider({ delayDuration, ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Provider>): JSX.Element;

export declare function TooltipTrigger({ ...props }: React_2.ComponentProps<typeof TooltipPrimitive.Trigger>): JSX.Element;

declare type TransformedDataType<T> = {
    [P in keyof T as Exclude<P, "children">]: T[P];
};

export declare function TypingIndicator(): JSX.Element;

export declare const Typo: React_2.FC<TypoProps>;

export declare interface TypoProps extends React_2.HTMLAttributes<HTMLElement> {
    variant?: TypoVariant;
    as?: React_2.ElementType;
}

declare type TypoVariant = "hero-title" | "title" | "subtitle" | "body" | "body-bold" | "caption" | "overline" | "button" | "small" | "h1" | "h2" | "h3" | "h4" | "h5";

export declare function useAudioRecording({ transcribeAudio, onTranscriptionComplete, }: UseAudioRecordingOptions): {
    isListening: boolean;
    isSpeechSupported: boolean;
    isRecording: boolean;
    isTranscribing: boolean;
    audioStream: MediaStream | null;
    toggleListening: () => Promise<void>;
    stopRecording: () => Promise<void>;
};

declare interface UseAudioRecordingOptions {
    transcribeAudio?: (blob: Blob) => Promise<string>;
    onTranscriptionComplete?: (text: string) => void;
}

export declare function useAutoScroll(dependencies: React.DependencyList): {
    containerRef: RefObject<HTMLDivElement | null>;
    scrollToBottom: () => void;
    handleScroll: () => void;
    shouldAutoScroll: boolean;
    handleTouchStart: () => void;
};

export declare function useAutosizeTextArea({ ref, maxHeight, borderWidth, dependencies, }: UseAutosizeTextAreaProps): void;

declare interface UseAutosizeTextAreaProps {
    ref: React.RefObject<HTMLTextAreaElement>;
    maxHeight?: number;
    borderWidth?: number;
    dependencies: React.DependencyList;
}

declare type UseCarouselParameters = Parameters<typeof default_2>;

export declare function useCopyToClipboard({ text, copyMessage, }: UseCopyToClipboardProps): {
    isCopied: boolean;
    handleCopy: () => void;
};

declare type UseCopyToClipboardProps = {
    text: string;
    copyMessage?: string;
};

export declare function useDebounce<T>(value: T, delay: number): T;

export declare const useFormField: () => {
    invalid: boolean;
    isDirty: boolean;
    isTouched: boolean;
    isValidating: boolean;
    error?: FieldError;
    id: string;
    name: string;
    formItemId: string;
    formDescriptionId: string;
    formMessageId: string;
};

export declare function useIsMobile(): boolean;

export declare function useSidebar(): SidebarContextProps;

export { }