@facter/ds-core 1.1.3 → 1.3.0

package/dist/index.d.ts

@@ -1,19 +1,26 @@
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import * as React$1 from 'react';
+import { ReactNode, ComponentType } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as SelectPrimitive from '@radix-ui/react-select';
 import * as TabsPrimitive from '@radix-ui/react-tabs';
 import * as _tanstack_react_table from '@tanstack/react-table';
 import { ColumnDef, Column, SortingState, ColumnFiltersState, VisibilityState, RowSelectionState, PaginationState, Table as Table$1 } from '@tanstack/react-table';
-export { flexRender } from '@tanstack/react-table';
+export { ColumnDef, flexRender } from '@tanstack/react-table';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
-import { Toaster as Toaster$1 } from 'sonner';
+import { Toaster as Toaster$1, toast as toast$1 } from 'sonner';
 import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
 import * as SwitchPrimitives from '@radix-ui/react-switch';
-import { FieldValues, FieldPath, UseFormReturn, SubmitHandler, SubmitErrorHandler } from 'react-hook-form';
+import { FieldValues, FieldPath, UseFormReturn, SubmitHandler, SubmitErrorHandler, Path } from 'react-hook-form';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
 import { LucideIcon } from 'lucide-react';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
 import { ClassValue } from 'clsx';
+export { FACTER_THEMES, FacterTheme, THEME_INFO } from './themes/index.js';
 
 declare const buttonVariants: (props?: ({
     variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
@@ -24,6 +31,43 @@ interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, V
 }
 declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
+interface CardProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare function Card({ className, ...props }: CardProps): react_jsx_runtime.JSX.Element;
+declare namespace Card {
+    var displayName: string;
+}
+interface CardHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare function CardHeader({ className, ...props }: CardHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace CardHeader {
+    var displayName: string;
+}
+interface CardTitleProps extends React$1.HTMLAttributes<HTMLHeadingElement> {
+}
+declare function CardTitle({ className, ...props }: CardTitleProps): react_jsx_runtime.JSX.Element;
+declare namespace CardTitle {
+    var displayName: string;
+}
+interface CardDescriptionProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
+}
+declare function CardDescription({ className, ...props }: CardDescriptionProps): react_jsx_runtime.JSX.Element;
+declare namespace CardDescription {
+    var displayName: string;
+}
+interface CardContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare function CardContent({ className, ...props }: CardContentProps): react_jsx_runtime.JSX.Element;
+declare namespace CardContent {
+    var displayName: string;
+}
+interface CardFooterProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare function CardFooter({ className, ...props }: CardFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace CardFooter {
+    var displayName: string;
+}
+
 declare const inputVariants: (props?: ({
     variant?: "default" | "error" | null | undefined;
     inputSize?: "default" | "sm" | "lg" | null | undefined;
@@ -48,6 +92,119 @@ declare namespace Badge {
     var displayName: string;
 }
 
+type SparklineColor = 'chart-1' | 'chart-2' | 'chart-3' | 'chart-4' | 'chart-5';
+type BigNumberCardSize = 'default' | 'sm' | 'lg';
+interface BigNumberCardRootProps {
+    children: React$1.ReactNode;
+    className?: string;
+    size?: BigNumberCardSize;
+}
+interface BigNumberCardHeaderProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface BigNumberCardTitleProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface BigNumberCardLinkProps {
+    children: React$1.ReactNode;
+    href?: string;
+    onClick?: () => void;
+    className?: string;
+}
+interface BigNumberCardContentProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+interface BigNumberCardValueProps {
+    children: React$1.ReactNode;
+    prefix?: string;
+    suffix?: string;
+    className?: string;
+}
+interface BigNumberCardTrendProps {
+    value: number;
+    direction: 'up' | 'down';
+    children?: React$1.ReactNode;
+    className?: string;
+    show?: boolean;
+}
+interface BigNumberCardSparklineProps {
+    data: number[];
+    color?: SparklineColor;
+    animate?: boolean;
+    className?: string;
+    show?: boolean;
+}
+
+declare function Sparkline({ data, color, animate, className, show, }: BigNumberCardSparklineProps): react_jsx_runtime.JSX.Element | null;
+declare namespace Sparkline {
+    var displayName: string;
+}
+
+declare function BigNumberCardRoot({ children, className, size }: BigNumberCardRootProps): react_jsx_runtime.JSX.Element;
+declare namespace BigNumberCardRoot {
+    var displayName: string;
+}
+declare function BigNumberCardHeader({ children, className }: BigNumberCardHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace BigNumberCardHeader {
+    var displayName: string;
+}
+declare function BigNumberCardTitle({ children, className }: BigNumberCardTitleProps): react_jsx_runtime.JSX.Element;
+declare namespace BigNumberCardTitle {
+    var displayName: string;
+}
+declare function BigNumberCardLink({ children, href, onClick, className }: BigNumberCardLinkProps): react_jsx_runtime.JSX.Element;
+declare namespace BigNumberCardLink {
+    var displayName: string;
+}
+declare function BigNumberCardContent({ children, className }: BigNumberCardContentProps): react_jsx_runtime.JSX.Element;
+declare namespace BigNumberCardContent {
+    var displayName: string;
+}
+declare function BigNumberCardValue({ children, prefix, suffix, className }: BigNumberCardValueProps): react_jsx_runtime.JSX.Element;
+declare namespace BigNumberCardValue {
+    var displayName: string;
+}
+declare function BigNumberCardTrend({ value, direction, children, className, show }: BigNumberCardTrendProps): react_jsx_runtime.JSX.Element | null;
+declare namespace BigNumberCardTrend {
+    var displayName: string;
+}
+interface BigNumberCardDescriptionProps {
+    children: React$1.ReactNode;
+    className?: string;
+    show?: boolean;
+}
+declare function BigNumberCardDescription({ children, className, show }: BigNumberCardDescriptionProps): react_jsx_runtime.JSX.Element | null;
+declare namespace BigNumberCardDescription {
+    var displayName: string;
+}
+declare function BigNumberCardSparklineWrapper(props: React$1.ComponentProps<typeof Sparkline>): react_jsx_runtime.JSX.Element | null;
+declare namespace BigNumberCardSparklineWrapper {
+    var displayName: string;
+}
+declare const BigNumberCard: {
+    Root: typeof BigNumberCardRoot;
+    Header: typeof BigNumberCardHeader;
+    Title: typeof BigNumberCardTitle;
+    Link: typeof BigNumberCardLink;
+    Content: typeof BigNumberCardContent;
+    Value: typeof BigNumberCardValue;
+    Trend: typeof BigNumberCardTrend;
+    Description: typeof BigNumberCardDescription;
+    Sparkline: typeof BigNumberCardSparklineWrapper;
+};
+
+interface SkeletonProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'circular' | 'text';
+    animation?: 'pulse' | 'wave' | 'none';
+}
+declare function Skeleton({ className, variant, animation, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+declare namespace Skeleton {
+    var displayName: string;
+}
+
 declare const selectVariants: (props?: ({
     variant?: "default" | "error" | null | undefined;
     selectSize?: "default" | "sm" | "lg" | null | undefined;
@@ -78,7 +235,7 @@ declare const TabsTrigger: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.
 declare const TabsContent: React$1.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 
 declare const loaderVariants: (props?: ({
-    variant?: "default" | "spinner" | "dots" | "pulse" | "bars" | null | undefined;
+    variant?: "default" | "pulse" | "spinner" | "dots" | "bars" | null | undefined;
     scope?: "local" | "global" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface LoaderProps extends VariantProps<typeof loaderVariants> {
@@ -403,9 +560,9 @@ declare const Table: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HT
 declare const TableHeader: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
 declare const TableBody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
 declare const TableFooter: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
-declare const TableRow: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>>;
+declare const TableRow: React$1.NamedExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & React$1.RefAttributes<HTMLTableRowElement>>;
 declare const TableHead: React$1.ForwardRefExoticComponent<React$1.ThHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
-declare const TableCell: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>>;
+declare const TableCell: React$1.NamedExoticComponent<React$1.TdHTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
 declare const TableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
 
 /**
@@ -511,18 +668,18 @@ declare const Dialog: React$1.FC<DialogPrimitive.DialogProps>;
 declare const DialogTrigger: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
 declare const DialogPortal: React$1.FC<DialogPrimitive.DialogPortalProps>;
 declare const DialogClose: React$1.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
-declare const DialogOverlay: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>>;
+declare const DialogOverlay: React$1.NamedExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
 declare const dialogContentVariants: (props?: ({
     size?: "sm" | "lg" | "md" | "xl" | "2xl" | "3xl" | "4xl" | "full" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface DialogContentProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof dialogContentVariants> {
     showCloseButton?: boolean;
 }
-declare const DialogContent: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<DialogContentProps & React$1.RefAttributes<HTMLDivElement>>>;
+declare const DialogContent: React$1.NamedExoticComponent<DialogContentProps & React$1.RefAttributes<HTMLDivElement>>;
 declare const DialogHeader: React$1.NamedExoticComponent<React$1.HTMLAttributes<HTMLDivElement>>;
 declare const DialogFooter: React$1.NamedExoticComponent<React$1.HTMLAttributes<HTMLDivElement>>;
-declare const DialogTitle: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>>;
-declare const DialogDescription: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>>;
+declare const DialogTitle: React$1.NamedExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>, "ref"> & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React$1.NamedExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>, "ref"> & React$1.RefAttributes<HTMLParagraphElement>>;
 declare const DialogBody: React$1.NamedExoticComponent<React$1.HTMLAttributes<HTMLDivElement>>;
 
 interface RippleEffectProps {
@@ -615,7 +772,7 @@ declare const toast: ((message: string) => string | number) & {
     error: (message: string | ToastProps) => string | number;
     warning: (message: string | ToastProps) => string | number;
     info: (message: string | ToastProps) => string | number;
-    custom: (component: (id: string | number) => React$1.ReactElement, options?: any) => string | number;
+    custom: (component: Parameters<typeof toast$1.custom>[0], options?: Parameters<typeof toast$1.custom>[1]) => string | number;
     dismiss: (id?: string | number) => string | number;
     promise: <T>(promise: Promise<T> | (() => Promise<T>), options: {
         loading: string;
@@ -636,7 +793,7 @@ declare const checkboxVariants: (props?: ({
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface CheckboxProps extends React$1.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>, VariantProps<typeof checkboxVariants> {
 }
-declare const Checkbox: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLButtonElement>>>;
+declare const Checkbox: React$1.NamedExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLButtonElement>>;
 
 declare const switchVariants: (props?: ({
     variant?: "default" | "secondary" | "success" | null | undefined;
@@ -644,7 +801,7 @@ declare const switchVariants: (props?: ({
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface SwitchProps extends React$1.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>, VariantProps<typeof switchVariants> {
 }
-declare const Switch: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>>;
+declare const Switch: React$1.NamedExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>;
 
 declare const textareaVariants: (props?: ({
     variant?: "default" | "error" | null | undefined;
@@ -658,7 +815,7 @@ interface TextareaProps extends Omit<React$1.TextareaHTMLAttributes<HTMLTextArea
     labelClassName?: string;
     autoResize?: boolean;
 }
-declare const Textarea: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>>;
+declare const Textarea: React$1.NamedExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
 
 interface FormLabelProps extends React$1.LabelHTMLAttributes<HTMLLabelElement> {
     required?: boolean;
@@ -819,16 +976,65 @@ declare const Form: typeof FormRoot & {
     Field: typeof FormFieldProvider;
 };
 
+interface AvatarProps extends React$1.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root> {
+    className?: string;
+}
+interface AvatarImageProps extends React$1.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image> {
+    className?: string;
+}
+interface AvatarFallbackProps extends React$1.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback> {
+    className?: string;
+}
+declare const Avatar: React$1.ForwardRefExoticComponent<AvatarProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React$1.ForwardRefExoticComponent<AvatarImageProps & React$1.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React$1.ForwardRefExoticComponent<AvatarFallbackProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const DropdownMenu: React$1.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React$1.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React$1.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React$1.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const Popover: React$1.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React$1.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
 interface AuthLayoutProps {
     children: React$1.ReactNode;
     className?: string;
 }
 interface AuthLayoutImageProps {
-    src: string;
-    alt: string;
+    /** Image source URL (optional if using showPattern) */
+    src?: string;
+    /** Image alt text */
+    alt?: string;
+    /** Position of the image panel */
     position?: 'left' | 'right';
+    /** Additional CSS classes */
     className?: string;
+    /** Whether to load image with priority */
     priority?: boolean;
+    /** Show geometric pattern overlay (useful as placeholder) */
+    showPattern?: boolean;
 }
 interface AuthLayoutContentProps {
     children: React$1.ReactNode;
@@ -842,6 +1048,8 @@ interface AuthLayoutHeaderProps {
     title?: string;
     description?: string;
     centered?: boolean;
+    /** Position of the header: 'default' (inline) or 'top-left' (absolute corner) */
+    position?: 'default' | 'top-left' | 'top-right';
 }
 interface AuthLayoutBodyProps {
     children: React$1.ReactNode;
@@ -863,7 +1071,7 @@ declare function AuthLayoutRoot({ children, className }: AuthLayoutProps): react
 declare namespace AuthLayoutRoot {
     var displayName: string;
 }
-declare function AuthLayoutImage({ src, alt, position: _position, className, priority, }: AuthLayoutImageProps): react_jsx_runtime.JSX.Element;
+declare function AuthLayoutImage({ src, alt, position: _position, className, priority, showPattern, }: AuthLayoutImageProps): react_jsx_runtime.JSX.Element;
 declare namespace AuthLayoutImage {
     var displayName: string;
 }
@@ -871,7 +1079,7 @@ declare function AuthLayoutContent({ children, className, maxWidth, }: AuthLayou
 declare namespace AuthLayoutContent {
     var displayName: string;
 }
-declare function AuthLayoutHeader({ children, className, logo, title, description, centered, }: AuthLayoutHeaderProps): react_jsx_runtime.JSX.Element;
+declare function AuthLayoutHeader({ children, className, logo, title, description, centered, position, }: AuthLayoutHeaderProps): react_jsx_runtime.JSX.Element;
 declare namespace AuthLayoutHeader {
     var displayName: string;
 }
@@ -1235,6 +1443,829 @@ declare const DashboardLayout: typeof DashboardLayoutRoot & {
     MobileNavItem: typeof DashboardLayoutMobileNavItem;
 };
 
+interface SidebarContextValue {
+    expanded: boolean;
+    setExpanded: (expanded: boolean) => void;
+    pinned: boolean;
+    setPinned: (pinned: boolean) => void;
+    activeSection: string | null;
+    setActiveSection: (id: string | null) => void;
+    isMobile: boolean;
+    collapsedWidth: number;
+    expandedWidth: number;
+}
+interface SidebarProps {
+    children: React.ReactNode;
+    defaultExpanded?: boolean;
+    defaultPinned?: boolean;
+    collapsedWidth?: number;
+    expandedWidth?: number;
+    className?: string;
+}
+interface SidebarHeaderProps {
+    logo?: React.ReactNode;
+    collapsedLogo?: React.ReactNode;
+    title?: string;
+    showPinButton?: boolean;
+    className?: string;
+}
+interface SidebarNavProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface SidebarSectionProps {
+    title?: string;
+    children: React.ReactNode;
+    className?: string;
+}
+type BadgeVariant = 'default' | 'notification' | 'success' | 'warning';
+interface SidebarNavItemProps {
+    icon?: LucideIcon | React.ReactNode;
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    isActive?: boolean;
+    badge?: string | number;
+    badgeVariant?: BadgeVariant;
+    disabled?: boolean;
+    className?: string;
+}
+interface SidebarNavGroupProps {
+    icon?: LucideIcon | React.ReactNode;
+    label: string;
+    children: React.ReactNode;
+    id?: string;
+    defaultOpen?: boolean;
+    isActive?: boolean;
+    badge?: string | number;
+    badgeVariant?: BadgeVariant;
+    className?: string;
+}
+interface SidebarFooterUser {
+    name: string;
+    email?: string;
+    avatar?: string;
+}
+interface SidebarFooterMenuItem {
+    icon?: LucideIcon;
+    label: string;
+    onClick: () => void;
+    variant?: 'default' | 'destructive';
+}
+interface SidebarFooterProps {
+    user?: SidebarFooterUser;
+    menuItems?: SidebarFooterMenuItem[];
+    children?: React.ReactNode;
+    className?: string;
+}
+
+interface SidebarRootProps {
+    children: React$1.ReactNode;
+    defaultExpanded?: boolean;
+    defaultPinned?: boolean;
+    collapsedWidth?: number;
+    expandedWidth?: number;
+}
+declare function SidebarRoot({ children, defaultExpanded, defaultPinned, collapsedWidth, expandedWidth, }: SidebarRootProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarRoot {
+    var displayName: string;
+}
+interface SidebarAsideProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function SidebarAside({ children, className }: SidebarAsideProps): react_jsx_runtime.JSX.Element | null;
+declare namespace SidebarAside {
+    var displayName: string;
+}
+interface SidebarContentProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function SidebarContent({ children, className }: SidebarContentProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarContent {
+    var displayName: string;
+}
+declare function LegacySidebar({ children, defaultExpanded, defaultPinned, collapsedWidth, expandedWidth, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
+declare namespace LegacySidebar {
+    var displayName: string;
+}
+declare const Sidebar: typeof LegacySidebar & {
+    Root: typeof SidebarRoot;
+    Aside: typeof SidebarAside;
+    Content: typeof SidebarContent;
+    Header: React$1.NamedExoticComponent<SidebarHeaderProps>;
+    Nav: React$1.NamedExoticComponent<SidebarNavProps>;
+    Section: React$1.NamedExoticComponent<SidebarSectionProps>;
+    NavItem: React$1.NamedExoticComponent<SidebarNavItemProps>;
+    NavGroup: React$1.NamedExoticComponent<SidebarNavGroupProps>;
+    Footer: React$1.NamedExoticComponent<SidebarFooterProps>;
+};
+
+declare function useSidebar(): SidebarContextValue;
+declare function useSidebarOptional(): SidebarContextValue | null;
+declare function useMediaQuery(query: string): boolean;
+
+interface MobileNavItemConfig {
+    icon: LucideIcon | React.ReactNode;
+    label: string;
+    href?: string;
+    onClick?: () => void;
+    isActive?: boolean;
+}
+interface MobileNavFabAction {
+    icon: React.ReactNode;
+    label: string;
+    onClick: () => void;
+}
+interface MobileNavProps {
+    items: MobileNavItemConfig[];
+    fabAction?: MobileNavFabAction;
+    className?: string;
+}
+interface MobileNavItemProps {
+    icon: LucideIcon | React.ReactNode;
+    label: string;
+    isActive?: boolean;
+    onClick?: () => void;
+}
+
+declare const MobileNav: React$1.NamedExoticComponent<MobileNavProps>;
+
+declare const MobileNavItem: React$1.NamedExoticComponent<MobileNavItemProps>;
+
+interface NavbarProps {
+    children: React$1.ReactNode;
+    className?: string;
+    style?: React$1.CSSProperties;
+}
+declare const Navbar: React$1.NamedExoticComponent<NavbarProps>;
+
+interface ThemeToggleProps {
+    className?: string;
+}
+declare function ThemeToggle({ className }: ThemeToggleProps): react_jsx_runtime.JSX.Element;
+declare namespace ThemeToggle {
+    var displayName: string;
+}
+
+interface NotificationItem {
+    id: string;
+    icon?: React$1.ReactNode;
+    title: string;
+    description: string;
+    time: string;
+    isHighlighted?: boolean;
+}
+interface NavbarNotificationProps {
+    notifications?: NotificationItem[];
+    onMarkAllAsRead?: () => void;
+    onViewAll?: () => void;
+}
+declare function NavbarNotification({ notifications, onMarkAllAsRead, onViewAll, }: NavbarNotificationProps): react_jsx_runtime.JSX.Element;
+declare namespace NavbarNotification {
+    var displayName: string;
+}
+
+interface Company {
+    id: string;
+    name: string;
+    cnpj?: string;
+}
+interface NavbarCompanyProfileProps {
+    /** Lista de empresas vinculadas */
+    companies: Company[];
+    /** ID da empresa ativa */
+    activeCompanyId?: string;
+    /** Callback quando uma empresa é selecionada */
+    onCompanySelect?: (companyId: string) => void;
+    /** Se está carregando as empresas */
+    isLoading?: boolean;
+    /** Função para formatar CNPJ (opcional) */
+    formatCnpj?: (cnpj: string) => string;
+}
+declare function NavbarCompanyProfile({ companies, activeCompanyId, onCompanySelect, isLoading, formatCnpj, }: NavbarCompanyProfileProps): react_jsx_runtime.JSX.Element | null;
+declare namespace NavbarCompanyProfile {
+    var displayName: string;
+}
+
+interface UserMenuItemConfig {
+    icon?: React$1.ReactNode;
+    label: string;
+    onClick?: () => void;
+    href?: string;
+    variant?: 'default' | 'destructive';
+}
+interface NavbarUserMenuProps {
+    /** Nome do usuário */
+    name: string;
+    /** Email do usuário */
+    email?: string;
+    /** URL do avatar */
+    avatarUrl?: string;
+    /** Se está no modo colapsado (só mostra avatar) */
+    isCollapsed?: boolean;
+    /** Itens do menu */
+    menuItems?: UserMenuItemConfig[];
+    /** Children customizado para o menu */
+    children?: React$1.ReactNode;
+}
+declare function NavbarUserMenu({ name, email, avatarUrl, isCollapsed, menuItems, children, }: NavbarUserMenuProps): react_jsx_runtime.JSX.Element;
+declare namespace NavbarUserMenu {
+    var displayName: string;
+}
+
+declare const Breadcrumb: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React$1.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React$1.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React$1.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React$1.ComponentProps<"li">): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React$1.ComponentProps<"span">): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const ScrollArea: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React$1.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Separator: React$1.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React$1.RefAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+
+interface SectionHeaderRootProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Adds a gradient from primary color on the left side
+     * @default true
+     */
+    gradient?: boolean;
+    /**
+     * Adds bottom border
+     * @default true
+     */
+    bordered?: boolean;
+}
+declare function SectionHeaderRoot({ children, className, gradient, bordered, ...props }: SectionHeaderRootProps): react_jsx_runtime.JSX.Element;
+declare namespace SectionHeaderRoot {
+    var displayName: string;
+}
+interface SectionHeaderIconProps {
+    icon: LucideIcon;
+    className?: string;
+}
+declare function SectionHeaderIcon({ icon: Icon, className }: SectionHeaderIconProps): react_jsx_runtime.JSX.Element;
+declare namespace SectionHeaderIcon {
+    var displayName: string;
+}
+interface SectionHeaderContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare function SectionHeaderContent({ children, className, ...props }: SectionHeaderContentProps): react_jsx_runtime.JSX.Element;
+declare namespace SectionHeaderContent {
+    var displayName: string;
+}
+interface SectionHeaderTitleProps extends React$1.HTMLAttributes<HTMLHeadingElement> {
+}
+declare function SectionHeaderTitle({ children, className, ...props }: SectionHeaderTitleProps): react_jsx_runtime.JSX.Element;
+declare namespace SectionHeaderTitle {
+    var displayName: string;
+}
+interface SectionHeaderSubtitleProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
+}
+declare function SectionHeaderSubtitle({ children, className, ...props }: SectionHeaderSubtitleProps): react_jsx_runtime.JSX.Element;
+declare namespace SectionHeaderSubtitle {
+    var displayName: string;
+}
+interface SectionHeaderActionsProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare function SectionHeaderActions({ children, className, ...props }: SectionHeaderActionsProps): react_jsx_runtime.JSX.Element;
+declare namespace SectionHeaderActions {
+    var displayName: string;
+}
+interface SectionHeaderBadgeProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+    variant?: 'default' | 'muted';
+}
+declare function SectionHeaderBadge({ children, className, variant, ...props }: SectionHeaderBadgeProps): react_jsx_runtime.JSX.Element;
+declare namespace SectionHeaderBadge {
+    var displayName: string;
+}
+declare const SectionHeader: typeof SectionHeaderRoot & {
+    Icon: typeof SectionHeaderIcon;
+    Content: typeof SectionHeaderContent;
+    Title: typeof SectionHeaderTitle;
+    Subtitle: typeof SectionHeaderSubtitle;
+    Actions: typeof SectionHeaderActions;
+    Badge: typeof SectionHeaderBadge;
+};
+
+interface KanbanItem {
+    id: string;
+    [key: string]: unknown;
+}
+interface KanbanColumnConfig {
+    id: string;
+    title: string;
+    color?: string;
+    headerClassName?: string;
+    dropZoneClassName?: string;
+}
+interface KanbanBoardProps {
+    children: ReactNode;
+    onDragEnd?: (result: KanbanDragResult) => void;
+    onDragStart?: (itemId: string, sourceColumnId: string) => void;
+    className?: string;
+}
+interface KanbanColumnProps {
+    id: string;
+    title: string;
+    count?: number;
+    children?: ReactNode;
+    className?: string;
+    headerClassName?: string;
+    emptyMessage?: string;
+    /** Optional footer element (e.g., "Add Task" button) */
+    footer?: ReactNode;
+    /** Callback to check if a drop is allowed in this column */
+    canDrop?: (itemId: string, sourceColumnId: string) => boolean;
+}
+interface KanbanCardProps {
+    id: string;
+    columnId: string;
+    children: ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+interface KanbanDragResult {
+    itemId: string;
+    sourceColumnId: string;
+    destinationColumnId: string;
+}
+interface KanbanContextValue {
+    isDragging: boolean;
+    draggedItemId: string | null;
+    sourceColumnId: string | null;
+    hoveredColumnId: string | null;
+    setHoveredColumnId: (columnId: string | null) => void;
+    canDropInColumn: (columnId: string) => boolean;
+    registerDropValidator: (columnId: string, validator: (itemId: string, sourceColumnId: string) => boolean) => void;
+    unregisterDropValidator: (columnId: string) => void;
+}
+interface KanbanEmptyProps {
+    message?: string;
+    className?: string;
+}
+
+declare function KanbanBoard({ children, onDragEnd, onDragStart, className, }: KanbanBoardProps): react_jsx_runtime.JSX.Element;
+declare namespace KanbanBoard {
+    var displayName: string;
+}
+
+declare function KanbanColumn({ id, title, count, children, className, headerClassName, emptyMessage, footer, canDrop, }: KanbanColumnProps): react_jsx_runtime.JSX.Element;
+declare namespace KanbanColumn {
+    var displayName: string;
+}
+
+declare function KanbanCard({ id, columnId, children, className, disabled, }: KanbanCardProps): react_jsx_runtime.JSX.Element;
+declare namespace KanbanCard {
+    var displayName: string;
+}
+
+/**
+ * Kanban - A compound component for building Kanban boards
+ *
+ * @example
+ * ```tsx
+ * <Kanban.Board onDragEnd={handleDragEnd}>
+ *   <Kanban.Column id="pending" title="Pendente" count={3}>
+ *     <Kanban.Card id="1" columnId="pending">
+ *       <div>Card content</div>
+ *     </Kanban.Card>
+ *   </Kanban.Column>
+ *   <Kanban.Column
+ *     id="done"
+ *     title="Concluido"
+ *     canDrop={(itemId, sourceColumnId) => sourceColumnId === 'in-progress'}
+ *   >
+ *     <Kanban.Card id="2" columnId="done">
+ *       <div>Card content</div>
+ *     </Kanban.Card>
+ *   </Kanban.Column>
+ * </Kanban.Board>
+ * ```
+ */
+declare const Kanban: {
+    Board: typeof KanbanBoard;
+    Column: typeof KanbanColumn;
+    Card: typeof KanbanCard;
+};
+
+declare function useKanban(): KanbanContextValue;
+declare function useKanbanOptional(): KanbanContextValue | null;
+
+/**
+ * Generic validation schema interface
+ * Compatible with Zod and other validation libraries
+ */
+interface ValidationSchema {
+    safeParseAsync: (data: unknown) => Promise<{
+        success: boolean;
+        error?: {
+            issues: Array<{
+                path: (string | number)[];
+                message: string;
+            }>;
+        };
+    }>;
+}
+/**
+ * Configuration for a single wizard step
+ */
+interface WizardStepConfig<T extends FieldValues = FieldValues> {
+    /** Unique identifier for the step */
+    id: string;
+    /** Step name used for lookups and matching with Panel */
+    name: string;
+    /** Display label for the step indicator */
+    label?: string;
+    /** Optional description shown below the label */
+    description?: string;
+    /** Icon component to display in step indicator */
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Fields that belong to this step (for validation) */
+    fields?: Path<T>[];
+    /** Validation schema for per-step validation (Zod compatible) */
+    validationSchema?: ValidationSchema;
+    /** Whether this step can be skipped */
+    isOptional?: boolean;
+    /** Whether step is disabled (static or dynamic) */
+    isDisabled?: boolean | ((data: T) => boolean);
+    /** Whether step is hidden (static or dynamic) */
+    isHidden?: boolean | ((data: T) => boolean);
+}
+/**
+ * Props for the root Wizard component
+ */
+interface WizardProps<T extends FieldValues = FieldValues> {
+    /** Child components (Wizard.Steps, Wizard.Content, etc.) */
+    children: ReactNode;
+    /** React Hook Form instance */
+    form: UseFormReturn<T>;
+    /** Array of step configurations */
+    steps: WizardStepConfig<T>[];
+    /** Initial step index (0-based) */
+    initialStep?: number;
+    /** Callback when step changes */
+    onStepChange?: (step: number, direction: 'next' | 'prev' | 'jump') => void;
+    /** Callback when wizard completes (form submit on last step) */
+    onComplete?: (data: T) => void | Promise<void>;
+    /** Whether to validate before advancing to next step (default: true) */
+    validateOnNext?: boolean;
+    /** Whether to allow jumping to any completed step (default: false) */
+    allowJumpToStep?: boolean;
+    /** Additional class name for the wizard container */
+    className?: string;
+}
+/**
+ * Context value provided by the Wizard
+ */
+interface WizardContextValue<T extends FieldValues = FieldValues> {
+    /** Current step index (0-based) */
+    currentStep: number;
+    /** Total number of visible steps */
+    totalSteps: number;
+    /** Filtered list of visible steps */
+    activeSteps: WizardStepConfig<T>[];
+    /** All step configurations (including hidden) */
+    allSteps: WizardStepConfig<T>[];
+    /** Whether current step is the first step */
+    isFirstStep: boolean;
+    /** Whether current step is the last step */
+    isLastStep: boolean;
+    /** Progress percentage (0-100) */
+    progress: number;
+    /** Navigate to next step (validates current step first) */
+    goToNextStep: () => Promise<boolean>;
+    /** Navigate to previous step (no validation) */
+    goToPrevStep: () => void;
+    /** Navigate to specific step by index */
+    goToStep: (index: number) => Promise<boolean>;
+    /** Reset wizard to initial state */
+    reset: () => void;
+    /** Validate current step fields */
+    validateCurrentStep: () => Promise<boolean>;
+    /** Check if a step has been completed */
+    isStepCompleted: (index: number) => boolean;
+    /** Check if a step has errors */
+    hasStepErrors: (index: number) => boolean;
+    /** React Hook Form instance */
+    form: UseFormReturn<T>;
+    /** Current step configuration */
+    currentStepConfig: WizardStepConfig<T>;
+    /** Get step config by index */
+    getStepConfig: (index: number) => WizardStepConfig<T> | undefined;
+    /** Get step config by name */
+    getStepByName: (name: string) => WizardStepConfig<T> | undefined;
+    /** Get step index by name */
+    getStepIndexByName: (name: string) => number;
+    /** Whether jumping to steps is allowed */
+    allowJumpToStep: boolean;
+}
+/**
+ * Props for Wizard.Steps component
+ */
+interface WizardStepsProps {
+    /** Layout variant */
+    variant?: 'horizontal' | 'vertical';
+    /** Whether to show step descriptions */
+    showDescription?: boolean;
+    /** Whether to show step numbers instead of icons */
+    showNumbers?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * Props for individual Wizard.Step indicator
+ */
+interface WizardStepIndicatorProps {
+    /** Step configuration */
+    step: WizardStepConfig;
+    /** Step index (0-based) */
+    index: number;
+    /** Step state */
+    state: 'completed' | 'current' | 'pending' | 'error' | 'disabled';
+    /** Whether to show step number */
+    showNumber?: boolean;
+    /** Whether to show description */
+    showDescription?: boolean;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Whether step is clickable */
+    isClickable?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+}
+/**
+ * Props for step connector line
+ */
+interface WizardStepConnectorProps {
+    /** Whether the step before this connector is completed */
+    isCompleted?: boolean;
+    /** Layout variant */
+    variant?: 'horizontal' | 'vertical';
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * Props for Wizard.Content component
+ */
+interface WizardContentProps {
+    /** Panel children */
+    children: ReactNode;
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * Props for Wizard.Panel component
+ */
+interface WizardPanelProps {
+    /** Name matching a step's name */
+    name: string;
+    /** Panel content */
+    children: ReactNode;
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * Props for Wizard.Navigation component
+ */
+interface WizardNavigationProps {
+    /** Label for cancel button (default: "Cancelar") */
+    cancelLabel?: string;
+    /** Label for previous button (default: "Voltar") */
+    prevLabel?: string;
+    /** Label for next button (default: "Continuar") */
+    nextLabel?: string;
+    /** Label for submit button (default: "Finalizar") */
+    submitLabel?: string;
+    /** Label shown when loading (default: "Processando...") */
+    loadingLabel?: string;
+    /** Handler for cancel button */
+    onCancel?: () => void;
+    /** Whether to show cancel button (default: true on first step) */
+    showCancel?: boolean;
+    /** Whether submit button is disabled */
+    submitDisabled?: boolean;
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * Props for Wizard.Progress component
+ */
+interface WizardProgressProps {
+    /** Whether to show percentage text */
+    showPercentage?: boolean;
+    /** Whether to show step count (e.g., "2 de 4") */
+    showStepCount?: boolean;
+    /** Additional class name */
+    className?: string;
+}
+/**
+ * Step state type
+ */
+type StepState = 'completed' | 'current' | 'pending' | 'error' | 'disabled';
+
+/**
+ * Visual step indicators component
+ *
+ * Displays the wizard steps with their current states:
+ * - Completed (checkmark, green)
+ * - Current (highlighted, primary)
+ * - Pending (muted)
+ * - Error (red indicator)
+ * - Disabled (grayed out)
+ *
+ * @example
+ * ```tsx
+ * <Wizard.Steps variant="horizontal" showDescription />
+ * ```
+ */
+declare function WizardSteps({ variant, showDescription, showNumbers, size, className, }: WizardStepsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Container for wizard step panels
+ *
+ * Automatically renders only the panel matching the current step
+ *
+ * @example
+ * ```tsx
+ * <Wizard.Content>
+ *   <Wizard.Panel name="step1">Step 1 content</Wizard.Panel>
+ *   <Wizard.Panel name="step2">Step 2 content</Wizard.Panel>
+ * </Wizard.Content>
+ * ```
+ */
+declare function WizardContent({ children, className }: WizardContentProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Individual panel for wizard step content
+ *
+ * The `name` prop must match a step's `name` or `id` in the wizard configuration
+ *
+ * @example
+ * ```tsx
+ * <Wizard.Panel name="personal">
+ *   <Form.Input name="name" label="Nome" required />
+ *   <Form.Input name="email" label="Email" required />
+ * </Wizard.Panel>
+ * ```
+ */
+declare function WizardPanel({ name, children, className }: WizardPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Navigation buttons for the wizard
+ *
+ * Provides:
+ * - Cancel button (first step only by default)
+ * - Previous button
+ * - Next button (type="button" - does NOT submit)
+ * - Submit button (last step only, type="submit")
+ *
+ * @example
+ * ```tsx
+ * <Wizard.Navigation
+ *   cancelLabel="Cancelar"
+ *   prevLabel="Voltar"
+ *   nextLabel="Continuar"
+ *   submitLabel="Finalizar"
+ *   onCancel={() => dialog.close()}
+ * />
+ * ```
+ */
+declare function WizardNavigation({ cancelLabel, prevLabel, nextLabel, submitLabel, loadingLabel, onCancel, showCancel, submitDisabled, className, }: WizardNavigationProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Progress bar component for the wizard
+ *
+ * Displays a visual progress indicator with optional percentage and step count
+ *
+ * @example
+ * ```tsx
+ * <Wizard.Progress showPercentage showStepCount />
+ * ```
+ */
+declare function WizardProgress({ showPercentage, showStepCount, className, }: WizardProgressProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Root Wizard component
+ *
+ * Provides multi-step form functionality with:
+ * - Per-step validation with Zod schemas
+ * - Visual step indicators
+ * - Navigation controls
+ * - Progress tracking
+ *
+ * @example
+ * ```tsx
+ * const form = useForm<FormData>({
+ *   resolver: zodResolver(schema),
+ *   mode: 'onTouched',
+ * });
+ *
+ * <Wizard form={form} steps={steps} onComplete={handleSubmit}>
+ *   <Wizard.Steps />
+ *   <Wizard.Content>
+ *     <Wizard.Panel name="step1">...</Wizard.Panel>
+ *     <Wizard.Panel name="step2">...</Wizard.Panel>
+ *   </Wizard.Content>
+ *   <Wizard.Navigation onCancel={handleClose} />
+ * </Wizard>
+ * ```
+ */
+declare function WizardRoot<T extends FieldValues>({ children, form, steps, initialStep, onStepChange, onComplete, validateOnNext, allowJumpToStep, className, }: WizardProps<T>): react_jsx_runtime.JSX.Element;
+declare const Wizard: typeof WizardRoot & {
+    /** Visual step indicators */
+    Steps: typeof WizardSteps;
+    /** Container for step panels */
+    Content: typeof WizardContent;
+    /** Individual step content panel */
+    Panel: typeof WizardPanel;
+    /** Navigation buttons (prev, next, submit) */
+    Navigation: typeof WizardNavigation;
+    /** Progress bar indicator */
+    Progress: typeof WizardProgress;
+};
+
+/**
+ * Hook to access wizard context
+ * @throws Error if used outside of Wizard component
+ */
+declare function useWizardContext<T extends FieldValues = FieldValues>(): WizardContextValue<T>;
+/**
+ * Optional hook that returns undefined if outside wizard context
+ */
+declare function useWizardContextOptional<T extends FieldValues = FieldValues>(): WizardContextValue<T> | undefined;
+interface WizardProviderProps<T extends FieldValues> extends WizardProps<T> {
+    children: ReactNode;
+}
+/**
+ * Wizard context provider component
+ */
+declare function WizardProvider<T extends FieldValues>({ children, form, steps, initialStep, onStepChange, validateOnNext, allowJumpToStep, }: WizardProviderProps<T>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Individual step indicator component
+ *
+ * Displays a step with:
+ * - Circle with number/icon/checkmark
+ * - Optional label
+ * - Optional description
+ */
+declare function WizardStepIndicator({ step, index, state, showNumber, showDescription, size, isClickable, onClick, }: WizardStepIndicatorProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Connector line between wizard steps
+ *
+ * Changes color based on completion state:
+ * - Completed: primary/green color
+ * - Pending: muted gray
+ */
+declare function WizardStepConnector({ isCompleted, variant, className, }: WizardStepConnectorProps): react_jsx_runtime.JSX.Element;
+
+interface LogoProps {
+    /** Width of the logo (number for px, string for custom units) */
+    width?: number | string;
+    /** Color of the logo (defaults to currentColor for theme compatibility) */
+    color?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+/**
+ * Facter brand logo - SVG component
+ *
+ * The logo uses currentColor by default, so it inherits the text color
+ * from its parent. Use the `color` prop to override, or apply text color
+ * classes via `className`.
+ *
+ * @example
+ * // Basic usage (inherits color from parent)
+ * <Logo width={32} />
+ *
+ * // With explicit color class
+ * <Logo width={32} className="text-primary" />
+ *
+ * // With custom color
+ * <Logo width={32} color="#ffffff" />
+ */
+declare function Logo({ width, color, className, }: LogoProps): react_jsx_runtime.JSX.Element;
+
 type Theme = 'dark' | 'light' | 'system';
 interface ThemeProviderProps {
     children: React$1.ReactNode;
@@ -1257,4 +2288,4 @@ declare const useTheme: () => ThemeProviderState;
  */
 declare function cn(...inputs: ClassValue[]): string;
 
-export { AuthLayout, type AuthLayoutBodyProps, type AuthLayoutContentProps, type AuthLayoutDividerProps, type AuthLayoutFooterProps, type AuthLayoutHeaderProps, type AuthLayoutImageProps, type AuthLayoutLinkProps, type AuthLayoutProps, Badge, type BadgeProps, type BaseFieldProps, Button, type ButtonProps, Checkbox, type CheckboxProps, DENSITY_CONFIG, DashboardLayout, type DashboardLayoutBreadcrumbsProps, type DashboardLayoutContentProps, type DashboardLayoutContextValue, type DashboardLayoutHeaderActionsProps, type DashboardLayoutHeaderProps, type DashboardLayoutHeaderTitleProps, type DashboardLayoutHeaderUserProps, type DashboardLayoutMobileNavItemProps, type DashboardLayoutMobileNavProps, type DashboardLayoutProps, type DashboardLayoutSidebarFooterProps, type DashboardLayoutSidebarHeaderProps, type DashboardLayoutSidebarNavGroupProps, type DashboardLayoutSidebarNavItemProps, type DashboardLayoutSidebarNavProps, type DashboardLayoutSidebarProps, type DashboardLayoutSidebarSectionProps, DataTable, type DataTableBulkActionsProps, type DataTableColumnHeaderProps, type DataTableColumnVisibilityProps, type DataTableContentProps, type DataTableContextValue, type DataTableDensity, type DataTableDensityToggleProps, type DataTableEmptyStateProps, type DataTableExportFormat, type DataTableExportProps, type DataTableFilterOption, type DataTableFilterProps, type DataTableFiltersProps, type DataTableLoadingProps, type DataTableMeta, type DataTablePaginationMode, type DataTablePaginationProps, type DataTableProps, type DataTableRowActionsProps, type DataTableSearchProps, type DataTableState, type DataTableTab, type DataTableTabsProps, type DataTableToolbarProps, Dialog, DialogBody, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DialogWrapper, type DialogWrapperProps, EmptyState, type EmptyStateProps, Form, FormCheckbox, type FormCheckboxProps, type FormContextValue, FormDescription, type FormDescriptionProps, FormError, type FormErrorProps, type FormFieldContextValue, FormFieldProvider, FormFieldWrapper, type FormFieldWrapperProps, FormInput, type FormInputProps, FormLabel, type FormLabelProps, FormProvider, FormRadioGroup, type FormRadioGroupProps, type FormRootProps, FormSelect, type FormSelectProps, FormSwitch, type FormSwitchProps, FormTextarea, type FormTextareaProps, GlobalLoaderController, Input, type InputProps, Loader, type LoaderProps, LoaderProvider, type MaskType, type PaginatedResponse, type PaginationMeta, type PaginationParams, type RadioOption, RippleBackground, type RippleBackgroundProps, RippleEffect, type RippleEffectProps, RippleWrapper, type RippleWrapperProps, Select, SelectGroup, SelectItem, type SelectItemProps, SelectLabel, type SelectOption, type SelectProps, SelectSeparator, SelectionLayout, type SelectionLayoutCardProps, type SelectionLayoutEmptyProps, type SelectionLayoutHeaderProps, type SelectionLayoutHeadlineProps, type SelectionLayoutListProps, type SelectionLayoutLogoProps, type SelectionLayoutMainProps, type SelectionLayoutProps, type SelectionLayoutSearchProps, type SelectionLayoutSidebarProps, type SelectionLayoutStatsProps, type SelectionLayoutTabProps, type SelectionLayoutTabsProps, Switch, type SwitchProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, type TextareaProps, ThemeProvider, Toaster, type ToasterProps, type UseDataTableConfig, cn, loader, toast, useDashboardLayout, useDataTable, useDataTableColumnVisibility, useDataTableDensity, useDataTableEmpty, useDataTableInstance, useDataTableLoading, useDataTableMeta, useDataTablePagination, useDataTableSelection, useDataTableSorting, useDataTableState, useDebounce, useDebouncedCallback, useFormContext, useFormFieldContext, useLoader, useTheme };
+export { AuthLayout, type AuthLayoutBodyProps, type AuthLayoutContentProps, type AuthLayoutDividerProps, type AuthLayoutFooterProps, type AuthLayoutHeaderProps, type AuthLayoutImageProps, type AuthLayoutLinkProps, type AuthLayoutProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, Badge, type BadgeProps, type BadgeVariant, type BaseFieldProps, BigNumberCard, type BigNumberCardContentProps, type BigNumberCardHeaderProps, type BigNumberCardLinkProps, type BigNumberCardRootProps, type BigNumberCardSize, type BigNumberCardSparklineProps, type BigNumberCardTitleProps, type BigNumberCardTrendProps, type BigNumberCardValueProps, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, type ButtonProps, Card, CardContent, type CardContentProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Checkbox, type CheckboxProps, type Company, DENSITY_CONFIG, DashboardLayout, type DashboardLayoutBreadcrumbsProps, type DashboardLayoutContentProps, type DashboardLayoutContextValue, type DashboardLayoutHeaderActionsProps, type DashboardLayoutHeaderProps, type DashboardLayoutHeaderTitleProps, type DashboardLayoutHeaderUserProps, type DashboardLayoutMobileNavItemProps, type DashboardLayoutMobileNavProps, type DashboardLayoutProps, type DashboardLayoutSidebarFooterProps, type DashboardLayoutSidebarHeaderProps, type DashboardLayoutSidebarNavGroupProps, type DashboardLayoutSidebarNavItemProps, type DashboardLayoutSidebarNavProps, type DashboardLayoutSidebarProps, type DashboardLayoutSidebarSectionProps, DataTable, type DataTableBulkActionsProps, type DataTableColumnHeaderProps, type DataTableColumnVisibilityProps, type DataTableContentProps, type DataTableContextValue, type DataTableDensity, type DataTableDensityToggleProps, type DataTableEmptyStateProps, type DataTableExportFormat, type DataTableExportProps, type DataTableFilterOption, type DataTableFilterProps, type DataTableFiltersProps, type DataTableLoadingProps, type DataTableMeta, type DataTablePaginationMode, type DataTablePaginationProps, type DataTableProps, type DataTableRowActionsProps, type DataTableSearchProps, type DataTableState, type DataTableTab, type DataTableTabsProps, type DataTableToolbarProps, Dialog, DialogBody, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DialogWrapper, type DialogWrapperProps, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, type EmptyStateProps, Form, FormCheckbox, type FormCheckboxProps, type FormContextValue, FormDescription, type FormDescriptionProps, FormError, type FormErrorProps, type FormFieldContextValue, FormFieldProvider, FormFieldWrapper, type FormFieldWrapperProps, FormInput, type FormInputProps, FormLabel, type FormLabelProps, FormProvider, FormRadioGroup, type FormRadioGroupProps, type FormRootProps, FormSelect, type FormSelectProps, FormSwitch, type FormSwitchProps, FormTextarea, type FormTextareaProps, GlobalLoaderController, Input, type InputProps, Kanban, type KanbanBoardProps, type KanbanCardProps, type KanbanColumnConfig, type KanbanColumnProps, type KanbanContextValue, type KanbanDragResult, type KanbanEmptyProps, type KanbanItem, Loader, type LoaderProps, LoaderProvider, Logo, type LogoProps, type MaskType, MobileNav, type MobileNavFabAction, MobileNavItem, type MobileNavItemConfig, type MobileNavItemProps, type MobileNavProps, Navbar, NavbarCompanyProfile, type NavbarCompanyProfileProps, NavbarNotification, type NavbarNotificationProps, type NavbarProps, NavbarUserMenu, type NavbarUserMenuProps, type NotificationItem, type PaginatedResponse, type PaginationMeta, type PaginationParams, Popover, PopoverContent, PopoverTrigger, type RadioOption, RippleBackground, type RippleBackgroundProps, RippleEffect, type RippleEffectProps, RippleWrapper, type RippleWrapperProps, ScrollArea, ScrollBar, SectionHeader, SectionHeaderActions, type SectionHeaderActionsProps, SectionHeaderBadge, type SectionHeaderBadgeProps, SectionHeaderContent, type SectionHeaderContentProps, SectionHeaderIcon, type SectionHeaderIconProps, SectionHeaderRoot, type SectionHeaderRootProps, SectionHeaderSubtitle, type SectionHeaderSubtitleProps, SectionHeaderTitle, type SectionHeaderTitleProps, Select, SelectGroup, SelectItem, type SelectItemProps, SelectLabel, type SelectOption, type SelectProps, SelectSeparator, SelectionLayout, type SelectionLayoutCardProps, type SelectionLayoutEmptyProps, type SelectionLayoutHeaderProps, type SelectionLayoutHeadlineProps, type SelectionLayoutListProps, type SelectionLayoutLogoProps, type SelectionLayoutMainProps, type SelectionLayoutProps, type SelectionLayoutSearchProps, type SelectionLayoutSidebarProps, type SelectionLayoutStatsProps, type SelectionLayoutTabProps, type SelectionLayoutTabsProps, Separator, Sidebar, type SidebarContextValue, type SidebarFooterMenuItem, type SidebarFooterProps, type SidebarFooterUser, type SidebarHeaderProps, type SidebarNavGroupProps, type SidebarNavItemProps, type SidebarNavProps, type SidebarProps, type SidebarSectionProps, Skeleton, type SkeletonProps, Sparkline, type SparklineColor, type StepState, Switch, type SwitchProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, type TextareaProps, ThemeProvider, ThemeToggle, type ThemeToggleProps, Toaster, type ToasterProps, type UseDataTableConfig, type UserMenuItemConfig, type ValidationSchema, Wizard, WizardContent, type WizardContentProps, type WizardContextValue, WizardNavigation, type WizardNavigationProps, WizardPanel, type WizardPanelProps, WizardProgress, type WizardProgressProps, type WizardProps, WizardProvider, type WizardStepConfig, WizardStepConnector, type WizardStepConnectorProps, WizardStepIndicator, type WizardStepIndicatorProps, WizardSteps, type WizardStepsProps, cn, loader, toast, useDashboardLayout, useDataTable, useDataTableColumnVisibility, useDataTableDensity, useDataTableEmpty, useDataTableInstance, useDataTableLoading, useDataTableMeta, useDataTablePagination, useDataTableSelection, useDataTableSorting, useDataTableState, useDebounce, useDebouncedCallback, useFormContext, useFormFieldContext, useKanban, useKanbanOptional, useLoader, useMediaQuery, useSidebar, useSidebarOptional, useTheme, useWizardContext, useWizardContextOptional };