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 * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import { ClassProp } from 'class-variance-authority/types';
import { ClassValue } from 'clsx';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import { ColumnDef } from '@tanstack/react-table';
import { Command as Command_2 } from 'cmdk';
import { ComponentProps } from 'react';
import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
import { ControllerProps } from 'react-hook-form';
import { ControllerRenderProps } from 'react-hook-form';
import { DateRange } from 'react-day-picker';
import { DayPicker } from 'react-day-picker';
import { default as default_2 } from 'react';
import { default as default_3 } from 'embla-carousel-react';
import { DialogContentProps } from '@radix-ui/react-dialog';
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 { JSX } from 'react/jsx-runtime';
import { JSX as JSX_2 } from 'react';
import * as LabelPrimitive from '@radix-ui/react-label';
import { Locale } from 'date-fns';
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 { Row } from '@tanstack/react-table';
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 * 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 { toast } from 'sonner';
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 { TooltipContentProps as TooltipContentProps_2 } from '@radix-ui/react-tooltip';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { UseAskResult } from 'use-ask';
import { UseEmblaCarouselType } from 'embla-carousel-react';
import { UseFormReturn } from 'react-hook-form';
import { VariantProps } from 'class-variance-authority';

declare type AcceptItem = "pdf" | "doc" | "docx" | "xls" | "xlsx" | "ppt" | "pptx" | "txt" | "csv" | "jpg" | "jpeg" | "png" | "gif" | "image" | "video" | "audio" | "zip" | "rar" | "7z" | "tar" | "gz" | "tgz";

/**
 * Distributive helper: for a given key K, creates a config where cell gets the resolved value type.
 * By distributing over each key individually, TypeScript narrows the value type based on the literal accessorKey.
 */
declare type AccessorColumnConfigForKey<TData, K extends string> = BaseColumnFields & {
    accessorKey: K;
    cell?: (value: DeepValue<TData, K>, row: TData, tableRow: Row<TData>) => React.ReactNode;
    cellClassName?: string | ((value: DeepValue<TData, K>, row: TData) => string);
};

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 AppCard({ header, title, description, body, actions, footer, variant, size, isLoading, showHeaderBorder, showFooterBorder, className, headerClassName, bodyClassName, footerClassName, children, ...props }: Readonly<AppCardProps>): JSX.Element;

export declare interface AppCardProps extends Omit<React_2.ComponentProps<"div">, "title"> {
    /** Header content (title and/or description) */
    header?: React_2.ReactNode;
    /** Card title displayed in the header */
    title?: string | React_2.ReactNode;
    /** Card description displayed below the title */
    description?: string | React_2.ReactNode;
    /** Main content of the card */
    body?: React_2.ReactNode;
    /**
     * Fallback body content when `body` is not provided.
     * `body` takes precedence over `children` if both are passed.
     */
    children?: React_2.ReactNode;
    /** Action buttons typically displayed in the header (right-aligned) */
    actions?: React_2.ReactNode;
    /** Footer content (typically action buttons) */
    footer?: React_2.ReactNode;
    /** Visual variant of the card */
    variant?: AppCardVariant;
    /** Controls internal padding via the base Card component */
    size?: AppCardSize;
    /** When true, renders skeleton placeholders instead of content */
    isLoading?: boolean;
    /** Whether to show a border between header and body */
    showHeaderBorder?: boolean;
    /** Whether to show a border between body and footer */
    showFooterBorder?: boolean;
    /** Additional className for the card container */
    className?: string;
    /** Additional className for the header section */
    headerClassName?: string;
    /** Additional className for the body section */
    bodyClassName?: string;
    /** Additional className for the footer section */
    footerClassName?: string;
}

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

export declare type AppCardVariant = "default" | "elevated" | "outlined" | "ghost" | "flat" | "interactive" | "success" | "warning" | "destructive" | "info";

export declare function AppCheckbox({ options, value, defaultValue, onValueChange, label, description, disabled, required, name, orientation, className, wrpClassName, optionClassName, layout, error, id, "data-testid": dataTestId, }: AppCheckboxProps): JSX.Element;

export declare interface AppCheckboxOption {
    value: string;
    label: string | React_2.ReactNode;
    description?: string | React_2.ReactNode;
    disabled?: boolean;
    icon?: IconName;
}

export declare interface AppCheckboxProps {
    options: AppCheckboxOption[];
    value?: string[];
    defaultValue?: string[];
    onValueChange?: (value: string[]) => void;
    label?: string | React_2.ReactNode;
    description?: string | React_2.ReactNode;
    disabled?: boolean;
    required?: boolean;
    name?: string;
    orientation?: "horizontal" | "vertical";
    className?: string;
    wrpClassName?: string;
    optionClassName?: string;
    layout?: "default" | "card";
    error?: string;
    id?: string;
    "data-testid"?: string;
}

export declare function AppDialog({ children, trigger, title, description, footer, size, open, defaultOpen, onOpenChange, triggerClassName, headerClassName, bodyClassName, footerClassName, disabled, asChild, preventClose, ...contentProps }: Readonly<AppDialogProps>): JSX.Element;

export declare interface AppDialogProps extends Omit<DialogContentProps, "title"> {
    /** Element that triggers the dialog on click */
    trigger?: React_2.ReactNode;
    /** Dialog title displayed in the header */
    title: string | React_2.ReactNode;
    /** Dialog description displayed below the title */
    description?: string | React_2.ReactNode;
    /** Footer content (typically action buttons) */
    footer?: React_2.ReactNode;
    /** Size variant of the dialog */
    size?: "sm" | "default" | "lg" | "xl" | "full";
    /** Whether the dialog can be closed by clicking the overlay */
    closeOnOverlay?: boolean;
    /** Controlled open state */
    open?: boolean;
    /** Default open state for uncontrolled usage */
    defaultOpen?: boolean;
    /** Callback when open state changes */
    onOpenChange?: (open: boolean) => void;
    /** Additional className for the dialog */
    className?: string;
    /** Additional className for the trigger wrapper */
    triggerClassName?: string;
    /** Additional className for the dialog content */
    contentClassName?: string;
    /** Additional className for the dialog's header */
    headerClassName?: string;
    /** Additional className for the dialog's body */
    bodyClassName?: string;
    /** Additional className for the dialog's footer */
    footerClassName?: string;
    /** Whether to disable the trigger */
    disabled?: boolean;
    /** Whether to use asChild pattern for trigger (for custom elements) */
    asChild?: boolean;
    preventClose?: "overlay" | "all";
}

export declare function AppEditor({ defaultValue, onMarkdownEdit, plugins, toolbars, placeholder, onlyMarkdown, className, wrpClassName, }: AppEditorProps): JSX.Element;

declare type AppEditorPlugin = "clear" | "counter";

declare interface AppEditorProps {
    defaultValue?: string;
    onMarkdownEdit?: (markdown: string) => void;
    plugins?: AppEditorPlugin[];
    toolbars?: AppEditorToolbar[];
    placeholder?: string;
    onlyMarkdown?: boolean;
    className?: string;
    wrpClassName?: string;
}

declare type AppEditorToolbar = "block-format" | "font-format" | "history";

export declare const AppForm: <TFormValues extends FieldValues = FieldValues, TAsyncOption = unknown>({ items, cols, form, submitText, onSubmit, isSubmitting, showSubmitButton, }: AppFormProps<TFormValues, TAsyncOption>) => JSX.Element;

declare type AppFormComponentType = "input" | "select" | "textarea" | "checkbox" | "multiselect" | "datepicker" | "radio" | "switch" | "slider" | "async" | "async-multiple" | "custom";

export declare type AppFormItem<TAsyncOption = unknown, TComponent extends AppFormComponentType = AppFormComponentType> = {
    /** Field label displayed above the component. */
    label: string;
    /** The type of form component to render. */
    component: TComponent;
    /** Field name used for React Hook Form state binding and validation. */
    name: string;
    /**
     * HTML input type. Only applies when `component` is `"input"`.
     * @example "text" | "email" | "password" | "number" | "url" | "search" | "tel"
     */
    inputType?: ComponentProps<"input">["type"];
    /** Initial value for the field. */
    defaultValue?: string | boolean | number | string[] | Date | number[];
    /** Options list for `select`, `multiselect`, and `radio` components. */
    options?: AppSelectOption[];
    /**
     * Disables the field, preventing user interaction.
     * @default false
     */
    disabled?: boolean;
    /** Placeholder text shown when no value is selected or entered. */
    placeholder?: string;
    /** Helper text displayed below the field. */
    caption?: string;
    /**
     * Enables range mode on the `datepicker` component when provided.
     * The two dates define the selectable calendar boundaries.
     */
    calendarRange?: [Date, Date];
    /** Minimum value for the `slider` component. @default 0 */
    min?: number;
    /** Maximum value for the `slider` component. @default 100 */
    max?: number;
    /** Step increment for the `slider` component. @default 1 */
    step?: number;
    /**
     * Async data loader for `async` and `async-multiple` components.
     * Called with the current search query; must return a promise of options.
     */
    fetcher?: (query?: string) => Promise<TAsyncOption[]>;
    /**
     * Custom render function for each option item in the async dropdown.
     * Required for `async` and `async-multiple` components.
     */
    renderOptionItem?: (option: TAsyncOption) => React.ReactNode;
    /**
     * Extracts the unique string value from an async option object.
     * Required for `async` and `async-multiple` components.
     */
    resolveOptionValue?: (option: TAsyncOption) => string;
    /**
     * Custom render function for the selected value chip/label.
     * Required for `async` and `async-multiple` components.
     */
    renderSelectedValue?: (option: TAsyncOption) => React.ReactNode;
    /**
     * Pre-loaded options used to hydrate the async select on mount,
     * avoiding an initial fetch when the value is already known.
     */
    initialOptions?: TAsyncOption[];
    /** Custom node displayed when the async fetcher returns no results at all. */
    notFound?: React.ReactNode;
    /** Message shown when the async search query returns no matching results. */
    noResultsMessage?: string;
    /**
     * Debounce delay in milliseconds for the async search input.
     * @default 300
     */
    debounce?: number;
    /**
     * Allows the user to clear the selected value in the async select.
     * @default false
     */
    clearable?: boolean;
    /** Extra props forwarded directly to the `DatePicker` component. */
    datePickerProps?: Partial<DatePickerProps>;
    /**
     * Column span for the item in the grid.
     * @default undefined (auto, or `"full"` for the last item)
     */
    colSpan?: "1" | "2" | "3" | "full";
    /**
     * Icon to display on the left side of the input.
     * Only applies when `component` is `"input"`.
     */
    iconLeft?: IconName;
    /**
     * Icon to display on the right side of the input.
     * Only applies when `component` is `"input"`.
     */
    iconRight?: IconName;
    /**
     * Enables search/filter functionality inside `select` and `multiselect` dropdowns.
     * @default true
     */
    searchable?: boolean;
    /**
     * Custom render function for the component.
     * Required when `component` is `"custom"`.
     */
    render?: (props: {
        field: ControllerRenderProps<FieldValues, string>;
        error?: string;
        label: React.ReactNode;
    }) => React.ReactNode;
    /**
     * Hides the label above the field.
     * @default false
     */
    hideLabel?: boolean;
    /**
     * Additional props forwarded to the underlying UI component.
     * Strongly typed based on the chosen `component` value.
     */
    componentProps?: AppFormItemComponentProps<TAsyncOption>[TComponent];
    /** Additional CSS class name applied to the item container div. */
    className?: string;
};

declare interface AppFormItemComponentProps<TAsyncOption = unknown> {
    input: Omit<InputProps, "name" | "value" | "onChange" | "onBlur" | "disabled" | "placeholder" | "type" | "iconLeft" | "iconRight" | "label">;
    select: Omit<SingleSelectProps, "options" | "placeholder" | "disabled" | "searchable" | "value" | "onValueChange" | "multiple" | "label">;
    multiselect: Omit<MultiSelectProps, "options" | "placeholder" | "disabled" | "searchable" | "value" | "onValueChange" | "multiple" | "label">;
    textarea: Omit<ComponentProps<typeof Textarea>, "name" | "value" | "onChange" | "onBlur" | "disabled" | "placeholder" | "label">;
    checkbox: Omit<ComponentProps<typeof Checkbox>, "checked" | "onCheckedChange" | "disabled" | "id" | "name">;
    datepicker: Omit<DatePickerProps, "mode" | "value" | "onChange" | "placeholder" | "disabled" | "label">;
    radio: Omit<ComponentProps<typeof RadioGroup>, "value" | "onValueChange" | "disabled" | "name">;
    switch: Omit<ComponentProps<typeof Switch>, "checked" | "onCheckedChange" | "disabled" | "id" | "name">;
    slider: Omit<ComponentProps<typeof Slider>, "value" | "onValueChange" | "min" | "max" | "step" | "disabled">;
    async: Omit<AsyncSelectProps<TAsyncOption>, "multiple" | "fetcher" | "initialOptions" | "renderOptionItem" | "resolveOptionValue" | "renderSelectedValue" | "value" | "onChange" | "placeholder" | "disabled" | "notFound" | "noResultsMessage" | "debounce" | "clearable" | "label">;
    "async-multiple": Omit<AsyncSelectProps<TAsyncOption>, "multiple" | "fetcher" | "initialOptions" | "renderOptionItem" | "resolveOptionValue" | "renderSelectedValue" | "value" | "onChange" | "placeholder" | "disabled" | "notFound" | "noResultsMessage" | "debounce" | "clearable" | "label">;
    custom: Record<string, unknown>;
}

declare interface AppFormProps<TFormValues extends FieldValues = FieldValues, TAsyncOption = unknown> {
    /** Number of grid columns for the form layout. @default "2" */
    cols?: "1" | "2" | "3";
    /** Array of field configurations describing each form field. */
    items: AppFormItem<TAsyncOption, AppFormComponentType>[];
    /** React Hook Form instance returned by `useForm`. */
    form: UseFormReturn<TFormValues>;
    /** Text label for the internal submit button. @default "Invia" */
    submitText?: string;
    /** Callback fired with validated form data on submission. */
    onSubmit?: (data: TFormValues) => void;
    /**
     * When `true`, shows a loading spinner on the submit button.
     * @default false
     */
    isSubmitting?: boolean;
    /**
     * When `true`, renders an internal submit button at the bottom of the form.
     * The button is disabled while the form is invalid or pristine.
     * @default false
     */
    showSubmitButton?: boolean;
}

export declare function AppKanban<T = unknown>({ columns, initialTasks, onTaskMove, onTaskEdit, onTaskCreate, taskActions, renderTaskContent, className, allowTaskCreate, }: AppKanbanConfig<T>): JSX.Element;

export declare type AppKanbanColumn = {
    id: string;
    label: string;
    disabled?: boolean;
    /**
     * Prevent dropping cards into this column.
     */
    disableOnDragIn?: boolean;
    /**
     * Prevent dragging cards out of this column.
     */
    disableOnDragOut?: boolean;
};

export declare type AppKanbanConfig<T = unknown> = {
    columns: AppKanbanColumn[];
    initialTasks: Record<string, AppKanbanTask<T>[]>;
    onTaskMove?: (taskId: string, fromColumn: string, toColumn: string) => void;
    onTaskEdit?: (task: AppKanbanTask<T>, columnId: string) => void;
    onTaskCreate?: (columnId: string) => void;
    taskActions?: (task: AppKanbanTask<T>, columnId: string) => KanbanBoardCardAction[];
    renderTaskContent?: (task: AppKanbanTask<T>, columnId: string) => ReactNode;
    className?: string;
    allowTaskCreate?: boolean;
    createTaskLabel?: string;
};

export declare type AppKanbanTask<T = unknown> = {
    id: string;
    title: string;
    description?: string;
    data?: T;
    meta?: KanbanBoardCardMetaItem[];
    icon?: IconName;
    createTaskLabel?: string;
};

/**
 * @deprecated This component is deprecated. Please use AppSelect component instead.
 */
export declare function AppMultipleSelectDropdown({ options, value, onChange, onClear, placeholder, disabled, size, label, labelClassName, emptyMessage, className, searchPlaceholder, searchable, cancelLabel, maxSelectedItems, }: MultipleSelectDropdownProps): JSX.Element;

/**
 * @deprecated This interface is deprecated. Please use AppSelect component instead.
 */
export declare interface AppMultipleSelectOption {
    value: string;
    label: string;
    disabled?: boolean;
}

export declare function AppRadioGroup({ options, value, defaultValue, onValueChange, label, description, disabled, required, name, orientation, loop, className, wrpClassName, optionClassName, layout, error, id, "data-testid": dataTestId, }: AppRadioGroupProps): JSX.Element;

export declare interface AppRadioGroupOption {
    value: string;
    label: string | React_2.ReactNode;
    description?: string | React_2.ReactNode;
    disabled?: boolean;
    icon?: IconName;
}

export declare interface AppRadioGroupProps {
    options: AppRadioGroupOption[];
    value?: string;
    defaultValue?: string;
    onValueChange?: (value: string) => void;
    label?: string | React_2.ReactNode;
    description?: string | React_2.ReactNode;
    disabled?: boolean;
    required?: boolean;
    name?: string;
    orientation?: "horizontal" | "vertical";
    loop?: boolean;
    className?: string;
    wrpClassName?: string;
    optionClassName?: string;
    layout?: "default" | "card";
    error?: string;
    id?: string;
    "data-testid"?: string;
}

export declare function AppSelect(props: AppSelectProps): JSX.Element;

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

export declare type AppSelectProps = SingleSelectProps | MultiSelectProps;

export declare function AppSidebar({ navigation, navigationFooter, 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<React_2.AnchorHTMLAttributes<HTMLAnchorElement> & {
        href: string;
    }>;
    linkProps?: Record<string, unknown>;
}

export declare interface AppStep {
    id: number;
    label: React_2.ReactNode;
    component: React_2.ReactNode;
    completed?: boolean;
    disabled?: boolean;
    loading?: boolean;
    "data-testid"?: string;
}

export declare function AppStepper({ steps, align, size, showSeparators, defaultStep, allowStepNavigation, allowClickOnlyCompleted, onStepClick, indicators, id, "data-testid": dataTestId, ...stepperProps }: AppStepperProps): JSX.Element;

export declare interface AppStepperProps extends Omit<StepperProps, "children"> {
    steps: AppStep[];
    align?: "horizontal" | "vertical";
    size?: "sm" | "md";
    showSeparators?: boolean;
    defaultStep?: number;
    allowStepNavigation?: boolean;
    allowClickOnlyCompleted?: boolean;
    onStepClick?: (step: AppStep, index: number) => void;
    indicators?: StepIndicators;
    id?: string;
    "data-testid"?: string;
}

export declare function AppTimePicker(props: AppTimePickerProps): JSX.Element;

export declare interface AppTimePickerProps {
    /** The currently selected time as a Date object (controlled). */
    value?: Date;
    /** Callback fired when the selected time changes. */
    onChange?: (date: Date | undefined) => void;
    /** Callback fired when the value is cleared. */
    onClear?: () => void;
    /** Label displayed above the trigger. */
    label?: string | React.ReactNode;
    /** Placeholder text shown when no time is selected. @default "Seleziona orario" */
    placeholder?: string;
    /** Disables the time picker. @default false */
    disabled?: boolean;
    /** Show a clear button to reset the selection. @default false */
    clearable?: boolean;
    /** Additional CSS classes applied to the trigger element. */
    className?: string;
    /** CSS classes for the label element. */
    labelClassName?: string;
    /** CSS classes for the outer wrapper `<div>`. */
    wrpClassName?: string;
    /** Size variant of the trigger. @default "default" */
    size?: AppTimePickerSize;
    /** Visual variant of the trigger. @default "default" */
    variant?: AppTimePickerVariant;
    /** Use UTC time instead of local time. @default false */
    useUtc?: boolean;
    /** Show seconds column in the time picker. @default false */
    withSeconds?: boolean;
    /** Step interval for minute options. Must be between 1 and 59. @default 1 */
    minuteStep?: number;
    /** Step interval for second options. Must be between 1 and 59. @default 1 */
    secondStep?: number;
    /** HTML `id` for the trigger element. */
    id?: string;
    /** `data-testid` attribute for E2E testing (e.g. Playwright). */
    "data-testid"?: string;
    /** Minimum selectable time. Hours/minutes/seconds before this are disabled. */
    minTime?: Date;
    /** Maximum selectable time. Hours/minutes/seconds after this are disabled. */
    maxTime?: Date;
}

export declare type AppTimePickerSize = "sm" | "default" | "lg";

export declare type AppTimePickerVariant = "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";

export declare function AppTooltip({ content, children, label, labelClassName, header, variant, triggerVariant, size, className, wrpClassName, contentClassName, side, align, sideOffset, matchTriggerWidth, delayDuration, disabled, asChild, }: AppTooltipProps): JSX.Element;

export declare type AppTooltipAlign = TooltipContentProps_2["align"];

declare interface AppTooltipProps {
    /** Content displayed inside the tooltip */
    content: React_2.ReactNode;
    /** Element that triggers the tooltip on hover/focus */
    children: React_2.ReactNode;
    /** Optional label displayed above the tooltip trigger */
    label?: string | React_2.ReactNode;
    /** Optional header displayed at the top of the tooltip content */
    header?: string | React_2.ReactNode;
    /** Tooltip content variant - affects background and styling */
    variant?: AppTooltipVariant;
    /** Trigger element variant - affects hover states */
    triggerVariant?: VariantProps<typeof tooltipTriggerVariants>["variant"];
    /** Size of the trigger element */
    size?: VariantProps<typeof tooltipTriggerVariants>["size"];
    /** Additional className for the trigger wrapper */
    className?: string;
    /** Additional className for the outer wrapper (includes label) */
    wrpClassName?: string;
    /** Additional className for the tooltip content */
    contentClassName?: string;
    /** Additional className for the label */
    labelClassName?: string;
    /** Side where the tooltip appears */
    side?: AppTooltipSide;
    /** Alignment of the tooltip relative to the trigger */
    align?: AppTooltipAlign;
    /** Offset from the trigger in pixels */
    sideOffset?: number;
    /** Whether the tooltip should match the trigger's width */
    matchTriggerWidth?: boolean;
    /** Delay before showing tooltip (ms) */
    delayDuration?: number;
    /** Whether to disable the tooltip */
    disabled?: boolean;
    /** Whether to use asChild pattern for trigger (for custom elements) */
    asChild?: boolean;
}

export declare type AppTooltipSide = TooltipContentProps_2["side"];

export declare type AppTooltipVariant = VariantProps<typeof tooltipVariants>["variant"];

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

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

export declare function AsyncSelect<T = Option_2>({ fetcher, initialOptions, debounce, renderOptionItem, resolveOptionValue, renderSelectedValue, notFound, label, placeholder, value, onChange, disabled, className, wrpClassName, noResultsMessage, clearable, multiple, size, id, "data-testid": dataTestId, }: AsyncSelectProps<T>): JSX.Element;

declare interface AsyncSelectMultipleProps<T> extends VariantProps<typeof selectTriggerVariants> {
    multiple: boolean;
    fetcher: (query?: string) => Promise<T[]>;
    initialOptions?: T[];
    debounce?: number;
    renderOptionItem: (option: T) => React_2.ReactNode;
    resolveOptionValue: (option: T) => string;
    renderSelectedValue: (option: T) => React_2.ReactNode;
    notFound?: React_2.ReactNode;
    value?: string[];
    onChange?: (value: string[]) => void;
    label?: string | React_2.ReactNode;
    placeholder?: string;
    disabled?: boolean;
    className?: string;
    wrpClassName?: string;
    noResultsMessage?: string;
    clearable?: boolean;
    id?: string;
    "data-testid"?: string;
}

declare type AsyncSelectProps<T> = AsyncSelectSingleProps<T> | AsyncSelectMultipleProps<T>;

declare interface AsyncSelectSingleProps<T> extends VariantProps<typeof selectTriggerVariants> {
    multiple?: false;
    fetcher: (query?: string) => Promise<T[]>;
    initialOptions?: T[];
    debounce?: number;
    renderOptionItem: (option: T) => React_2.ReactNode;
    resolveOptionValue: (option: T) => string;
    renderSelectedValue: (option: T) => React_2.ReactNode;
    notFound?: React_2.ReactNode;
    value?: string;
    onChange?: (value: string) => void;
    label?: string | React_2.ReactNode;
    placeholder?: string;
    disabled?: boolean;
    className?: string;
    wrpClassName?: string;
    noResultsMessage?: string;
    clearable?: boolean;
    id?: string;
    "data-testid"?: 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, disabled, iconLeft, iconRight, ...props }: BadgeProps & React_2.ComponentProps<"span">): JSX.Element;

export declare interface BadgeProps extends React_2.ComponentPropsWithoutRef<"span"> {
    variant?: "default" | "destructive" | "warning" | "success" | "outline" | "outline-primary" | "outline-destructive" | "outline-warning" | "outline-success" | "secondary" | "ghost" | "ghost-destructive" | "ghost-accent" | "ghost-warning" | "ghost-success" | "link";
    asChild?: boolean;
    disabled?: boolean;
    iconLeft?: IconName;
    iconRight?: IconName;
}

export declare const badgeVariants: (props?: ({
    variant?: "link" | "default" | "outline" | "ghost" | "destructive" | "warning" | "success" | "outline-primary" | "outline-destructive" | "outline-warning" | "outline-success" | "secondary" | "ghost-destructive" | "ghost-accent" | "ghost-warning" | "ghost-success" | null | undefined;
} & ClassProp) | undefined) => string;

declare type BarItemDataType = RepeatDataType | NoRepeatDataType;

/** Base configuration for all column types — discriminated on accessorKey presence */
export declare type BaseColumnConfig<TData> = DistributedAccessorConfig<TData> | DisplayColumnConfig<TData>;

/** Common fields shared by all column configs */
declare type BaseColumnFields = {
    id?: string;
    sortable?: boolean;
    filterable?: boolean;
    searchable?: boolean;
    pinned?: "left" | "right";
    headerClassName?: string;
} & HeaderConfig;

declare type BaseProps = {
    options: AppSelectOption[];
    placeholder?: string;
    searchPlaceholder?: string;
    emptyPlaceholder?: string;
    addItemPlaceholder?: string;
    noGroupLabel?: string;
    itemCountMessage?: (selected: number) => string;
    maxSelectedMessage?: (max: number) => string;
    label?: string | React.ReactNode;
    className?: string;
    labelClassName?: string;
    wrpClassName?: string;
    searchable?: boolean;
    creatable?: boolean;
    isSingleSelectClearable?: boolean;
    disabled?: boolean;
    maxSelected?: number;
    showChipsInsteadOfCount?: boolean;
    size?: SelectSizeType;
    onClear?: () => void;
    id?: string;
    "data-testid"?: string;
};

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"> {
    variant?: ButtonVariant;
    size?: ButtonSize;
    asChild?: boolean;
    iconLeft?: IconName;
    iconRight?: IconName;
    isLoading?: boolean;
}

export declare type ButtonSize = "default" | "sm" | "lg" | "icon";

export declare type ButtonVariant = "default" | "destructive" | "outline" | "outline-primary" | "outline-destructive" | "secondary" | "ghost" | "ghost-destructive" | "ghost-accent" | "link";

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

export declare function Calendar({ className, classNames, showOutsideDays, buttonVariant, formatters, components, locale, minDate, maxDate, disabled, ...props }: CalendarProps): JSX.Element;

export declare interface CalendarAppointment {
    id: number;
    title: string;
    description?: string;
    date: string;
    startTime: string;
    endTime?: string;
    color?: string;
    attributes?: {
        key: string;
        value: default_2.ReactNode | string;
        showPreview?: boolean;
        showTooltip?: boolean;
    }[];
    className?: string;
    groupBy?: string;
}

export declare type CalendarProps = React_2.ComponentProps<typeof DayPicker> & {
    buttonVariant?: React_2.ComponentProps<typeof Button>["variant"];
    minDate?: Date;
    maxDate?: Date;
};

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_2.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, }: {
    className?: string;
    hideIcon?: boolean;
    payload?: Array<{
        value?: string;
        dataKey?: string;
        color?: string;
    }>;
    verticalAlign?: "top" | "middle" | "bottom";
    nameKey?: string;
} & React_2.HTMLAttributes<HTMLDivElement>): 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, }: {
    active?: boolean;
    payload?: Array<{
        dataKey?: string;
        name?: string;
        value?: unknown;
        color?: string;
        payload?: Record<string, unknown>;
    }>;
    label?: string | number;
    className?: string;
    indicator?: "line" | "dot" | "dashed";
    hideLabel?: boolean;
    hideIndicator?: boolean;
    labelFormatter?: (value: unknown, payload: unknown) => React_2.ReactNode;
    labelClassName?: string;
    formatter?: (value: unknown, name: unknown, item: unknown, index: number, payload: unknown) => React_2.ReactNode;
    color?: string;
    nameKey?: string;
    labelKey?: string;
} & React_2.HTMLAttributes<HTMLDivElement>): JSX.Element | null;

export declare function Chat({ messages, welcomeTitle, handleSubmit, input, handleInputChange, stop, isGenerating, append, suggestions, className, onRateResponse, setMessages, transcribeAudio, allowAttachments, onEdit, onMessageSave, }: 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_2.FC<ChatMessageProps>;

export declare interface ChatMessageProps extends Message {
    showTimeStamp?: boolean;
    animation?: Animation_2;
    actions?: default_2.ReactNode;
    editable?: boolean;
    onEdit?: (newContent: string) => void;
    onMessageSave?: (messageId: string, content: string) => void;
}

export declare function ChatMessages({ children }: React.PropsWithChildren): 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>;
    allowAttachments?: boolean;
    onEdit?: (messageId: string, newContent: string) => void;
    onMessageSave?: (messageId: string, content: string) => void;
    welcomeTitle?: 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, checked, ...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 cn(...inputs: ClassValue[]): string;

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 const Command: React_2.ForwardRefExoticComponent<Omit<{
    children?: React_2.ReactNode;
} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
    ref?: React_2.Ref<HTMLDivElement>;
} & {
    asChild?: boolean;
}, "key" | keyof React_2.HTMLAttributes<HTMLDivElement> | "asChild"> & {
    label?: string;
    shouldFilter?: boolean;
    filter?: (value: string, search: string, keywords?: string[]) => number;
    defaultValue?: string;
    value?: string;
    onValueChange?: (value: string) => void;
    loop?: boolean;
    disablePointerSelection?: boolean;
    vimBindings?: boolean;
} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

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: unknown;
}

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>;
    variant?: "default" | "destructive";
}

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_2.FC<ControlsProps>;

declare interface ControlsProps {
    className?: string;
}

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

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

/**
 * Creates an action column (not sortable/filterable/searchable)
 * @example
 * createActionColumn<Person>({
 *   id: "actions",
 *   header: "Azioni",
 *   pinned: "right",
 *   cell: (row) => <Button>Edit {row.name}</Button>
 * })
 */
export declare function createActionColumn<TData>(config: {
    id: string;
    pinned?: "left" | "right";
    cell: (row: TData) => React.ReactNode;
} & HeaderConfig): ColumnDef<TData>;

/**
 * Creates a boolean column with sensible defaults
 * @example
 * createBooleanColumn<Person>({
 *   accessorKey: "is_active",
 *   header: "Attivo",
 *   filterable: true,
 *   cell: (value) => value ? "✓" : "✗"
 * })
 */
export declare function createBooleanColumn<TData>(config: BaseColumnConfig<TData>): ColumnDef<TData>;

/**
 * Creates a boolean filter badge
 * @example
 * createBooleanFilter("is_active", "Attivo", "checked")
 */
export declare function createBooleanFilter(columnId: string, columnAccessorKey: string, columnLabel: string, operator: "checked" | "unchecked" | "eq" | "ne", value?: boolean): DataTableBadgeFilter;

/**
 * Creates a computed column with a specific type (allows filtering/sorting based on computed value)
 * Useful when you want to compute a value from row data but still have type-specific filtering
 * @example
 * // Age in months (computed from age)
 * createComputedColumn<Person>({
 *   id: "age_months",
 *   header: "Età (mesi)",
 *   type: "number",
 *   cell: (row) => row.age * 12,
 *   sortable: true
 * })
 */
export declare function createComputedColumn<TData>(config: {
    id?: string;
    type: "string" | "number" | "boolean" | "date" | "datetime";
    cell: (row: TData) => React.ReactNode;
    pinned?: "left" | "right";
    sortable?: boolean;
    filterable?: boolean;
    searchable?: boolean;
} & HeaderConfig): ColumnDef<TData>;

/**
 * Creates a date column with sensible defaults
 * @example
 * createDateColumn<Person>({
 *   accessorKey: "birth_date",
 *   header: "Data di nascita",
 *   sortable: true,
 *   filterable: true
 * })
 */
export declare function createDateColumn<TData>(config: BaseColumnConfig<TData>): ColumnDef<TData>;

/**
 * Creates a date filter badge
 * @example
 * createDateFilter("birth_date", "Data di nascita", "date_after", "2000-01-01")
 */
export declare function createDateFilter(columnId: string, columnAccessorKey: string, columnLabel: string, operator: "eq" | "date_before" | "date_after" | "eq_null" | "n_eq_null", value?: string): DataTableBadgeFilter;

/**
 * Creates a datetime column with sensible defaults
 * @example
 * createDateTimeColumn<Person>({
 *   accessorKey: "created_at",
 *   header: "Data creazione",
 *   sortable: true,
 *   filterable: true
 * })
 */
export declare function createDateTimeColumn<TData>(config: BaseColumnConfig<TData>): ColumnDef<TData>;

/**
 * Creates a datetime filter badge
 * @example
 * createDateTimeFilter("created_at", "Data creazione", "date_time_after", "2024-01-01T00:00:00")
 */
export declare function createDateTimeFilter(columnId: string, columnAccessorKey: string, columnLabel: string, operator: "date_time_before" | "date_time_after" | "eq_null" | "n_eq_null", value?: string): DataTableBadgeFilter;

/**
 * Creates a display-only column (no data binding, for computed/derived values)
 * @example
 * // Computed full name column
 * createDisplayColumn<Person>({
 *   id: "full_name",
 *   header: "Nome Completo",
 *   cell: (row) => `${row.firstName} ${row.lastName}`,
 *   searchable: true  // Can make it searchable if needed
 * })
 *
 * // Status badge column
 * createDisplayColumn<Person>({
 *   id: "status_badge",
 *   header: "Stato",
 *   cell: (row) => <Badge color={row.is_active ? "green" : "red"}>{row.status}</Badge>
 * })
 */
export declare function createDisplayColumn<TData>(config: {
    id?: string;
    cell: (row: TData) => React.ReactNode;
    pinned?: "left" | "right";
    searchable?: boolean;
} & HeaderConfig): ColumnDef<TData>;

/**
 * Creates a filter badge with auto-generated ID
 * @example
 * createFilterBadge({
 *   columnId: "name",
 *   columnLabel: "Nome",
 *   columnType: "string",
 *   columnAccessorKey: "name",
 *   operator: "like",
 *   value: "John"
 * })
 */
export declare function createFilterBadge(config: FilterBadgeConfig): DataTableBadgeFilter;

/**
 * Creates multiple filter badges at once
 * @example
 * createFilterBadges([
 *   { columnId: "name", columnLabel: "Nome", columnType: "string", operator: "like", value: "John" },
 *   { columnId: "age", columnLabel: "Età", columnType: "number", operator: "gt", value: 25 }
 * ])
 */
export declare function createFilterBadges(configs: FilterBadgeConfig[]): DataTableBadgeFilter[];

/**
 * Creates initial state configuration for DataTable
 * @example
 * createInitialState({
 *   filters: [createStringFilter("name", "Nome", "like", "John")],
 *   searchbarFilter: "active users",
 *   sorting: [{ column: "name", order: "asc" }],
 *   pagination: { pageIndex: 0, pageSize: 20 }
 * })
 */
export declare function createInitialState<TData = Record<string, unknown>>(config: InitialStateConfig<TData>): DataTableState<TData>;

/**
 * Creates a list filter badge
 * @example
 * createListFilter("role", "Ruolo", "list_single_select", "array_overlap", ["Admin"], roleOptions)
 */
export declare function createListFilter(columnId: string, columnAccessorKey: string, columnLabel: string, columnType: "list_single_select" | "list_multi_select", operator: "array_overlap" | "n_array_overlap" | "eq_null" | "n_eq_null", value?: Array<string | number>, listOptions?: AppSelectOption[]): DataTableBadgeFilter;

/**
 * Creates a multi select list column (array where user can select multiple values)
 * @example
 * createMultiSelectColumn<Person>({
 *   accessorKey: "tags",
 *   header: "Tags",
 *   options: ["frontend", "backend", "devops"],
 *   filterable: true
 * })
 */
export declare function createMultiSelectColumn<TData>(config: ListColumnConfig<TData>): ColumnDef<TData>;

/**
 * Creates a number column with sensible defaults
 * @example
 * createNumberColumn<Person>({
 *   accessorKey: "age",
 *   header: "Età",
 *   sortable: true,
 *   filterable: true
 * })
 *
 * // Display-only computed column
 * createNumberColumn<Person>({
 *   id: "age_in_months",
 *   header: "Età (mesi)",
 *   cell: (_, row) => row.age * 12
 * })
 */
export declare function createNumberColumn<TData>(config: BaseColumnConfig<TData>): ColumnDef<TData>;

/**
 * Creates a number filter badge
 * @example
 * createNumberFilter("age", "Età", "gt", 25)
 */
export declare function createNumberFilter(columnId: string, columnAccessorKey: string, columnLabel: string, operator: "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "eq_null" | "n_eq_null", value?: number): DataTableBadgeFilter;

/**
 * Creates a single select list column (array where user can select one value)
 * @example
 * createSingleSelectColumn<Person>({
 *   accessorKey: "role",
 *   header: "Ruolo",
 *   options: ["Admin", "User", "Guest"],
 *   filterable: true
 * })
 */
export declare function createSingleSelectColumn<TData>(config: ListColumnConfig<TData>): ColumnDef<TData>;

/**
 * Creates sorting configuration
 * @example
 * createSorting([
 *   { column: "name", order: "asc" },
 *   { column: "age", order: "desc" }
 * ])
 */
export declare function createSorting(sorts: Array<{
    column: string;
    order: "asc" | "desc";
}>): DataTableSorting;

/**
 * Creates a string column with sensible defaults
 * @example
 * // Data-bound column
 * createStringColumn<Person>({
 *   accessorKey: "name",
 *   header: "Nome",
 *   sortable: true,
 *   filterable: true
 * })
 *
 * // Nested object path (supports dot notation, including nullable/optional objects)
 * createStringColumn<Person>({
 *   accessorKey: "address.city",
 *   header: "Città",
 *   sortable: true,
 *   filterable: true
 * })
 *
 * // Nullable nested object (e.g., item?: PricingItem | null)
 * createStringColumn<Order>({
 *   accessorKey: "item.cod_master_pu",
 *   header: "Master PU",
 *   sortable: true
 * })
 *
 * // Multiple columns with same accessor (use unique IDs)
 * createStringColumn<Person>({
 *   id: "name_display",
 *   accessorKey: "name",
 *   header: "Nome (Display)",
 *   cell: (value) => <strong>{value}</strong>
 * })
 *
 * // Display-only column (no accessorKey)
 * createStringColumn<Person>({
 *   id: "custom_display",
 *   header: "Custom",
 *   cell: (_, row) => `${row.firstName} ${row.lastName}`
 * })
 */
export declare function createStringColumn<TData>(config: BaseColumnConfig<TData>): ColumnDef<TData>;

/**
 * Creates a string filter badge
 * @example
 * createStringFilter("name", "Nome", "like", "John")
 */
export declare function createStringFilter(columnId: string, columnAccessorKey: string, columnLabel: string, operator: "like" | "n_like" | "starts_with" | "ends_with" | "eq" | "ne" | "eq_null" | "n_eq_null", value?: string): DataTableBadgeFilter;

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_2.FC<DataCrossTableButtonsGroupProps>;

export declare interface DataCrossTableButtonsGroupProps {
    className?: string;
}

declare interface DataCrossTableContextType {
    editedCells: Record<string, {
        value: unknown;
        cell: CrossTableCell;
    }>;
    setEditedCells: default_2.Dispatch<default_2.SetStateAction<Record<string, {
        value: unknown;
        cell: CrossTableCell;
    }>>>;
    toDefaultCells: Record<string, {
        value: unknown;
        cell: CrossTableCell;
    }>;
    setToDefaultCells: default_2.Dispatch<default_2.SetStateAction<Record<string, {
        value: unknown;
        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_2.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, actions, customComponentsLeft, customComponentsRight, hidePagination, hideActionsRow, i18n, maxSortedColumns, initialState, serverMode, serverConfig, disableAutoPageSize, id, "data-testid": dataTestId, rowClassName, }: DataTableProps<TData, TValue>): JSX.Element;

export declare interface DataTableActions {
    label: string;
    icon: IconName;
    onClick: () => void;
    "data-testid"?: string;
}

export declare interface DataTableAdvancedFilter {
    id: string;
    rootGroup: IAdvancedFilterGroup;
}

declare interface DataTableAndGroup {
    _and: DataTableFilterForSearch[];
}

export declare interface DataTableBadgeFilter {
    id: string;
    columnId: string;
    columnAccessorKey: string;
    columnLabel: string;
    columnType: IColumnType;
    operator: FilterOperator;
    value?: string | number | boolean | Array<string | number>;
    listOptions?: AppSelectOption[];
}

export declare interface DataTableFieldCondition {
    [field: string]: {
        operator: FilterOperator;
        value: string | number | boolean | (string | number | boolean)[];
    };
}

export declare type DataTableFilterForSearch = DataTableFieldCondition | DataTableOrGroup | DataTableAndGroup;

export declare interface DataTableI18n {
    search: string;
    searchPlaceholder: string;
    clearSearch: string;
    reset: string;
    loading: string;
    notFoundMessage: string;
    searchTooltipLabel: string;
    selectAll: string;
    selectRow: string;
    filters: {
        addFilter: string;
        advancedFilter: string;
        addFilterRule: string;
        addFilterGroup: string;
        deleteFilter: string;
        deleteCondition: string;
        deleteGroup: string;
        duplicateCondition: string;
        duplicateGroup: string;
        operator: string;
        value: string;
        searchFilters: string;
        searchPlaceholder: string;
        selectDate: string;
        where: string;
        and: string;
        or: string;
        filterNotSupported: string;
        column: string;
        filter: string;
    };
    stringOperators: {
        eq: string;
        ne: string;
        like: string;
        nLike: string;
        startsWith: string;
        endsWith: string;
        eqNull: string;
        nEqNull: string;
    };
    numberOperators: {
        eq: string;
        ne: string;
        lt: string;
        le: string;
        gt: string;
        ge: string;
        eqNull: string;
        nEqNull: string;
    };
    booleanOperators: {
        eq: string;
        ne: string;
        checked: string;
        unchecked: string;
        true: string;
        false: string;
    };
    dateOperators: {
        is: string;
        isBefore: string;
        isAfter: string;
        eqNull: string;
        nEqNull: string;
    };
    dateTimeOperators: {
        isBefore: string;
        isAfter: string;
        eqNull: string;
        nEqNull: string;
    };
    listOperators: {
        is: string;
        isNot: string;
        contains: string;
        doesNotContain: string;
        eqNull: string;
        nEqNull: string;
    };
    sorting: {
        sort: string;
        sorting: string;
        column: string;
        order: string;
        sortBy: string;
        ascending: string;
        descending: string;
        clearSort: string;
        resetSorting: string;
        addSort: string;
    };
    columnVisibility: {
        visibleColumns: string;
        hiddenColumns: string;
        hideColumn: string;
        showColumn: string;
        hideAll: string;
        showAll: string;
    };
    pagination: {
        previous: string;
        next: string;
        first: string;
        last: string;
        page: string;
        of: string;
        rows: string;
        pages: string;
        rowsPerPage: string;
        goToPage: string;
        showing: string;
        to: string;
        entries: string;
    };
    tableActions: {
        actions: string;
    };
}

declare interface DataTableOrGroup {
    _or: DataTableFilterForSearch[];
}

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

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;
    actions?: DataTableActions[];
    customComponentsLeft?: ReactNode;
    customComponentsRight?: ReactNode;
    hidePagination?: boolean;
    hideActionsRow?: boolean;
    i18n?: DataTableI18n;
    maxSortedColumns?: number;
    initialState?: DataTableState<TData>;
    serverMode?: boolean;
    serverConfig?: DataTableServerConfig;
    disableAutoPageSize?: boolean;
    id?: string;
    "data-testid"?: string;
    rowClassName?: string | ((row: Row<TData>) => string);
}

export declare interface DataTableServerConfig {
    totalItems: number;
    onStateChange: (state: ServerState) => void;
    serverDebounceTime?: number;
}

export declare interface DataTableSorting {
    sort_by: string[];
    sort_order: ("asc" | "desc")[];
}

export declare interface DataTableState<TData = Record<string, unknown>> {
    filters?: IFilterState;
    sorting?: DataTableSorting;
    pagination?: DataTablePagination;
    searchbarFilter?: string;
    computedFilter?: DataTableFilterForSearch;
    computedSorting?: DataTableSorting;
    columnVisibility?: Partial<Record<keyof TData, boolean>>;
}

export declare function DatePicker(props: DatePickerProps): JSX.Element;

declare interface DatePickerBaseProps {
    /** Placeholder text shown when no date is selected. @default "Seleziona data" */
    placeholder?: string;
    /** Display format string (date-fns). @default "dd/MM/yyyy" (or "dd/MM/yyyy HH:mm" with showTime) */
    dateFormat?: string;
    /** Additional CSS classes applied to the trigger element. */
    className?: string;
    /**
     * @deprecated This prop is unused. Use `className` to style the trigger instead.
     */
    buttonVariant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
    /** Disables the date picker. @default false */
    disabled?: boolean;
    /** Size variant of the trigger. @default "default" */
    size?: "sm" | "default" | "lg";
    /**
     * @deprecated Use `minDate` instead.
     * Minimum selectable date.
     */
    firstDate?: Date;
    /**
     * @deprecated Use `maxDate` instead.
     * Maximum selectable date.
     */
    lastDate?: Date;
    /** Restrict selection to only these specific dates. All other dates will be disabled. */
    availableDates?: Date[];
    /** date-fns locale for formatting and calendar labels. @default it (Italian) */
    locale?: Partial<Locale>;
    /** Month to display when the calendar first opens (overridden by `value` if set). */
    initialCalendarMonth?: Date;
    /** Additional props forwarded to the underlying `<Calendar>` component. */
    customCalendarProps?: React_2.ComponentProps<typeof Calendar>;
    /** Label displayed above the trigger. */
    label?: string | React_2.ReactNode;
    /** CSS classes for the label element. */
    labelClassName?: string;
    /** CSS classes for the outer wrapper `<div>`. */
    wrpClassName?: string;
    /** HTML `id` for the trigger element. Auto-generated if omitted. */
    id?: string;
    /** `data-testid` attribute for E2E testing (e.g. Playwright). */
    "data-testid"?: string;
    /** Minimum selectable date. Dates before this are disabled. */
    minDate?: Date;
    /** Maximum selectable date. Dates after this are disabled. */
    maxDate?: Date;
    /** Number of months to display side-by-side. @default 1 */
    numberOfMonths?: number;
    /** Show a clear button to reset the selection. @default false */
    clearable?: boolean;
    /** Callback fired when the value is cleared via the clear button. */
    onClear?: () => void;
}

export declare type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;

declare interface DatePickerRangeProps extends DatePickerBaseProps {
    /** Selection mode set to range. */
    mode: "range";
    /** The currently selected date range (controlled). */
    value?: DateRange;
    /** Callback fired when the selected range changes. */
    onChange?: (range: DateRange | undefined) => void;
}

declare interface DatePickerSingleProps extends DatePickerBaseProps {
    /** Selection mode. @default "single" */
    mode?: "single";
    /** The currently selected date (controlled). */
    value?: Date;
    /** Callback fired when the selected date changes. */
    onChange?: (date: Date | undefined) => void;
    /** Show time picker columns alongside the calendar. @default false */
    showTime?: boolean;
    /** Show seconds column in the time picker (requires `showTime`). @default false */
    withSeconds?: boolean;
    /** Step interval for minute options in time picker. Must be between 1 and 59. @default 1 */
    minuteStep?: number;
    /** Step interval for second options in time picker. Must be between 1 and 59. @default 1 */
    secondStep?: number;
}

/**
 * Type helper to extract all possible deep paths from an object type
 * Supports nested properties with dot notation (e.g., "user.name", "address.city")
 * Handles nullable and optional nested objects (e.g., "item?.cod_master_pu")
 */
declare type DeepKeys<T> = T extends object ? {
    [K in keyof T & string]: NonNullable<T[K]> extends object ? NonNullable<T[K]> extends any[] ? `${K}` : `${K}` | `${K}.${DeepKeys<NonNullable<T[K]>>}` : `${K}`;
}[keyof T & string] : never;

/**
 * Type helper to resolve the actual value type from a dot-notation accessor path
 * e.g. DeepValue<{ user: { name: string } }, "user.name"> = string
 */
declare type DeepValue<T, K extends string> = K extends `${infer First}.${infer Rest}` ? First extends keyof T ? DeepValue<NonNullable<T[First]>, Rest> : never : K extends keyof T ? T[K] : never;

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

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

export declare function DialogContent({ className, children, size, closeOnOverlay, showCloseButton, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Content> & {
    size?: "sm" | "default" | "lg" | "xl";
    closeOnOverlay?: boolean;
    showCloseButton?: boolean;
}): 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;

/** Column config without accessorKey — cell receives undefined as value */
declare type DisplayColumnConfig<TData> = BaseColumnFields & {
    accessorKey?: undefined;
    cell?: (value: undefined, row: TData, tableRow: Row<TData>) => React.ReactNode;
    cellClassName?: string | ((value: undefined, row: TData) => string);
};

/** Maps each key to its typed accessor config, then unions them */
declare type DistributedAccessorConfig<TData> = {
    [K in DeepKeys<TData> & string]: AccessorColumnConfigForKey<TData, K>;
}[DeepKeys<TData> & string];

export declare const downloadFile: (url: string, filename?: string) => void;

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 DropdownMenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;

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

export declare const DropdownMenuGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
    variant?: "default" | "destructive";
} & 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 DropdownMenuPortal: React_2.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;

export declare const DropdownMenuRadioGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;

export declare const DropdownMenuRadioItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & 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 DropdownMenuShortcut: {
    ({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
    displayName: string;
};

export declare const DropdownMenuSub: React_2.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;

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

export declare const DropdownMenuSubTrigger: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
    inset?: boolean;
} & 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_2.ForwardRefExoticComponent<FilePreviewProps & default_2.RefAttributes<HTMLDivElement>>;

/**
 * Props for the `FilePreview` component.
 *
 * The component renders different previews depending on file type (image, text, generic).
 * If you pass a native `File`, an object URL is created and revoked automatically.
 */
declare type FilePreviewBaseProps = {
    /**
     * The file to render.
     *
     * - If a native `File` is provided, the component will create a temporary object URL.
     * - If an object is provided, `url` is used directly.
     */
    file: IFilePreviewCallbackReturn;
    /**
     * Optional container click handler.
     *
     * If provided, it takes precedence over `onPreview` when the container is activated.
     *
     * Returning `false` currently has no special meaning in the component implementation
     * (it is allowed for convenience/consistency with other APIs).
     */
    onClick?: (event: default_2.MouseEvent | default_2.KeyboardEvent) => void | Promise<void> | false;
    /**
     * Called when the user requests to remove the file.
     * Receives the resolved file URL (object URL for `File`, otherwise `file.url`).
     */
    onRemove?: (url: string) => void | Promise<void>;
    /**
     * Called when the user requests to preview/open the file.
     * Receives the resolved file URL (object URL for `File`, otherwise `file.url`).
     */
    onPreview?: (url: string) => void | Promise<void>;
    /**
     * Called when the user requests to download the file.
     * Receives the resolved file URL (object URL for `File`, otherwise `file.url`).
     */
    onDownload?: (url: string) => void | Promise<void>;
    /**
     * Shows a dropdown menu with the available actions (Preview/Download/Remove)
     * depending on which callbacks are provided.
     *
     * @default false
     */
    showActionMenu?: boolean;
    /**
     * Controls whether a thumbnail/preview is rendered when available.
     *
     * - **Images**: when `true`, renders the image thumbnail; when `false`, renders the format icon instead.
     * - **Text files**: when `true` and a preview can be extracted (only for native `File`), renders the first characters of the file;
     *   otherwise falls back to the format icon.
     * - **Other file types**: this prop has no effect.
     *
     * @default true
     */
    showThumbnail?: boolean;
    /** Optional additional className applied to the root container. */
    className?: string;
    variant?: FilePreviewVariant;
    size?: FilePreviewSize;
};

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

declare type FilePreviewProps = (FilePreviewBaseProps & {
    /**
     * Enables click/keyboard interaction on the container.
     *
     * Note: the container is effectively clickable only if `onPreview` or `onClick` is provided.
     *
     * @default true
     */
    clickable?: boolean;
    showActionMenu?: false | undefined;
}) | (FilePreviewBaseProps & {
    showActionMenu: true;
    clickable?: never;
    onClick?: never;
});

declare type FilePreviewSize = "default" | "sm";

declare type FilePreviewVariant = "default" | "outline" | "ghost";

export declare const FileUploader: default_2.FC<FileUploaderProps>;

declare interface FileUploaderProps {
    extensions?: AcceptItem[];
    multiple?: boolean;
    onUpload?: (files: File[]) => void;
    description?: string;
    formatDescription?: string;
    selectedLabel?: string;
    removeAllLabel?: string;
    maxTotalSize?: number;
    maxFiles?: number;
    id?: string;
    "data-testid"?: string;
}

declare interface FilterBadgeConfig {
    columnId: string;
    columnAccessorKey: string;
    columnLabel: string;
    columnType: IColumnType;
    operator: FilterOperator;
    value?: string | number | boolean | Array<string | number>;
    listOptions?: AppSelectOption[];
}

declare type FilterOperator = "array_overlap" | "checked" | "date_after" | "date_before" | "date_time_after" | "date_time_before" | "ends_with" | "eq" | "eq_null" | "ge" | "gt" | "le" | "like" | "lt" | "n_array_overlap" | "n_eq_null" | "n_like" | "ne" | "starts_with" | "unchecked";

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_2.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;
};

/**
 * Extracts column IDs from column definitions
 * @example
 * getColumnIds(columns) // ["name", "email", "age", "actions"]
 */
export declare function getColumnIds<TData>(columns: ColumnDef<TData>[]): string[];

/**
 * Base configuration for all column types
 * - accessorKey: optional, type-safe key from TData (supports nested paths like "user.name")
 * - id: optional, auto-generated if not provided (allows multiple columns with same accessor)
 * - cell: can receive either value (if accessorKey provided) or just row (if no accessorKey)
 */
export declare type HeaderConfig = {
    header: string;
    headerLabel?: string;
} | {
    header: React.ReactNode;
    headerLabel: string;
};

export declare const hexContrast: (hex: string) => string;

export declare const hexToRgba: (hex: string, alpha: number) => 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;

declare interface IAdvancedFilterCondition {
    id: string;
    columnId: string;
    columnAccessorKey: string;
    columnLabel: string;
    columnType: IColumnType;
    operator: FilterOperator;
    value?: string | number | boolean | Array<string | number>;
    listOptions?: AppSelectOption[];
}

declare interface IAdvancedFilterGroup {
    id: string;
    logicalOperator: LogicalOperator;
    conditions: IAdvancedFilterCondition[];
    groups?: IAdvancedFilterGroup[];
}

declare type IColumnType = "number" | "string" | "boolean" | "date" | "datetime" | "list_single_select" | "list_multi_select" | "other";

/**
 * 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]: unknown;
}

declare type IconSize = keyof typeof sizeMap;

declare type IFilePreviewCallbackReturn = File | {
    name: string;
    url: string;
    type?: string;
};

declare interface IFilterState {
    filterBadges?: DataTableBadgeFilter[];
    advancedFilterBadge?: DataTableAdvancedFilter;
    searchbarFilter?: string;
}

declare interface InitialStateConfig<TData = Record<string, unknown>> {
    filters?: DataTableBadgeFilter[];
    searchbarFilter?: string;
    sorting?: Array<{
        column: string;
        order: "asc" | "desc";
    }>;
    pagination?: {
        pageIndex: number;
        pageSize: number;
    };
    columnVisibility?: Partial<Record<keyof TData, 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;

export 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;
    startContent?: React_2.ReactNode;
    endContent?: React_2.ReactNode;
    validityI18n?: InputValidityI18n;
    showValidMessage?: boolean;
    showValidityMessage?: boolean;
}

export declare function InputSelector({ value, onChange, min, max, className, buttonClassName, counterClassName, id, "data-testid": dataTestId, }: InputSelectorProps): JSX.Element;

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

export declare interface InputValidityI18n {
    valid?: string;
    valueMissing?: string;
    typeMismatch?: string;
    patternMismatch?: string;
    tooLong?: string;
    tooShort?: string;
    rangeUnderflow?: string;
    rangeOverflow?: string;
    badInput?: string;
    stepMismatch?: string;
    customError?: 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;
}

/**
 * Validates if a filter operator is valid for a column type
 * @example
 * isValidOperatorForType("like", "string") // true
 * isValidOperatorForType("like", "number") // false
 */
export declare function isValidOperatorForType(operator: FilterOperator, columnType: IColumnType): boolean;

declare type KanbanBoardCardAction = {
    label: string;
    icon?: ReactNode;
    onClick: () => void;
    variant?: "default" | "destructive";
};

declare type KanbanBoardCardMetaItem = {
    name: ReactNode;
    value?: ReactNode;
};

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

export declare type ListColumnConfig<TData> = BaseColumnConfig<TData> & {
    options: string[] | AppSelectOption[];
};

declare type LogicalOperator = "AND" | "OR";

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, "data-testid": dataTestId, ...props }: MessageInputProps): JSX.Element;

export declare namespace MessageInput {
    var displayName: string;
}

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

declare type MessageInputProps = MessageInputWithoutAttachmentProps | MessageInputWithAttachmentsProps;

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

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

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

declare interface MessageListProps {
    messages: Message[];
    showTimeStamps?: boolean;
    isTyping?: boolean;
    messageOptions?: AdditionalMessageOptions | ((message: Message) => AdditionalMessageOptions);
    onEdit?: (messageId: string, newContent: string) => void;
    onMessageSave?: (messageId: string, content: string) => void;
}

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

/**
 * @deprecated This component is deprecated. Please use AppSelect component instead.
 */
declare interface MultipleSelectDropdownProps {
    options: AppMultipleSelectOption[];
    value: string[];
    onChange: (value: string[]) => void;
    onClear?: () => void;
    placeholder?: string;
    disabled?: boolean;
    size?: MultipleSelectSizeType;
    label?: string | React_2.ReactNode;
    labelClassName?: string;
    emptyMessage?: string;
    className?: string;
    searchPlaceholder?: string;
    searchable?: boolean;
    maxSelectedItems?: number;
    cancelLabel?: string;
}

/**
 * @deprecated This component is deprecated. Please use AppSelect component instead.
 */
export declare const MultipleSelector: React_2.ForwardRefExoticComponent<MultipleSelectorProps & React_2.RefAttributes<MultipleSelectorRef>>;

/**
 * @deprecated This component is deprecated. Please use AppSelect component instead.
 */
declare interface MultipleSelectorProps {
    value?: Option_3[];
    defaultOptions?: Option_3[];
    /** manually controlled options */
    options?: Option_3[];
    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_3[]>;
    /**
     * 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_3[];
    onChange?: (options: Option_3[]) => 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;
}

/**
 * @deprecated This interface is deprecated. Please use AppSelect component instead.
 */
export declare interface MultipleSelectorRef {
    selectedValue: Option_3[];
    input: HTMLInputElement;
    focus: () => void;
    reset: () => void;
}

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

declare type MultiSelectProps = BaseProps & {
    multiple: true;
    value?: (string | number)[];
    defaultValue?: (string | number)[];
    onValueChange?: (value: (string | number)[]) => void;
    renderValue?: (option: AppSelectOption) => React.ReactNode;
    selectableAll?: boolean;
};

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> = Record<string, unknown>> = (barData: GanttItemDataType<T>, data: (GanttItemDataType<T> & T)[]) => void;

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

declare interface Option_2 {
    value: string;
    label: string;
    disabled?: boolean;
    description?: string;
    icon?: React_2.ReactNode;
}

/**
 * @deprecated This interface is deprecated. Please use AppSelect component instead.
 */
declare interface Option_3 {
    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;
}

/**
 * Creates a pinned version of existing columns
 * @example
 * pinColumns(columns, { left: ["name", "email"], right: ["actions"] })
 */
export declare function pinColumns<TData>(columns: ColumnDef<TData>[], pinConfig: {
    left?: string[];
    right?: string[];
}): ColumnDef<TData>[];

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

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

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

declare type PreviewArg = string | PreviewOptions;

export declare const previewFile: (url: string, filename?: string) => void;

export declare function previewFileModal(arg: PreviewArg): Promise<void>;

declare interface PreviewOptions {
    url?: string;
    filename?: string;
    mimeType?: string;
    title?: default_2.ReactNode;
    readOnly?: boolean;
    page?: number;
}

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, disabled, ...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 safePreviewFileModal(arg: PreviewArg): Promise<UseAskResult<void, unknown>>;

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 SecurePdfViewer({ url, initialPage, className, }: SecurePdfViewerProps): JSX.Element;

declare interface SecurePdfViewerProps {
    url: string;
    initialPage?: number;
    className?: string;
}

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

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

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

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

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;

declare interface ServerState {
    filters?: IFilterState;
    pagination: DataTablePagination;
    computedFilter?: DataTableFilterForSearch;
    computedSorting?: DataTableSorting;
}

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, "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, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

declare type SingleSelectProps = BaseProps & {
    multiple?: false;
    value?: string | number;
    defaultValue?: string | number;
    onValueChange?: (value: string | number | undefined) => void;
    renderValue?: (option: AppSelectOption) => React.ReactNode;
};

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" | "medium" | "large" | 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 Spinner({ size, variant, className, ...props }: SpinnerProps): JSX.Element;

export declare interface SpinnerProps extends React_2.ComponentProps<"svg"> {
    size?: SpinnerSize | number;
    variant?: SpinnerVariant;
}

export declare type SpinnerSize = "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl";

export declare type SpinnerVariant = "default" | "destructive" | "primary" | "secondary";

export declare type StepIndicators = {
    active?: React_2.ReactNode;
    completed?: React_2.ReactNode;
    inactive?: React_2.ReactNode;
    loading?: React_2.ReactNode;
};

declare type StepIndicators_2 = {
    active?: React_2.ReactNode;
    completed?: React_2.ReactNode;
    inactive?: React_2.ReactNode;
    loading?: React_2.ReactNode;
};

declare type StepperOrientation = "horizontal" | "vertical";

declare interface StepperProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof stepperVariants> {
    defaultValue?: number;
    value?: number;
    onValueChange?: (value: number) => void;
    orientation?: StepperOrientation;
    indicators?: StepIndicators_2;
}

declare const stepperVariants: (props?: ({
    orientation?: "horizontal" | "vertical" | null | undefined;
} & ClassProp) | undefined) => string;

export declare const stringToHexColor: (str: string) => string;

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({ wrpClassName, className, label, labelClassName, id, ...props }: React_2.ComponentProps<"textarea"> & {
    wrpClassName?: string;
    label?: React_2.ReactNode;
    labelClassName?: string;
}): 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 { toast }

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

export 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 interface ToolCallData {
    state: "call";
    toolName: string;
}

declare type ToolInvocation = PartialToolCall | ToolCallData | ToolResult;

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

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

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

export declare function TooltipContent({ className, sideOffset, variant, children, ...props }: TooltipContentProps): JSX.Element;

declare interface TooltipContentProps extends React_2.ComponentProps<typeof TooltipPrimitive.Content>, VariantProps<typeof tooltipVariants> {
}

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 const tooltipTriggerVariants: (props?: ({
    variant?: "default" | "ghost" | "secondary" | "primary" | "muted" | "accent" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & ClassProp) | undefined) => string;

declare const tooltipVariants: (props?: ({
    variant?: "secondary" | "primary" | "card" | null | undefined;
} & ClassProp) | undefined) => string;

/**
 * Converts string array to AppSelectOption array
 * @example
 * toSelectOptions(["Admin", "User", "Guest"])
 * // Returns: [{ value: "Admin", label: "Admin" }, ...]
 */
export declare function toSelectOptions(values: string[]): AppSelectOption[];

/**
 * Converts array of objects to AppSelectOption array
 * @example
 * toSelectOptionsFromObjects(users, "id", "name")
 * // Returns: [{ value: user.id, label: user.name }, ...]
 */
export declare function toSelectOptionsFromObjects<T>(items: T[], valueKey: keyof T, labelKey: keyof T): AppSelectOption[];

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

export declare function TruncatedCell({ children, text, title, popoverContent, className, wrapperClassName, popoverClassName, showButton, emptyFallback, }: TruncatedCellProps): JSX.Element;

export declare interface TruncatedCellProps {
    /** The text to display and potentially truncate (can be string or ReactNode) */
    children?: React.ReactNode;
    /** The text value to use for truncation detection, accessibility and default popover content */
    text?: string;
    /** Optional title for the popover dialog */
    title?: string;
    /** Custom popover content to override default text display */
    popoverContent?: React.ReactNode;
    /** Additional CSS classes for the wrapper container */
    wrapperClassName?: string;
    /** Additional CSS classes for cell */
    className?: string;
    /** CSS classes for the popoverContent component */
    popoverClassName?: string;
    /** Flg used to show / hide the eye button */
    showButton?: boolean;
    /** Custom placeholder rendered when there is no content */
    emptyFallback?: React.ReactNode;
}

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

/**
 * Updates list options for a specific column in columns array
 * @example
 * updateColumnListOptions(columns, "role", ["Admin", "User", "Guest"])
 */
export declare function updateColumnListOptions<TData>(columns: ColumnDef<TData>[], columnAccessorKey: string, options: string[] | AppSelectOption[]): ColumnDef<TData>[];

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(): {
    containerRef: RefObject<HTMLDivElement | null>;
    scrollToBottom: () => void;
    handleScroll: () => void;
    shouldAutoScroll: boolean;
    handleTouchStart: () => void;
};

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

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

declare type UseCarouselParameters = Parameters<typeof default_3>;

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 function useEditorModal(): [
JSX_2.Element | null,
(title: string, showModal: (onClose: () => void) => JSX_2.Element) => void
];

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 declare function WeeklyCalendar({ appointments, onWeekChange, initialWeekOffset, showNavigation, customActions, enableGrouping, groupLabel, calendarStartHour, calendarEndHour, todayString, }: WeeklyCalendarProps): JSX.Element;

export declare interface WeeklyCalendarProps {
    appointments: CalendarAppointment[];
    onWeekChange?: (weekOffset: number, weekStart: string, weekEnd: string) => void;
    initialWeekOffset?: number;
    className?: string;
    showNavigation?: boolean;
    showWeekIndicator?: boolean;
    customActions?: default_2.ReactNode;
    enableGrouping?: boolean;
    groupLabel?: string;
    calendarStartHour?: number;
    calendarEndHour?: number;
    todayString?: string;
}

export { }


declare module "@tanstack/react-table" {
    interface ColumnMeta<TData extends unknown, TValue> {
        type: IColumnType;
        headerLabel?: string;
        sortable?: boolean;
        filterable?: boolean;
        searchable?: boolean;
        pinned?: "left" | "right";
        listOptions?: AppSelectOption[];
        cellClassName?: string | ((value: unknown, row: TData) => string);
        headerClassName?: string;
    }
}