@hxdhxd/harmony-flow-ui 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1496 @@
+import * as react from 'react';
+import { CSSProperties, PropsWithChildren, HTMLAttributes, ButtonHTMLAttributes, ReactNode, InputHTMLAttributes, AnchorHTMLAttributes, ReactElement, SVGAttributes, SelectHTMLAttributes, FormEvent, TextareaHTMLAttributes, FormHTMLAttributes } from 'react';
+
+interface ThemeTokens {
+    colorPrimary: string;
+    colorPrimaryHover: string;
+    colorBackground: string;
+    colorSurface: string;
+    colorText: string;
+    colorTextMuted: string;
+    colorBorder: string;
+    radiusMd: string;
+    radiusLg: string;
+    shadowElevated: string;
+    motionDuration: string;
+}
+declare const defaultTheme: ThemeTokens;
+declare const darkTheme: ThemeTokens;
+declare const highContrastTheme: ThemeTokens;
+declare function tokensToStyle(tokens: Partial<ThemeTokens>): CSSProperties;
+
+interface ThemeProviderProps extends HTMLAttributes<HTMLDivElement> {
+    tokens?: Partial<ThemeTokens>;
+    mode?: 'light' | 'dark' | 'high-contrast';
+}
+declare function ThemeProvider({ children, tokens, mode, className, style, ...props }: PropsWithChildren<ThemeProviderProps>): react.JSX.Element;
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'primary' | 'secondary' | 'outline' | 'quiet' | 'danger';
+    size?: 'sm' | 'md' | 'lg';
+    shape?: 'rounded' | 'pill' | 'square';
+    fullWidth?: boolean;
+    loading?: boolean;
+    leadingIcon?: ReactNode;
+    trailingIcon?: ReactNode;
+    iconOnly?: boolean;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface SplitButtonOption {
+    key: string;
+    label: ReactNode;
+    disabled?: boolean;
+    danger?: boolean;
+}
+interface SplitButtonProps extends Pick<ButtonProps, 'variant' | 'size' | 'disabled'> {
+    label: ReactNode;
+    options: readonly SplitButtonOption[];
+    onPrimaryAction: () => void;
+    onOptionSelect: (key: string) => void;
+}
+declare function SplitButton({ label, options, onPrimaryAction, onOptionSelect, variant, size, disabled }: SplitButtonProps): react.JSX.Element;
+
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'prefix'> {
+    label?: string;
+    hint?: string;
+    error?: string;
+    prefix?: ReactNode;
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    label: string;
+}
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;
+
+interface SegmentOption<T extends string> {
+    label: string;
+    value: T;
+}
+interface SegmentedControlProps<T extends string> {
+    label: string;
+    options: readonly SegmentOption<T>[];
+    value: T;
+    onChange: (value: T) => void;
+    className?: string;
+}
+declare function SegmentedControl<T extends string>({ label, options, value, onChange, className }: SegmentedControlProps<T>): react.JSX.Element;
+
+interface CardProps extends HTMLAttributes<HTMLElement> {
+    title?: string;
+    eyebrow?: string;
+    action?: ReactNode;
+    interactive?: boolean;
+}
+declare function Card({ children, title, eyebrow, action, interactive, className, ...props }: PropsWithChildren<CardProps>): react.JSX.Element;
+
+interface ModalProps {
+    open: boolean;
+    title: string;
+    children: ReactNode;
+    onClose: () => void;
+    footer?: ReactNode;
+}
+declare function Modal({ open, title, children, onClose, footer }: PropsWithChildren<ModalProps>): react.ReactPortal | null;
+
+interface ToastProps {
+    open: boolean;
+    message: string;
+    tone?: 'success' | 'info' | 'error';
+    duration?: number;
+    onClose: () => void;
+}
+declare function Toast({ open, message, tone, duration, onClose }: ToastProps): react.ReactPortal | null;
+
+declare function Divider({ orientation, label, className }: {
+    orientation?: 'horizontal' | 'vertical';
+    label?: ReactNode;
+    className?: string;
+}): react.JSX.Element;
+declare function Link({ external, className, children, ...props }: AnchorHTMLAttributes<HTMLAnchorElement> & {
+    external?: boolean;
+}): react.JSX.Element;
+type Tone = 'neutral' | 'primary' | 'success' | 'warning' | 'danger';
+declare function Badge({ tone, dot, className, ...props }: HTMLAttributes<HTMLSpanElement> & {
+    tone?: Tone;
+    dot?: boolean;
+}): react.JSX.Element;
+declare function Tag({ tone, onRemove, removeLabel, className, children, ...props }: HTMLAttributes<HTMLSpanElement> & {
+    tone?: Tone;
+    onRemove?: () => void;
+    removeLabel?: string;
+}): react.JSX.Element;
+declare function Avatar({ src, name, alt, size, status, className }: {
+    src?: string;
+    name: string;
+    alt?: string;
+    size?: 'sm' | 'md' | 'lg';
+    status?: 'online' | 'busy' | 'away';
+    className?: string;
+}): react.JSX.Element;
+
+interface AccordionItem {
+    key: string;
+    title: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+}
+interface AccordionProps {
+    items: readonly AccordionItem[];
+    value?: readonly string[];
+    defaultValue?: readonly string[];
+    onChange?: (keys: string[]) => void;
+    multiple?: boolean;
+}
+declare function Accordion({ items, value, defaultValue, onChange, multiple }: AccordionProps): react.JSX.Element;
+
+interface DropdownItem {
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    danger?: boolean;
+    separatorBefore?: boolean;
+}
+interface DropdownProps {
+    trigger: ReactElement;
+    items: readonly DropdownItem[];
+    onSelect: (key: string) => void;
+    placement?: 'left' | 'right';
+    label?: string;
+}
+declare function Dropdown({ trigger, items, onSelect, placement, label }: DropdownProps): react.JSX.Element;
+
+interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    label: string;
+    icon: ReactNode;
+    variant?: 'primary' | 'secondary' | 'quiet' | 'danger';
+    size?: 'sm' | 'md' | 'lg';
+}
+declare const IconButton: react.ForwardRefExoticComponent<IconButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare function ButtonGroup({ children, orientation, attached, className, ...props }: PropsWithChildren<HTMLAttributes<HTMLDivElement> & {
+    orientation?: 'horizontal' | 'vertical';
+    attached?: boolean;
+}>): react.JSX.Element;
+interface ColorPickerProps {
+    value: string;
+    onChange: (value: string) => void;
+    label?: string;
+    presets?: readonly string[];
+    disabled?: boolean;
+}
+declare function ColorPicker({ value, onChange, label, presets, disabled }: ColorPickerProps): react.JSX.Element;
+interface ContextMenuProps {
+    items: readonly DropdownItem[];
+    onSelect: (key: string) => void;
+    label?: string;
+}
+declare function ContextMenu({ items, onSelect, label, children }: PropsWithChildren<ContextMenuProps>): react.JSX.Element;
+
+interface RichTextEditorProps {
+    value: string;
+    onChange: (html: string) => void;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+}
+declare function RichTextEditor({ value, onChange, label, placeholder, disabled }: RichTextEditorProps): react.JSX.Element;
+interface MentionOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+interface MentionInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    options: readonly MentionOption[];
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+}
+declare function MentionInput({ value, onChange, options, label, placeholder, disabled }: MentionInputProps): react.JSX.Element;
+interface CodeEditorProps {
+    value: string;
+    onChange: (value: string) => void;
+    language?: string;
+    label?: string;
+    readOnly?: boolean;
+    height?: number;
+}
+declare function CodeEditor({ value, onChange, language, label, readOnly, height }: CodeEditorProps): react.JSX.Element;
+
+interface ChatMessageProps {
+    role: 'user' | 'assistant' | 'system';
+    children: ReactNode;
+    avatar?: ReactNode;
+    name?: ReactNode;
+    timestamp?: ReactNode;
+    actions?: ReactNode;
+    streaming?: boolean;
+    error?: ReactNode;
+}
+declare function ChatMessage({ role, children, avatar, name, timestamp, actions, streaming, error }: ChatMessageProps): react.JSX.Element;
+interface ChatAttachment {
+    id: string;
+    name: string;
+    size?: string;
+    icon?: ReactNode;
+}
+interface ChatComposerProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSend: (value: string) => void;
+    attachments?: readonly ChatAttachment[];
+    onRemoveAttachment?: (id: string) => void;
+    onAttach?: () => void;
+    placeholder?: string;
+    disabled?: boolean;
+    sending?: boolean;
+    footer?: ReactNode;
+    maxLength?: number;
+}
+declare function ChatComposer({ value, onChange, onSend, attachments, onRemoveAttachment, onAttach, placeholder, disabled, sending, footer, maxLength }: ChatComposerProps): react.JSX.Element;
+interface PromptSuggestion {
+    id: string;
+    title: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    prompt?: string;
+}
+interface PromptSuggestionsProps {
+    items: readonly PromptSuggestion[];
+    onSelect: (item: PromptSuggestion) => void;
+    title?: ReactNode;
+    columns?: 1 | 2 | 3;
+}
+declare function PromptSuggestions({ items, onSelect, title, columns }: PromptSuggestionsProps): react.JSX.Element;
+type ToolCallStatus = 'queued' | 'running' | 'success' | 'error' | 'cancelled';
+interface ToolCallCardProps {
+    name: ReactNode;
+    status: ToolCallStatus;
+    description?: ReactNode;
+    input?: ReactNode;
+    output?: ReactNode;
+    duration?: ReactNode;
+    icon?: ReactNode;
+    defaultExpanded?: boolean;
+    onRetry?: () => void;
+    onCancel?: () => void;
+}
+declare function ToolCallCard({ name, status, description, input, output, duration, icon, defaultExpanded, onRetry, onCancel }: ToolCallCardProps): react.JSX.Element;
+interface CitationItem {
+    id: string;
+    title: ReactNode;
+    url?: string;
+    source?: ReactNode;
+    excerpt?: ReactNode;
+    favicon?: ReactNode;
+}
+interface CitationListProps {
+    items: readonly CitationItem[];
+    title?: ReactNode;
+    onSelect?: (item: CitationItem) => void;
+}
+declare function CitationList({ items, title, onSelect }: CitationListProps): react.JSX.Element;
+type AgentRunStatus = ToolCallStatus;
+interface AgentRunStep {
+    id: string;
+    title: ReactNode;
+    status: AgentRunStatus;
+    description?: ReactNode;
+    timestamp?: ReactNode;
+    detail?: ReactNode;
+}
+interface AgentRunTimelineProps {
+    steps: readonly AgentRunStep[];
+    activeId?: string;
+    onSelect?: (id: string) => void;
+    label?: string;
+}
+declare function AgentRunTimeline({ steps, activeId, onSelect, label }: AgentRunTimelineProps): react.JSX.Element;
+
+interface MarkdownContentProps {
+    content: string;
+    className?: string;
+}
+declare function MarkdownContent({ content, className }: MarkdownContentProps): react.JSX.Element;
+interface CodeBlockProps {
+    code: string;
+    language?: string;
+    filename?: ReactNode;
+    wrap?: boolean;
+    showLineNumbers?: boolean;
+    onCopy?: (code: string) => void;
+}
+declare function CodeBlock({ code, language, filename, wrap, showLineNumbers, onCopy }: CodeBlockProps): react.JSX.Element;
+interface VoiceInputProps {
+    state?: 'idle' | 'listening' | 'processing' | 'error';
+    duration?: string;
+    level?: number;
+    disabled?: boolean;
+    onStart?: () => void;
+    onStop?: () => void;
+    onCancel?: () => void;
+    error?: ReactNode;
+}
+declare function VoiceInput({ state, duration, level, disabled, onStart, onStop, onCancel, error }: VoiceInputProps): react.JSX.Element;
+interface ModelOption {
+    id: string;
+    name: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    tags?: readonly string[];
+    disabled?: boolean;
+}
+interface ModelSelectorProps {
+    models: readonly ModelOption[];
+    value: string;
+    onChange: (id: string) => void;
+    label?: string;
+    disabled?: boolean;
+}
+declare function ModelSelector({ models, value, onChange, label, disabled }: ModelSelectorProps): react.JSX.Element;
+interface ConversationBranchProps {
+    current: number;
+    total: number;
+    onChange: (index: number) => void;
+    label?: ReactNode;
+}
+declare function ConversationBranch({ current, total, onChange, label }: ConversationBranchProps): react.JSX.Element;
+interface TokenUsageProps {
+    used: number;
+    limit: number;
+    input?: number;
+    output?: number;
+    cached?: number;
+    label?: ReactNode;
+    compact?: boolean;
+}
+declare function TokenUsage({ used, limit, input, output, cached, label, compact }: TokenUsageProps): react.JSX.Element;
+
+type PresenceStatus = 'online' | 'away' | 'busy' | 'offline';
+interface PresenceProps {
+    status: PresenceStatus;
+    label?: ReactNode;
+    showLabel?: boolean;
+    pulse?: boolean;
+}
+declare function Presence({ status, label, showLabel, pulse }: PresenceProps): react.JSX.Element;
+interface AvatarGroupItem {
+    id: string;
+    name: string;
+    src?: string;
+    status?: Exclude<PresenceStatus, 'offline'>;
+}
+interface AvatarGroupProps {
+    items: readonly AvatarGroupItem[];
+    max?: number;
+    size?: 'sm' | 'md' | 'lg';
+    onMore?: () => void;
+    label?: string;
+}
+declare function AvatarGroup({ items, max, size, onMore, label }: AvatarGroupProps): react.JSX.Element;
+interface CommentItem {
+    id: string;
+    author: {
+        name: string;
+        avatar?: string;
+    };
+    content: ReactNode;
+    timestamp?: ReactNode;
+    edited?: boolean;
+    reactions?: readonly {
+        emoji: string;
+        count: number;
+        active?: boolean;
+    }[];
+    replies?: readonly CommentItem[];
+}
+interface CommentThreadProps {
+    comments: readonly CommentItem[];
+    onReply?: (id: string, content: string) => void;
+    onReact?: (id: string, emoji: string) => void;
+    onDelete?: (id: string) => void;
+    empty?: ReactNode;
+}
+declare function CommentThread({ comments, onReply, onReact, onDelete, empty }: CommentThreadProps): react.JSX.Element;
+interface ActivityItem {
+    id: string;
+    actor: ReactNode;
+    action: ReactNode;
+    target?: ReactNode;
+    timestamp?: ReactNode;
+    avatar?: ReactNode;
+    icon?: ReactNode;
+    detail?: ReactNode;
+}
+interface ActivityFeedProps {
+    items: readonly ActivityItem[];
+    grouped?: boolean;
+    empty?: ReactNode;
+}
+declare function ActivityFeed({ items, grouped, empty }: ActivityFeedProps): react.JSX.Element;
+type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'skipped';
+interface ApprovalStep {
+    id: string;
+    title: ReactNode;
+    approver?: ReactNode;
+    status: ApprovalStatus;
+    timestamp?: ReactNode;
+    comment?: ReactNode;
+}
+interface ApprovalFlowProps {
+    steps: readonly ApprovalStep[];
+    currentId?: string;
+    onApprove?: (id: string) => void;
+    onReject?: (id: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+}
+declare function ApprovalFlow({ steps, currentId, onApprove, onReject, orientation }: ApprovalFlowProps): react.JSX.Element;
+interface AuditEvent {
+    id: string;
+    timestamp: ReactNode;
+    actor: ReactNode;
+    action: ReactNode;
+    resource?: ReactNode;
+    result?: 'success' | 'failure' | 'warning';
+    ip?: ReactNode;
+    detail?: ReactNode;
+}
+interface AuditLogProps {
+    events: readonly AuditEvent[];
+    onSelect?: (id: string) => void;
+    empty?: ReactNode;
+    caption?: string;
+}
+declare function AuditLog({ events, onSelect, empty, caption }: AuditLogProps): react.JSX.Element;
+
+interface FileItem {
+    id: string;
+    name: ReactNode;
+    type: 'folder' | 'file';
+    children?: readonly FileItem[];
+    size?: ReactNode;
+    modified?: ReactNode;
+    icon?: ReactNode;
+}
+declare function FileExplorer({ items, selectedId, onSelect, empty }: {
+    items: readonly FileItem[];
+    selectedId?: string;
+    onSelect?: (id: string) => void;
+    empty?: ReactNode;
+}): react.JSX.Element;
+declare function FilePreview({ name, type, children, size, modified, actions, empty }: {
+    name?: ReactNode;
+    type?: string;
+    children?: ReactNode;
+    size?: ReactNode;
+    modified?: ReactNode;
+    actions?: ReactNode;
+    empty?: ReactNode;
+}): react.JSX.Element;
+interface VersionItem {
+    id: string;
+    version: string;
+    author: {
+        name: string;
+        avatar?: string;
+    };
+    timestamp: ReactNode;
+    description?: ReactNode;
+    current?: boolean;
+    tags?: readonly string[];
+}
+declare function VersionHistory({ versions, selectedId, onSelect, onRestore }: {
+    versions: readonly VersionItem[];
+    selectedId?: string;
+    onSelect?: (id: string) => void;
+    onRestore?: (id: string) => void;
+}): react.JSX.Element;
+type PermissionLevel = 'none' | 'view' | 'comment' | 'edit' | 'admin';
+interface PermissionSubject {
+    id: string;
+    name: ReactNode;
+    description?: ReactNode;
+    avatar?: ReactNode;
+}
+interface PermissionResource {
+    id: string;
+    name: ReactNode;
+}
+declare function PermissionMatrix({ subjects, resources, value, onChange, disabled }: {
+    subjects: readonly PermissionSubject[];
+    resources: readonly PermissionResource[];
+    value: Readonly<Record<string, Readonly<Record<string, PermissionLevel>>>>;
+    onChange: (subjectId: string, resourceId: string, level: PermissionLevel) => void;
+    disabled?: boolean;
+}): react.JSX.Element;
+interface MemberOption {
+    id: string;
+    name: string;
+    avatar?: string;
+    description?: ReactNode;
+}
+declare function MemberPicker({ members, value, onChange, label, disabled }: {
+    members: readonly MemberOption[];
+    value: readonly string[];
+    onChange: (ids: string[]) => void;
+    label?: string;
+    disabled?: boolean;
+}): react.JSX.Element;
+type ShareScope = 'restricted' | 'organization' | 'public';
+declare function SharePanel({ scope, onScopeChange, members, onCopyLink, linkCopied, footer }: {
+    scope: ShareScope;
+    onScopeChange: (scope: ShareScope) => void;
+    members?: ReactNode;
+    onCopyLink?: () => void;
+    linkCopied?: boolean;
+    footer?: ReactNode;
+}): react.JSX.Element;
+
+interface ScheduleEvent {
+    id: string;
+    title: ReactNode;
+    start: string;
+    end: string;
+    color?: string;
+    resourceId?: string;
+}
+declare function EventCard({ event, onClick, }: {
+    event: ScheduleEvent;
+    onClick?: (id: string) => void;
+}): react.JSX.Element;
+declare function Scheduler({ days, events, onEventClick, }: {
+    days: readonly string[];
+    events: readonly ScheduleEvent[];
+    onEventClick?: (id: string) => void;
+}): react.JSX.Element;
+interface CalendarResource {
+    id: string;
+    name: ReactNode;
+}
+declare function ResourceCalendar({ resources, events, }: {
+    resources: readonly CalendarResource[];
+    events: readonly ScheduleEvent[];
+}): react.JSX.Element;
+interface RecurrenceValue {
+    frequency: "none" | "daily" | "weekly" | "monthly";
+    interval: number;
+    end?: string;
+}
+declare function RecurrenceEditor({ value, onChange, }: {
+    value: RecurrenceValue;
+    onChange: (v: RecurrenceValue) => void;
+}): react.JSX.Element;
+interface TimezoneOption {
+    value: string;
+    label: string;
+    offset: string;
+}
+declare function TimezoneSelect({ options, value, onChange, }: {
+    options: readonly TimezoneOption[];
+    value: string;
+    onChange: (v: string) => void;
+}): react.JSX.Element;
+type AvailabilityState = "available" | "busy" | "tentative" | "unavailable";
+declare function AvailabilityGrid({ people, slots, value, }: {
+    people: readonly {
+        id: string;
+        name: ReactNode;
+    }[];
+    slots: readonly string[];
+    value: Readonly<Record<string, Readonly<Record<string, AvailabilityState>>>>;
+}): react.JSX.Element;
+
+type IconName = 'check' | 'close' | 'info' | 'warning' | 'error' | 'search' | 'chevron-down' | 'arrow-right' | 'user' | 'inbox';
+interface IconProps extends Omit<SVGAttributes<SVGSVGElement>, 'children'> {
+    name: IconName;
+    size?: number;
+    label?: string;
+}
+declare function Icon({ name, size, label, className, ...props }: IconProps): react.JSX.Element;
+
+type TypographyVariant = 'display' | 'h1' | 'h2' | 'h3' | 'body' | 'body-sm' | 'caption' | 'code';
+interface TypographyProps extends HTMLAttributes<HTMLElement> {
+    as?: 'h1' | 'h2' | 'h3' | 'h4' | 'p' | 'span' | 'code';
+    variant?: TypographyVariant;
+    muted?: boolean;
+    truncate?: boolean;
+}
+declare function Typography({ as, variant, muted, truncate, className, ...props }: TypographyProps): react.JSX.Element;
+
+interface NavigationItem {
+    key: string;
+    label: string;
+    href?: string;
+    icon?: ReactNode;
+    description?: string;
+    children?: readonly NavigationItem[];
+}
+interface NavigationSelectionProps {
+    activeKey?: string;
+    onItemSelect?: (item: NavigationItem) => void;
+}
+declare function activateNavigationItem(item: NavigationItem, onItemSelect?: (item: NavigationItem) => void): void;
+
+interface FloatingNavProps extends HTMLAttributes<HTMLElement>, NavigationSelectionProps {
+    brand: ReactNode;
+    items: readonly NavigationItem[];
+    action?: ReactNode;
+}
+declare function FloatingNav({ brand, items, action, activeKey, onItemSelect, className, ...props }: FloatingNavProps): react.JSX.Element;
+
+interface SidebarProps extends HTMLAttributes<HTMLElement>, NavigationSelectionProps {
+    brand?: ReactNode;
+    items: readonly NavigationItem[];
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    appearance?: 'flush' | 'floating' | 'inset';
+}
+declare function Sidebar({ brand, items, activeKey, collapsed, defaultCollapsed, onCollapsedChange, onItemSelect, appearance, className, ...props }: SidebarProps): react.JSX.Element;
+
+interface BreadcrumbProps extends HTMLAttributes<HTMLElement>, NavigationSelectionProps {
+    items: readonly NavigationItem[];
+    separator?: string;
+}
+declare function Breadcrumb({ items, separator, onItemSelect, className, ...props }: BreadcrumbProps): react.JSX.Element;
+
+interface BaseMenuProps extends HTMLAttributes<HTMLDivElement>, NavigationSelectionProps {
+    label: string;
+    items: readonly NavigationItem[];
+}
+declare function DropdownMenu({ label, items, activeKey, onItemSelect, className, ...props }: BaseMenuProps): react.JSX.Element;
+declare function MegaMenu({ label, items, onItemSelect, className, ...props }: BaseMenuProps): react.JSX.Element;
+
+interface MobileNavigationProps extends HTMLAttributes<HTMLDivElement>, NavigationSelectionProps {
+    brand: ReactNode;
+    items: readonly NavigationItem[];
+    mode?: 'drawer' | 'fullscreen';
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function MobileNavigation({ brand, items, mode, activeKey, open, onOpenChange, onItemSelect, className, ...props }: MobileNavigationProps): react.JSX.Element;
+
+interface ScrollspyProps extends HTMLAttributes<HTMLElement>, NavigationSelectionProps {
+    items: readonly NavigationItem[];
+    rootMargin?: string;
+}
+declare function Scrollspy({ items, activeKey, onItemSelect, rootMargin, className, ...props }: ScrollspyProps): react.JSX.Element;
+
+interface ShrinkNavProps extends HTMLAttributes<HTMLElement>, NavigationSelectionProps {
+    brand: ReactNode;
+    items: readonly NavigationItem[];
+    threshold?: number;
+    action?: ReactNode;
+}
+declare function ShrinkNav({ brand, items, threshold, action, activeKey, onItemSelect, className, ...props }: ShrinkNavProps): react.JSX.Element;
+
+interface TabItem<T extends string = string> {
+    key: T;
+    label: ReactNode;
+    content: ReactNode;
+    badge?: ReactNode;
+    disabled?: boolean;
+    icon?: ReactNode;
+}
+interface TabsProps<T extends string = string> {
+    items: readonly TabItem<T>[];
+    value: T;
+    onChange: (value: T) => void;
+    variant?: 'line' | 'card' | 'pill' | 'underline' | 'vertical' | 'scroll';
+    label?: string;
+}
+declare function Tabs<T extends string>({ items, value, onChange, variant, label }: TabsProps<T>): react.JSX.Element;
+
+interface StepItem {
+    key: string;
+    title: ReactNode;
+    description?: ReactNode;
+    disabled?: boolean;
+    optional?: boolean;
+}
+interface StepsProps {
+    items: readonly StepItem[];
+    current: string;
+    onChange?: (key: string) => void;
+    orientation?: 'horizontal' | 'vertical';
+}
+declare function Steps({ items, current, onChange, orientation }: StepsProps): react.JSX.Element;
+
+interface CommandItem {
+    key: string;
+    label: string;
+    description?: string;
+    group?: string;
+    shortcut?: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+interface CommandPaletteProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    items: readonly CommandItem[];
+    onSelect: (key: string) => void;
+    placeholder?: string;
+}
+declare function CommandPalette({ open, onOpenChange, items, onSelect, placeholder }: CommandPaletteProps): react.ReactPortal | null;
+
+interface GridProps extends HTMLAttributes<HTMLDivElement> {
+    columns?: number | 'auto';
+    minItemWidth?: number;
+    gap?: number;
+}
+interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg' | 'full';
+    padding?: number;
+}
+declare function Container({ size, padding, className, style, ...props }: PropsWithChildren<ContainerProps>): react.JSX.Element;
+interface StackProps extends HTMLAttributes<HTMLDivElement> {
+    direction?: 'row' | 'column';
+    gap?: number;
+    align?: CSSProperties['alignItems'];
+    justify?: CSSProperties['justifyContent'];
+    wrap?: boolean;
+}
+declare function Stack({ direction, gap, align, justify, wrap, className, style, ...props }: PropsWithChildren<StackProps>): react.JSX.Element;
+declare function Grid({ columns, minItemWidth, gap, className, style, ...props }: PropsWithChildren<GridProps>): react.JSX.Element;
+interface MasonryProps extends HTMLAttributes<HTMLDivElement> {
+    columns?: number;
+    minColumnWidth?: number;
+    gap?: number;
+}
+declare function Masonry({ columns, minColumnWidth, gap, className, style, children, ...props }: PropsWithChildren<MasonryProps>): react.JSX.Element;
+interface PageLayoutProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: 'single' | 'sidebar-left' | 'sidebar-right' | 'split' | 'dashboard' | 'full-screen';
+    sidebar?: ReactNode;
+    header?: ReactNode;
+    sidebarWidth?: number;
+}
+declare function PageLayout({ variant, sidebar, header, sidebarWidth, className, style, children, ...props }: PropsWithChildren<PageLayoutProps>): react.JSX.Element;
+
+interface SkeletonProps extends HTMLAttributes<HTMLSpanElement> {
+    width?: number | string;
+    height?: number | string;
+    radius?: number | string;
+    circle?: boolean;
+    animated?: boolean;
+}
+declare function Skeleton({ width, height, radius, circle, animated, className, style, ...props }: SkeletonProps): react.JSX.Element;
+
+declare function Spinner({ label, size, className }: {
+    label?: string;
+    size?: number;
+    className?: string;
+}): react.JSX.Element;
+declare function LoadingDots({ label }: {
+    label?: string;
+}): react.JSX.Element;
+declare function ProgressBar({ value, label, indeterminate, className }: {
+    value?: number;
+    label?: ReactNode;
+    indeterminate?: boolean;
+    className?: string;
+}): react.JSX.Element;
+declare function ProgressRing({ value, size, label }: {
+    value: number;
+    size?: number;
+    label?: string;
+}): react.JSX.Element;
+interface LoadingOverlayProps extends HTMLAttributes<HTMLDivElement> {
+    active?: boolean;
+    label?: string;
+}
+declare function LoadingOverlay({ active, label, className, children, ...props }: PropsWithChildren<LoadingOverlayProps>): react.JSX.Element;
+
+interface SelectOption {
+    label: ReactNode;
+    value: string;
+    disabled?: boolean;
+}
+interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'children'> {
+    label?: string;
+    hint?: string;
+    error?: string;
+    options: readonly SelectOption[];
+    placeholder?: string;
+}
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLSelectElement>>;
+
+interface MultiSelectProps {
+    label?: string;
+    options: readonly SelectOption[];
+    value: readonly string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    max?: number;
+    hint?: ReactNode;
+    disabled?: boolean;
+}
+declare function MultiSelect({ label, options, value, onChange, placeholder, max, hint, disabled }: MultiSelectProps): react.JSX.Element;
+
+interface ChoiceOption<T extends string = string> {
+    label: ReactNode;
+    value: T;
+    description?: ReactNode;
+    disabled?: boolean;
+}
+interface ChoiceGroupProps<T extends string> {
+    label?: string;
+    options: readonly ChoiceOption<T>[];
+    value?: T | T[];
+    defaultValue?: T | T[];
+    onChange?: (value: T | T[]) => void;
+    type?: 'radio' | 'checkbox';
+    direction?: 'row' | 'column';
+    disabled?: boolean;
+    name?: string;
+}
+declare function ChoiceGroup<T extends string>({ label, options, value, defaultValue, onChange, type, direction, disabled, name }: ChoiceGroupProps<T>): react.JSX.Element;
+declare function RadioGroup<T extends string>(props: Omit<ChoiceGroupProps<T>, 'type' | 'value' | 'defaultValue' | 'onChange'> & {
+    value?: T;
+    defaultValue?: T;
+    onChange?: (value: T) => void;
+}): react.JSX.Element;
+declare function CheckboxGroup<T extends string>(props: Omit<ChoiceGroupProps<T>, 'type' | 'value' | 'defaultValue' | 'onChange'> & {
+    value?: T[];
+    defaultValue?: T[];
+    onChange?: (value: T[]) => void;
+}): react.JSX.Element;
+
+interface ValidationRule {
+    validate: (value: string) => boolean;
+    message: string;
+}
+interface ValidatedInputProps extends Omit<InputProps, 'error' | 'onChange' | 'onBlur'> {
+    value: string;
+    rules: readonly ValidationRule[];
+    validateOn?: 'blur' | 'change';
+    onChange: (value: string) => void;
+    onValidityChange?: (valid: boolean) => void;
+}
+declare function validateValue(value: string, rules: readonly ValidationRule[]): string | undefined;
+declare function ValidatedInput({ value, rules, validateOn, onChange, onValidityChange, ...props }: ValidatedInputProps): react.JSX.Element;
+declare function validateForm(event: FormEvent<HTMLFormElement>): boolean;
+
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: ReactNode;
+    hint?: ReactNode;
+    error?: ReactNode;
+    resize?: 'none' | 'vertical' | 'both';
+}
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+declare const Checkbox: react.ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "type"> & {
+    label: ReactNode;
+    description?: ReactNode;
+} & {
+    indeterminate?: boolean;
+} & react.RefAttributes<HTMLInputElement>>;
+declare const Radio: react.ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "type"> & {
+    label: ReactNode;
+    description?: ReactNode;
+} & react.RefAttributes<HTMLInputElement>>;
+
+interface CalendarProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    min?: string;
+    max?: string;
+    className?: string;
+}
+declare function Calendar({ value, onChange, min, max, className }: CalendarProps): react.JSX.Element;
+interface DatePickerProps {
+    label?: ReactNode;
+    value?: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    min?: string;
+    max?: string;
+    error?: ReactNode;
+}
+declare function DatePicker({ label, value, onChange, placeholder, min, max, error, }: DatePickerProps): react.JSX.Element;
+interface TimePickerProps {
+    label?: ReactNode;
+    value?: string;
+    onChange: (value: string) => void;
+    step?: number;
+}
+declare function TimePicker({ label, value, onChange, step }: TimePickerProps): react.JSX.Element;
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'value' | 'onChange'> {
+    label?: ReactNode;
+    value: number;
+    onChange: (value: number) => void;
+    showValue?: boolean;
+}
+declare function Slider({ label, value, min, max, step, onChange, showValue, ...props }: SliderProps): react.JSX.Element;
+
+interface FormProps extends FormHTMLAttributes<HTMLFormElement> {
+    layout?: 'vertical' | 'horizontal';
+    disabled?: boolean;
+}
+declare function Form({ layout, disabled, className, children, ...props }: FormProps): react.JSX.Element;
+interface FormItemProps extends HTMLAttributes<HTMLDivElement> {
+    label?: ReactNode;
+    required?: boolean;
+    hint?: ReactNode;
+    error?: ReactNode;
+    children: ReactNode;
+}
+declare function FormItem({ label, required, hint, error, children, className, ...props }: FormItemProps): react.JSX.Element;
+
+type UploadRejectionReason = 'file-too-large' | 'file-type-not-accepted' | 'too-many-files';
+interface UploadRejection {
+    file: File;
+    reason: UploadRejectionReason;
+    message: string;
+}
+interface UploadValidationOptions {
+    accept?: string;
+    maxFiles?: number;
+    maxSize?: number;
+}
+interface UploadProps extends UploadValidationOptions {
+    label?: ReactNode;
+    multiple?: boolean;
+    onFiles: (files: File[]) => void;
+    onReject?: (rejections: UploadRejection[]) => void;
+    hint?: ReactNode;
+    disabled?: boolean;
+}
+declare function Upload({ label, accept, multiple, maxFiles, maxSize, onFiles, onReject, hint, disabled, }: UploadProps): react.JSX.Element;
+
+interface ComboboxOption {
+    label: ReactNode;
+    value: string;
+    keywords?: string;
+    disabled?: boolean;
+}
+interface ComboboxProps {
+    label?: ReactNode;
+    options: readonly ComboboxOption[];
+    value?: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    hint?: ReactNode;
+    error?: ReactNode;
+    disabled?: boolean;
+    emptyText?: ReactNode;
+}
+declare function Combobox({ label, options, value, onChange, placeholder, hint, error, disabled, emptyText }: ComboboxProps): react.JSX.Element;
+
+interface NumberInputProps {
+    label?: ReactNode;
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    hint?: ReactNode;
+    error?: ReactNode;
+    disabled?: boolean;
+}
+declare function NumberInput({ label, value, onChange, min, max, step, prefix, suffix, hint, error, disabled }: NumberInputProps): react.JSX.Element;
+
+interface CascaderOption {
+    value: string;
+    label: string;
+    children?: readonly CascaderOption[];
+    disabled?: boolean;
+}
+declare function Cascader({ options, value, onChange, label }: {
+    options: readonly CascaderOption[];
+    value?: readonly string[];
+    onChange: (value: string[]) => void;
+    label?: ReactNode;
+}): react.JSX.Element;
+interface TreeSelectOption {
+    key: string;
+    label: string;
+    children?: readonly TreeSelectOption[];
+    disabled?: boolean;
+}
+declare function TreeSelect({ options, value, onChange, label, placeholder }: {
+    options: readonly TreeSelectOption[];
+    value?: string;
+    onChange: (value: string) => void;
+    label?: ReactNode;
+    placeholder?: string;
+}): react.JSX.Element;
+interface TransferItem {
+    key: string;
+    label: ReactNode;
+    disabled?: boolean;
+}
+declare function Transfer({ items, value, onChange, titles }: {
+    items: readonly TransferItem[];
+    value: readonly string[];
+    onChange: (value: string[]) => void;
+    titles?: readonly [string, string];
+}): react.JSX.Element;
+declare function DateRangePicker({ label, value, onChange, min, max }: {
+    label?: ReactNode;
+    value: readonly [string, string];
+    onChange: (value: [string, string]) => void;
+    min?: string;
+    max?: string;
+}): react.JSX.Element;
+declare function SearchInput({ onSearch, loading, clearable, ...props }: Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> & {
+    onSearch: (value: string) => void;
+    loading?: boolean;
+    clearable?: boolean;
+}): react.JSX.Element;
+
+interface DrawerProps {
+    open: boolean;
+    title: string;
+    children: ReactNode;
+    onClose: () => void;
+    footer?: ReactNode;
+    side?: 'left' | 'right' | 'bottom';
+    size?: 'sm' | 'md' | 'lg';
+}
+declare function Drawer({ open, title, children, onClose, footer, side, size }: DrawerProps): react.ReactPortal | null;
+
+interface PopoverProps {
+    trigger: ReactElement;
+    children: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    label?: string;
+}
+declare function Popover({ trigger, children, open, defaultOpen, onOpenChange, placement, label }: PopoverProps): react.JSX.Element;
+
+type StatusTone = 'info' | 'success' | 'warning' | 'danger';
+declare function Tooltip({ content, children, placement }: {
+    content: ReactNode;
+    children: ReactElement;
+    placement?: 'top' | 'right' | 'bottom' | 'left';
+}): react.JSX.Element;
+declare function Alert({ tone, title, children, onClose, action }: {
+    tone?: StatusTone;
+    title: ReactNode;
+    children?: ReactNode;
+    onClose?: () => void;
+    action?: ReactNode;
+}): react.JSX.Element;
+
+interface PopconfirmProps {
+    trigger: ReactElement;
+    title: ReactNode;
+    description?: ReactNode;
+    confirmText?: string;
+    cancelText?: string;
+    tone?: 'primary' | 'danger';
+    onConfirm: () => void;
+}
+declare function Popconfirm({ trigger, title, description, confirmText, cancelText, tone, onConfirm }: PopconfirmProps): react.JSX.Element;
+interface NotificationProps {
+    title: ReactNode;
+    children?: ReactNode;
+    tone?: 'info' | 'success' | 'warning' | 'danger';
+    time?: ReactNode;
+    unread?: boolean;
+    action?: ReactNode;
+    onClose?: () => void;
+}
+declare function Notification({ title, children, tone, time, unread, action, onClose }: NotificationProps): react.JSX.Element;
+interface ResultProps {
+    status?: 'success' | 'error' | 'warning' | 'info' | '404' | '403';
+    title: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    extra?: ReactNode;
+}
+declare function Result({ status, title, description, actions, extra }: ResultProps): react.JSX.Element;
+
+interface StatisticCardProps extends HTMLAttributes<HTMLElement> {
+    label: ReactNode;
+    value: ReactNode;
+    trend?: ReactNode;
+    icon?: ReactNode;
+    tone?: 'blue' | 'green' | 'violet' | 'amber';
+}
+declare function StatisticCard({ label, value, trend, icon, tone, className, ...props }: StatisticCardProps): react.JSX.Element;
+/** COMPAT: StatisticCard remains available for existing consumers; Stat is the concise public name. */
+declare const Stat: typeof StatisticCard;
+interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    value: number;
+    max?: number;
+    label?: ReactNode;
+    showValue?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    tone?: 'primary' | 'success' | 'warning';
+}
+declare function Progress({ value, max, label, showValue, size, tone, className, ...props }: ProgressProps): react.JSX.Element;
+interface CircularProgressProps extends HTMLAttributes<HTMLDivElement> {
+    value: number;
+    max?: number;
+    label?: ReactNode;
+    size?: number;
+    thickness?: number;
+}
+declare function CircularProgress({ value, max, label, size, thickness, className, ...props }: CircularProgressProps): react.JSX.Element;
+interface StepProgressProps extends HTMLAttributes<HTMLOListElement> {
+    steps: readonly ReactNode[];
+    current: number;
+}
+declare function StepProgress({ steps, current, className, ...props }: StepProgressProps): react.JSX.Element;
+interface ActivityIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+    variant?: 'spinner' | 'dots' | 'radar' | 'wave';
+    label?: string;
+    size?: 'sm' | 'md' | 'lg';
+}
+declare function ActivityIndicator({ variant, label, size, className, ...props }: ActivityIndicatorProps): react.JSX.Element;
+interface SparklineProps extends HTMLAttributes<SVGSVGElement> {
+    data: readonly number[];
+    width?: number;
+    height?: number;
+    label?: string;
+    filled?: boolean;
+}
+declare function Sparkline({ data, width, height, label, filled, ...props }: SparklineProps): react.JSX.Element;
+
+interface TableColumn<T> {
+    key: string;
+    header: ReactNode;
+    render?: (item: T, index: number) => ReactNode;
+    align?: 'left' | 'center' | 'right';
+    width?: number | string;
+}
+interface TableProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    columns: readonly TableColumn<T>[];
+    data: readonly T[];
+    rowKey: keyof T | ((item: T, index: number) => string | number);
+    caption?: string;
+    empty?: ReactNode;
+    striped?: boolean;
+    onRowClick?: (item: T, index: number) => void;
+}
+declare function Table<T extends object>({ columns, data, rowKey, caption, empty, striped, onRowClick, className, ...props }: TableProps<T>): react.JSX.Element;
+interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'> {
+    page: number;
+    total: number;
+    pageSize?: number;
+    siblingCount?: number;
+    onChange: (page: number) => void;
+}
+declare function Pagination({ page, total, pageSize, siblingCount, onChange, className, ...props }: PaginationProps): react.JSX.Element;
+interface ListItem {
+    key: string | number;
+    title: ReactNode;
+    description?: ReactNode;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+}
+declare function List({ items, divided, className, ...props }: HTMLAttributes<HTMLUListElement> & {
+    items: readonly ListItem[];
+    divided?: boolean;
+}): react.JSX.Element;
+interface DescriptionItem {
+    key: string | number;
+    label: ReactNode;
+    value: ReactNode;
+    span?: 1 | 2 | 3;
+}
+declare function Descriptions({ items, columns, bordered, className, ...props }: HTMLAttributes<HTMLDListElement> & {
+    items: readonly DescriptionItem[];
+    columns?: 1 | 2 | 3;
+    bordered?: boolean;
+}): react.JSX.Element;
+
+interface TimelineItem {
+    key: string;
+    title: ReactNode;
+    description?: ReactNode;
+    time?: ReactNode;
+    status?: 'complete' | 'current' | 'upcoming';
+}
+declare function Timeline({ items, label }: {
+    items: readonly TimelineItem[];
+    label?: string;
+}): react.JSX.Element;
+interface InsightBoardProps {
+    summary: ReactNode;
+    trend: ReactNode;
+    detail: ReactNode;
+    heading?: ReactNode;
+    filters?: ReactNode;
+}
+declare function InsightBoard({ summary, trend, detail, heading, filters }: InsightBoardProps): react.JSX.Element;
+
+declare function EmptyState({ icon, title, description, action, size }: {
+    icon?: IconName;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    size?: 'sm' | 'md';
+}): react.JSX.Element;
+
+interface DataGridColumn<T> {
+    key: string;
+    header: ReactNode;
+    render?: (item: T) => ReactNode;
+    value?: (item: T) => string | number;
+    sortable?: boolean;
+    width?: string | number;
+}
+interface DataGridProps<T> {
+    columns: readonly DataGridColumn<T>[];
+    data: readonly T[];
+    rowKey: keyof T | ((item: T) => string);
+    selectedKeys?: readonly string[];
+    onSelectionChange?: (keys: string[]) => void;
+    empty?: ReactNode;
+    caption?: string;
+}
+declare function DataGrid<T extends object>({ columns, data, rowKey, selectedKeys, onSelectionChange, empty, caption }: DataGridProps<T>): react.JSX.Element;
+
+interface TreeNode {
+    key: string;
+    label: ReactNode;
+    children?: readonly TreeNode[];
+    disabled?: boolean;
+    icon?: ReactNode;
+}
+interface TreeProps {
+    nodes: readonly TreeNode[];
+    selectedKey?: string;
+    onSelect?: (key: string) => void;
+    defaultExpandedKeys?: readonly string[];
+    label?: string;
+}
+declare function Tree({ nodes, selectedKey, onSelect, defaultExpandedKeys, label }: TreeProps): react.JSX.Element;
+
+interface AuthLayoutProps {
+    children: ReactNode;
+    brand?: ReactNode;
+    aside?: ReactNode;
+    footer?: ReactNode;
+    variant?: 'split' | 'card' | 'immersive' | 'step';
+    backgroundImage?: string;
+    currentStep?: number;
+    steps?: number;
+}
+declare function AuthLayout({ children, brand, aside, footer, variant, backgroundImage, currentStep, steps }: AuthLayoutProps): react.JSX.Element;
+
+interface HeroProps {
+    eyebrow?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    primaryAction?: ReactNode;
+    secondaryAction?: ReactNode;
+    visual?: ReactNode;
+    proof?: ReactNode;
+    align?: 'left' | 'center';
+    kind?: 'product' | 'personal' | 'event' | 'commerce';
+}
+declare function Hero({ eyebrow, title, description, primaryAction, secondaryAction, visual, proof, align, kind }: HeroProps): react.JSX.Element;
+
+interface ResizablePanelProps {
+    primary: ReactNode;
+    secondary: ReactNode;
+    defaultSize?: number;
+    minSize?: number;
+    maxSize?: number;
+    direction?: 'horizontal' | 'vertical';
+    onResize?: (size: number) => void;
+}
+declare function ResizablePanel({ primary, secondary, defaultSize, minSize, maxSize, direction, onResize }: ResizablePanelProps): react.JSX.Element;
+
+interface NotificationItem extends Omit<NotificationProps, 'onClose'> {
+    key: string;
+    content?: ReactNode;
+}
+interface NotificationCenterProps {
+    items: readonly NotificationItem[];
+    onRead?: (key: string) => void;
+    onDismiss?: (key: string) => void;
+    onReadAll?: () => void;
+    empty?: ReactNode;
+    title?: ReactNode;
+}
+declare function NotificationCenter({ items, onRead, onDismiss, onReadAll, empty, title }: NotificationCenterProps): react.JSX.Element;
+
+interface VirtualListProps<T> {
+    items: readonly T[];
+    itemHeight: number;
+    height: number;
+    renderItem: (item: T, index: number) => ReactNode;
+    itemKey: (item: T, index: number) => string | number;
+    overscan?: number;
+    label?: string;
+}
+declare function VirtualList<T>({ items, itemHeight, height, renderItem, itemKey, overscan, label }: VirtualListProps<T>): react.JSX.Element;
+
+interface JsonViewerProps {
+    data: unknown;
+    name?: string;
+    defaultExpanded?: boolean;
+    maxDepth?: number;
+}
+declare function JsonViewer({ data, name, defaultExpanded, maxDepth }: JsonViewerProps): react.JSX.Element;
+interface DiffViewerProps {
+    before: string;
+    after: string;
+    beforeLabel?: string;
+    afterLabel?: string;
+    mode?: 'split' | 'unified';
+}
+declare function DiffViewer({ before, after, beforeLabel, afterLabel, mode }: DiffViewerProps): react.JSX.Element;
+
+interface QueryField {
+    key: string;
+    label: string;
+    type?: 'text' | 'number' | 'date';
+    operators?: readonly QueryOperator[];
+}
+interface QueryOperator {
+    value: string;
+    label: string;
+}
+interface QueryRule {
+    id: string;
+    field: string;
+    operator: string;
+    value: string;
+}
+interface QueryBuilderProps {
+    fields: readonly QueryField[];
+    rules: readonly QueryRule[];
+    onChange: (rules: QueryRule[]) => void;
+    conjunction?: 'and' | 'or';
+    onConjunctionChange?: (value: 'and' | 'or') => void;
+    disabled?: boolean;
+}
+declare function QueryBuilder({ fields, rules, onChange, conjunction, onConjunctionChange, disabled }: QueryBuilderProps): react.JSX.Element;
+
+interface FlowNode {
+    id: string;
+    label: ReactNode;
+    x: number;
+    y: number;
+    status?: 'default' | 'active' | 'success' | 'warning';
+    description?: ReactNode;
+}
+interface FlowEdge {
+    id?: string;
+    from: string;
+    to: string;
+    label?: string;
+}
+interface FlowCanvasProps {
+    nodes: readonly FlowNode[];
+    edges: readonly FlowEdge[];
+    width?: number;
+    height?: number;
+    selectedId?: string;
+    onSelect?: (id: string) => void;
+    empty?: ReactNode;
+}
+declare function FlowCanvas({ nodes, edges, width, height, selectedId, onSelect, empty }: FlowCanvasProps): react.JSX.Element;
+interface KanbanCard {
+    id: string;
+    title: ReactNode;
+    description?: ReactNode;
+    meta?: ReactNode;
+    tags?: readonly string[];
+}
+interface KanbanColumn {
+    id: string;
+    title: ReactNode;
+    cards: readonly KanbanCard[];
+    limit?: number;
+    accent?: string;
+}
+interface KanbanBoardProps {
+    columns: readonly KanbanColumn[];
+    onMove?: (cardId: string, fromColumnId: string, toColumnId: string) => void;
+    onCardClick?: (cardId: string, columnId: string) => void;
+    empty?: ReactNode;
+}
+declare function KanbanBoard({ columns, onMove, onCardClick, empty }: KanbanBoardProps): react.JSX.Element;
+interface GanttTask {
+    id: string;
+    label: ReactNode;
+    start: string | Date;
+    end: string | Date;
+    progress?: number;
+    group?: string;
+    color?: string;
+}
+interface GanttChartProps {
+    tasks: readonly GanttTask[];
+    start?: string | Date;
+    end?: string | Date;
+    onTaskClick?: (id: string) => void;
+    empty?: ReactNode;
+}
+declare function GanttChart({ tasks, start, end, onTaskClick, empty }: GanttChartProps): react.JSX.Element;
+interface ChartLegendItem {
+    label: ReactNode;
+    color: string;
+    value?: ReactNode;
+}
+interface ChartContainerProps {
+    title?: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    legend?: readonly ChartLegendItem[];
+    children: ReactNode;
+    height?: number;
+    loading?: boolean;
+    empty?: boolean;
+    emptyContent?: ReactNode;
+}
+declare function ChartContainer({ title, description, actions, legend, children, height, loading, empty, emptyContent }: ChartContainerProps): react.JSX.Element;
+interface PivotValue<T> {
+    key: string;
+    label: ReactNode;
+    value: (item: T) => number;
+    aggregate?: 'sum' | 'average' | 'count';
+    format?: (value: number) => ReactNode;
+}
+interface PivotTableProps<T> {
+    data: readonly T[];
+    row: (item: T) => string;
+    column: (item: T) => string;
+    values: readonly PivotValue<T>[];
+    rowLabel?: ReactNode;
+    showTotals?: boolean;
+    empty?: ReactNode;
+}
+declare function PivotTable<T>({ data, row, column, values, rowLabel, showTotals, empty }: PivotTableProps<T>): react.JSX.Element;
+
+interface FilterOption {
+    value: string;
+    label: string;
+}
+interface FilterField {
+    key: string;
+    label: string;
+    options?: readonly FilterOption[];
+    type?: 'text' | 'number' | 'date';
+}
+interface FilterValue {
+    id: string;
+    field: string;
+    value: string;
+}
+interface FilterBuilderProps {
+    fields: readonly FilterField[];
+    value: readonly FilterValue[];
+    onChange: (value: FilterValue[]) => void;
+    disabled?: boolean;
+    addLabel?: string;
+}
+declare function FilterBuilder({ fields, value, onChange, disabled, addLabel }: FilterBuilderProps): react.JSX.Element;
+
+export { Accordion, type AccordionItem, type AccordionProps, ActivityFeed, type ActivityFeedProps, ActivityIndicator, type ActivityIndicatorProps, type ActivityItem, type AgentRunStatus, type AgentRunStep, AgentRunTimeline, type AgentRunTimelineProps, Alert, ApprovalFlow, type ApprovalFlowProps, type ApprovalStatus, type ApprovalStep, type AuditEvent, AuditLog, type AuditLogProps, AuthLayout, type AuthLayoutProps, AvailabilityGrid, type AvailabilityState, Avatar, AvatarGroup, type AvatarGroupItem, type AvatarGroupProps, Badge, Breadcrumb, type BreadcrumbProps, Button, ButtonGroup, type ButtonProps, Calendar, type CalendarProps, type CalendarResource, Card, type CardProps, Cascader, type CascaderOption, ChartContainer, type ChartContainerProps, type ChartLegendItem, type ChatAttachment, ChatComposer, type ChatComposerProps, ChatMessage, type ChatMessageProps, Checkbox, CheckboxGroup, ChoiceGroup, type ChoiceOption, CircularProgress, type CircularProgressProps, type CitationItem, CitationList, type CitationListProps, CodeBlock, type CodeBlockProps, CodeEditor, type CodeEditorProps, ColorPicker, type ColorPickerProps, Combobox, type ComboboxOption, type ComboboxProps, type CommandItem, CommandPalette, type CommandPaletteProps, type CommentItem, CommentThread, type CommentThreadProps, Container, type ContainerProps, ContextMenu, type ContextMenuProps, ConversationBranch, type ConversationBranchProps, DataGrid, type DataGridColumn, type DataGridProps, DatePicker, type DatePickerProps, DateRangePicker, type DescriptionItem, Descriptions, DiffViewer, type DiffViewerProps, Divider, Drawer, type DrawerProps, Dropdown, type DropdownItem, DropdownMenu, type DropdownProps, EmptyState, EventCard, FileExplorer, type FileItem, FilePreview, FilterBuilder, type FilterBuilderProps, type FilterField, type FilterOption, type FilterValue, FloatingNav, type FloatingNavProps, FlowCanvas, type FlowCanvasProps, type FlowEdge, type FlowNode, Form, FormItem, type FormItemProps, type FormProps, GanttChart, type GanttChartProps, type GanttTask, Grid, type GridProps, Hero, type HeroProps, Icon, IconButton, type IconButtonProps, type IconName, type IconProps, Input, type InputProps, InsightBoard, type InsightBoardProps, JsonViewer, type JsonViewerProps, KanbanBoard, type KanbanBoardProps, type KanbanCard, type KanbanColumn, Link, List, type ListItem, LoadingDots, LoadingOverlay, type LoadingOverlayProps, MarkdownContent, type MarkdownContentProps, Masonry, type MasonryProps, MegaMenu, type MemberOption, MemberPicker, MentionInput, type MentionInputProps, type MentionOption, MobileNavigation, type MobileNavigationProps, Modal, type ModalProps, type ModelOption, ModelSelector, type ModelSelectorProps, MultiSelect, type MultiSelectProps, type NavigationItem, type NavigationSelectionProps, Notification, NotificationCenter, type NotificationCenterProps, type NotificationItem, type NotificationProps, NumberInput, type NumberInputProps, PageLayout, type PageLayoutProps, Pagination, type PaginationProps, type PermissionLevel, PermissionMatrix, type PermissionResource, type PermissionSubject, PivotTable, type PivotTableProps, type PivotValue, Popconfirm, type PopconfirmProps, Popover, type PopoverProps, Presence, type PresenceProps, type PresenceStatus, Progress, ProgressBar, type ProgressProps, ProgressRing, type PromptSuggestion, PromptSuggestions, type PromptSuggestionsProps, QueryBuilder, type QueryBuilderProps, type QueryField, type QueryOperator, type QueryRule, Radio, RadioGroup, RecurrenceEditor, type RecurrenceValue, ResizablePanel, type ResizablePanelProps, ResourceCalendar, Result, type ResultProps, RichTextEditor, type RichTextEditorProps, type ScheduleEvent, Scheduler, Scrollspy, type ScrollspyProps, SearchInput, type SegmentOption, SegmentedControl, type SegmentedControlProps, Select, type SelectOption, type SelectProps, SharePanel, type ShareScope, ShrinkNav, type ShrinkNavProps, Sidebar, type SidebarProps, Skeleton, type SkeletonProps, Slider, type SliderProps, Sparkline, type SparklineProps, Spinner, SplitButton, type SplitButtonOption, type SplitButtonProps, Stack, type StackProps, Stat, StatisticCard, type StatisticCardProps, type StepItem, StepProgress, type StepProgressProps, Steps, type StepsProps, Switch, type SwitchProps, type TabItem, Table, type TableColumn, type TableProps, Tabs, type TabsProps, Tag, Textarea, type TextareaProps, ThemeProvider, type ThemeProviderProps, type ThemeTokens, TimePicker, type TimePickerProps, Timeline, type TimelineItem, type TimezoneOption, TimezoneSelect, Toast, type ToastProps, TokenUsage, type TokenUsageProps, ToolCallCard, type ToolCallCardProps, type ToolCallStatus, Tooltip, Transfer, type TransferItem, Tree, type TreeNode, type TreeProps, TreeSelect, type TreeSelectOption, Typography, type TypographyProps, type TypographyVariant, Upload, type UploadProps, type UploadRejection, type UploadRejectionReason, ValidatedInput, type ValidatedInputProps, type ValidationRule, VersionHistory, type VersionItem, VirtualList, type VirtualListProps, VoiceInput, type VoiceInputProps, activateNavigationItem, darkTheme, defaultTheme, highContrastTheme, tokensToStyle, validateForm, validateValue };