@vacano/ui 1.13.0 → 1.15.0

package/dist/index.d.ts

@@ -12,6 +12,53 @@ import { Ref } from 'react';
 import { StringSchema } from 'yup';
 import { TextareaHTMLAttributes } from 'react';
 
+export declare const Accordion: ({ className, classnames, defaultValue, items, multiple, onChange, ref, value: controlledValue, variant, ...rest }: AccordionProps) => JSX.Element;
+
+export declare type AccordionClassNames = {
+    item?: string;
+    trigger?: string;
+    content?: string;
+    icon?: string;
+};
+
+export declare type AccordionItem = {
+    value: string;
+    title: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+};
+
+export declare type AccordionProps = VacanoComponentProps<HTMLDivElement, AccordionClassNames> & {
+    items: AccordionItem[];
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    multiple?: boolean;
+    variant?: AccordionVariant;
+};
+
+export declare type AccordionVariant = 'outlined' | 'splitted';
+
+export declare const Alert: ({ className, classnames, description, icon, radius, ref, title, variant, ...rest }: AlertProps) => JSX.Element;
+
+export declare type AlertClassNames = {
+    icon?: string;
+    title?: string;
+    description?: string;
+};
+
+export declare type AlertProps = VacanoComponentProps<HTMLDivElement, AlertClassNames> & Omit<React.HTMLAttributes<HTMLDivElement>, 'title' | 'className'> & {
+    icon?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    variant?: AlertVariant;
+    radius?: AlertRadius;
+};
+
+export declare type AlertRadius = 'none' | 'sm' | 'md' | 'lg' | 'full';
+
+export declare type AlertVariant = 'normal' | 'success' | 'warning' | 'danger';
+
 export declare const alpha: (hexColor: string, percentage: number) => string;
 
 export declare const Autocomplete: ({ className, classnames, disabled, fullWidth, label, ref, message, size, variant, value, onChange, onSearch, debounceMs, minChars, noResultsMessage, ...rest }: AutocompleteProps) => JSX.Element;
@@ -50,6 +97,108 @@ export declare type AutocompleteValue = {
 
 export declare type AutocompleteVariant = 'normal' | 'error';
 
+export declare const Avatar: ({ bordered, className, classnames, color, disabled, icon, name, radius, ref, size, src, ...rest }: AvatarProps) => JSX.Element;
+
+export declare type AvatarClassNames = {
+    image?: string;
+    fallback?: string;
+    initials?: string;
+};
+
+export declare type AvatarColor = 'default' | 'primary' | 'success' | 'warning' | 'danger';
+
+export declare const AvatarGroup: ({ children, className, classnames, max, ref, size, ...rest }: AvatarGroupProps) => JSX.Element;
+
+export declare type AvatarGroupClassNames = {
+    count?: string;
+};
+
+export declare type AvatarGroupProps = VacanoComponentProps<HTMLDivElement, AvatarGroupClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    max?: number;
+    size?: AvatarSize;
+};
+
+export declare type AvatarProps = VacanoComponentProps<HTMLDivElement, AvatarClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    bordered?: boolean;
+    color?: AvatarColor;
+    disabled?: boolean;
+    icon?: ReactNode;
+    name?: string;
+    radius?: AvatarRadius;
+    size?: AvatarSize;
+    src?: string;
+};
+
+export declare type AvatarRadius = 'sm' | 'md' | 'lg' | 'full';
+
+export declare type AvatarSize = 'sm' | 'md' | 'lg';
+
+export declare const Badge: ({ children, className, classnames, color, content, dot, invisible, placement, ref, shape, showOutline, size, variant, ...rest }: BadgeProps) => JSX.Element;
+
+export declare type BadgeClassNames = {
+    badge?: string;
+};
+
+export declare type BadgeColor = 'default' | 'success' | 'warning' | 'danger';
+
+export declare type BadgePlacement = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+
+export declare type BadgeProps = VacanoComponentProps<HTMLDivElement, BadgeClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'content'> & {
+    children?: ReactNode;
+    color?: BadgeColor;
+    content?: ReactNode;
+    dot?: boolean;
+    invisible?: boolean;
+    placement?: BadgePlacement;
+    shape?: BadgeShape;
+    showOutline?: boolean;
+    size?: BadgeSize;
+    variant?: BadgeVariant;
+};
+
+export declare type BadgeShape = 'circle' | 'rectangle';
+
+export declare type BadgeSize = 'sm' | 'md' | 'lg';
+
+export declare type BadgeVariant = 'solid' | 'flat' | 'bordered';
+
+export declare const BreadcrumbItem: ({ children, ...rest }: BreadcrumbItemProps) => JSX.Element;
+
+export declare type BreadcrumbItemClassNames = {
+    separator?: string;
+};
+
+export declare type BreadcrumbItemProps = VacanoComponentProps<HTMLLIElement, BreadcrumbItemClassNames> & Omit<HTMLAttributes<HTMLLIElement>, 'className'> & {
+    current?: boolean;
+    disabled?: boolean;
+    href?: string;
+    separator?: ReactNode;
+    startContent?: ReactNode;
+    endContent?: ReactNode;
+};
+
+export declare const Breadcrumbs: ({ children, className, classnames, disabled, itemsAfterCollapse, itemsBeforeCollapse, maxItems, ref, separator, size, variant, ...rest }: BreadcrumbsProps) => JSX.Element;
+
+export declare type BreadcrumbsClassNames = {
+    list?: string;
+    separator?: string;
+    ellipsis?: string;
+};
+
+export declare type BreadcrumbsProps = VacanoComponentProps<HTMLElement, BreadcrumbsClassNames> & Omit<HTMLAttributes<HTMLElement>, 'className'> & {
+    disabled?: boolean;
+    itemsAfterCollapse?: number;
+    itemsBeforeCollapse?: number;
+    maxItems?: number;
+    separator?: ReactNode;
+    size?: BreadcrumbsSize;
+    variant?: BreadcrumbsVariant;
+};
+
+export declare type BreadcrumbsSize = 'sm' | 'md' | 'lg';
+
+export declare type BreadcrumbsVariant = 'light' | 'solid' | 'bordered';
+
 declare type Breakpoint = keyof typeof BREAKPOINTS;
 
 export declare const BREAKPOINTS: {
@@ -88,13 +237,49 @@ export declare type ButtonVariant = 'normal' | 'system' | 'success' | 'warning'
 
 export declare type CalendarView = 'days' | 'months' | 'years';
 
-export declare const Card: ({ children, className, ref, border, shadow, ...rest }: PropsWithChildren<CardProps>) => JSX.Element;
+export declare const Card: ({ blurred, border, children, className, disabled, footerBlurred, fullWidth, hoverable, pressable, radius, ref, shadow, ...rest }: CardProps) => JSX.Element;
+
+export declare const CardBody: ({ children, className, ref, ...rest }: CardBodyProps) => JSX.Element;
+
+export declare type CardBodyProps = VacanoComponentProps<HTMLDivElement> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    children?: ReactNode;
+};
+
+export declare type CardClassNames = {
+    header?: string;
+    body?: string;
+    footer?: string;
+};
 
-export declare type CardProps = VacanoComponentProps<HTMLDivElement> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+export declare const CardFooter: ({ blurred, children, className, ref, ...rest }: CardFooterProps) => JSX.Element;
+
+export declare type CardFooterProps = VacanoComponentProps<HTMLDivElement> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    blurred?: boolean;
+    children?: ReactNode;
+};
+
+export declare const CardHeader: ({ children, className, ref, ...rest }: CardHeaderProps) => JSX.Element;
+
+export declare type CardHeaderProps = VacanoComponentProps<HTMLDivElement> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    children?: ReactNode;
+};
+
+export declare type CardProps = VacanoComponentProps<HTMLDivElement, CardClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    blurred?: boolean;
     border?: boolean;
-    shadow?: boolean;
+    disabled?: boolean;
+    footerBlurred?: boolean;
+    fullWidth?: boolean;
+    hoverable?: boolean;
+    pressable?: boolean;
+    radius?: CardRadius;
+    shadow?: CardShadow | boolean;
 };
 
+export declare type CardRadius = 'none' | 'sm' | 'md' | 'lg';
+
+export declare type CardShadow = 'none' | 'sm' | 'md' | 'lg';
+
 export declare const Checkbox: ({ checked, className, classnames, disabled, indeterminate, label, onChange, ref, variant, ...rest }: CheckboxProps) => JSX.Element;
 
 export declare const CheckboxCard: ({ checked, className, classnames, description, disabled, fullWidth, label, onChange, ref, variant, ...rest }: CheckboxCardProps) => JSX.Element;
@@ -156,15 +341,17 @@ export declare type CheckboxProps = VacanoComponentProps<HTMLInputElement, Check
 
 export declare type CheckboxVariant = 'normal' | 'error';
 
-export declare const Chip: ({ children, className, classnames, deletable, onDelete, ref, variant, ...rest }: ChipProps) => JSX.Element;
+export declare const Chip: ({ children, className, classnames, deletable, icon, onDelete, ref, variant, ...rest }: ChipProps) => JSX.Element;
 
 export declare type ChipClassNames = {
+    icon?: string;
     delete?: string;
     label?: string;
 };
 
 export declare type ChipProps = VacanoComponentProps<HTMLSpanElement, ChipClassNames> & Omit<HTMLAttributes<HTMLSpanElement>, 'className'> & {
     children: ReactNode;
+    icon?: ReactNode;
     variant?: ChipVariant;
     deletable?: boolean;
     onDelete?: () => void;
@@ -267,6 +454,21 @@ export declare type DatePickerProps = VacanoComponentProps<HTMLDivElement, DateP
 
 export declare type DatePickerVariant = 'normal' | 'error';
 
+export declare const DateRange: ({ className, classnames, from, presentLabel, ref, to, ...rest }: DateRangeProps) => JSX.Element;
+
+export declare type DateRangeClassNames = {
+    hash?: string;
+    from?: string;
+    separator?: string;
+    to?: string;
+};
+
+export declare type DateRangeProps = VacanoComponentProps<HTMLSpanElement, DateRangeClassNames> & Omit<HTMLAttributes<HTMLSpanElement>, 'className'> & {
+    from: Date;
+    to?: Date;
+    presentLabel?: string;
+};
+
 export declare const Divider: ({ children, className, classnames, ref, spacing, ...rest }: DividerProps) => JSX.Element;
 
 export declare type DividerClassNames = {
@@ -315,6 +517,22 @@ export declare type DropdownProps = VacanoComponentProps<HTMLDivElement, Dropdow
 
 declare const email: (options?: string) => StringSchema<string | undefined, AnyObject, undefined, "">;
 
+export declare const EmptyState: ({ actions, className, classnames, description, icon, ref, title, ...rest }: EmptyStateProps) => JSX.Element;
+
+export declare type EmptyStateClassNames = {
+    icon?: string;
+    title?: string;
+    description?: string;
+    actions?: string;
+};
+
+export declare type EmptyStateProps = VacanoComponentProps<HTMLDivElement, EmptyStateClassNames> & {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+};
+
 export declare const FieldLabel: ({ children, className, ref, required, variant, ...rest }: FieldLabelProps) => JSX.Element | null;
 
 export declare type FieldLabelProps = VacanoComponentProps<HTMLSpanElement> & {
@@ -340,6 +558,61 @@ export declare type FieldRowProps = VacanoComponentProps<HTMLDivElement> & Omit<
     gap?: number | string;
 };
 
+export declare const FileUpload: ({ accept, children, className, classnames, description, disabled, hint, icon, maxSize, multiple, onChange, onReject, ref, ...rest }: FileUploadProps) => JSX.Element;
+
+export declare type FileUploadClassNames = {
+    dropzone?: string;
+    icon?: string;
+    text?: string;
+    hint?: string;
+    list?: string;
+};
+
+export declare type FileUploadFile = {
+    id: string;
+    name: string;
+    size: number;
+    progress?: number;
+    status: FileUploadItemStatus;
+    file?: File;
+};
+
+export declare const FileUploadItem: ({ name, size, status, progress, icon, onRemove, onRetry, className, classnames, ref, }: FileUploadItemProps) => JSX.Element;
+
+export declare type FileUploadItemClassNames = {
+    icon?: string;
+    info?: string;
+    name?: string;
+    size?: string;
+    progress?: string;
+    action?: string;
+};
+
+export declare type FileUploadItemProps = VacanoComponentProps<HTMLDivElement, FileUploadItemClassNames> & {
+    name: string;
+    size: number;
+    status?: FileUploadItemStatus;
+    progress?: number;
+    icon?: ReactNode;
+    onRemove?: () => void;
+    onRetry?: () => void;
+};
+
+export declare type FileUploadItemStatus = 'uploading' | 'complete' | 'failed';
+
+export declare type FileUploadProps = VacanoComponentProps<HTMLDivElement, FileUploadClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'onChange'> & {
+    accept?: string;
+    children?: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    hint?: ReactNode;
+    icon?: ReactNode;
+    maxSize?: number;
+    multiple?: boolean;
+    onChange?: (files: File[]) => void;
+    onReject?: (files: File[], reason: 'type' | 'size') => void;
+};
+
 /**
  * Go-style date formatting
  * Reference time: Mon Jan 2 15:04:05 MST 2006
@@ -366,6 +639,8 @@ export declare type FieldRowProps = VacanoComponentProps<HTMLDivElement> & Omit<
  */
 export declare const formatDateGo: (date: Date, format: string, locale?: string) => string;
 
+export declare const formatFileSize: (bytes: number) => string;
+
 export declare const getBrowser: () => Browser;
 
 export declare const getKeySymbols: (keys?: KeyboardEventKey[]) => string[];
@@ -374,6 +649,28 @@ export declare const getOperatingSystem: () => OperatingSystem;
 
 export declare const GlobalStyle: () => JSX.Element;
 
+export declare const Hashtag: ({ children, className, classnames, href, onClick, ref, ...rest }: HashtagProps) => JSX.Element;
+
+export declare type HashtagClassNames = {
+    hash?: string;
+    label?: string;
+};
+
+export declare type HashtagProps = VacanoComponentProps<HTMLSpanElement, HashtagClassNames> & Omit<HTMLAttributes<HTMLSpanElement>, 'className'> & {
+    children: ReactNode;
+    href?: string;
+};
+
+export declare const Heading: ({ as, children, className, level, ref, ...rest }: HeadingProps) => JSX.Element;
+
+export declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+
+export declare type HeadingProps = VacanoComponentProps<HTMLHeadingElement> & Omit<HTMLAttributes<HTMLHeadingElement>, 'className'> & {
+    children: ReactNode;
+    level?: HeadingLevel;
+    as?: HeadingLevel;
+};
+
 declare const hexColor: (message?: string) => StringSchema<string | undefined, AnyObject, undefined, "">;
 
 export declare const ImageCropper: ({ allowedTypes, applyLabel, buttonLabel, cancelLabel, className, classnames, compression, maxFileSize, onCrop, onError, outputSize, portalSize, previewSize, ref, type, value, ...rest }: ImageCropperProps) => JSX.Element;
@@ -570,6 +867,20 @@ export declare const mediaDown: (bp: Breakpoint) => string;
 
 export declare const mediaUp: (bp: Breakpoint) => string;
 
+export declare const MenuButton: ({ className, classnames, defaultOpen, disabled, onOpenChange, open: controlledOpen, ref, size, ...rest }: MenuButtonProps) => JSX.Element;
+
+export declare type MenuButtonClassNames = {
+    line?: string;
+};
+
+export declare type MenuButtonProps = VacanoComponentProps<HTMLButtonElement, MenuButtonClassNames> & Omit<React.HTMLAttributes<HTMLButtonElement>, 'children' | 'className'> & {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    size?: VacanoComponentSize;
+    disabled?: boolean;
+};
+
 declare const minAge: (years: number, message?: string) => DateSchema<Date | undefined, AnyObject, undefined, "">;
 
 export declare const Modal: ({ animated, children, className, classnames, open, ref, width, ...rest }: ModalProps) => ReactPortal | null;
@@ -703,9 +1014,46 @@ export declare type OtpCodeProps = VacanoComponentProps<HTMLDivElement, OtpCodeC
 
 export declare type OtpCodeVariant = 'normal' | 'error';
 
-export declare const Panel: ({ children, className, classnames, description, ref, title, variant, ...rest }: PanelProps) => JSX.Element;
+export declare const Overline: ({ children, className, classnames, description, ref, ...rest }: OverlineProps) => JSX.Element;
+
+export declare type OverlineClassNames = {
+    label?: string;
+    description?: string;
+};
+
+export declare type OverlineProps = VacanoComponentProps<HTMLDivElement, OverlineClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    children: ReactNode;
+    description?: ReactNode;
+};
+
+export declare const Pagination: ({ boundaries, className, classnames, disabled, initialPage, loop, onChange, page: controlledPage, ref, showControls, siblings, total, variant, ...rest }: PaginationProps) => JSX.Element;
+
+export declare type PaginationClassNames = {
+    item?: string;
+    cursor?: string;
+    controls?: string;
+    ellipsis?: string;
+};
+
+export declare type PaginationProps = VacanoComponentProps<HTMLElement, PaginationClassNames> & Omit<HTMLAttributes<HTMLElement>, 'className' | 'onChange'> & {
+    boundaries?: number;
+    disabled?: boolean;
+    initialPage?: number;
+    loop?: boolean;
+    onChange?: (page: number) => void;
+    page?: number;
+    showControls?: boolean;
+    siblings?: number;
+    total: number;
+    variant?: PaginationVariant;
+};
+
+export declare type PaginationVariant = 'flat' | 'bordered' | 'light';
+
+export declare const Panel: ({ children, className, classnames, description, label, ref, title, variant, ...rest }: PanelProps) => JSX.Element;
 
 export declare type PanelClassNames = {
+    label?: string;
     title?: string;
     description?: string;
     content?: string;
@@ -714,6 +1062,7 @@ export declare type PanelClassNames = {
 export declare type PanelProps = VacanoComponentProps<HTMLDivElement, PanelClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'title'> & {
     children: ReactNode;
     description?: string;
+    label?: ReactNode;
     title?: string;
     variant?: PanelVariant;
 };
@@ -722,6 +1071,20 @@ export declare type PanelVariant = 'light' | 'dark';
 
 declare const password: (message?: string) => StringSchema<string | undefined, AnyObject, undefined, "">;
 
+export declare const PendingScreen: ({ className, classnames, description, interval, phrases: phrasesProp, ref, ...rest }: PendingScreenProps) => JSX.Element;
+
+export declare type PendingScreenClassNames = {
+    board?: string;
+    description?: string;
+    indicator?: string;
+};
+
+export declare type PendingScreenProps = VacanoComponentProps<HTMLDivElement, PendingScreenClassNames> & {
+    description?: string;
+    interval?: number;
+    phrases?: string[];
+};
+
 declare const phone: (message?: string) => StringSchema<string | undefined, AnyObject, undefined, "">;
 
 export declare const Progress: ({ value, size, className, classnames, ref, ...rest }: ProgressProps) => JSX.Element;
@@ -843,6 +1206,41 @@ export declare type SelectProps = VacanoComponentProps<HTMLDivElement, SelectCla
 
 export declare type SelectVariant = 'normal' | 'error';
 
+export declare const ShellScreen: ({ children, className, classnames, description, footer, gridSize, icon, logo, ref, title, ...rest }: ShellScreenProps) => JSX.Element;
+
+export declare type ShellScreenClassNames = {
+    grid?: string;
+    header?: string;
+    title?: string;
+    description?: string;
+    content?: string;
+    footer?: string;
+};
+
+export declare type ShellScreenProps = VacanoComponentProps<HTMLDivElement, ShellScreenClassNames> & {
+    logo?: ReactNode;
+    icon?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    gridSize?: number;
+};
+
+export declare const Skeleton: ({ animation, circle, className, height, radius, ref, width, ...rest }: SkeletonProps) => JSX.Element;
+
+export declare type SkeletonAnimation = 'pulse' | 'wave' | 'none';
+
+export declare type SkeletonProps = VacanoComponentProps<HTMLDivElement> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    width?: number | string;
+    height?: number | string;
+    radius?: SkeletonRadius;
+    animation?: SkeletonAnimation;
+    circle?: boolean;
+};
+
+export declare type SkeletonRadius = 'none' | 'sm' | 'md' | 'lg' | 'full';
+
 declare const slug: (message?: string) => StringSchema<string | undefined, AnyObject, undefined, "">;
 
 export declare const Spinner: ({ "aria-label": ariaLabel, className, ref, size, ...rest }: SpinnerProps) => JSX.Element;
@@ -856,11 +1254,61 @@ export declare type SpinnerProps = VacanoComponentProps<HTMLDivElement, SpinnerC
 
 export declare type SpinnerSize = 'xs' | 'sm' | 'md' | 'lg';
 
+export declare const SplitFlapText: ({ className, ref, text, ...rest }: SplitFlapTextProps) => JSX.Element;
+
+export declare type SplitFlapTextClassNames = Record<string, never>;
+
+export declare type SplitFlapTextProps = VacanoComponentProps<HTMLDivElement, SplitFlapTextClassNames> & {
+    text: string;
+};
+
+export declare const Stat: ({ className, classnames, label, ref, value, ...rest }: StatProps) => JSX.Element;
+
+export declare type StatClassNames = {
+    value?: string;
+    label?: string;
+};
+
+export declare type StatProps = VacanoComponentProps<HTMLSpanElement, StatClassNames> & Omit<HTMLAttributes<HTMLSpanElement>, 'className'> & {
+    value: ReactNode;
+    label: string;
+};
+
 export declare type StepItem = {
     value: string;
     label: string;
 };
 
+export declare const StepLog: ({ className, classnames, defaultValue, onChange, ref, steps, value: controlledValue, ...rest }: StepLogProps) => JSX.Element;
+
+export declare type StepLogClassNames = {
+    step?: string;
+    header?: string;
+    log?: string;
+};
+
+export declare type StepLogItem = {
+    value: string;
+    title: ReactNode;
+    status?: StepLogStatus;
+    duration?: string;
+    lines?: StepLogLine[];
+};
+
+export declare type StepLogLine = {
+    line: number;
+    text: string;
+};
+
+export declare type StepLogProps = VacanoComponentProps<HTMLDivElement, StepLogClassNames> & {
+    steps: StepLogItem[];
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+};
+
+export declare type StepLogStatus = 'success' | 'error' | 'running' | 'pending';
+
 export declare const Stepper: ({ className, classnames, onChange, orientation, ref, steps, value, ...rest }: StepperProps) => JSX.Element;
 
 export declare type StepperClassNames = {
@@ -949,6 +1397,28 @@ export declare type TextareaProps = VacanoComponentProps<HTMLTextAreaElement, Te
 
 export declare type TextareaVariant = 'normal' | 'error';
 
+export declare const Timeline: ({ className, classnames, items, ref, ...rest }: TimelineProps) => JSX.Element;
+
+export declare type TimelineClassNames = {
+    item?: string;
+    dot?: string;
+    line?: string;
+    content?: string;
+    title?: string;
+    description?: string;
+    body?: string;
+};
+
+export declare type TimelineItem = {
+    title: string;
+    description?: ReactNode;
+    children?: ReactNode;
+};
+
+export declare type TimelineProps = VacanoComponentProps<HTMLDivElement, TimelineClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    items: TimelineItem[];
+};
+
 export declare type Toast = {
     id: string;
     message: string;
@@ -1101,6 +1571,22 @@ export declare const useNotification: () => NotificationContextValue;
 
 export declare const useNotifyConfirmation: () => NotifyConfirmationContextValue;
 
+export declare const User: ({ avatarPosition, avatarProps, className, classnames, description, name, ref, src, ...rest }: UserProps) => JSX.Element;
+
+export declare type UserClassNames = {
+    avatar?: string;
+    name?: string;
+    description?: string;
+};
+
+export declare type UserProps = VacanoComponentProps<HTMLDivElement, UserClassNames> & Omit<HTMLAttributes<HTMLDivElement>, 'className'> & {
+    name: ReactNode;
+    description?: ReactNode;
+    src?: string;
+    avatarProps?: Omit<AvatarProps, 'ref'>;
+    avatarPosition?: 'left' | 'right';
+};
+
 export declare const useSaveProgress: () => SaveProgressContextValue;
 
 export declare const useToastr: () => ToastContextValue;