@mlw-packages/react-components 1.7.22 → 1.7.24

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as React$1 from 'react';
-import React__default, { ReactNode, ComponentPropsWithoutRef, ComponentType } from 'react';
+import React__default, { ReactNode, ComponentType, ComponentPropsWithoutRef } from 'react';
 import * as SelectPrimitive from '@radix-ui/react-select';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as AvatarPrimitive from '@radix-ui/react-avatar';
@@ -68,1837 +68,1831 @@ type ModeToggleBaseProps = {
 };
 declare function ModeToggleBase({ themes, }: ModeToggleBaseProps): react_jsx_runtime.JSX.Element;
 
-interface ComboboxItem<T extends string> {
-    label: string;
-    value: T;
-}
+declare const AvatarBase: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImageBase: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallbackBase: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
 
-interface ComboboxTestIds {
-    root?: string;
-    trigger?: string;
-    popover?: string;
-    command?: string;
-    search?: string;
-    list?: string;
-    empty?: string;
-    group?: string;
-    option?: string;
-    check?: string;
-    selected?: string;
+declare const badgeVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+type BadgeColorType = "green" | "gray" | "red" | "yellow" | "blue" | "purple";
+interface BadgeBaseProps extends React$1.ComponentProps<"span">, VariantProps<typeof badgeVariants> {
+    asChild?: boolean;
+    color?: BadgeColorType;
+    size?: "sm" | "md" | "lg";
+    status?: string;
 }
-interface ComboboxProps<T extends string> extends ErrorMessageProps {
-    items: ComboboxItem<T>[];
-    selected: ComboboxItem<T>["value"] | null;
-    onChange: (value: ComboboxItem<T>["value"] | null) => void;
-    className?: string;
-    placeholder?: string;
-    searchPlaceholder?: string;
-    empty?: React.ReactNode;
-    label?: string;
-    labelClassname?: string;
-    testIds?: ComboboxTestIds;
-    disabled?: boolean;
+declare function Badge({ className, color, size, asChild, children, style, ...props }: BadgeBaseProps): react_jsx_runtime.JSX.Element;
+
+type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
+declare function CalendarBase({ className, classNames, showOutsideDays, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
+declare namespace CalendarBase {
+    var displayName: string;
 }
-declare function Combobox<T extends string>({ items, selected, onChange, className, placeholder, searchPlaceholder, empty, disabled, label, labelClassname, testIds, error, }: ComboboxProps<T>): react_jsx_runtime.JSX.Element;
 
-interface MultiComboboxTestIds {
-    root?: string;
-    label?: string;
-    selectedWrapper?: string;
-    emptyPlaceholder?: string;
-    selectedItem?: (value: string) => string;
-    clearAll?: string;
+declare const CardBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardHeaderBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardTitleBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardDescriptionBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardContentBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const CardFooterBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+
+interface FileWithPreview extends File {
+    id?: string;
+    error?: string;
+    preview?: string;
 }
-interface MultiComboboxProps<T extends string> extends Omit<ComboboxProps<T>, "selected" | "onChange">, ErrorMessageProps {
-    selected: T[];
-    onChange: (value: T[]) => void;
-    label?: string;
-    labelClassname?: string;
-    testIds?: MultiComboboxTestIds;
-    keepOpen?: boolean;
-    showClearAll?: boolean;
+interface FileUploaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onDrop"> {
+    accept: string[];
+    maxSize: number;
+    maxFiles?: number;
+    onValueChange: (files: FileWithPreview[]) => void;
     disabled?: boolean;
+    value?: FileWithPreview[];
+    onUpload?: (files: FileWithPreview[]) => Promise<void>;
+    showPreview?: boolean;
+    dropzoneText?: string;
+    dropzoneSubtext?: string;
+    animate?: boolean;
 }
-declare function MultiCombobox<T extends string>({ items, selected, onChange, className, placeholder, searchPlaceholder, label, labelClassname, testIds, error, disabled, keepOpen, showClearAll, empty, }: MultiComboboxProps<T>): react_jsx_runtime.JSX.Element;
+declare const FileUploader: React$1.ForwardRefExoticComponent<FileUploaderProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface SelectItem<T extends string> {
-    label: string;
-    value: T;
+declare const AlertDialogBase: React$1.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTriggerBase: React$1.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortalBase: React$1.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlayBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContentBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeaderBase: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooterBase: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitleBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescriptionBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogActionBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancelBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+
+interface DestructiveDialogProps {
+    title: string;
+    description: string;
+    onConfirm: () => void;
+    onCancel?: () => void;
+    children?: React$1.ReactNode;
+    triggerContent?: React$1.ReactNode;
+    className?: string;
 }
-interface SelectTestIds {
-    root?: string;
-    base?: string;
-    trigger?: string;
-    value?: string;
-    scrollarea?: string;
-    content?: string;
-    group?: string;
+declare const DestructiveDialog: React$1.FC<DestructiveDialogProps>;
+
+type TestIdProps$2 = {
+    testid?: string;
+};
+declare const DialogBase: React$1.FC<DialogPrimitive.DialogProps>;
+declare const DialogTriggerBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortalBase: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogCloseBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlayBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps$2 & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogContentBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps$2 & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogHeaderBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & TestIdProps$2 & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogFooterBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & TestIdProps$2 & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogTitleBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & TestIdProps$2 & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescriptionBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & TestIdProps$2 & React$1.RefAttributes<HTMLParagraphElement>>;
+
+declare const loadingVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "xl" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface LoadingBaseProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof loadingVariants> {
+    message?: string;
+    overlay?: boolean;
+    variant?: "spinner" | "dots";
+}
+declare const LoadingBase: React$1.ForwardRefExoticComponent<LoadingBaseProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type TestIdProps$1 = {
+    testid?: string;
+};
+declare const ModalBase: React$1.FC<DialogPrimitive.DialogProps>;
+declare const ModalTriggerBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ModalPortalBase: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const ModalCloseBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ModalOverlayBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps$1 & React$1.RefAttributes<HTMLDivElement>>;
+type ModalSize = "sm" | "md" | "lg" | "full";
+declare const ModalContentBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps$1 & {
+    size?: ModalSize;
+    centered?: boolean;
+    backdropBlur?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const ModalHeaderBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & TestIdProps$1 & React$1.RefAttributes<HTMLDivElement>>;
+declare const ModalFooterBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & TestIdProps$1 & React$1.RefAttributes<HTMLDivElement>>;
+declare const ModalTitleBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & TestIdProps$1 & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const ModalDescriptionBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & TestIdProps$1 & React$1.RefAttributes<HTMLParagraphElement>>;
+
+type ProgressType = "bar" | "segments" | "panels" | "circles";
+interface ProgressBaseProps extends React$1.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> {
+    variant?: ProgressType;
     label?: string;
-    item?: (value: string) => string;
-    paginationPrev?: string;
-    paginationNext?: string;
-    paginationPage?: (page: number) => string;
+    leftIcon?: React$1.ReactNode;
+    rightIcon?: React$1.ReactNode;
+    showValue?: boolean;
+    valuePosition?: "left" | "right" | "inside";
+    segments?: number;
+    steps?: string[];
+    currentStep?: number;
+    autocolor?: number[];
+    plusIndicator?: boolean;
 }
-interface DefaultSelectProps<T extends string> extends ErrorMessageProps {
-    selected: T | null;
-    onChange: (value: T) => void;
-    placeholder?: string;
-    disabled?: boolean;
-    className?: string;
+declare const ProgressBase: React$1.ForwardRefExoticComponent<ProgressBaseProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ProgressSegmentsBaseProps {
     label?: string;
-    labelClassname?: string;
-    pagination?: number;
+    segments: number;
+    value: number;
 }
-interface SelectPropsWithItems<T extends string> extends DefaultSelectProps<T> {
-    items: SelectItem<T>[];
-    groupItems?: never;
-    testIds?: SelectTestIds;
+declare const ProgressSegmentsBase: ({ label, segments, value, }: ProgressSegmentsBaseProps) => react_jsx_runtime.JSX.Element;
+interface ProgressPanelsBaseProps {
+    label?: string;
+    steps: string[];
+    currentStep: number;
 }
-interface SelectPropsWithGroupItems<T extends string> extends DefaultSelectProps<T> {
-    items?: never;
-    groupItems: {
-        [key: string]: SelectItem<T>[];
-    };
-    testIds?: SelectTestIds;
+declare const ProgressPanelsBase: ({ label, steps, currentStep, }: ProgressPanelsBaseProps) => react_jsx_runtime.JSX.Element;
+interface ProgressCirclesBaseProps {
+    label?: string;
+    steps: string[];
+    currentStep: number;
 }
-type NewSelectProps<T extends string> = SelectPropsWithItems<T> | SelectPropsWithGroupItems<T>;
-declare function Select<T extends string>({ items, groupItems, placeholder, onChange, error, testIds, disabled, selected, label, labelClassname, className, pagination, }: NewSelectProps<T>): react_jsx_runtime.JSX.Element;
+declare const ProgressCirclesBase: ({ label, steps, currentStep, }: ProgressCirclesBaseProps) => react_jsx_runtime.JSX.Element;
 
-declare const formatFieldName: (fieldName: string) => string;
-declare const detectDataFields: (data: Record<string, unknown>[], xAxisKey: string) => string[];
-declare const detectXAxis: (data: Record<string, unknown>[]) => string;
-declare const generateAdditionalColors: (baseColors: string[], count: number) => string[];
-declare const niceCeil: (value: number) => number;
-declare const compactTick: (value: number) => string;
-type Padding = number | Partial<{
-    left: number;
-    right: number;
-    top: number;
-    bottom: number;
-}>;
-type Margins = Partial<{
-    top: number;
-    right: number;
-    left: number;
-    bottom: number;
-}>;
-declare const resolveContainerPaddingLeft: (padding?: Padding, containerPaddingLeft?: number, defaultLeft?: number) => number;
-declare const resolveChartMargins: (margins?: Margins, chartMargins?: Margins, showLabels?: boolean) => {
-    top: number;
-    right: number;
-    left: number;
-    bottom: number;
-};
+declare function SkeletonBase({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
 
-type Variant = "filled" | "outline" | "soft";
-type LabelRendererProps = {
-    x?: number | string;
-    y?: number | string;
-    value?: number | string;
-    index?: number;
-    payload?: unknown;
-    width?: number | string;
-    height?: number | string;
-    viewBox?: {
-        x?: number;
-        y?: number;
-        width?: number;
-        height?: number;
-    } | Record<string, unknown> | undefined;
-    cx?: number | string;
-    cy?: number | string;
+type ToasterProps = React.ComponentProps<typeof Toaster$1> & {
+    testId?: string;
+};
+declare const Toaster: ({ testId, ...props }: ToasterProps) => react_jsx_runtime.JSX.Element;
+declare const toast: {
+    success: (message: string) => string | number;
+    error: (message: string) => string | number;
+    warning: (message: string) => string | number;
+    info: (message: string) => string | number;
+    loading: (message: string) => string | number;
 };
-type valueFormatter = (props: {
-    value: number | string | undefined;
-    formattedValue: string;
-    [key: string]: unknown;
-}) => string;
-declare const renderPillLabel: (color: string, variant: Variant, valueFormatter?: valueFormatter) => (props: LabelRendererProps) => react_jsx_runtime.JSX.Element;
 
-declare const renderInsideBarLabel: (color: string, valueFormatter?: valueFormatter) => (props: LabelRendererProps) => react_jsx_runtime.JSX.Element;
+declare const TooltipProviderBase: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const TooltipBase: React$1.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTriggerBase: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContentBase: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
-interface ChartData$1 {
-    [key: string]: string | number | boolean | null | undefined;
+declare const buttonVariantsBase: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "select" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "select" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariantsBase> {
+    asChild?: boolean;
+    testid?: string;
+    isLoading?: boolean;
 }
-interface XAxisConfig$2 {
-    dataKey: string;
+declare const ButtonBase: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface ButtonGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    children: React$1.ReactNode;
+    orientation?: "horizontal" | "vertical";
+}
+declare const ButtonGroupBase: React$1.ForwardRefExoticComponent<ButtonGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const CheckboxBase: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const CollapsibleBase: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const CollapsibleTriggerBase: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    leftIcon?: React$1.ReactNode;
+    showCaret?: boolean;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+declare const CollapsibleContentBase: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare function HoverCardBase(props: React$1.ComponentProps<typeof HoverCardPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function HoverCardTriggerBase(props: React$1.ComponentProps<typeof HoverCardPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare const HoverCardContentBase: React$1.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare function InputOTPBase({ className, containerClassName, ...props }: React$1.ComponentProps<typeof OTPInput> & {
+    containerClassName?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function InputOTPGroupBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function InputOTPSlotBase({ index, className, ...props }: React$1.ComponentProps<"div"> & {
+    index: number;
+}): react_jsx_runtime.JSX.Element;
+declare function InputOTPSeparatorBase({ ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+
+interface InputBaseProps extends React$1.ComponentProps<"input"> {
     label?: string;
-    valueFormatter?: (value: string | number) => string;
-    autoLabel?: boolean;
+    labelClassname?: string;
+    leftIcon?: React$1.ReactNode;
+    rightIcon?: React$1.ReactNode;
+    "data-testid"?: string;
+    error?: string | undefined;
 }
-interface BiaxialConfig {
-    key: string[];
+declare const InputBase: React$1.ForwardRefExoticComponent<Omit<InputBaseProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const LabelBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+    asChild?: boolean;
+    testid?: string;
+} & React$1.RefAttributes<HTMLLabelElement>>;
+
+interface SliderBaseProps extends React$1.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> {
     label?: string;
-    percentage?: boolean;
-    decimals?: number;
-    stroke?: string | Record<string, string>;
+    leftIcon?: React$1.ReactNode;
+    rightIcon?: React$1.ReactNode;
 }
-type SeriesProp$1 = {
-    bar?: string[];
-    line?: string[];
-    area?: string[];
-};
-interface ChartProps {
-    data: ChartData$1[];
-    series?: SeriesProp$1;
+declare const SlideBase: React$1.ForwardRefExoticComponent<SliderBaseProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+interface QuickButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    disabled?: boolean;
+    onClick?: (e?: React$1.MouseEvent<HTMLButtonElement>) => void;
+    testid?: string;
     className?: string;
-    chartMargin?: Partial<{
-        top: number;
-        right: number;
-        left: number;
-        bottom: number;
-    }>;
-    height?: number;
-    width?: number | string;
-    colors?: string[];
-    gridColor?: string;
-    showGrid?: boolean;
-    showTooltip?: boolean;
-    showLegend?: boolean;
-    title?: string;
-    titlePosition?: "left" | "center" | "right";
-    showLabels?: boolean;
-    labelMap?: Record<string, string>;
-    valueFormatter?: valueFormatter;
-    categoryFormatter?: (value: string | number) => string;
-    periodLabel?: string;
-    xAxisLabel?: string;
-    yAxisLabel?: string;
-    xAxis?: XAxisConfig$2 | string;
-    biaxial?: BiaxialConfig | string | string[];
-    enableHighlights?: boolean;
-    enableShowOnly?: boolean;
-    enablePeriodsDropdown?: boolean;
-    enableDraggableTooltips?: boolean;
-    showTooltipTotal?: boolean;
-    maxTooltips?: number;
-    formatBR?: boolean;
+    iconSize?: number;
+    iconColor?: string;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+    size?: "default" | "sm" | "lg" | "icon";
 }
-declare const Chart: React__default.FC<ChartProps>;
-
-interface BarChartData {
-    [key: string]: string | number | boolean | null | undefined;
+declare const EditButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const ChangeButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SaveButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const AddButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const CloseButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DownloadButton: React$1.FC<QuickButtonProps>;
+declare const UploadButton: React$1.FC<QuickButtonProps>;
+declare const CopyButton: React$1.FC<QuickButtonProps>;
+declare const RefreshButton: React$1.FC<QuickButtonProps>;
+declare const SearchButton: React$1.FC<QuickButtonProps>;
+declare const BackButton: React$1.FC<QuickButtonProps>;
+declare const SettingsButton: React$1.FC<QuickButtonProps>;
+declare const NotificationButton: React$1.FC<QuickButtonProps>;
+declare const MoreButton: React$1.FC<QuickButtonProps>;
+declare const CheckButton: React$1.FC<QuickButtonProps>;
+interface FilterButtonProps extends QuickButtonProps {
+    active?: boolean;
 }
-interface XAxisConfig$1 {
-    dataKey: string;
-    label?: string;
-    valueFormatter?: (value: string | number) => string;
-    autoLabel?: boolean;
+declare const FilterButton: React$1.FC<FilterButtonProps>;
+interface LikeButtonProps extends QuickButtonProps {
+    isLiked?: boolean;
 }
-interface DataMapper {
-    [dataKey: string]: {
-        label?: string;
-        valueFormatter?: (value: string | number) => string | number;
-        color?: string;
-        type?: "number" | "string" | "auto";
-        visible?: boolean;
-    };
+declare const LikeButton: React$1.FC<LikeButtonProps>;
+interface FavoriteButtonProps extends QuickButtonProps {
+    isFavorite?: boolean;
 }
-interface BarChartProps {
-    data: BarChartData[];
-    className?: string;
-    padding?: Padding;
-    margins?: Margins;
-    containerPaddingLeft?: number;
-    chartMargins?: Margins;
-    height?: number;
-    width?: number | string;
-    colors?: string[];
-    gridColor?: string;
-    showGrid?: boolean;
-    showTooltip?: boolean;
-    showLegend?: boolean;
-    title?: string;
-    titlePosition?: "left" | "center" | "right";
-    showLabels?: boolean;
-    labelMap?: Record<string, string>;
-    xAxis?: XAxisConfig$1 | string;
-    mapper?: DataMapper | string[];
-    yAxis?: DataMapper | string[];
-    autoDetect?: boolean;
+declare const FavoriteButton: React$1.FC<FavoriteButtonProps>;
+interface VisibilityButtonProps extends QuickButtonProps {
+    isVisible?: boolean;
 }
-declare const BarChart: React__default.FC<BarChartProps>;
+declare const VisibilityButton: React$1.FC<VisibilityButtonProps>;
+declare const ViewButton: React$1.FC<QuickButtonProps>;
+declare const HideButton: React$1.FC<QuickButtonProps>;
+interface LockButtonProps extends QuickButtonProps {
+    isLocked?: boolean;
+}
+declare const LockButton: React$1.FC<LockButtonProps>;
+declare const UnlockButton: React$1.FC<QuickButtonProps>;
 
-interface LineChartData {
-    name: string;
-    [key: string]: string | number;
+declare const SwitchBase: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+
+interface TextAreaBaseProps extends React$1.ComponentProps<"textarea"> {
+    clearable?: boolean;
+    onClear?: () => void;
 }
-interface CustomLineChartProps {
-    data?: LineChartData[];
-    className?: string;
-    padding?: Padding;
-    margins?: Margins;
-    containerPaddingLeft?: number;
-    chartMargins?: Margins;
-    height?: number;
-    width?: number | string;
-    colors?: string[];
-    gridColor?: string;
-    showGrid?: boolean;
-    showTooltip?: boolean;
-    showLegend?: boolean;
-    title?: string;
-    titlePosition?: "left" | "center" | "right";
-    strokeWidth?: number;
-    showDots?: boolean;
-    showLabels?: boolean;
-}
-declare const CustomLineChart: React__default.FC<CustomLineChartProps>;
+declare const TextAreaBase: React$1.ForwardRefExoticComponent<Omit<TextAreaBaseProps, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;
 
-interface PieChartData {
-    name: string;
-    value: number;
-    [key: string]: string | number;
-}
-interface CustomPieChartProps {
-    data?: PieChartData[];
-    className?: string;
-    height?: number;
-    width?: number | string;
-    colors?: string[];
-    showTooltip?: boolean;
-    showLegend?: boolean;
-    showLabels?: boolean;
-    innerRadius?: number;
-    outerRadius?: number;
-    centerX?: string | number;
-    centerY?: string | number;
-}
-declare const CustomPieChart: React__default.FC<CustomPieChartProps>;
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+};
+declare function CarouselBase({ orientation, opts, setApi, plugins, className, children, ...props }: React$1.ComponentProps<"div"> & CarouselProps): react_jsx_runtime.JSX.Element;
+declare function CarouselContentBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function CarouselItemBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function CarouselPreviousBase({ className, variant, size, ...props }: React$1.ComponentProps<typeof ButtonBase>): react_jsx_runtime.JSX.Element;
+declare function CarouselNextBase({ className, variant, size, ...props }: React$1.ComponentProps<typeof ButtonBase>): react_jsx_runtime.JSX.Element;
 
-interface Props$4 {
-    processedData: Array<{
-        name: string;
-    }>;
-    onOpenPeriod: (periodName: string) => void;
-    rightOffset?: number;
-    topOffset?: number;
-    activePeriod?: string;
-    activePeriods?: string[];
-}
-declare function PeriodsDropdown({ processedData, onOpenPeriod, rightOffset, topOffset, activePeriod, activePeriods, }: Props$4): react_jsx_runtime.JSX.Element;
+declare const ScrollAreaBase: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBarBase: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
-interface Props$3 {
-    showOnlyHighlighted: boolean;
-    setShowOnlyHighlighted: React__default.Dispatch<React__default.SetStateAction<boolean>>;
-    highlightedSeriesSize: number;
-    clearHighlights: () => void;
-}
-/**
- * ShowOnly
- * - Botão principal alterna entre mostrar somente os itens destacados ou mostrar todos
- * - Botão secundário limpa os destaques quando houver algum
- * - Acessibilidade: aria-pressed, aria-labels e estados desabilitados
- */
-declare const ShowOnly: React__default.FC<Props$3>;
+declare const SeparatorBase: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
-interface MapperEntry {
-    label?: string;
-    valueFormatter?: (value: string | number) => string | number;
-    color?: string;
-    type?: string;
-    visible?: boolean;
-}
-interface Props$2 {
-    allKeys: string[];
-    mapperConfig: Record<string, MapperEntry>;
-    finalColors: Record<string, string>;
-    highlightedSeries: Set<string>;
-    toggleHighlight: (key: string) => void;
-    containerWidth?: number;
-}
-declare const Highlights: React__default.FC<Props$2>;
+declare const TableBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
+declare const TableHeaderBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBodyBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooterBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRowBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
+declare const TableHeadBase: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCellBase: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaptionBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
 
-interface CloseAllButtonProps {
-    count: number;
-    onCloseAll: () => void;
-    position?: "top-left" | "top-right" | "top-center";
-    variant?: "floating" | "inline";
-}
-declare const CloseAllButton: React__default.FC<CloseAllButtonProps>;
+declare const TabsBase: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const TabsListBase: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+type TabsTriggerAnimation = "default" | "none" | "scale" | "underline" | string;
+declare const TabsTriggerBase: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
+    animation?: TabsTriggerAnimation;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+type TabsContentAnimation = "default" | "fade" | "slide" | "none" | string;
+declare const TabsContentBase: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    animation?: TabsContentAnimation;
+} & React$1.RefAttributes<HTMLDivElement>>;
 
-interface TooltipData {
-    name: string;
-    [key: string]: string | number;
-}
-interface Position$1 {
-    top: number;
-    left: number;
-}
-interface DraggableTooltipProps {
-    id: string;
-    data: TooltipData;
-    position: Position$1;
-    isDragging?: boolean;
-    title?: string;
-    dataKeys: string[];
-    finalColors: Record<string, string>;
-    onMouseDown?: (id: string, e: React__default.MouseEvent) => void;
-    onClose: (id: string) => void;
-    periodLabel?: string;
-    dataLabel?: string;
-    showCloseAllButton?: boolean;
-    globalTooltipCount?: number;
-    onCloseAll?: () => void;
-    closeAllButtonPosition?: "top-left" | "top-right" | "top-center";
-    closeAllButtonVariant?: "floating" | "inline";
-    onPositionChange?: (id: string, position: Position$1) => void;
-    highlightedSeries?: Set<string>;
-    toggleHighlight?: (key: string) => void;
-    showOnlyHighlighted?: boolean;
-    valueFormatter?: valueFormatter;
-    categoryFormatter?: (value: string | number) => string;
-}
-declare const DraggableTooltip: React__default.NamedExoticComponent<DraggableTooltipProps>;
+declare function BreadcrumbBase({ ...props }: React$1.ComponentProps<"nav">): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbListBase({ className, ...props }: React$1.ComponentProps<"ol">): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbItemBase({ className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbLinkBase({ asChild, className, ...props }: React$1.ComponentProps<"a"> & {
+    asChild?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbPageBase({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbSeparatorBase({ children, className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbEllipsisBase({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
 
-type TooltipPayloadItem$1 = {
-    dataKey: string;
-    value: number;
-    name: string;
-    color?: string;
-};
-interface Props$1 {
-    active?: boolean;
-    payload?: TooltipPayloadItem$1[];
+declare const CommandBase: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     label?: string;
-    finalColors?: Record<string, string>;
-    periodLabel?: string;
-    totalLabel?: string;
-    valueFormatter?: valueFormatter;
-    categoryFormatter?: (value: string | number) => string;
-    yAxisMap?: Record<string, "left" | "right">;
-    isBiaxial?: boolean;
-}
-declare const RechartTooltipWithTotal: React__default.FC<Props$1>;
-
-type TooltipPayloadItem = {
-    dataKey: string;
-    value: number;
-    name: string;
-    color?: string;
-};
-interface Props {
-    active?: boolean;
-    payload?: TooltipPayloadItem[];
+    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$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandDialogBase: ({ children, open, ...props }: DialogProps) => react_jsx_runtime.JSX.Element;
+declare const CommandInputBase: React$1.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React$1.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React$1.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React$1.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React$1.RefAttributes<HTMLInputElement>, "ref"> & {
+    testid?: string;
+} & React$1.RefAttributes<HTMLInputElement>>;
+declare const CommandListBase: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
     label?: string;
-    finalColors?: Record<string, string>;
-    periodLabel?: string;
-    valueFormatter?: valueFormatter;
-    categoryFormatter?: (value: string | number) => string;
-    yAxisMap?: Record<string, "left" | "right">;
-    isBiaxial?: boolean;
-}
-declare const TooltipSimple: React__default.FC<Props>;
-
-interface UseChartHighlightsReturn {
-    highlightedSeries: Set<string>;
-    showOnlyHighlighted: boolean;
-    toggleHighlight: (key: string) => void;
-    setShowOnlyHighlighted: (show: boolean) => void;
-    clearHighlights: () => void;
-    getSeriesStyle: (key: string) => React.CSSProperties;
-    isHighlighted: (key: string) => boolean;
-}
-declare const useChartHighlights: () => UseChartHighlightsReturn;
-
-interface NoDataProps {
-    paddingLeft?: number;
-    height?: number | string;
-    message?: string;
-    className?: string;
-}
-declare const NoData: React__default.FC<NoDataProps>;
-
-type Primitive = string | number | boolean | null | undefined;
-interface ChartData {
-    [key: string]: Primitive;
-    name?: string;
-}
-interface XAxisConfig {
-    dataKey: string;
-    label?: string;
-    valueFormatter?: (value: string | number) => string;
-    autoLabel?: boolean;
-}
-type ValueFormatter = (value: string | number) => string | number;
-type FinalValueFormatter = (value: number | string | null | undefined) => string;
-type SeriesProp = {
-    bar?: string[];
-    line?: string[];
-    area?: string[];
-};
-type SeriesEntry = {
-    type: "bar" | "line" | "area";
-    key: string;
-};
-type SeriesCounts = {
-    bar: number;
-    line: number;
-    area: number;
-};
-type YAxisSide = "left" | "right";
-type YAxisMap = Record<string, YAxisSide>;
-interface MapperConfigEntry {
-    label?: string;
-    valueFormatter?: ValueFormatter;
-    color?: string;
-    type?: "number" | "string" | "auto";
-    visible?: boolean;
-}
-type MapperConfig = Record<string, MapperConfigEntry>;
-interface YAxisOptions {
-    label?: string;
-    stroke?: string;
-    width?: number;
-    percent?: boolean;
-    percentDecimals?: number;
-}
-type YAxes = Partial<{
-    left: YAxisOptions;
-    right: YAxisOptions;
-}>;
-interface TooltipItem {
-    id: string;
-    data: ChartData;
-    position: {
-        top: number;
-        left: number;
-    };
-}
-type TooltipAdaptedRow = Record<string, string | number> & {
-    name: string;
-};
-interface ChartHooksArgs {
-    width?: number | string;
-    measuredWidth?: number | null;
-    points?: number;
-    seriesCounts?: SeriesCounts;
-    niceMax?: number;
-    yAxes?: YAxes;
-    yAxisLabel?: string;
-    chartMargin?: Partial<{
-        top: number;
-        right: number;
-        left: number;
-        bottom: number;
-    }>;
-    showLabels?: boolean;
-    showLegend?: boolean;
-    xAxisLabel?: string;
-}
-
-declare const AvatarBase: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
-declare const AvatarImageBase: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React$1.RefAttributes<HTMLImageElement>, "ref"> & React$1.RefAttributes<HTMLImageElement>>;
-declare const AvatarFallbackBase: React$1.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
-
-declare const badgeVariants: (props?: ({
-    size?: "sm" | "lg" | "md" | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
-type BadgeColorType = "green" | "gray" | "red" | "yellow" | "blue" | "purple";
-interface BadgeBaseProps extends React$1.ComponentProps<"span">, VariantProps<typeof badgeVariants> {
-    asChild?: boolean;
-    color?: BadgeColorType;
-    size?: "sm" | "md" | "lg";
-    status?: string;
-}
-declare function Badge({ className, color, size, asChild, children, style, ...props }: BadgeBaseProps): react_jsx_runtime.JSX.Element;
-
-type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
-declare function CalendarBase({ className, classNames, showOutsideDays, ...props }: CalendarProps): react_jsx_runtime.JSX.Element;
-declare namespace CalendarBase {
-    var displayName: string;
-}
-
-declare const CardBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const CardHeaderBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     testid?: string;
 } & React$1.RefAttributes<HTMLDivElement>>;
-declare const CardTitleBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+declare const CommandEmptyBase: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     testid?: string;
 } & React$1.RefAttributes<HTMLDivElement>>;
-declare const CardDescriptionBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+declare const CommandGroupBase: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
+    heading?: React$1.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     testid?: string;
 } & React$1.RefAttributes<HTMLDivElement>>;
-declare const CardContentBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+declare const CommandSeparatorBase: React$1.ForwardRefExoticComponent<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    alwaysRender?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     testid?: string;
 } & React$1.RefAttributes<HTMLDivElement>>;
-declare const CardFooterBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+declare const CommandItemBase: React$1.ForwardRefExoticComponent<Omit<{
+    children?: React$1.ReactNode;
+} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React$1.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     testid?: string;
 } & React$1.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcutBase: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
 
-interface FileWithPreview extends File {
-    id?: string;
-    error?: string;
-    preview?: string;
-}
-interface FileUploaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onDrop"> {
-    accept: string[];
-    maxSize: number;
-    maxFiles?: number;
-    onValueChange: (files: FileWithPreview[]) => void;
-    disabled?: boolean;
-    value?: FileWithPreview[];
-    onUpload?: (files: FileWithPreview[]) => Promise<void>;
-    showPreview?: boolean;
-    dropzoneText?: string;
-    dropzoneSubtext?: string;
-    animate?: boolean;
-}
-declare const FileUploader: React$1.ForwardRefExoticComponent<FileUploaderProps & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const AlertDialogBase: React$1.FC<AlertDialogPrimitive.AlertDialogProps>;
-declare const AlertDialogTriggerBase: React$1.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const AlertDialogPortalBase: React$1.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
-declare const AlertDialogOverlayBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    testid?: string;
+declare const DropDownMenuBase: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropDownMenuTriggerBase: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropDownMenuGroupBase: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropDownMenuPortalBase: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropDownMenuSubBase: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropDownMenuRadioGroupBase: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropDownMenuSubTriggerBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
 } & React$1.RefAttributes<HTMLDivElement>>;
-declare const AlertDialogContentBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+declare const DropDownMenuSubContentBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropDownMenuContentBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
     testid?: string;
 } & React$1.RefAttributes<HTMLDivElement>>;
-declare const AlertDialogHeaderBase: {
-    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
-declare const AlertDialogFooterBase: {
-    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare const DropDownMenuItemBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+    leftIcon?: React$1.ReactNode;
+    rightIcon?: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropDownMenuCheckboxItemBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropDownMenuRadioItemBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropDownMenuLabelBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropDownMenuSeparatorBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropDownMenuShortcutBase: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
-declare const AlertDialogTitleBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLHeadingElement>>;
-declare const AlertDialogDescriptionBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLParagraphElement>>;
-declare const AlertDialogActionBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLButtonElement>>;
-declare const AlertDialogCancelBase: React$1.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLButtonElement>>;
 
-interface DestructiveDialogProps {
-    title: string;
-    description: string;
-    onConfirm: () => void;
-    onCancel?: () => void;
-    children?: React$1.ReactNode;
-    triggerContent?: React$1.ReactNode;
-    className?: string;
-}
-declare const DestructiveDialog: React$1.FC<DestructiveDialogProps>;
+declare function NavigationMenuBase({ className, children, viewport, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Root> & {
+    viewport?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuListBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.List>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuItemBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Item>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuTriggerBase({ className, children, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuContentBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuViewportBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Viewport>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuLinkBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Link>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuIndicatorBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Indicator>): react_jsx_runtime.JSX.Element;
 
-type TestIdProps$2 = {
-    testid?: string;
+type SidebarContext = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
 };
-declare const DialogBase: React$1.FC<DialogPrimitive.DialogProps>;
-declare const DialogTriggerBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const DialogPortalBase: React$1.FC<DialogPrimitive.DialogPortalProps>;
-declare const DialogCloseBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const DialogOverlayBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps$2 & React$1.RefAttributes<HTMLDivElement>>;
-declare const DialogContentBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps$2 & React$1.RefAttributes<HTMLDivElement>>;
-declare const DialogHeaderBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & TestIdProps$2 & React$1.RefAttributes<HTMLDivElement>>;
-declare const DialogFooterBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & TestIdProps$2 & React$1.RefAttributes<HTMLDivElement>>;
-declare const DialogTitleBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & TestIdProps$2 & React$1.RefAttributes<HTMLHeadingElement>>;
-declare const DialogDescriptionBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & TestIdProps$2 & React$1.RefAttributes<HTMLParagraphElement>>;
-
-declare const loadingVariants: (props?: ({
-    size?: "sm" | "lg" | "md" | "xl" | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
-interface LoadingBaseProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof loadingVariants> {
-    message?: string;
-    overlay?: boolean;
-    variant?: "spinner" | "dots";
-}
-declare const LoadingBase: React$1.ForwardRefExoticComponent<LoadingBaseProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarContext: React$1.Context<SidebarContext | null>;
+declare function UseSideBarBase(): SidebarContext;
+declare const SidebarProviderBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarTriggerBase: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarRailBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarInsetBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarInputBase: React$1.ForwardRefExoticComponent<Omit<Omit<InputBaseProps, "ref"> & React$1.RefAttributes<HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+declare const SidebarHeaderBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarFooterBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarSeparatorBase: React$1.ForwardRefExoticComponent<Omit<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarContentBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupLabelBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupActionBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarGroupContentBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuItemBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuButtonBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React$1.ComponentProps<typeof TooltipContentBase>;
+} & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuActionBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuBadgeBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSkeletonBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
+    showIcon?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSubBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuSubItemBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuSubButtonBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLAnchorElement> & React$1.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}, "ref"> & React$1.RefAttributes<HTMLAnchorElement>>;
 
-type TestIdProps$1 = {
+declare function DrawerBase({ ...props }: React$1.ComponentProps<typeof Drawer.Root>): react_jsx_runtime.JSX.Element;
+declare function DrawerTriggerBase({ ...props }: React$1.ComponentProps<typeof Drawer.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DrawerPortalBase({ ...props }: React$1.ComponentProps<typeof Drawer.Portal>): react_jsx_runtime.JSX.Element;
+declare function DrawerCloseBase({ ...props }: React$1.ComponentProps<typeof Drawer.Close>): react_jsx_runtime.JSX.Element;
+declare function DrawerOverlayBase({ className, ...props }: React$1.ComponentProps<typeof Drawer.Overlay>): react_jsx_runtime.JSX.Element;
+declare function DrawerContentBase({ className, children, ...props }: React$1.ComponentProps<typeof Drawer.Content>): react_jsx_runtime.JSX.Element;
+declare function DrawerHeaderBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function DrawerFooterBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function DrawerTitleBase({ className, ...props }: React$1.ComponentProps<typeof Drawer.Title>): react_jsx_runtime.JSX.Element;
+declare function DrawerDescriptionBase({ className, ...props }: React$1.ComponentProps<typeof Drawer.Description>): react_jsx_runtime.JSX.Element;
+
+declare const PopoverBase: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTriggerBase: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchorBase: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React$1.RefAttributes<HTMLDivElement>>;
+type TestIdProps = {
     testid?: string;
 };
-declare const ModalBase: React$1.FC<DialogPrimitive.DialogProps>;
-declare const ModalTriggerBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const ModalPortalBase: React$1.FC<DialogPrimitive.DialogPortalProps>;
-declare const ModalCloseBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const ModalOverlayBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps$1 & React$1.RefAttributes<HTMLDivElement>>;
-type ModalSize = "sm" | "md" | "lg" | "full";
-declare const ModalContentBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps$1 & {
-    size?: ModalSize;
-    centered?: boolean;
-    backdropBlur?: boolean;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const ModalHeaderBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & TestIdProps$1 & React$1.RefAttributes<HTMLDivElement>>;
-declare const ModalFooterBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & TestIdProps$1 & React$1.RefAttributes<HTMLDivElement>>;
-declare const ModalTitleBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & TestIdProps$1 & React$1.RefAttributes<HTMLHeadingElement>>;
-declare const ModalDescriptionBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & TestIdProps$1 & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const PopoverContentBase: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps & React$1.RefAttributes<HTMLDivElement>>;
 
-type ProgressType = "bar" | "segments" | "panels" | "circles";
-interface ProgressBaseProps extends React$1.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> {
-    variant?: ProgressType;
-    label?: string;
-    leftIcon?: React$1.ReactNode;
-    rightIcon?: React$1.ReactNode;
-    showValue?: boolean;
-    valuePosition?: "left" | "right" | "inside";
-    segments?: number;
-    steps?: string[];
-    currentStep?: number;
-    autocolor?: number[];
-    plusIndicator?: boolean;
+declare const SheetBase: React$1.FC<DialogPrimitive.DialogProps>;
+declare const SheetTriggerBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetCloseBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortalBase: React$1.FC<DialogPrimitive.DialogPortalProps>;
+declare const SheetOverlayBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "bottom" | "left" | "right" | "top" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
 }
-declare const ProgressBase: React$1.ForwardRefExoticComponent<ProgressBaseProps & React$1.RefAttributes<HTMLDivElement>>;
-interface ProgressSegmentsBaseProps {
-    label?: string;
-    segments: number;
-    value: number;
+declare const SheetContentBase: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const SheetHeaderBase: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetFooterBase: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SheetTitleBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescriptionBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+
+interface UniversalTooltipRendererProps {
+    className?: string;
+    showCloseButton?: boolean;
+    showCloseAllButton?: boolean;
+    tooltipClassName?: string;
+    guideClassName?: string;
+    closeButtonClassName?: string;
+    closeAllButtonClassName?: string;
 }
-declare const ProgressSegmentsBase: ({ label, segments, value, }: ProgressSegmentsBaseProps) => react_jsx_runtime.JSX.Element;
-interface ProgressPanelsBaseProps {
-    label?: string;
-    steps: string[];
-    currentStep: number;
+declare const UniversalTooltipRenderer: React__default.FC<UniversalTooltipRendererProps>;
+
+declare function ContextMenuBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuTriggerBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuGroupBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Group>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuPortalBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Portal>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuSubBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Sub>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuRadioGroupBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuSubTriggerBase({ className, inset, children, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function ContextMenuSubContentBase({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.SubContent>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuContentBase({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuItemBase({ className, inset, variant, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): react_jsx_runtime.JSX.Element;
+declare function ContextMenuCheckboxItemBase({ className, children, checked, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuRadioItemBase({ className, children, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.RadioItem>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuLabelBase({ className, inset, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Label> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function ContextMenuSeparatorBase({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Separator>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuShortcutBase({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+
+type CodeBlockProps = {
+    language: string;
+    filename: string;
+    highlightLines?: number[];
+    breadcrumb?: string[];
+    showStats?: boolean;
+    loading?: boolean;
+    loaderWords?: string[];
+} & ({
+    code: string;
+    tabs?: never;
+} | {
+    code?: never;
+    tabs: Array<{
+        name: string;
+        code: string;
+        language?: string;
+        highlightLines?: number[];
+    }>;
+} | {
+    code?: string;
+    tabs?: Array<{
+        name: string;
+        code: string;
+        language?: string;
+        highlightLines?: number[];
+    }>;
+});
+declare const CodeBlock: ({ language, filename, code, highlightLines, tabs, breadcrumb, showStats, }: CodeBlockProps) => react_jsx_runtime.JSX.Element;
+
+interface StatusProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    color?: "green" | "gray" | "red" | "yellow" | "blue" | "purple" | "retire";
+    size?: "xs" | "sm" | "md" | "lg";
+    position?: "top-right" | "top-left" | "bottom-right" | "bottom-left" | "inline";
+    show?: boolean;
+    children?: React$1.ReactNode;
 }
-declare const ProgressPanelsBase: ({ label, steps, currentStep, }: ProgressPanelsBaseProps) => react_jsx_runtime.JSX.Element;
-interface ProgressCirclesBaseProps {
+declare function StatusIndicator({ color, size, position, show, children, className, ...props }: StatusProps): react_jsx_runtime.JSX.Element;
+
+interface DebouncedInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value">, ErrorMessageProps {
+    value: string;
+    onChange: (value: string) => void;
+    debounce?: number;
     label?: string;
-    steps: string[];
-    currentStep: number;
+    labelClassname?: string;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+    showLoadingIndicator?: boolean;
+    error?: string | undefined;
 }
-declare const ProgressCirclesBase: ({ label, steps, currentStep, }: ProgressCirclesBaseProps) => react_jsx_runtime.JSX.Element;
+declare function DebouncedInput({ value: initialValue, onChange, debounce, label, labelClassname, leftIcon, rightIcon, showLoadingIndicator, className, error, ...props }: DebouncedInputProps): react_jsx_runtime.JSX.Element;
 
-declare function SkeletonBase({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+interface TreeNode {
+    id: string;
+    label: string;
+    defaultChecked?: boolean;
+    children?: TreeNode[];
+}
+interface CheckboxTreeProps {
+    tree: TreeNode;
+    renderNode: (props: {
+        node: TreeNode;
+        isChecked: boolean | "indeterminate";
+        onCheckedChange: () => void;
+        children: React__default.ReactNode;
+    }) => React__default.ReactNode;
+}
+declare function CheckboxTree({ tree, renderNode }: CheckboxTreeProps): React__default.ReactNode;
 
-type ToasterProps = React.ComponentProps<typeof Toaster$1> & {
-    testId?: string;
+type IconProps = {
+    className?: string;
+    size?: number | string;
 };
-declare const Toaster: ({ testId, ...props }: ToasterProps) => react_jsx_runtime.JSX.Element;
-declare const toast: {
-    success: (message: string) => string | number;
-    error: (message: string) => string | number;
-    warning: (message: string) => string | number;
-    info: (message: string) => string | number;
-    loading: (message: string) => string | number;
+type BannerProps = {
+    icon?: ReactNode | ComponentType<IconProps>;
+    title?: string;
+    description?: string;
+    actionText?: ReactNode;
+    id?: string;
 };
 
-declare const TooltipProviderBase: React$1.FC<TooltipPrimitive.TooltipProviderProps>;
-declare const TooltipBase: React$1.FC<TooltipPrimitive.TooltipProps>;
-declare const TooltipTriggerBase: React$1.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const TooltipContentBase: React$1.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const buttonVariantsBase: (props?: ({
-    variant?: "default" | "destructive" | "outline" | "select" | "secondary" | "ghost" | "link" | null | undefined;
-    size?: "default" | "select" | "sm" | "lg" | "icon" | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
-interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariantsBase> {
-    asChild?: boolean;
-    testid?: string;
-    isLoading?: boolean;
-}
-declare const ButtonBase: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
-interface ButtonGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    children: React$1.ReactNode;
-    orientation?: "horizontal" | "vertical";
+interface DateTimePickerProps extends ErrorMessageProps {
+    label?: string;
+    date: Date | undefined;
+    onChange: (date: Date | undefined) => void;
+    displayFormat?: boolean;
+    hideTime?: boolean;
+    hideSeconds?: boolean;
+    fromDate?: Date;
+    toDate?: Date;
+    disabled?: boolean;
+    className?: string;
+    error?: string;
 }
-declare const ButtonGroupBase: React$1.ForwardRefExoticComponent<ButtonGroupProps & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const CheckboxBase: React$1.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLButtonElement>>;
-
-declare const CollapsibleBase: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const CollapsibleTriggerBase: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
-    leftIcon?: React$1.ReactNode;
-    showCaret?: boolean;
-} & React$1.RefAttributes<HTMLButtonElement>>;
-declare const CollapsibleContentBase: React$1.ForwardRefExoticComponent<Omit<CollapsiblePrimitive.CollapsibleContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-
-declare function HoverCardBase(props: React$1.ComponentProps<typeof HoverCardPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function HoverCardTriggerBase(props: React$1.ComponentProps<typeof HoverCardPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare const HoverCardContentBase: React$1.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-
-declare function InputOTPBase({ className, containerClassName, ...props }: React$1.ComponentProps<typeof OTPInput> & {
-    containerClassName?: string;
-}): react_jsx_runtime.JSX.Element;
-declare function InputOTPGroupBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
-declare function InputOTPSlotBase({ index, className, ...props }: React$1.ComponentProps<"div"> & {
-    index: number;
-}): react_jsx_runtime.JSX.Element;
-declare function InputOTPSeparatorBase({ ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function DateTimePicker({ label, date, onChange, displayFormat, hideTime, hideSeconds, fromDate, toDate, disabled, className, error, }: DateTimePickerProps): react_jsx_runtime.JSX.Element;
 
-interface InputBaseProps extends React$1.ComponentProps<"input"> {
+interface RangePickerProps extends ErrorMessageProps {
+    value?: DateRange;
+    onChange?: (range: DateRange | undefined) => void;
     label?: string;
-    labelClassname?: string;
-    leftIcon?: React$1.ReactNode;
-    rightIcon?: React$1.ReactNode;
-    "data-testid"?: string;
+    minDate?: Date;
+    maxDate?: Date;
     error?: string | undefined;
 }
-declare const InputBase: React$1.ForwardRefExoticComponent<Omit<InputBaseProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+declare function RangePicker({ value, onChange, label, minDate, maxDate, error, }: RangePickerProps): react_jsx_runtime.JSX.Element;
+declare namespace RangePicker {
+    var displayName: string;
+}
 
-declare const LabelBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
-    asChild?: boolean;
-    testid?: string;
-} & React$1.RefAttributes<HTMLLabelElement>>;
+interface TimePickerProps {
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+    hideSeconds?: boolean;
+    enableButton?: boolean;
+}
+declare function TimePicker({ date, setDate, hideSeconds, enableButton, }: TimePickerProps): react_jsx_runtime.JSX.Element;
 
-interface SliderBaseProps extends React$1.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> {
+/**
+ * regular expression to check for valid hour format (01-23)
+ */
+declare function isValidHour(value: string): boolean;
+/**
+ * regular expression to check for valid 12 hour format (01-12)
+ */
+declare function isValid12Hour(value: string): boolean;
+/**
+ * regular expression to check for valid minute format (00-59)
+ */
+declare function isValidMinuteOrSecond(value: string): boolean;
+type GetValidNumberConfig = {
+    max: number;
+    min?: number;
+    loop?: boolean;
+};
+declare function getValidNumber(value: string, { max, min, loop }: GetValidNumberConfig): string;
+declare function getValidHour(value: string): string;
+declare function getValid12Hour(value: string): string;
+declare function getValidMinuteOrSecond(value: string): string;
+type GetValidArrowNumberConfig = {
+    min: number;
+    max: number;
+    step: number;
+};
+declare function getValidArrowNumber(value: string, { min, max, step }: GetValidArrowNumberConfig): string;
+declare function getValidArrowHour(value: string, step: number): string;
+declare function getValidArrow12Hour(value: string, step: number): string;
+declare function getValidArrowMinuteOrSecond(value: string, step: number): string;
+declare function setMinutes(date: Date, value: string): Date;
+declare function setSeconds(date: Date, value: string): Date;
+declare function setHours(date: Date, value: string): Date;
+declare function set12Hours(date: Date, value: string, period: Period): Date;
+type TimePickerType = "minutes" | "seconds" | "hours" | "12hours";
+type Period = "AM" | "PM";
+declare function setDateByType(date: Date, value: string, type: TimePickerType, period?: Period): Date;
+declare function getDateByType(date: Date, type: TimePickerType): string;
+declare function getArrowByType(value: string, step: number, type: TimePickerType): string;
+/**
+ * handles value change of 12-hour input
+ * 12:00 PM is 12:00
+ * 12:00 AM is 00:00
+ */
+declare function convert12HourTo24Hour(hour: number, period: Period): number;
+/**
+ * time is stored in the 24-hour form,
+ * but needs to be displayed to the user
+ * in its 12-hour representation
+ */
+declare function display12HourValue(hours: number): string;
+
+interface TimePickerInputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    picker: TimePickerType;
+    date: Date | undefined;
+    setDate: (date: Date | undefined) => void;
+    period?: Period;
+    onRightFocus?: () => void;
+    onLeftFocus?: () => void;
+    showArrows?: boolean;
     label?: string;
-    leftIcon?: React$1.ReactNode;
-    rightIcon?: React$1.ReactNode;
+    error?: boolean;
+    inputSize?: "sm" | "md" | "lg";
+    enableButton?: boolean;
+    buttonText?: string;
+    buttonIcon?: React__default.ReactNode;
 }
-declare const SlideBase: React$1.ForwardRefExoticComponent<SliderBaseProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const TimePickerInput: React__default.ForwardRefExoticComponent<TimePickerInputProps & React__default.RefAttributes<HTMLInputElement>>;
 
-interface QuickButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
-    disabled?: boolean;
-    onClick?: (e?: React$1.MouseEvent<HTMLButtonElement>) => void;
-    testid?: string;
-    className?: string;
-    iconSize?: number;
-    iconColor?: string;
-    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
-    size?: "default" | "sm" | "lg" | "icon";
-}
-declare const EditButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const ChangeButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SaveButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const AddButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const CloseButton: React$1.ForwardRefExoticComponent<QuickButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const DownloadButton: React$1.FC<QuickButtonProps>;
-declare const UploadButton: React$1.FC<QuickButtonProps>;
-declare const CopyButton: React$1.FC<QuickButtonProps>;
-declare const RefreshButton: React$1.FC<QuickButtonProps>;
-declare const SearchButton: React$1.FC<QuickButtonProps>;
-declare const BackButton: React$1.FC<QuickButtonProps>;
-declare const SettingsButton: React$1.FC<QuickButtonProps>;
-declare const NotificationButton: React$1.FC<QuickButtonProps>;
-declare const MoreButton: React$1.FC<QuickButtonProps>;
-declare const CheckButton: React$1.FC<QuickButtonProps>;
-interface FilterButtonProps extends QuickButtonProps {
-    active?: boolean;
-}
-declare const FilterButton: React$1.FC<FilterButtonProps>;
-interface LikeButtonProps extends QuickButtonProps {
-    isLiked?: boolean;
-}
-declare const LikeButton: React$1.FC<LikeButtonProps>;
-interface FavoriteButtonProps extends QuickButtonProps {
-    isFavorite?: boolean;
-}
-declare const FavoriteButton: React$1.FC<FavoriteButtonProps>;
-interface VisibilityButtonProps extends QuickButtonProps {
-    isVisible?: boolean;
-}
-declare const VisibilityButton: React$1.FC<VisibilityButtonProps>;
-declare const ViewButton: React$1.FC<QuickButtonProps>;
-declare const HideButton: React$1.FC<QuickButtonProps>;
-interface LockButtonProps extends QuickButtonProps {
-    isLocked?: boolean;
+interface AgendaViewProps$1 {
+    currentDate: Date;
+    events: CalendarEventAgenda[];
+    onEventSelect?: (event: CalendarEventAgenda, e?: React.MouseEvent) => void;
+    showUndatedEvents?: boolean;
 }
-declare const LockButton: React$1.FC<LockButtonProps>;
-declare const UnlockButton: React$1.FC<QuickButtonProps>;
-
-declare const SwitchBase: React$1.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLButtonElement>>;
+declare function Agenda({ currentDate, events, onEventSelect, showUndatedEvents, }: AgendaViewProps$1): react_jsx_runtime.JSX.Element;
 
-interface TextAreaBaseProps extends React$1.ComponentProps<"textarea"> {
-    clearable?: boolean;
-    onClear?: () => void;
+interface CalendarDndProviderProps$1 {
+    children: ReactNode;
+    onEventUpdate: (event: CalendarEventAgenda) => void;
 }
-declare const TextAreaBase: React$1.ForwardRefExoticComponent<Omit<TextAreaBaseProps, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;
+declare function CalendarDndProviderAgenda({ children, onEventUpdate, }: CalendarDndProviderProps$1): react_jsx_runtime.JSX.Element;
 
-type CarouselApi = UseEmblaCarouselType[1];
-type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
-type CarouselOptions = UseCarouselParameters[0];
-type CarouselPlugin = UseCarouselParameters[1];
-type CarouselProps = {
-    opts?: CarouselOptions;
-    plugins?: CarouselPlugin;
-    orientation?: "horizontal" | "vertical";
-    setApi?: (api: CarouselApi) => void;
+type CalendarDndContextType$1 = {
+    activeEvent: CalendarEventAgenda | null;
+    activeId: UniqueIdentifier | null;
+    activeView: "month" | "week" | "day" | null;
+    currentTime: Date | null;
+    eventHeight: number | null;
+    isMultiDay: boolean;
+    multiDayWidth: number | null;
+    dragHandlePosition: {
+        x?: number;
+        y?: number;
+        data?: {
+            isFirstDay?: boolean;
+            isLastDay?: boolean;
+        };
+    } | null;
 };
-declare function CarouselBase({ orientation, opts, setApi, plugins, className, children, ...props }: React$1.ComponentProps<"div"> & CarouselProps): react_jsx_runtime.JSX.Element;
-declare function CarouselContentBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
-declare function CarouselItemBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
-declare function CarouselPreviousBase({ className, variant, size, ...props }: React$1.ComponentProps<typeof ButtonBase>): react_jsx_runtime.JSX.Element;
-declare function CarouselNextBase({ className, variant, size, ...props }: React$1.ComponentProps<typeof ButtonBase>): react_jsx_runtime.JSX.Element;
+declare const useCalendarDndAgenda: () => CalendarDndContextType$1;
 
-declare const ScrollAreaBase: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const ScrollBarBase: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-
-declare const SeparatorBase: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const EventHeightAgenda = 24;
+declare const EventGapAgenda = 4;
+declare const WeekCellsHeightAgenda = 64;
+declare const AgendaDaysToShowAgenda = 30;
+declare const StartHourAgenda = 0;
+declare const EndHourAgenda = 24;
+declare const DefaultStartHourAgenda = 9;
+declare const DefaultEndHourAgenda = 10;
 
-declare const TableBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & React$1.RefAttributes<HTMLTableElement>>;
-declare const TableHeaderBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
-declare const TableBodyBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
-declare const TableFooterBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
-declare const TableRowBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
-declare const TableHeadBase: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
-declare const TableCellBase: React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
-declare const TableCaptionBase: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+type CalendarViewAgenda = "month" | "week" | "day" | "agenda";
+interface CalendarEventAgenda {
+    id: string;
+    title: string;
+    description?: ReactNode;
+    start?: Date | null;
+    end?: Date | null;
+    allDay?: boolean;
+    color?: EventColorAgenda;
+    location?: string;
+    duration?: number;
+}
+type EventColorAgenda = "sky" | "amber" | "violet" | "rose" | "emerald" | "orange" | "green" | "blue" | "red" | "purple";
 
-declare const TabsBase: React$1.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const TabsListBase: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-type TabsTriggerAnimation = "default" | "none" | "scale" | "underline" | string;
-declare const TabsTriggerBase: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & {
-    animation?: TabsTriggerAnimation;
-} & React$1.RefAttributes<HTMLButtonElement>>;
-type TabsContentAnimation = "default" | "fade" | "slide" | "none" | string;
-declare const TabsContentBase: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    animation?: TabsContentAnimation;
-} & React$1.RefAttributes<HTMLDivElement>>;
+interface DayViewProps$1 {
+    currentDate: Date;
+    events: CalendarEventAgenda[];
+    onEventSelect: (event: CalendarEventAgenda, e?: React__default.MouseEvent) => void;
+    showUndatedEvents?: boolean;
+}
+declare function DayViewAgenda({ currentDate, events, onEventSelect, showUndatedEvents, }: DayViewProps$1): react_jsx_runtime.JSX.Element;
 
-declare function BreadcrumbBase({ ...props }: React$1.ComponentProps<"nav">): react_jsx_runtime.JSX.Element;
-declare function BreadcrumbListBase({ className, ...props }: React$1.ComponentProps<"ol">): react_jsx_runtime.JSX.Element;
-declare function BreadcrumbItemBase({ className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
-declare function BreadcrumbLinkBase({ asChild, className, ...props }: React$1.ComponentProps<"a"> & {
-    asChild?: boolean;
-}): react_jsx_runtime.JSX.Element;
-declare function BreadcrumbPageBase({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
-declare function BreadcrumbSeparatorBase({ children, className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
-declare function BreadcrumbEllipsisBase({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+interface DroppableCellProps$1 {
+    id: string;
+    date: Date;
+    time?: number;
+    children?: React.ReactNode;
+    className?: string;
+    onClick?: () => void;
+}
+declare function DroppableCellAgenda({ id, date, time, children, className, onClick, }: DroppableCellProps$1): react_jsx_runtime.JSX.Element;
 
-declare const CommandBase: React$1.ForwardRefExoticComponent<Omit<{
-    children?: React$1.ReactNode;
-} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    ref?: React$1.Ref<HTMLDivElement>;
-} & {
-    asChild?: boolean;
-}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    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$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const CommandDialogBase: ({ children, open, ...props }: DialogProps) => react_jsx_runtime.JSX.Element;
-declare const CommandInputBase: React$1.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React$1.InputHTMLAttributes<HTMLInputElement>> & {
-    ref?: React$1.Ref<HTMLInputElement>;
-} & {
-    asChild?: boolean;
-}, "asChild" | "key" | keyof React$1.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
-    value?: string;
-    onValueChange?: (search: string) => void;
-} & React$1.RefAttributes<HTMLInputElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLInputElement>>;
-declare const CommandListBase: React$1.ForwardRefExoticComponent<Omit<{
-    children?: React$1.ReactNode;
-} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    ref?: React$1.Ref<HTMLDivElement>;
-} & {
-    asChild?: boolean;
-}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    label?: string;
-} & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const CommandEmptyBase: React$1.ForwardRefExoticComponent<Omit<{
-    children?: React$1.ReactNode;
-} & Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    ref?: React$1.Ref<HTMLDivElement>;
-} & {
-    asChild?: boolean;
-}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const CommandGroupBase: React$1.ForwardRefExoticComponent<Omit<{
-    children?: React$1.ReactNode;
-} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    ref?: React$1.Ref<HTMLDivElement>;
-} & {
-    asChild?: boolean;
-}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
-    heading?: React$1.ReactNode;
-    value?: string;
-    forceMount?: boolean;
-} & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const CommandSeparatorBase: React$1.ForwardRefExoticComponent<Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    ref?: React$1.Ref<HTMLDivElement>;
-} & {
-    asChild?: boolean;
-}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    alwaysRender?: boolean;
-} & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const CommandItemBase: React$1.ForwardRefExoticComponent<Omit<{
-    children?: React$1.ReactNode;
-} & Omit<Pick<Pick<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React$1.HTMLAttributes<HTMLDivElement>> & {
-    ref?: React$1.Ref<HTMLDivElement>;
-} & {
-    asChild?: boolean;
-}, "asChild" | "key" | keyof React$1.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
-    disabled?: boolean;
-    onSelect?: (value: string) => void;
-    value?: string;
-    keywords?: string[];
-    forceMount?: boolean;
-} & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const CommandShortcutBase: {
-    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
+interface EventCalendarProps$1 {
+    events?: CalendarEventAgenda[];
+    onEventUpdate?: (event: CalendarEventAgenda) => void;
+    className?: string;
+    initialView?: CalendarViewAgenda;
+    initialDate?: Date;
+    onClick?: ((event: CalendarEventAgenda, e?: React__default.MouseEvent) => void) | React__default.ReactElement<ModalLikeProps>;
+}
+interface ModalLikeProps {
+    event?: CalendarEventAgenda;
+    onClose?: () => void;
+    [key: string]: unknown;
+}
+declare function EventAgenda({ events, onEventUpdate, className, initialView, initialDate, onClick, }: EventCalendarProps$1): react_jsx_runtime.JSX.Element;
 
-declare const DropDownMenuBase: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
-declare const DropDownMenuTriggerBase: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const DropDownMenuGroupBase: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuPortalBase: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
-declare const DropDownMenuSubBase: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
-declare const DropDownMenuRadioGroupBase: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuSubTriggerBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    inset?: boolean;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuSubContentBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuContentBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    testid?: string;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuItemBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    inset?: boolean;
-    leftIcon?: React$1.ReactNode;
-    rightIcon?: React$1.ReactNode;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuCheckboxItemBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuRadioItemBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuLabelBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
-    inset?: boolean;
-} & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuSeparatorBase: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const DropDownMenuShortcutBase: {
-    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
+interface EventItemProps$1 {
+    event: CalendarEventAgenda;
+    view: "month" | "week" | "day" | "agenda";
+    agendaOnly?: boolean;
+    isDragging?: boolean;
+    onClick?: (e: React.MouseEvent) => void;
+    showTime?: boolean;
+    currentTime?: Date;
+    isFirstDay?: boolean;
+    isLastDay?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+    dndListeners?: SyntheticListenerMap;
+    dndAttributes?: DraggableAttributes;
+    onMouseDown?: (e: React.MouseEvent) => void;
+    onTouchStart?: (e: React.TouchEvent) => void;
+}
+declare function EventItemAgenda({ event, view, onClick, showTime, currentTime, isFirstDay, isLastDay, children, className, dndListeners, dndAttributes, onMouseDown, onTouchStart, agendaOnly, }: EventItemProps$1): react_jsx_runtime.JSX.Element;
 
-declare function NavigationMenuBase({ className, children, viewport, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Root> & {
-    viewport?: boolean;
-}): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuListBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.List>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuItemBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Item>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuTriggerBase({ className, children, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuContentBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuViewportBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Viewport>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuLinkBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Link>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuIndicatorBase({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Indicator>): react_jsx_runtime.JSX.Element;
+interface UndatedEventsProps {
+    events: CalendarEventAgenda[];
+    onEventSelect?: (event: CalendarEventAgenda, e?: React.MouseEvent) => void;
+    className?: string;
+    title?: string;
+    show?: boolean;
+}
+declare function UndatedEvents({ events, onEventSelect, className, title, show, }: UndatedEventsProps): react_jsx_runtime.JSX.Element | null;
 
-type SidebarContext = {
-    state: "expanded" | "collapsed";
-    open: boolean;
-    setOpen: (open: boolean) => void;
-    openMobile: boolean;
-    setOpenMobile: (open: boolean) => void;
-    isMobile: boolean;
-    toggleSidebar: () => void;
+declare function useCurrentTimeIndicatorAgenda(currentDate: Date, view: "day" | "week"): {
+    currentTimePosition: number;
+    currentTimeVisible: boolean;
 };
-declare const SidebarContext: React$1.Context<SidebarContext | null>;
-declare function UseSideBarBase(): SidebarContext;
-declare const SidebarProviderBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
-    defaultOpen?: boolean;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
-    side?: "left" | "right";
-    variant?: "sidebar" | "floating" | "inset";
-    collapsible?: "offcanvas" | "icon" | "none";
-}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarTriggerBase: React$1.ForwardRefExoticComponent<Omit<ButtonProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SidebarRailBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SidebarInsetBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarInputBase: React$1.ForwardRefExoticComponent<Omit<Omit<InputBaseProps, "ref"> & React$1.RefAttributes<HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
-declare const SidebarHeaderBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarFooterBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarSeparatorBase: React$1.ForwardRefExoticComponent<Omit<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarContentBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarGroupBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarGroupLabelBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
-    asChild?: boolean;
-}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarGroupActionBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
-    asChild?: boolean;
-}, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SidebarGroupContentBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarMenuBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
-declare const SidebarMenuItemBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
-declare const SidebarMenuButtonBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
-    asChild?: boolean;
-    isActive?: boolean;
-    tooltip?: string | React$1.ComponentProps<typeof TooltipContentBase>;
-} & VariantProps<(props?: ({
-    variant?: "default" | "outline" | null | undefined;
-    size?: "default" | "sm" | "lg" | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SidebarMenuActionBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLButtonElement> & React$1.ButtonHTMLAttributes<HTMLButtonElement> & {
-    asChild?: boolean;
-    showOnHover?: boolean;
-}, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SidebarMenuBadgeBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarMenuSkeletonBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement> & {
-    showIcon?: boolean;
-}, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const SidebarMenuSubBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React$1.RefAttributes<HTMLUListElement>>;
-declare const SidebarMenuSubItemBase: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
-declare const SidebarMenuSubButtonBase: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLAnchorElement> & React$1.AnchorHTMLAttributes<HTMLAnchorElement> & {
-    asChild?: boolean;
-    size?: "sm" | "md";
-    isActive?: boolean;
-}, "ref"> & React$1.RefAttributes<HTMLAnchorElement>>;
 
-declare function DrawerBase({ ...props }: React$1.ComponentProps<typeof Drawer.Root>): react_jsx_runtime.JSX.Element;
-declare function DrawerTriggerBase({ ...props }: React$1.ComponentProps<typeof Drawer.Trigger>): react_jsx_runtime.JSX.Element;
-declare function DrawerPortalBase({ ...props }: React$1.ComponentProps<typeof Drawer.Portal>): react_jsx_runtime.JSX.Element;
-declare function DrawerCloseBase({ ...props }: React$1.ComponentProps<typeof Drawer.Close>): react_jsx_runtime.JSX.Element;
-declare function DrawerOverlayBase({ className, ...props }: React$1.ComponentProps<typeof Drawer.Overlay>): react_jsx_runtime.JSX.Element;
-declare function DrawerContentBase({ className, children, ...props }: React$1.ComponentProps<typeof Drawer.Content>): react_jsx_runtime.JSX.Element;
-declare function DrawerHeaderBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
-declare function DrawerFooterBase({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
-declare function DrawerTitleBase({ className, ...props }: React$1.ComponentProps<typeof Drawer.Title>): react_jsx_runtime.JSX.Element;
-declare function DrawerDescriptionBase({ className, ...props }: React$1.ComponentProps<typeof Drawer.Description>): react_jsx_runtime.JSX.Element;
+interface EventVisibilityOptions$1 {
+    eventHeight: number;
+    eventGap: number;
+}
+interface EventVisibilityResult$1 {
+    contentRef: React.RefObject<HTMLDivElement>;
+    contentHeight: number | null;
+    getVisibleEventCount: (totalEvents: number) => number;
+}
+/**
+ * Hook for calculating event visibility based on container height
+ * Uses ResizeObserver for efficient updates
+ */
+declare function useEventVisibilityAgenda({ eventHeight, eventGap, }: EventVisibilityOptions$1): EventVisibilityResult$1;
 
-declare const PopoverBase: React$1.FC<PopoverPrimitive.PopoverProps>;
-declare const PopoverTriggerBase: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const PopoverAnchorBase: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React$1.RefAttributes<HTMLDivElement>>;
-type TestIdProps = {
-    testid?: string;
+interface MonthViewProps$1 {
+    currentDate: Date;
+    events: CalendarEventAgenda[];
+    onEventSelect: (event: CalendarEventAgenda, e?: React__default.MouseEvent) => void;
+    showUndatedEvents?: boolean;
+}
+declare function MonthViewAgenda({ currentDate, events, onEventSelect, showUndatedEvents, }: MonthViewProps$1): react_jsx_runtime.JSX.Element;
+
+/**
+ * Get CSS classes for event colors
+ */
+declare function getEventColorClassesAgenda(color?: EventColorAgenda | string): string;
+/**
+ * Get CSS classes for border radius based on event position in multi-day events
+ */
+declare function getBorderRadiusClassesAgenda(isFirstDay: boolean, isLastDay: boolean): string;
+/**
+ * Check if an event is a multi-day event
+ */
+declare function isMultiDayEventAgenda(event: CalendarEventAgenda): boolean;
+/**
+ * Filter events for a specific day
+ */
+declare function getEventsForDayAgenda(events: CalendarEventAgenda[], day: Date): CalendarEventAgenda[];
+declare function sortEventsAgenda(events: CalendarEventAgenda[]): CalendarEventAgenda[];
+declare function getSpanningEventsForDayAgenda(events: CalendarEventAgenda[], day: Date): CalendarEventAgenda[];
+/**
+ * Get all events visible on a specific day (starting, ending, or spanning)
+ */
+declare function getAllEventsForDayAgenda(events: CalendarEventAgenda[], day: Date): CalendarEventAgenda[];
+/**
+ * Get all events for a day (for agenda view)
+ */
+declare function getAgendaEventsForDayAgenda(events: CalendarEventAgenda[], day: Date): CalendarEventAgenda[];
+/**
+ * Return the event start as a Date if possible
+ */
+declare function getEventStartDate(event: CalendarEventAgenda): Date | undefined;
+/**
+ * Return the event end as a Date. If `end` is not provided but `duration` (minutes) is,
+ * compute end = start + duration minutes.
+ */
+declare function getEventEndDate(event: CalendarEventAgenda): Date | undefined;
+declare function normalizeAttendDate(d?: unknown): Date | undefined;
+/**
+ * Add hours to a date
+ */
+declare function addMinutesToDateAgenda(date: Date, minutes: number): Date;
+declare function addHoursToDateAgenda(date: Date, hours: number): Date;
+
+interface WeekViewProps$1 {
+    currentDate: Date;
+    events: CalendarEventAgenda[];
+    onEventSelect: (event: CalendarEventAgenda, e?: React__default.MouseEvent) => void;
+    onEventCreate?: (startTime: Date) => void;
+    showUndatedEvents?: boolean;
+}
+declare function WeekViewAgenda({ currentDate, events, onEventSelect, onEventCreate, showUndatedEvents, }: WeekViewProps$1): react_jsx_runtime.JSX.Element;
+
+interface AgendaViewProps {
+    currentDate: Date;
+    events: CalendarEvent[];
+    onEventSelect?: (event: CalendarEvent) => void;
+    showUndatedEvents?: boolean;
+}
+declare function AgendaView({ currentDate, events, onEventSelect, showUndatedEvents, }: AgendaViewProps): react_jsx_runtime.JSX.Element;
+
+interface CalendarDndProviderProps {
+    children: ReactNode;
+    onEventUpdate: (event: CalendarEvent) => void;
+}
+declare function CalendarDndProvider({ children, onEventUpdate, }: CalendarDndProviderProps): react_jsx_runtime.JSX.Element;
+
+type CalendarDndContextType = {
+    activeEvent: CalendarEvent | null;
+    activeId: UniqueIdentifier | null;
+    activeView: "month" | "week" | "day" | null;
+    currentTime: Date | null;
+    eventHeight: number | null;
+    isMultiDay: boolean;
+    multiDayWidth: number | null;
+    dragHandlePosition: {
+        x?: number;
+        y?: number;
+        data?: {
+            isFirstDay?: boolean;
+            isLastDay?: boolean;
+        };
+    } | null;
 };
-declare const PopoverContentBase: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & TestIdProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const useCalendarDnd: () => CalendarDndContextType;
 
-declare const SheetBase: React$1.FC<DialogPrimitive.DialogProps>;
-declare const SheetTriggerBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SheetCloseBase: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const SheetPortalBase: React$1.FC<DialogPrimitive.DialogPortalProps>;
-declare const SheetOverlayBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
-declare const sheetVariants: (props?: ({
-    side?: "bottom" | "left" | "right" | "top" | null | undefined;
-} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
-interface SheetContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+declare const EventHeight = 24;
+declare const EventGap = 4;
+declare const WeekCellsHeight = 64;
+declare const AgendaDaysToShow = 30;
+declare const StartHour = 0;
+declare const EndHour = 24;
+declare const DefaultStartHour = 9;
+declare const DefaultEndHour = 10;
+
+interface DayViewProps {
+    currentDate: Date;
+    events: CalendarEvent[];
+    onEventSelect: (event: CalendarEvent) => void;
+    onEventCreate: (startTime: Date) => void;
 }
-declare const SheetContentBase: React$1.ForwardRefExoticComponent<SheetContentProps & React$1.RefAttributes<HTMLDivElement>>;
-declare const SheetHeaderBase: {
-    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
-declare const SheetFooterBase: {
-    ({ className, ...props }: React$1.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
-declare const SheetTitleBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
-declare const SheetDescriptionBase: React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
+declare function DayView({ currentDate, events, onEventSelect, onEventCreate, }: DayViewProps): react_jsx_runtime.JSX.Element;
 
-interface UniversalTooltipRendererProps {
-    className?: string;
-    showCloseButton?: boolean;
-    showCloseAllButton?: boolean;
-    tooltipClassName?: string;
-    guideClassName?: string;
-    closeButtonClassName?: string;
-    closeAllButtonClassName?: string;
+interface DraggableEventProps {
+    event: CalendarEvent;
+    view: "month" | "week" | "day";
+    showTime?: boolean;
+    onClick?: (e: React.MouseEvent) => void;
+    height?: number;
+    isMultiDay?: boolean;
+    multiDayWidth?: number;
+    isFirstDay?: boolean;
+    isLastDay?: boolean;
+    "aria-hidden"?: boolean | "true" | "false";
 }
-declare const UniversalTooltipRenderer: React__default.FC<UniversalTooltipRendererProps>;
+declare function DraggableEvent({ event, view, showTime, onClick, height, isMultiDay, multiDayWidth, isFirstDay, isLastDay, "aria-hidden": ariaHidden, }: DraggableEventProps): react_jsx_runtime.JSX.Element;
 
-interface DateTimePickerProps extends ErrorMessageProps {
-    label?: string;
-    date: Date | undefined;
-    onChange: (date: Date | undefined) => void;
-    displayFormat?: boolean;
-    hideTime?: boolean;
-    hideSeconds?: boolean;
-    fromDate?: Date;
-    toDate?: Date;
-    disabled?: boolean;
+interface DroppableCellProps {
+    id: string;
+    date: Date;
+    time?: number;
+    children?: React.ReactNode;
     className?: string;
-    error?: string;
+    onClick?: () => void;
 }
-declare function DateTimePicker({ label, date, onChange, displayFormat, hideTime, hideSeconds, fromDate, toDate, disabled, className, error, }: DateTimePickerProps): react_jsx_runtime.JSX.Element;
+declare function DroppableCell({ id, date, time, children, className, onClick, }: DroppableCellProps): react_jsx_runtime.JSX.Element;
 
-interface RangePickerProps extends ErrorMessageProps {
-    value?: DateRange;
-    onChange?: (range: DateRange | undefined) => void;
-    label?: string;
-    minDate?: Date;
-    maxDate?: Date;
-    error?: string | undefined;
-}
-declare function RangePicker({ value, onChange, label, minDate, maxDate, error, }: RangePickerProps): react_jsx_runtime.JSX.Element;
-declare namespace RangePicker {
-    var displayName: string;
+interface EventCalendarProps {
+    events?: CalendarEvent[];
+    onEventAdd?: (event: CalendarEvent) => void;
+    onEventUpdate?: (event: CalendarEvent) => void;
+    onEventDelete?: (eventId: string) => void;
+    className?: string;
+    initialView?: CalendarView;
 }
+declare function EventCalendar({ events, onEventAdd, onEventUpdate, onEventDelete, className, initialView, }: EventCalendarProps): react_jsx_runtime.JSX.Element;
 
-interface TimePickerProps {
-    date: Date | undefined;
-    setDate: (date: Date | undefined) => void;
-    hideSeconds?: boolean;
-    enableButton?: boolean;
+interface EventDialogProps {
+    event: CalendarEvent | null;
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (event: CalendarEvent) => void;
+    onDelete: (eventId: string) => void;
 }
-declare function TimePicker({ date, setDate, hideSeconds, enableButton, }: TimePickerProps): react_jsx_runtime.JSX.Element;
-
-/**
- * regular expression to check for valid hour format (01-23)
- */
-declare function isValidHour(value: string): boolean;
-/**
- * regular expression to check for valid 12 hour format (01-12)
- */
-declare function isValid12Hour(value: string): boolean;
-/**
- * regular expression to check for valid minute format (00-59)
- */
-declare function isValidMinuteOrSecond(value: string): boolean;
-type GetValidNumberConfig = {
-    max: number;
-    min?: number;
-    loop?: boolean;
-};
-declare function getValidNumber(value: string, { max, min, loop }: GetValidNumberConfig): string;
-declare function getValidHour(value: string): string;
-declare function getValid12Hour(value: string): string;
-declare function getValidMinuteOrSecond(value: string): string;
-type GetValidArrowNumberConfig = {
-    min: number;
-    max: number;
-    step: number;
-};
-declare function getValidArrowNumber(value: string, { min, max, step }: GetValidArrowNumberConfig): string;
-declare function getValidArrowHour(value: string, step: number): string;
-declare function getValidArrow12Hour(value: string, step: number): string;
-declare function getValidArrowMinuteOrSecond(value: string, step: number): string;
-declare function setMinutes(date: Date, value: string): Date;
-declare function setSeconds(date: Date, value: string): Date;
-declare function setHours(date: Date, value: string): Date;
-declare function set12Hours(date: Date, value: string, period: Period): Date;
-type TimePickerType = "minutes" | "seconds" | "hours" | "12hours";
-type Period = "AM" | "PM";
-declare function setDateByType(date: Date, value: string, type: TimePickerType, period?: Period): Date;
-declare function getDateByType(date: Date, type: TimePickerType): string;
-declare function getArrowByType(value: string, step: number, type: TimePickerType): string;
-/**
- * handles value change of 12-hour input
- * 12:00 PM is 12:00
- * 12:00 AM is 00:00
- */
-declare function convert12HourTo24Hour(hour: number, period: Period): number;
-/**
- * time is stored in the 24-hour form,
- * but needs to be displayed to the user
- * in its 12-hour representation
- */
-declare function display12HourValue(hours: number): string;
+declare function EventDialog({ event, isOpen, onClose, onSave, onDelete, }: EventDialogProps): react_jsx_runtime.JSX.Element;
 
-interface TimePickerInputProps extends Omit<React__default.InputHTMLAttributes<HTMLInputElement>, "size"> {
-    picker: TimePickerType;
-    date: Date | undefined;
-    setDate: (date: Date | undefined) => void;
-    period?: Period;
-    onRightFocus?: () => void;
-    onLeftFocus?: () => void;
-    showArrows?: boolean;
-    label?: string;
-    error?: boolean;
-    inputSize?: "sm" | "md" | "lg";
-    enableButton?: boolean;
-    buttonText?: string;
-    buttonIcon?: React__default.ReactNode;
+interface EventItemProps {
+    event: CalendarEvent;
+    view: "month" | "week" | "day" | "agenda";
+    agendaOnly?: boolean;
+    isDragging?: boolean;
+    onClick?: (e: React.MouseEvent) => void;
+    showTime?: boolean;
+    currentTime?: Date;
+    isFirstDay?: boolean;
+    isLastDay?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+    dndListeners?: SyntheticListenerMap;
+    dndAttributes?: DraggableAttributes;
+    onMouseDown?: (e: React.MouseEvent) => void;
+    onTouchStart?: (e: React.TouchEvent) => void;
 }
-declare const TimePickerInput: React__default.ForwardRefExoticComponent<TimePickerInputProps & React__default.RefAttributes<HTMLInputElement>>;
+declare function EventItem({ event, view, onClick, showTime, currentTime, isFirstDay, isLastDay, children, className, dndListeners, dndAttributes, onMouseDown, onTouchStart, agendaOnly, }: EventItemProps): react_jsx_runtime.JSX.Element;
 
-declare function ContextMenuBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuTriggerBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuGroupBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Group>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuPortalBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Portal>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuSubBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.Sub>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuRadioGroupBase(props: React$1.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuSubTriggerBase({ className, inset, children, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
-    inset?: boolean;
-}): react_jsx_runtime.JSX.Element;
-declare function ContextMenuSubContentBase({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.SubContent>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuContentBase({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuItemBase({ className, inset, variant, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Item> & {
-    inset?: boolean;
-    variant?: "default" | "destructive";
-}): react_jsx_runtime.JSX.Element;
-declare function ContextMenuCheckboxItemBase({ className, children, checked, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuRadioItemBase({ className, children, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.RadioItem>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuLabelBase({ className, inset, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Label> & {
-    inset?: boolean;
-}): react_jsx_runtime.JSX.Element;
-declare function ContextMenuSeparatorBase({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Separator>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuShortcutBase({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+interface EventsPopupProps {
+    date: Date;
+    events: CalendarEvent[];
+    position: {
+        top: number;
+        left: number;
+    };
+    onClose: () => void;
+    onEventSelect?: (event: CalendarEvent) => void;
+}
+declare function EventsPopup({ date, events, position, onClose, onEventSelect, }: EventsPopupProps): react_jsx_runtime.JSX.Element;
 
-type CodeBlockProps = {
-    language: string;
-    filename: string;
-    highlightLines?: number[];
-    breadcrumb?: string[];
-    showStats?: boolean;
-    loading?: boolean;
-    loaderWords?: string[];
-} & ({
-    code: string;
-    tabs?: never;
-} | {
-    code?: never;
-    tabs: Array<{
-        name: string;
-        code: string;
-        language?: string;
-        highlightLines?: number[];
-    }>;
-} | {
-    code?: string;
-    tabs?: Array<{
-        name: string;
-        code: string;
-        language?: string;
-        highlightLines?: number[];
-    }>;
-});
-declare const CodeBlock: ({ language, filename, code, highlightLines, tabs, breadcrumb, showStats, }: CodeBlockProps) => react_jsx_runtime.JSX.Element;
+declare function useCurrentTimeIndicator(currentDate: Date, view: "day" | "week"): {
+    currentTimePosition: number;
+    currentTimeVisible: boolean;
+};
 
-interface StatusProps extends React$1.HTMLAttributes<HTMLDivElement> {
-    color?: "green" | "gray" | "red" | "yellow" | "blue" | "purple" | "retire";
-    size?: "xs" | "sm" | "md" | "lg";
-    position?: "top-right" | "top-left" | "bottom-right" | "bottom-left" | "inline";
-    show?: boolean;
-    children?: React$1.ReactNode;
+interface EventVisibilityOptions {
+    eventHeight: number;
+    eventGap: number;
 }
-declare function StatusIndicator({ color, size, position, show, children, className, ...props }: StatusProps): react_jsx_runtime.JSX.Element;
-
-interface DebouncedInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value">, ErrorMessageProps {
-    value: string;
-    onChange: (value: string) => void;
-    debounce?: number;
-    label?: string;
-    labelClassname?: string;
-    leftIcon?: React.ReactNode;
-    rightIcon?: React.ReactNode;
-    showLoadingIndicator?: boolean;
-    error?: string | undefined;
+interface EventVisibilityResult {
+    contentRef: React.RefObject<HTMLDivElement>;
+    contentHeight: number | null;
+    getVisibleEventCount: (totalEvents: number) => number;
 }
-declare function DebouncedInput({ value: initialValue, onChange, debounce, label, labelClassname, leftIcon, rightIcon, showLoadingIndicator, className, error, ...props }: DebouncedInputProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook for calculating event visibility based on container height
+ * Uses ResizeObserver for efficient updates
+ */
+declare function useEventVisibility({ eventHeight, eventGap, }: EventVisibilityOptions): EventVisibilityResult;
 
-interface AgendaViewProps$1 {
+interface MonthViewProps {
     currentDate: Date;
     events: CalendarEvent[];
-    onEventSelect?: (event: CalendarEvent) => void;
-    showUndatedEvents?: boolean;
+    onEventSelect: (event: CalendarEvent) => void;
+    onEventCreate: (startTime: Date) => void;
 }
-declare function AgendaView({ currentDate, events, onEventSelect, showUndatedEvents, }: AgendaViewProps$1): react_jsx_runtime.JSX.Element;
+declare function MonthView({ currentDate, events, onEventSelect, onEventCreate, }: MonthViewProps): react_jsx_runtime.JSX.Element;
 
-interface CalendarDndProviderProps$1 {
-    children: ReactNode;
-    onEventUpdate: (event: CalendarEvent) => void;
+type CalendarView = "month" | "week" | "day" | "agenda";
+interface CalendarEvent {
+    id: string;
+    title: string;
+    description?: string;
+    start: Date;
+    end: Date;
+    attend_date?: Date | null;
+    allDay?: boolean;
+    color?: EventColor;
+    location?: string;
 }
-declare function CalendarDndProvider({ children, onEventUpdate, }: CalendarDndProviderProps$1): react_jsx_runtime.JSX.Element;
-
-type CalendarDndContextType$1 = {
-    activeEvent: CalendarEvent | null;
-    activeId: UniqueIdentifier | null;
-    activeView: "month" | "week" | "day" | null;
-    currentTime: Date | null;
-    eventHeight: number | null;
-    isMultiDay: boolean;
-    multiDayWidth: number | null;
-    dragHandlePosition: {
-        x?: number;
-        y?: number;
-        data?: {
-            isFirstDay?: boolean;
-            isLastDay?: boolean;
-        };
-    } | null;
-};
-declare const useCalendarDnd: () => CalendarDndContextType$1;
+type EventColor = "sky" | "amber" | "violet" | "rose" | "emerald" | "orange";
 
-declare const EventHeight = 24;
-declare const EventGap = 4;
-declare const WeekCellsHeight = 64;
-declare const AgendaDaysToShow = 30;
-declare const StartHour = 0;
-declare const EndHour = 24;
-declare const DefaultStartHour = 9;
-declare const DefaultEndHour = 10;
+/**
+ * Get CSS classes for event colors
+ */
+declare function getEventColorClasses(color?: EventColor | string): string;
+/**
+ * Get CSS classes for border radius based on event position in multi-day events
+ */
+declare function getBorderRadiusClasses(isFirstDay: boolean, isLastDay: boolean): string;
+/**
+ * Check if an event is a multi-day event
+ */
+declare function isMultiDayEvent(event: CalendarEvent): boolean;
+/**
+ * Filter events for a specific day
+ */
+declare function getEventsForDay(events: CalendarEvent[], day: Date): CalendarEvent[];
+declare function sortEvents(events: CalendarEvent[]): CalendarEvent[];
+declare function getSpanningEventsForDay(events: CalendarEvent[], day: Date): CalendarEvent[];
+/**
+ * Get all events visible on a specific day (starting, ending, or spanning)
+ */
+declare function getAllEventsForDay(events: CalendarEvent[], day: Date): CalendarEvent[];
+/**
+ * Get all events for a day (for agenda view)
+ */
+declare function getAgendaEventsForDay(events: CalendarEvent[], day: Date): CalendarEvent[];
+/**
+ * Add hours to a date
+ */
+declare function addHoursToDate(date: Date, hours: number): Date;
 
-interface DayViewProps$1 {
+interface WeekViewProps {
     currentDate: Date;
     events: CalendarEvent[];
     onEventSelect: (event: CalendarEvent) => void;
     onEventCreate: (startTime: Date) => void;
 }
-declare function DayView({ currentDate, events, onEventSelect, onEventCreate, }: DayViewProps$1): react_jsx_runtime.JSX.Element;
+declare function WeekView({ currentDate, events, onEventSelect, onEventCreate, }: WeekViewProps): react_jsx_runtime.JSX.Element;
 
-interface DraggableEventProps {
-    event: CalendarEvent;
-    view: "month" | "week" | "day";
-    showTime?: boolean;
-    onClick?: (e: React.MouseEvent) => void;
-    height?: number;
-    isMultiDay?: boolean;
-    multiDayWidth?: number;
-    isFirstDay?: boolean;
-    isLastDay?: boolean;
-    "aria-hidden"?: boolean | "true" | "false";
+interface AvatarComboboxItem<T extends string> {
+    label: string;
+    value: T;
+    avatar?: ReactNode;
+    avatarClassName?: string;
 }
-declare function DraggableEvent({ event, view, showTime, onClick, height, isMultiDay, multiDayWidth, isFirstDay, isLastDay, "aria-hidden": ariaHidden, }: DraggableEventProps): react_jsx_runtime.JSX.Element;
+interface AvatarComboboxTestIds {
+    root?: string;
+    base?: string;
+    trigger?: string;
+    value?: string;
+    scrollarea?: string;
+    content?: string;
+    group?: string;
+    label?: string;
+    item?: (value: string) => string;
+}
+interface DefaultAvatarComboboxProps extends ErrorMessageProps {
+    placeholder?: string;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    className?: string;
+    colors?: string[];
+}
+interface AvatarComboboxPropsWithItems<T extends string> extends DefaultAvatarComboboxProps {
+    items: AvatarComboboxItem<T>[];
+    groupItems?: never;
+    testIds?: AvatarComboboxTestIds;
+}
+interface AvatarComboboxPropsWithGroupItems<T extends string> extends DefaultAvatarComboboxProps {
+    items?: never;
+    groupItems: {
+        [key: string]: AvatarComboboxItem<T>[];
+    };
+    testIds?: AvatarComboboxTestIds;
+}
+type AvatarComboboxProps<T extends string> = AvatarComboboxPropsWithItems<T> | AvatarComboboxPropsWithGroupItems<T>;
+declare function AvatarCombobox<T extends string>({ items, groupItems, placeholder, onChange, error, testIds, disabled, selected, label, labelClassname, className, colors, }: AvatarComboboxProps<T> & {
+    selected?: T | null;
+    label?: string;
+    labelClassname?: string;
+}): react_jsx_runtime.JSX.Element;
 
-interface DroppableCellProps$1 {
-    id: string;
-    date: Date;
-    time?: number;
-    children?: React.ReactNode;
+interface ComboboxItem<T extends string> {
+    label: string;
+    value: T;
+}
+
+interface ComboboxTestIds {
+    root?: string;
+    trigger?: string;
+    popover?: string;
+    command?: string;
+    search?: string;
+    list?: string;
+    empty?: string;
+    group?: string;
+    option?: string;
+    check?: string;
+    selected?: string;
+}
+interface ComboboxProps<T extends string> extends ErrorMessageProps {
+    items: ComboboxItem<T>[];
+    selected: ComboboxItem<T>["value"] | null;
+    onChange: (value: ComboboxItem<T>["value"] | null) => void;
     className?: string;
-    onClick?: () => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    empty?: React.ReactNode;
+    label?: string;
+    labelClassname?: string;
+    testIds?: ComboboxTestIds;
+    disabled?: boolean;
+}
+declare function Combobox<T extends string>({ items, selected, onChange, className, placeholder, searchPlaceholder, empty, disabled, label, labelClassname, testIds, error, }: ComboboxProps<T>): react_jsx_runtime.JSX.Element;
+
+interface MultiComboboxTestIds {
+    root?: string;
+    label?: string;
+    selectedWrapper?: string;
+    emptyPlaceholder?: string;
+    selectedItem?: (value: string) => string;
+    clearAll?: string;
+}
+interface MultiComboboxProps<T extends string> extends Omit<ComboboxProps<T>, "selected" | "onChange">, ErrorMessageProps {
+    selected: T[];
+    onChange: (value: T[]) => void;
+    label?: string;
+    labelClassname?: string;
+    testIds?: MultiComboboxTestIds;
+    keepOpen?: boolean;
+    showClearAll?: boolean;
+    disabled?: boolean;
+}
+declare function MultiCombobox<T extends string>({ items, selected, onChange, className, placeholder, searchPlaceholder, label, labelClassname, testIds, error, disabled, keepOpen, showClearAll, empty, }: MultiComboboxProps<T>): react_jsx_runtime.JSX.Element;
+
+type MultiSelectContextType = {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    selectedValues: Set<string>;
+    toggleValue: (value: string) => void;
+    items: Map<string, ReactNode>;
+    onItemAdded: (value: string, label: ReactNode) => void;
+    disabled?: boolean;
+    emptyMessage?: ReactNode;
+    error?: string;
+};
+declare function MultiSelectBase({ children, values, defaultValues, onValuesChange, disabled, empty, error, }: {
+    children: ReactNode;
+    values?: string[];
+    defaultValues?: string[];
+    onValuesChange?: (values: string[]) => void;
+    disabled?: boolean;
+    empty?: ReactNode;
+    error?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function MultiSelectTriggerBase({ className, children, error: propError, ...props }: {
+    className?: string;
+    children?: ReactNode;
+} & ComponentPropsWithoutRef<typeof ButtonBase> & ErrorMessageProps): react_jsx_runtime.JSX.Element;
+declare function MultiSelectValueBase({ placeholder, clickToRemove, className, overflowBehavior, ...props }: {
+    placeholder?: string;
+    clickToRemove?: boolean;
+    overflowBehavior?: "wrap" | "wrap-when-open" | "cutoff";
+} & Omit<ComponentPropsWithoutRef<"div">, "children">): react_jsx_runtime.JSX.Element;
+declare function MultiSelectContentBase({ search, children, ...props }: {
+    search?: boolean | {
+        placeholder?: string;
+        emptyMessage?: string;
+    };
+    children: ReactNode;
+} & Omit<ComponentPropsWithoutRef<typeof CommandBase>, "children">): react_jsx_runtime.JSX.Element;
+declare function MultiSelectItemBase({ value, children, badgeLabel, onSelect, ...props }: {
+    badgeLabel?: ReactNode;
+    value: string;
+} & Omit<ComponentPropsWithoutRef<typeof CommandItemBase>, "value">): react_jsx_runtime.JSX.Element;
+declare function MultiSelectGroupBase(props: ComponentPropsWithoutRef<typeof CommandGroupBase>): react_jsx_runtime.JSX.Element;
+declare function MultiSelectSeparatorBase(props: ComponentPropsWithoutRef<typeof CommandSeparatorBase>): react_jsx_runtime.JSX.Element;
+
+interface SelectItem<T extends string> {
+    label: string;
+    value: T;
+}
+interface SelectTestIds {
+    root?: string;
+    base?: string;
+    trigger?: string;
+    value?: string;
+    scrollarea?: string;
+    content?: string;
+    group?: string;
+    label?: string;
+    item?: (value: string) => string;
+    paginationPrev?: string;
+    paginationNext?: string;
+    paginationPage?: (page: number) => string;
 }
-declare function DroppableCell({ id, date, time, children, className, onClick, }: DroppableCellProps$1): react_jsx_runtime.JSX.Element;
-
-interface EventCalendarProps$1 {
-    events?: CalendarEvent[];
-    onEventAdd?: (event: CalendarEvent) => void;
-    onEventUpdate?: (event: CalendarEvent) => void;
-    onEventDelete?: (eventId: string) => void;
+interface DefaultSelectProps<T extends string> extends ErrorMessageProps {
+    selected: T | null;
+    onChange: (value: T) => void;
+    placeholder?: string;
+    disabled?: boolean;
     className?: string;
-    initialView?: CalendarView;
-}
-declare function EventCalendar({ events, onEventAdd, onEventUpdate, onEventDelete, className, initialView, }: EventCalendarProps$1): react_jsx_runtime.JSX.Element;
-
-interface EventDialogProps {
-    event: CalendarEvent | null;
-    isOpen: boolean;
-    onClose: () => void;
-    onSave: (event: CalendarEvent) => void;
-    onDelete: (eventId: string) => void;
+    label?: string;
+    labelClassname?: string;
+    pagination?: number;
 }
-declare function EventDialog({ event, isOpen, onClose, onSave, onDelete, }: EventDialogProps): react_jsx_runtime.JSX.Element;
-
-interface EventItemProps$1 {
-    event: CalendarEvent;
-    view: "month" | "week" | "day" | "agenda";
-    agendaOnly?: boolean;
-    isDragging?: boolean;
-    onClick?: (e: React.MouseEvent) => void;
-    showTime?: boolean;
-    currentTime?: Date;
-    isFirstDay?: boolean;
-    isLastDay?: boolean;
-    children?: React.ReactNode;
-    className?: string;
-    dndListeners?: SyntheticListenerMap;
-    dndAttributes?: DraggableAttributes;
-    onMouseDown?: (e: React.MouseEvent) => void;
-    onTouchStart?: (e: React.TouchEvent) => void;
+interface SelectPropsWithItems<T extends string> extends DefaultSelectProps<T> {
+    items: SelectItem<T>[];
+    groupItems?: never;
+    testIds?: SelectTestIds;
 }
-declare function EventItem({ event, view, onClick, showTime, currentTime, isFirstDay, isLastDay, children, className, dndListeners, dndAttributes, onMouseDown, onTouchStart, agendaOnly, }: EventItemProps$1): react_jsx_runtime.JSX.Element;
-
-interface EventsPopupProps {
-    date: Date;
-    events: CalendarEvent[];
-    position: {
-        top: number;
-        left: number;
+interface SelectPropsWithGroupItems<T extends string> extends DefaultSelectProps<T> {
+    items?: never;
+    groupItems: {
+        [key: string]: SelectItem<T>[];
     };
-    onClose: () => void;
-    onEventSelect?: (event: CalendarEvent) => void;
+    testIds?: SelectTestIds;
 }
-declare function EventsPopup({ date, events, position, onClose, onEventSelect, }: EventsPopupProps): react_jsx_runtime.JSX.Element;
+type NewSelectProps<T extends string> = SelectPropsWithItems<T> | SelectPropsWithGroupItems<T>;
+declare function Select<T extends string>({ items, groupItems, placeholder, onChange, error, testIds, disabled, selected, label, labelClassname, className, pagination, }: NewSelectProps<T>): react_jsx_runtime.JSX.Element;
 
-declare function useCurrentTimeIndicator(currentDate: Date, view: "day" | "week"): {
-    currentTimePosition: number;
-    currentTimeVisible: boolean;
+declare const formatFieldName: (fieldName: string) => string;
+declare const detectDataFields: (data: Record<string, unknown>[], xAxisKey: string) => string[];
+declare const detectXAxis: (data: Record<string, unknown>[]) => string;
+declare const generateAdditionalColors: (baseColors: string[], count: number) => string[];
+declare const niceCeil: (value: number) => number;
+declare const compactTick: (value: number) => string;
+type Padding = number | Partial<{
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}>;
+type Margins = Partial<{
+    top: number;
+    right: number;
+    left: number;
+    bottom: number;
+}>;
+declare const resolveContainerPaddingLeft: (padding?: Padding, containerPaddingLeft?: number, defaultLeft?: number) => number;
+declare const resolveChartMargins: (margins?: Margins, chartMargins?: Margins, showLabels?: boolean) => {
+    top: number;
+    right: number;
+    left: number;
+    bottom: number;
 };
 
-interface EventVisibilityOptions$1 {
-    eventHeight: number;
-    eventGap: number;
+type Variant = "filled" | "outline" | "soft";
+type LabelRendererProps = {
+    x?: number | string;
+    y?: number | string;
+    value?: number | string;
+    index?: number;
+    payload?: unknown;
+    width?: number | string;
+    height?: number | string;
+    viewBox?: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    } | Record<string, unknown> | undefined;
+    cx?: number | string;
+    cy?: number | string;
+};
+type valueFormatter = (props: {
+    value: number | string | undefined;
+    formattedValue: string;
+    [key: string]: unknown;
+}) => string;
+declare const renderPillLabel: (color: string, variant: Variant, valueFormatter?: valueFormatter) => (props: LabelRendererProps) => react_jsx_runtime.JSX.Element;
+
+declare const renderInsideBarLabel: (color: string, valueFormatter?: valueFormatter) => (props: LabelRendererProps) => react_jsx_runtime.JSX.Element;
+
+interface ChartData$1 {
+    [key: string]: string | number | boolean | null | undefined;
 }
-interface EventVisibilityResult$1 {
-    contentRef: React.RefObject<HTMLDivElement>;
-    contentHeight: number | null;
-    getVisibleEventCount: (totalEvents: number) => number;
+interface XAxisConfig$2 {
+    dataKey: string;
+    label?: string;
+    valueFormatter?: (value: string | number) => string;
+    autoLabel?: boolean;
 }
-/**
- * Hook for calculating event visibility based on container height
- * Uses ResizeObserver for efficient updates
- */
-declare function useEventVisibility({ eventHeight, eventGap, }: EventVisibilityOptions$1): EventVisibilityResult$1;
-
-interface MonthViewProps$1 {
-    currentDate: Date;
-    events: CalendarEvent[];
-    onEventSelect: (event: CalendarEvent) => void;
-    onEventCreate: (startTime: Date) => void;
+interface BiaxialConfig {
+    key: string[];
+    label?: string;
+    percentage?: boolean;
+    decimals?: number;
+    stroke?: string | Record<string, string>;
 }
-declare function MonthView({ currentDate, events, onEventSelect, onEventCreate, }: MonthViewProps$1): react_jsx_runtime.JSX.Element;
-
-type CalendarView = "month" | "week" | "day" | "agenda";
-interface CalendarEvent {
-    id: string;
-    title: string;
-    description?: string;
-    start: Date;
-    end: Date;
-    attend_date?: Date | null;
-    allDay?: boolean;
-    color?: EventColor;
-    location?: string;
+type SeriesProp$1 = {
+    bar?: string[];
+    line?: string[];
+    area?: string[];
+};
+interface ChartProps {
+    data: ChartData$1[];
+    series?: SeriesProp$1;
+    className?: string;
+    chartMargin?: Partial<{
+        top: number;
+        right: number;
+        left: number;
+        bottom: number;
+    }>;
+    height?: number;
+    width?: number | string;
+    colors?: string[];
+    gridColor?: string;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    title?: string;
+    titlePosition?: "left" | "center" | "right";
+    showLabels?: boolean;
+    labelMap?: Record<string, string>;
+    valueFormatter?: valueFormatter;
+    categoryFormatter?: (value: string | number) => string;
+    periodLabel?: string;
+    xAxisLabel?: string;
+    yAxisLabel?: string;
+    xAxis?: XAxisConfig$2 | string;
+    biaxial?: BiaxialConfig | string | string[];
+    enableHighlights?: boolean;
+    enableShowOnly?: boolean;
+    enablePeriodsDropdown?: boolean;
+    enableDraggableTooltips?: boolean;
+    showTooltipTotal?: boolean;
+    maxTooltips?: number;
+    formatBR?: boolean;
 }
-type EventColor = "sky" | "amber" | "violet" | "rose" | "emerald" | "orange";
-
-/**
- * Get CSS classes for event colors
- */
-declare function getEventColorClasses(color?: EventColor | string): string;
-/**
- * Get CSS classes for border radius based on event position in multi-day events
- */
-declare function getBorderRadiusClasses(isFirstDay: boolean, isLastDay: boolean): string;
-/**
- * Check if an event is a multi-day event
- */
-declare function isMultiDayEvent(event: CalendarEvent): boolean;
-/**
- * Filter events for a specific day
- */
-declare function getEventsForDay(events: CalendarEvent[], day: Date): CalendarEvent[];
-declare function sortEvents(events: CalendarEvent[]): CalendarEvent[];
-declare function getSpanningEventsForDay(events: CalendarEvent[], day: Date): CalendarEvent[];
-/**
- * Get all events visible on a specific day (starting, ending, or spanning)
- */
-declare function getAllEventsForDay(events: CalendarEvent[], day: Date): CalendarEvent[];
-/**
- * Get all events for a day (for agenda view)
- */
-declare function getAgendaEventsForDay(events: CalendarEvent[], day: Date): CalendarEvent[];
-/**
- * Add hours to a date
- */
-declare function addHoursToDate(date: Date, hours: number): Date;
+declare const Chart: React__default.FC<ChartProps>;
 
-interface WeekViewProps$1 {
-    currentDate: Date;
-    events: CalendarEvent[];
-    onEventSelect: (event: CalendarEvent) => void;
-    onEventCreate: (startTime: Date) => void;
+interface BarChartData {
+    [key: string]: string | number | boolean | null | undefined;
 }
-declare function WeekView({ currentDate, events, onEventSelect, onEventCreate, }: WeekViewProps$1): react_jsx_runtime.JSX.Element;
-
-interface TreeNode {
-    id: string;
-    label: string;
-    defaultChecked?: boolean;
-    children?: TreeNode[];
+interface XAxisConfig$1 {
+    dataKey: string;
+    label?: string;
+    valueFormatter?: (value: string | number) => string;
+    autoLabel?: boolean;
+}
+interface DataMapper {
+    [dataKey: string]: {
+        label?: string;
+        valueFormatter?: (value: string | number) => string | number;
+        color?: string;
+        type?: "number" | "string" | "auto";
+        visible?: boolean;
+    };
 }
-interface CheckboxTreeProps {
-    tree: TreeNode;
-    renderNode: (props: {
-        node: TreeNode;
-        isChecked: boolean | "indeterminate";
-        onCheckedChange: () => void;
-        children: React__default.ReactNode;
-    }) => React__default.ReactNode;
+interface BarChartProps {
+    data: BarChartData[];
+    className?: string;
+    padding?: Padding;
+    margins?: Margins;
+    containerPaddingLeft?: number;
+    chartMargins?: Margins;
+    height?: number;
+    width?: number | string;
+    colors?: string[];
+    gridColor?: string;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    title?: string;
+    titlePosition?: "left" | "center" | "right";
+    showLabels?: boolean;
+    labelMap?: Record<string, string>;
+    xAxis?: XAxisConfig$1 | string;
+    mapper?: DataMapper | string[];
+    yAxis?: DataMapper | string[];
+    autoDetect?: boolean;
 }
-declare function CheckboxTree({ tree, renderNode }: CheckboxTreeProps): React__default.ReactNode;
+declare const BarChart: React__default.FC<BarChartProps>;
 
-type MultiSelectContextType = {
-    open: boolean;
-    setOpen: (open: boolean) => void;
-    selectedValues: Set<string>;
-    toggleValue: (value: string) => void;
-    items: Map<string, ReactNode>;
-    onItemAdded: (value: string, label: ReactNode) => void;
-    disabled?: boolean;
-    emptyMessage?: ReactNode;
-    error?: string;
-};
-declare function MultiSelectBase({ children, values, defaultValues, onValuesChange, disabled, empty, error, }: {
-    children: ReactNode;
-    values?: string[];
-    defaultValues?: string[];
-    onValuesChange?: (values: string[]) => void;
-    disabled?: boolean;
-    empty?: ReactNode;
-    error?: string;
-}): react_jsx_runtime.JSX.Element;
-declare function MultiSelectTriggerBase({ className, children, error: propError, ...props }: {
+interface LineChartData {
+    name: string;
+    [key: string]: string | number;
+}
+interface CustomLineChartProps {
+    data?: LineChartData[];
     className?: string;
-    children?: ReactNode;
-} & ComponentPropsWithoutRef<typeof ButtonBase> & ErrorMessageProps): react_jsx_runtime.JSX.Element;
-declare function MultiSelectValueBase({ placeholder, clickToRemove, className, overflowBehavior, ...props }: {
-    placeholder?: string;
-    clickToRemove?: boolean;
-    overflowBehavior?: "wrap" | "wrap-when-open" | "cutoff";
-} & Omit<ComponentPropsWithoutRef<"div">, "children">): react_jsx_runtime.JSX.Element;
-declare function MultiSelectContentBase({ search, children, ...props }: {
-    search?: boolean | {
-        placeholder?: string;
-        emptyMessage?: string;
-    };
-    children: ReactNode;
-} & Omit<ComponentPropsWithoutRef<typeof CommandBase>, "children">): react_jsx_runtime.JSX.Element;
-declare function MultiSelectItemBase({ value, children, badgeLabel, onSelect, ...props }: {
-    badgeLabel?: ReactNode;
-    value: string;
-} & Omit<ComponentPropsWithoutRef<typeof CommandItemBase>, "value">): react_jsx_runtime.JSX.Element;
-declare function MultiSelectGroupBase(props: ComponentPropsWithoutRef<typeof CommandGroupBase>): react_jsx_runtime.JSX.Element;
-declare function MultiSelectSeparatorBase(props: ComponentPropsWithoutRef<typeof CommandSeparatorBase>): react_jsx_runtime.JSX.Element;
-
-interface AgendaViewProps {
-    currentDate: Date;
-    events: CalendarEventAgenda[];
-    onEventSelect?: (event: CalendarEventAgenda, e?: React.MouseEvent) => void;
-    showUndatedEvents?: boolean;
+    padding?: Padding;
+    margins?: Margins;
+    containerPaddingLeft?: number;
+    chartMargins?: Margins;
+    height?: number;
+    width?: number | string;
+    colors?: string[];
+    gridColor?: string;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    title?: string;
+    titlePosition?: "left" | "center" | "right";
+    strokeWidth?: number;
+    showDots?: boolean;
+    showLabels?: boolean;
 }
-declare function Agenda({ currentDate, events, onEventSelect, showUndatedEvents, }: AgendaViewProps): react_jsx_runtime.JSX.Element;
+declare const CustomLineChart: React__default.FC<CustomLineChartProps>;
 
-interface CalendarDndProviderProps {
-    children: ReactNode;
-    onEventUpdate: (event: CalendarEventAgenda) => void;
+interface PieChartData {
+    name: string;
+    value: number;
+    [key: string]: string | number;
 }
-declare function CalendarDndProviderAgenda({ children, onEventUpdate, }: CalendarDndProviderProps): react_jsx_runtime.JSX.Element;
-
-type CalendarDndContextType = {
-    activeEvent: CalendarEventAgenda | null;
-    activeId: UniqueIdentifier | null;
-    activeView: "month" | "week" | "day" | null;
-    currentTime: Date | null;
-    eventHeight: number | null;
-    isMultiDay: boolean;
-    multiDayWidth: number | null;
-    dragHandlePosition: {
-        x?: number;
-        y?: number;
-        data?: {
-            isFirstDay?: boolean;
-            isLastDay?: boolean;
-        };
-    } | null;
-};
-declare const useCalendarDndAgenda: () => CalendarDndContextType;
-
-declare const EventHeightAgenda = 24;
-declare const EventGapAgenda = 4;
-declare const WeekCellsHeightAgenda = 64;
-declare const AgendaDaysToShowAgenda = 30;
-declare const StartHourAgenda = 0;
-declare const EndHourAgenda = 24;
-declare const DefaultStartHourAgenda = 9;
-declare const DefaultEndHourAgenda = 10;
-
-type CalendarViewAgenda = "month" | "week" | "day" | "agenda";
-interface CalendarEventAgenda {
-    id: string;
-    title: string;
-    description?: ReactNode;
-    start?: Date | null;
-    end?: Date | null;
-    allDay?: boolean;
-    color?: EventColorAgenda;
-    location?: string;
-    duration?: number;
+interface CustomPieChartProps {
+    data?: PieChartData[];
+    className?: string;
+    height?: number;
+    width?: number | string;
+    colors?: string[];
+    showTooltip?: boolean;
+    showLegend?: boolean;
+    showLabels?: boolean;
+    innerRadius?: number;
+    outerRadius?: number;
+    centerX?: string | number;
+    centerY?: string | number;
 }
-type EventColorAgenda = "sky" | "amber" | "violet" | "rose" | "emerald" | "orange" | "green" | "blue" | "red" | "purple";
+declare const CustomPieChart: React__default.FC<CustomPieChartProps>;
 
-interface DayViewProps {
-    currentDate: Date;
-    events: CalendarEventAgenda[];
-    onEventSelect: (event: CalendarEventAgenda, e?: React__default.MouseEvent) => void;
-    showUndatedEvents?: boolean;
+interface Props$4 {
+    processedData: Array<{
+        name: string;
+    }>;
+    onOpenPeriod: (periodName: string) => void;
+    rightOffset?: number;
+    topOffset?: number;
+    activePeriod?: string;
+    activePeriods?: string[];
 }
-declare function DayViewAgenda({ currentDate, events, onEventSelect, showUndatedEvents, }: DayViewProps): react_jsx_runtime.JSX.Element;
+declare function PeriodsDropdown({ processedData, onOpenPeriod, rightOffset, topOffset, activePeriod, activePeriods, }: Props$4): react_jsx_runtime.JSX.Element;
 
-interface DroppableCellProps {
-    id: string;
-    date: Date;
-    time?: number;
-    children?: React.ReactNode;
-    className?: string;
-    onClick?: () => void;
+interface Props$3 {
+    showOnlyHighlighted: boolean;
+    setShowOnlyHighlighted: React__default.Dispatch<React__default.SetStateAction<boolean>>;
+    highlightedSeriesSize: number;
+    clearHighlights: () => void;
 }
-declare function DroppableCellAgenda({ id, date, time, children, className, onClick, }: DroppableCellProps): react_jsx_runtime.JSX.Element;
+declare const ShowOnly: React__default.FC<Props$3>;
 
-interface EventCalendarProps {
-    events?: CalendarEventAgenda[];
-    onEventUpdate?: (event: CalendarEventAgenda) => void;
-    className?: string;
-    initialView?: CalendarViewAgenda;
-    initialDate?: Date;
-    onClick?: ((event: CalendarEventAgenda, e?: React__default.MouseEvent) => void) | React__default.ReactElement<ModalLikeProps>;
+interface MapperEntry {
+    label?: string;
+    valueFormatter?: (value: string | number) => string | number;
+    color?: string;
+    type?: string;
+    visible?: boolean;
 }
-interface ModalLikeProps {
-    event?: CalendarEventAgenda;
-    onClose?: () => void;
-    [key: string]: unknown;
+interface Props$2 {
+    allKeys: string[];
+    mapperConfig: Record<string, MapperEntry>;
+    finalColors: Record<string, string>;
+    highlightedSeries: Set<string>;
+    toggleHighlight: (key: string) => void;
+    containerWidth?: number;
 }
-declare function EventAgenda({ events, onEventUpdate, className, initialView, initialDate, onClick, }: EventCalendarProps): react_jsx_runtime.JSX.Element;
+declare const Highlights: React__default.FC<Props$2>;
 
-interface EventItemProps {
-    event: CalendarEventAgenda;
-    view: "month" | "week" | "day" | "agenda";
-    agendaOnly?: boolean;
-    isDragging?: boolean;
-    onClick?: (e: React.MouseEvent) => void;
-    showTime?: boolean;
-    currentTime?: Date;
-    isFirstDay?: boolean;
-    isLastDay?: boolean;
-    children?: React.ReactNode;
-    className?: string;
-    dndListeners?: SyntheticListenerMap;
-    dndAttributes?: DraggableAttributes;
-    onMouseDown?: (e: React.MouseEvent) => void;
-    onTouchStart?: (e: React.TouchEvent) => void;
+interface CloseAllButtonProps {
+    count: number;
+    onCloseAll: () => void;
+    position?: "top-left" | "top-right" | "top-center";
+    variant?: "floating" | "inline";
 }
-declare function EventItemAgenda({ event, view, onClick, showTime, currentTime, isFirstDay, isLastDay, children, className, dndListeners, dndAttributes, onMouseDown, onTouchStart, agendaOnly, }: EventItemProps): react_jsx_runtime.JSX.Element;
+declare const CloseAllButton: React__default.FC<CloseAllButtonProps>;
 
-interface UndatedEventsProps {
-    events: CalendarEventAgenda[];
-    onEventSelect?: (event: CalendarEventAgenda, e?: React.MouseEvent) => void;
-    className?: string;
+interface TooltipData {
+    name: string;
+    [key: string]: string | number;
+}
+interface Position$1 {
+    top: number;
+    left: number;
+}
+interface DraggableTooltipProps {
+    id: string;
+    data: TooltipData;
+    position: Position$1;
+    isDragging?: boolean;
     title?: string;
-    show?: boolean;
+    dataKeys: string[];
+    finalColors: Record<string, string>;
+    onMouseDown?: (id: string, e: React__default.MouseEvent) => void;
+    onClose: (id: string) => void;
+    periodLabel?: string;
+    dataLabel?: string;
+    showCloseAllButton?: boolean;
+    globalTooltipCount?: number;
+    onCloseAll?: () => void;
+    closeAllButtonPosition?: "top-left" | "top-right" | "top-center";
+    closeAllButtonVariant?: "floating" | "inline";
+    onPositionChange?: (id: string, position: Position$1) => void;
+    highlightedSeries?: Set<string>;
+    toggleHighlight?: (key: string) => void;
+    showOnlyHighlighted?: boolean;
+    valueFormatter?: valueFormatter;
+    categoryFormatter?: (value: string | number) => string;
 }
-declare function UndatedEvents({ events, onEventSelect, className, title, show, }: UndatedEventsProps): react_jsx_runtime.JSX.Element | null;
+declare const DraggableTooltip: React__default.NamedExoticComponent<DraggableTooltipProps>;
 
-declare function useCurrentTimeIndicatorAgenda(currentDate: Date, view: "day" | "week"): {
-    currentTimePosition: number;
-    currentTimeVisible: boolean;
+type TooltipPayloadItem$1 = {
+    dataKey: string;
+    value: number;
+    name: string;
+    color?: string;
 };
-
-interface EventVisibilityOptions {
-    eventHeight: number;
-    eventGap: number;
-}
-interface EventVisibilityResult {
-    contentRef: React.RefObject<HTMLDivElement>;
-    contentHeight: number | null;
-    getVisibleEventCount: (totalEvents: number) => number;
+interface Props$1 {
+    active?: boolean;
+    payload?: TooltipPayloadItem$1[];
+    label?: string;
+    finalColors?: Record<string, string>;
+    periodLabel?: string;
+    totalLabel?: string;
+    valueFormatter?: valueFormatter;
+    categoryFormatter?: (value: string | number) => string;
+    yAxisMap?: Record<string, "left" | "right">;
+    isBiaxial?: boolean;
 }
-/**
- * Hook for calculating event visibility based on container height
- * Uses ResizeObserver for efficient updates
- */
-declare function useEventVisibilityAgenda({ eventHeight, eventGap, }: EventVisibilityOptions): EventVisibilityResult;
+declare const RechartTooltipWithTotal: React__default.FC<Props$1>;
 
-interface MonthViewProps {
-    currentDate: Date;
-    events: CalendarEventAgenda[];
-    onEventSelect: (event: CalendarEventAgenda, e?: React__default.MouseEvent) => void;
-    showUndatedEvents?: boolean;
+type TooltipPayloadItem = {
+    dataKey: string;
+    value: number;
+    name: string;
+    color?: string;
+};
+interface Props {
+    active?: boolean;
+    payload?: TooltipPayloadItem[];
+    label?: string;
+    finalColors?: Record<string, string>;
+    periodLabel?: string;
+    valueFormatter?: valueFormatter;
+    categoryFormatter?: (value: string | number) => string;
+    yAxisMap?: Record<string, "left" | "right">;
+    isBiaxial?: boolean;
 }
-declare function MonthViewAgenda({ currentDate, events, onEventSelect, showUndatedEvents, }: MonthViewProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Get CSS classes for event colors
- */
-declare function getEventColorClassesAgenda(color?: EventColorAgenda | string): string;
-/**
- * Get CSS classes for border radius based on event position in multi-day events
- */
-declare function getBorderRadiusClassesAgenda(isFirstDay: boolean, isLastDay: boolean): string;
-/**
- * Check if an event is a multi-day event
- */
-declare function isMultiDayEventAgenda(event: CalendarEventAgenda): boolean;
-/**
- * Filter events for a specific day
- */
-declare function getEventsForDayAgenda(events: CalendarEventAgenda[], day: Date): CalendarEventAgenda[];
-declare function sortEventsAgenda(events: CalendarEventAgenda[]): CalendarEventAgenda[];
-declare function getSpanningEventsForDayAgenda(events: CalendarEventAgenda[], day: Date): CalendarEventAgenda[];
-/**
- * Get all events visible on a specific day (starting, ending, or spanning)
- */
-declare function getAllEventsForDayAgenda(events: CalendarEventAgenda[], day: Date): CalendarEventAgenda[];
-/**
- * Get all events for a day (for agenda view)
- */
-declare function getAgendaEventsForDayAgenda(events: CalendarEventAgenda[], day: Date): CalendarEventAgenda[];
-/**
- * Return the event start as a Date if possible
- */
-declare function getEventStartDate(event: CalendarEventAgenda): Date | undefined;
-/**
- * Return the event end as a Date. If `end` is not provided but `duration` (minutes) is,
- * compute end = start + duration minutes.
- */
-declare function getEventEndDate(event: CalendarEventAgenda): Date | undefined;
-declare function normalizeAttendDate(d?: unknown): Date | undefined;
-/**
- * Add hours to a date
- */
-declare function addMinutesToDateAgenda(date: Date, minutes: number): Date;
-declare function addHoursToDateAgenda(date: Date, hours: number): Date;
+declare const TooltipSimple: React__default.FC<Props>;
 
-interface WeekViewProps {
-    currentDate: Date;
-    events: CalendarEventAgenda[];
-    onEventSelect: (event: CalendarEventAgenda, e?: React__default.MouseEvent) => void;
-    onEventCreate?: (startTime: Date) => void;
-    showUndatedEvents?: boolean;
+interface UseChartHighlightsReturn {
+    highlightedSeries: Set<string>;
+    showOnlyHighlighted: boolean;
+    toggleHighlight: (key: string) => void;
+    setShowOnlyHighlighted: (show: boolean) => void;
+    clearHighlights: () => void;
+    getSeriesStyle: (key: string) => React.CSSProperties;
+    isHighlighted: (key: string) => boolean;
 }
-declare function WeekViewAgenda({ currentDate, events, onEventSelect, onEventCreate, showUndatedEvents, }: WeekViewProps): react_jsx_runtime.JSX.Element;
+declare const useChartHighlights: () => UseChartHighlightsReturn;
 
-type IconProps = {
+interface NoDataProps {
+    paddingLeft?: number;
+    height?: number | string;
+    message?: string;
     className?: string;
-    size?: number | string;
-};
-type BannerProps = {
-    icon?: ReactNode | ComponentType<IconProps>;
-    title?: string;
-    description?: string;
-    actionText?: ReactNode;
-    id?: string;
-};
+}
+declare const NoData: React__default.FC<NoDataProps>;
 
-interface AvatarComboboxItem<T extends string> {
-    label: string;
-    value: T;
-    avatar?: ReactNode;
-    avatarClassName?: string;
+type Primitive = string | number | boolean | null | undefined;
+interface ChartData {
+    [key: string]: Primitive;
+    name?: string;
 }
-interface AvatarComboboxTestIds {
-    root?: string;
-    base?: string;
-    trigger?: string;
-    value?: string;
-    scrollarea?: string;
-    content?: string;
-    group?: string;
+interface XAxisConfig {
+    dataKey: string;
     label?: string;
-    item?: (value: string) => string;
+    valueFormatter?: (value: string | number) => string;
+    autoLabel?: boolean;
 }
-interface DefaultAvatarComboboxProps extends ErrorMessageProps {
-    placeholder?: string;
-    onChange: (value: string) => void;
-    disabled?: boolean;
-    className?: string;
-    colors?: string[];
+type ValueFormatter = (value: string | number) => string | number;
+type FinalValueFormatter = (value: number | string | null | undefined) => string;
+type SeriesProp = {
+    bar?: string[];
+    line?: string[];
+    area?: string[];
+};
+type SeriesEntry = {
+    type: "bar" | "line" | "area";
+    key: string;
+};
+type SeriesCounts = {
+    bar: number;
+    line: number;
+    area: number;
+};
+type YAxisSide = "left" | "right";
+type YAxisMap = Record<string, YAxisSide>;
+interface MapperConfigEntry {
+    label?: string;
+    valueFormatter?: ValueFormatter;
+    color?: string;
+    type?: "number" | "string" | "auto";
+    visible?: boolean;
 }
-interface AvatarComboboxPropsWithItems<T extends string> extends DefaultAvatarComboboxProps {
-    items: AvatarComboboxItem<T>[];
-    groupItems?: never;
-    testIds?: AvatarComboboxTestIds;
+type MapperConfig = Record<string, MapperConfigEntry>;
+interface YAxisOptions {
+    label?: string;
+    stroke?: string;
+    width?: number;
+    percent?: boolean;
+    percentDecimals?: number;
 }
-interface AvatarComboboxPropsWithGroupItems<T extends string> extends DefaultAvatarComboboxProps {
-    items?: never;
-    groupItems: {
-        [key: string]: AvatarComboboxItem<T>[];
+type YAxes = Partial<{
+    left: YAxisOptions;
+    right: YAxisOptions;
+}>;
+interface TooltipItem {
+    id: string;
+    data: ChartData;
+    position: {
+        top: number;
+        left: number;
     };
-    testIds?: AvatarComboboxTestIds;
 }
-type AvatarComboboxProps<T extends string> = AvatarComboboxPropsWithItems<T> | AvatarComboboxPropsWithGroupItems<T>;
-declare function AvatarCombobox<T extends string>({ items, groupItems, placeholder, onChange, error, testIds, disabled, selected, label, labelClassname, className, colors, }: AvatarComboboxProps<T> & {
-    selected?: T | null;
-    label?: string;
-    labelClassname?: string;
-}): react_jsx_runtime.JSX.Element;
+type TooltipAdaptedRow = Record<string, string | number> & {
+    name: string;
+};
+interface ChartHooksArgs {
+    width?: number | string;
+    measuredWidth?: number | null;
+    points?: number;
+    seriesCounts?: SeriesCounts;
+    niceMax?: number;
+    yAxes?: YAxes;
+    yAxisLabel?: string;
+    chartMargin?: Partial<{
+        top: number;
+        right: number;
+        left: number;
+        bottom: number;
+    }>;
+    showLabels?: boolean;
+    showLegend?: boolean;
+    xAxisLabel?: string;
+}
 
 declare function useIsMobile(): boolean;