@jacshuo/onyx 1.0.0 → 1.2.0

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,2136 @@
+import { ClassProp } from 'class-variance-authority/types';
+import { ClassValue } from 'clsx';
+import { JSX } from 'react/jsx-runtime';
+import { default as React_2 } from 'react';
+import { VariantProps } from 'class-variance-authority';
+
+declare function Accordion({ type, defaultValue, value, onValueChange, intent, size, className, children, ...props }: AccordionProps): JSX.Element;
+export { Accordion }
+export { Accordion as Accordion_alias_1 }
+export { Accordion as Accordion_alias_2 }
+export { Accordion as Accordion_alias_3 }
+
+declare function AccordionContent({ className, children, ...props }: AccordionContentProps): JSX.Element;
+export { AccordionContent }
+export { AccordionContent as AccordionContent_alias_1 }
+export { AccordionContent as AccordionContent_alias_2 }
+
+declare type AccordionContentProps = React_2.HTMLAttributes<HTMLDivElement>;
+
+declare const accordionContentVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { accordionContentVariants }
+export { accordionContentVariants as accordionContentVariants_alias_1 }
+export { accordionContentVariants as accordionContentVariants_alias_2 }
+
+declare function AccordionItem({ value, className, children, ...props }: AccordionItemProps): JSX.Element;
+export { AccordionItem }
+export { AccordionItem as AccordionItem_alias_1 }
+export { AccordionItem as AccordionItem_alias_2 }
+
+declare type AccordionItemProps = React_2.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+};
+
+declare type AccordionProps = React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof accordionVariants> & {
+    type?: "single" | "multiple";
+    defaultValue?: string[];
+    value?: string[];
+    onValueChange?: (value: string[]) => void;
+    /** Size of triggers and content text. @default 'md' */
+    size?: "sm" | "md" | "lg";
+};
+
+declare function AccordionTrigger({ className, children, ...props }: AccordionTriggerProps): JSX.Element;
+export { AccordionTrigger }
+export { AccordionTrigger as AccordionTrigger_alias_1 }
+export { AccordionTrigger as AccordionTrigger_alias_2 }
+
+declare type AccordionTriggerProps = React_2.ButtonHTMLAttributes<HTMLButtonElement>;
+
+declare const accordionTriggerVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { accordionTriggerVariants }
+export { accordionTriggerVariants as accordionTriggerVariants_alias_1 }
+export { accordionTriggerVariants as accordionTriggerVariants_alias_2 }
+
+declare const accordionVariants: (props?: ({
+    intent?: "ghost" | "default" | "bordered" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { accordionVariants }
+export { accordionVariants as accordionVariants_alias_1 }
+export { accordionVariants as accordionVariants_alias_2 }
+
+declare function addAlert(options: AlertOptions): string;
+
+declare function addSpin(target: HTMLElement, tip?: string): () => void;
+
+declare function Alert({ intent, className, children, ...props }: AlertProps): JSX.Element;
+export { Alert }
+export { Alert as Alert_alias_1 }
+export { Alert as Alert_alias_2 }
+export { Alert as Alert_alias_3 }
+
+declare function AlertContent({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { AlertContent }
+export { AlertContent as AlertContent_alias_1 }
+export { AlertContent as AlertContent_alias_2 }
+
+declare function AlertDescription({ className, ...props }: React_2.HTMLAttributes<HTMLParagraphElement>): JSX.Element;
+export { AlertDescription }
+export { AlertDescription as AlertDescription_alias_1 }
+export { AlertDescription as AlertDescription_alias_2 }
+
+declare function AlertIcon({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+export { AlertIcon }
+export { AlertIcon as AlertIcon_alias_1 }
+export { AlertIcon as AlertIcon_alias_2 }
+
+declare type AlertIntent = NonNullable<VariantProps<typeof alertVariants>["intent"]>;
+
+declare type AlertOptions = {
+    intent?: AlertIntent;
+    title?: string;
+    message: string;
+    position?: AlertPosition;
+    duration?: number;
+};
+export { AlertOptions }
+export { AlertOptions as AlertOptions_alias_1 }
+export { AlertOptions as AlertOptions_alias_2 }
+
+declare type AlertPosition = "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center";
+export { AlertPosition }
+export { AlertPosition as AlertPosition_alias_1 }
+export { AlertPosition as AlertPosition_alias_2 }
+
+declare type AlertProps = React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>;
+
+declare function AlertTitle({ className, ...props }: React_2.HTMLAttributes<HTMLHeadingElement>): JSX.Element;
+export { AlertTitle }
+export { AlertTitle as AlertTitle_alias_1 }
+export { AlertTitle as AlertTitle_alias_2 }
+
+declare const alertVariants: (props?: ({
+    intent?: "warning" | "success" | "error" | "info" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { alertVariants }
+export { alertVariants as alertVariants_alias_1 }
+export { alertVariants as alertVariants_alias_2 }
+
+declare function Badge({ intent, size, className, ...props }: BadgeProps): JSX.Element;
+export { Badge }
+export { Badge as Badge_alias_1 }
+export { Badge as Badge_alias_2 }
+export { Badge as Badge_alias_3 }
+
+declare type BadgeProps = React_2.HTMLAttributes<HTMLSpanElement> & VariantProps<typeof badgeVariants>;
+
+declare const badgeVariants: (props?: ({
+    intent?: "primary" | "warning" | "success" | "error" | "info" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { badgeVariants }
+export { badgeVariants as badgeVariants_alias_1 }
+export { badgeVariants as badgeVariants_alias_2 }
+
+/**
+ * Map of field names → ValidationResult returned from the `onValues` callback.
+ * Form will automatically display these errors in the matching named FormItems.
+ * Fields with `result: true` show a success message; `result: false` shows an error.
+ */
+declare type BulkValidationResult = Record<string, ValidationResult>;
+export { BulkValidationResult }
+export { BulkValidationResult as BulkValidationResult_alias_1 }
+
+declare function Button({ intent, size, className, ...props }: ButtonProps): JSX.Element;
+export { Button }
+export { Button as Button_alias_1 }
+export { Button as Button_alias_2 }
+export { Button as Button_alias_3 }
+
+declare type ButtonProps = React_2.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<typeof buttonVariants>;
+
+declare const buttonVariants: (props?: ({
+    intent?: "primary" | "secondary" | "danger" | "warning" | "ghost" | "outline" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { buttonVariants }
+export { buttonVariants as buttonVariants_alias_1 }
+export { buttonVariants as buttonVariants_alias_2 }
+
+declare function Card({ intent, size, className, ...props }: CardProps): JSX.Element;
+export { Card }
+export { Card as Card_alias_1 }
+export { Card as Card_alias_2 }
+export { Card as Card_alias_3 }
+
+declare function CardContent({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { CardContent }
+export { CardContent as CardContent_alias_1 }
+export { CardContent as CardContent_alias_2 }
+
+declare function CardDescription({ className, ...props }: React_2.HTMLAttributes<HTMLParagraphElement>): JSX.Element;
+export { CardDescription }
+export { CardDescription as CardDescription_alias_1 }
+export { CardDescription as CardDescription_alias_2 }
+
+declare function CardFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { CardFooter }
+export { CardFooter as CardFooter_alias_1 }
+export { CardFooter as CardFooter_alias_2 }
+
+declare function CardHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { CardHeader }
+export { CardHeader as CardHeader_alias_1 }
+export { CardHeader as CardHeader_alias_2 }
+
+declare type CardProps = React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof cardVariants>;
+
+declare function CardTitle({ className, ...props }: React_2.HTMLAttributes<HTMLHeadingElement>): JSX.Element;
+export { CardTitle }
+export { CardTitle as CardTitle_alias_1 }
+export { CardTitle as CardTitle_alias_2 }
+
+declare const cardVariants: (props?: ({
+    intent?: "ghost" | "default" | "elevated" | "outlined" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { cardVariants }
+export { cardVariants as cardVariants_alias_1 }
+export { cardVariants as cardVariants_alias_2 }
+
+declare function Chat({ messages, mode, autoScroll, className, ...props }: ChatProps): JSX.Element;
+export { Chat }
+export { Chat as Chat_alias_1 }
+export { Chat as Chat_alias_2 }
+export { Chat as Chat_alias_3 }
+
+declare interface ChatMessage {
+    /** Unique id for the message. */
+    id: string | number;
+    /** Sender display name. */
+    sender: string;
+    /** Avatar — URL string or ReactNode (icon / component). */
+    avatar?: string | React_2.ReactNode;
+    /** Message body. Can be text or rich ReactNode content. */
+    content: React_2.ReactNode;
+    /** Timestamp label, e.g. "10:30 AM". */
+    time?: string;
+    /** Mark as "self" (current user). Controls bubble alignment in split mode. */
+    self?: boolean;
+}
+export { ChatMessage }
+export { ChatMessage as ChatMessage_alias_1 }
+export { ChatMessage as ChatMessage_alias_2 }
+
+declare interface ChatProps extends React_2.HTMLAttributes<HTMLDivElement> {
+    /** Array of messages to render. */
+    messages: ChatMessage[];
+    /**
+     * Layout mode.
+     * - `'split'` — self messages on the right, others on the left (default)
+     * - `'left'`  — all messages aligned to the left
+     */
+    mode?: "split" | "left";
+    /** Auto-scroll to bottom when messages change. @default true */
+    autoScroll?: boolean;
+}
+export { ChatProps }
+export { ChatProps as ChatProps_alias_1 }
+export { ChatProps as ChatProps_alias_2 }
+
+declare function Checkbox({ checked: controlledChecked, defaultChecked, indeterminate, onCheckedChange, intent, size, label, id: propId, className, disabled, ...props }: CheckboxProps): JSX.Element;
+export { Checkbox }
+export { Checkbox as Checkbox_alias_1 }
+export { Checkbox as Checkbox_alias_2 }
+export { Checkbox as Checkbox_alias_3 }
+
+declare type CheckboxProps = Omit<React_2.InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & Omit<VariantProps<typeof checkboxVariants>, "checked"> & {
+    /** Controlled checked state. */
+    checked?: boolean;
+    /** Default checked state (uncontrolled). */
+    defaultChecked?: boolean;
+    /** Indeterminate state — overrides the check icon with a dash. */
+    indeterminate?: boolean;
+    /** Callback when the checkbox is toggled. */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Accessible label text shown beside the checkbox. */
+    label?: string;
+};
+export { CheckboxProps }
+export { CheckboxProps as CheckboxProps_alias_1 }
+export { CheckboxProps as CheckboxProps_alias_2 }
+
+declare const checkboxVariants: (props?: ({
+    intent?: "primary" | "secondary" | "danger" | "warning" | "success" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    checked?: "on" | "off" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { checkboxVariants }
+export { checkboxVariants as checkboxVariants_alias_1 }
+export { checkboxVariants as checkboxVariants_alias_2 }
+
+declare function CinePlayer({ playlist, initialTrack, autoPlay, shuffle: shuffleProp, loop: loopProp, onTrackChange, onPlayChange, accent, className, }: CinePlayerProps): JSX.Element;
+export { CinePlayer }
+export { CinePlayer as CinePlayer_alias_1 }
+export { CinePlayer as CinePlayer_alias_2 }
+export { CinePlayer as CinePlayer_alias_3 }
+
+declare interface CinePlayerMedia {
+    /** Display title. */
+    title: string;
+    /** Subtitle / description line. */
+    subtitle?: string;
+    /** Media type tag (e.g. 'movie', 'clip', 'episode'). Used for sorting. */
+    type?: string;
+    /** Source URL (http/blob/file). */
+    src: string;
+    /** Poster / thumbnail URL. */
+    poster?: string;
+    /** Duration in seconds (auto-detected if omitted). */
+    duration?: number;
+}
+export { CinePlayerMedia }
+export { CinePlayerMedia as CinePlayerMedia_alias_1 }
+export { CinePlayerMedia as CinePlayerMedia_alias_2 }
+
+declare interface CinePlayerProps {
+    /** Media playlist. */
+    playlist: CinePlayerMedia[];
+    /** Starting index. @default 0 */
+    initialTrack?: number;
+    /** Auto-play when ready. @default false */
+    autoPlay?: boolean;
+    /** Initial shuffle state. @default false */
+    shuffle?: boolean;
+    /** Initial loop state. @default false */
+    loop?: boolean;
+    /** Called on track change. */
+    onTrackChange?: (index: number, media: CinePlayerMedia) => void;
+    /** Called when play state changes. */
+    onPlayChange?: (playing: boolean) => void;
+    /** Accent color (any CSS color value). @default '#8b5cf6' */
+    accent?: string;
+    /** Extra class name on root. */
+    className?: string;
+}
+export { CinePlayerProps }
+export { CinePlayerProps as CinePlayerProps_alias_1 }
+export { CinePlayerProps as CinePlayerProps_alias_2 }
+
+declare type CinePlayerSortKey = "title" | "type" | "duration";
+export { CinePlayerSortKey }
+export { CinePlayerSortKey as CinePlayerSortKey_alias_1 }
+export { CinePlayerSortKey as CinePlayerSortKey_alias_2 }
+
+declare function cn(...inputs: ClassValue[]): string;
+export { cn }
+export { cn as cn_alias_1 }
+
+declare function CodeBlock({ code, language, lineNumbers, editable, onCodeChange, size, className, ...props }: CodeBlockProps): JSX.Element;
+export { CodeBlock }
+export { CodeBlock as CodeBlock_alias_1 }
+export { CodeBlock as CodeBlock_alias_2 }
+export { CodeBlock as CodeBlock_alias_3 }
+
+declare type CodeBlockLanguage = "typescript" | "javascript" | "tsx" | "jsx" | "html" | "css" | "json" | "markdown" | "python" | "rust" | "go" | "java" | "c" | "cpp" | "csharp" | "vue" | "xml" | "yaml" | "sql" | "bash" | "shell" | (string & {});
+export { CodeBlockLanguage }
+export { CodeBlockLanguage as CodeBlockLanguage_alias_1 }
+export { CodeBlockLanguage as CodeBlockLanguage_alias_2 }
+
+declare type CodeBlockProps = React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof codeBlockVariants> & {
+    /** The source code to highlight */
+    code: string;
+    /** Programming language for syntax highlighting */
+    language?: CodeBlockLanguage;
+    /** Show line numbers */
+    lineNumbers?: boolean;
+    /** Enable live editing — renders a transparent textarea over the highlighted output */
+    editable?: boolean;
+    /** Called when the user edits code (only fires when `editable` is true) */
+    onCodeChange?: (code: string) => void;
+};
+export { CodeBlockProps }
+export { CodeBlockProps as CodeBlockProps_alias_1 }
+export { CodeBlockProps as CodeBlockProps_alias_2 }
+
+declare const codeBlockVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { codeBlockVariants }
+export { codeBlockVariants as codeBlockVariants_alias_1 }
+export { codeBlockVariants as codeBlockVariants_alias_2 }
+
+declare type ColumnDef<T, K extends string = string> = {
+    /** Unique key identifying this column. */
+    key: K;
+    /** Header label. */
+    header: React_2.ReactNode;
+    /** Extract the cell value from a row. */
+    cell: (row: T) => React_2.ReactNode;
+    /** Whether this column is sortable. @default true */
+    sortable?: boolean;
+    /** Custom comparator. Receives two row objects and should return <0, 0, or >0. */
+    compareFn?: (a: T, b: T) => number;
+    /** Custom class for the <th> element. */
+    headerClassName?: string;
+    /** Custom class for the <td> element. */
+    cellClassName?: string;
+    /** Whether this column can be edited inline. @default true when table is editable. */
+    editable?: boolean;
+    /** Extract a raw string value for editing. Falls back to cell(). */
+    editValue?: (row: T) => string;
+    /** Hide this column below a given breakpoint. */
+    hideBelow?: "sm" | "md" | "lg";
+};
+export { ColumnDef }
+export { ColumnDef as ColumnDef_alias_1 }
+export { ColumnDef as ColumnDef_alias_2 }
+
+declare function configureAlertTopOffset(offset: number): void;
+export { configureAlertTopOffset }
+export { configureAlertTopOffset as configureAlertTopOffset_alias_1 }
+export { configureAlertTopOffset as configureAlertTopOffset_alias_2 }
+
+declare const DataDisplay: {
+    Table: typeof Table;
+    List: typeof List;
+    Tree: typeof Tree;
+    Chat: typeof Chat;
+    CodeBlock: typeof CodeBlock;
+};
+export { DataDisplay }
+export { DataDisplay as DataDisplay_alias_1 }
+export { DataDisplay as default_alias_1 }
+
+declare function DataTable<T, K extends string = string>({ columns, data, rowKey, sort: controlledSort, onSortChange, defaultSort, selectionMode, selected: controlledSelected, onSelectionChange, editable, onCellEdit, toolbar, onAdd, onDelete, rowActions, intent, density, className, empty, }: DataTableProps<T, K>): JSX.Element;
+export { DataTable }
+export { DataTable as DataTable_alias_1 }
+export { DataTable as DataTable_alias_2 }
+
+declare type DataTableProps<T, K extends string = string> = {
+    /** Column definitions. */
+    columns: ColumnDef<T, K>[];
+    /** Row data (controlled). */
+    data: T[];
+    /** Extract a unique key per row. */
+    rowKey: (row: T, index: number) => React_2.Key;
+    sort?: SortState<K>;
+    onSortChange?: (sort: SortState<K>) => void;
+    defaultSort?: SortState<K>;
+    /** Row selection mode. @default 'none' */
+    selectionMode?: SelectionMode_2;
+    /** Controlled selected keys. */
+    selected?: React_2.Key[];
+    /** Fired when selection changes. */
+    onSelectionChange?: (keys: React_2.Key[]) => void;
+    /** Enable inline cell editing on double-click. @default false */
+    editable?: boolean;
+    /** Called when a cell value is committed. */
+    onCellEdit?: (rowKey: React_2.Key, columnKey: K, value: string) => void;
+    /** Show the toolbar. @default false */
+    toolbar?: boolean;
+    /** Called when the Add button is clicked. */
+    onAdd?: () => void;
+    /** Called when Delete is clicked. Receives currently selected keys. */
+    onDelete?: (keys: React_2.Key[]) => void;
+    /** Render action buttons for each row. Receives the row data object. */
+    rowActions?: (row: T) => React_2.ReactNode;
+    intent?: VariantProps<typeof tableVariants>["intent"];
+    density?: VariantProps<typeof tableVariants>["density"];
+    className?: string;
+    /** Custom empty state props (icon, text). Shown when data is empty. */
+    empty?: TableEmptyProps;
+};
+export { DataTableProps }
+export { DataTableProps as DataTableProps_alias_1 }
+export { DataTableProps as DataTableProps_alias_2 }
+
+export declare const default_alias: {
+    Primitives: {
+        Button: Button;
+        Dropdown: Dropdown;
+        DropdownButton: DropdownButton;
+        Badge: Badge;
+        Indicator: Indicator;
+        Label: Label;
+        Input: Input;
+        TextBox: TextBox;
+        Switch: Switch;
+        Checkbox: Checkbox;
+        Radio: Radio;
+        RadioGroup: RadioGroup;
+    };
+    Layout: {
+        Card: Card;
+        ImageCard: ImageCard;
+        Panel: Panel;
+    };
+    DataDisplay: {
+        Table: Table;
+        List: List;
+        Tree: Tree;
+        Chat: Chat;
+        CodeBlock: CodeBlock;
+    };
+    Navigation: {
+        SideNav: SideNav;
+        Header: Header;
+        NavLink: NavLink;
+    };
+    Disclosure: {
+        Accordion: Accordion;
+        Tabs: Tabs;
+    };
+    Overlay: {
+        Dialog: Dialog;
+        Tooltip: Tooltip;
+    };
+    Feedback: {
+        Alert: Alert;
+        ProgressBar: ProgressBar;
+        Spin: Spin;
+    };
+    Extras: {
+        FilmReel: FilmReel;
+        MiniPlayer: MiniPlayer;
+        CinePlayer: CinePlayer;
+        FileExplorer: FileExplorer;
+        Masonry: Masonry;
+    };
+    Forms: {
+        Form: Form;
+    };
+};
+
+export declare function default_alias_10(): JSX.Element;
+
+export declare function default_alias_11(): JSX.Element;
+
+export declare function default_alias_12(): JSX.Element;
+
+export declare function default_alias_13(): JSX.Element;
+
+export declare function default_alias_14(): JSX.Element;
+
+export declare function default_alias_15(): JSX.Element;
+
+export declare function default_alias_16(): JSX.Element;
+
+export declare function default_alias_17(): JSX.Element;
+
+export declare function default_alias_18(): JSX.Element;
+
+export declare function default_alias_19(): JSX.Element;
+
+export declare function default_alias_20(): JSX.Element;
+
+export declare function default_alias_21(): JSX.Element;
+
+export declare function default_alias_22(): JSX.Element;
+
+export declare function default_alias_23(): JSX.Element;
+
+export declare function default_alias_24(): JSX.Element;
+
+export declare function default_alias_25(): JSX.Element;
+
+export declare function default_alias_26(): JSX.Element;
+
+export declare function default_alias_27(): JSX.Element;
+
+export declare function default_alias_28(): JSX.Element;
+
+export declare function default_alias_29(): JSX.Element;
+
+export declare function default_alias_30(): JSX.Element;
+
+export declare function default_alias_31(): JSX.Element;
+
+export declare function default_alias_32(): JSX.Element;
+
+export declare function default_alias_33(): JSX.Element;
+
+export declare function default_alias_34(): JSX.Element;
+
+export declare function default_alias_35(): JSX.Element;
+
+export declare function default_alias_36(): JSX.Element;
+
+export declare function default_alias_37(): JSX.Element;
+
+export declare function default_alias_38(): JSX.Element;
+
+export declare function default_alias_39(): JSX.Element;
+
+export declare function default_alias_40(): JSX.Element;
+
+export declare function default_alias_41(): JSX.Element;
+
+export declare function default_alias_42(): JSX.Element;
+
+export declare function default_alias_43(): JSX.Element;
+
+export declare function default_alias_44(): JSX.Element;
+
+declare function Dialog({ open, onOpenChange, modal, closeOnOutsideClick, children, }: DialogProps): JSX.Element | null;
+export { Dialog }
+export { Dialog as Dialog_alias_1 }
+export { Dialog as Dialog_alias_2 }
+export { Dialog as Dialog_alias_3 }
+
+declare function DialogClose({ className, ...props }: React_2.ButtonHTMLAttributes<HTMLButtonElement>): JSX.Element;
+export { DialogClose }
+export { DialogClose as DialogClose_alias_1 }
+export { DialogClose as DialogClose_alias_2 }
+
+declare function DialogContent({ size, position, className, children, ...props }: DialogContentProps): JSX.Element | null;
+export { DialogContent }
+export { DialogContent as DialogContent_alias_1 }
+export { DialogContent as DialogContent_alias_2 }
+
+declare type DialogContentProps = React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof dialogContentVariants> & {
+    /** Where to render the dialog in the viewport. @default 'center' */
+    position?: "center" | "bottom";
+};
+
+declare const dialogContentVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { dialogContentVariants }
+export { dialogContentVariants as dialogContentVariants_alias_1 }
+export { dialogContentVariants as dialogContentVariants_alias_2 }
+
+declare function DialogDescription({ className, ...props }: React_2.HTMLAttributes<HTMLParagraphElement>): JSX.Element;
+export { DialogDescription }
+export { DialogDescription as DialogDescription_alias_1 }
+export { DialogDescription as DialogDescription_alias_2 }
+
+declare function DialogFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { DialogFooter }
+export { DialogFooter as DialogFooter_alias_1 }
+export { DialogFooter as DialogFooter_alias_2 }
+
+declare function DialogHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { DialogHeader }
+export { DialogHeader as DialogHeader_alias_1 }
+export { DialogHeader as DialogHeader_alias_2 }
+
+declare type DialogProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    modal?: boolean;
+    /** When true, clicking outside the dialog closes it. @default false */
+    closeOnOutsideClick?: boolean;
+    children: React_2.ReactNode;
+};
+
+declare function DialogTitle({ className, ...props }: React_2.HTMLAttributes<HTMLHeadingElement>): JSX.Element;
+export { DialogTitle }
+export { DialogTitle as DialogTitle_alias_1 }
+export { DialogTitle as DialogTitle_alias_2 }
+
+declare const Disclosure: {
+    Accordion: typeof Accordion;
+    Tabs: typeof Tabs;
+};
+export { Disclosure }
+export { Disclosure as Disclosure_alias_1 }
+export { Disclosure as default_alias_2 }
+
+declare function Dropdown(props: DropdownProps): JSX.Element;
+export { Dropdown }
+export { Dropdown as Dropdown_alias_1 }
+export { Dropdown as Dropdown_alias_2 }
+export { Dropdown as Dropdown_alias_3 }
+
+declare interface DropdownBaseProps {
+    /** Available options. Supports nested children for cascading. */
+    options: DropdownOption[];
+    /** Placeholder text when nothing is selected. */
+    placeholder?: string;
+    /** Allow the user to type to filter options. @default false */
+    editable?: boolean;
+    /** Called when the user submits a value not in the list (editable mode). */
+    onAddItem?: (value: string) => void;
+    /** Disable the entire dropdown. */
+    disabled?: boolean;
+    /** Menu alignment. @default 'left' */
+    align?: "left" | "right";
+    /** Additional class name for the root container. */
+    className?: string;
+    /** Controls the trigger height and text size. @default 'md' */
+    size?: "sm" | "md" | "lg";
+    /** Enable domino flip-in/flip-out animation for menu items. @default true */
+    animated?: boolean;
+}
+
+declare function DropdownButton({ label, items, intent, size, align, className, disabled, editable, onAddItem, multiple, selected, onSelectionChange, animated, chevron, ...props }: DropdownButtonProps): JSX.Element;
+export { DropdownButton }
+export { DropdownButton as DropdownButton_alias_1 }
+export { DropdownButton as DropdownButton_alias_2 }
+export { DropdownButton as DropdownButton_alias_3 }
+
+declare interface DropdownButtonProps extends Omit<React_2.ButtonHTMLAttributes<HTMLButtonElement>, "children">, VariantProps<typeof buttonVariants> {
+    /** Button label. */
+    label: React_2.ReactNode;
+    /** Dropdown menu items. */
+    items: DropdownItem[];
+    /** Menu alignment. @default 'left' */
+    align?: "left" | "right";
+    /** Show a search/add input at the top of the menu. */
+    editable?: boolean;
+    /** Called when the user presses Enter on a value not in the list. */
+    onAddItem?: (value: string) => void;
+    /** Enable multi-select with checkboxes. */
+    multiple?: boolean;
+    /** Currently selected keys (controlled). */
+    selected?: string[];
+    /** Called when the selection changes (multi-select mode). */
+    onSelectionChange?: (selected: string[]) => void;
+    /** Enable domino flip-in/flip-out animation for menu items. @default true */
+    animated?: boolean;
+    /** Show the chevron indicator on the trigger button. @default true */
+    chevron?: boolean;
+}
+export { DropdownButtonProps }
+export { DropdownButtonProps as DropdownButtonProps_alias_1 }
+export { DropdownButtonProps as DropdownButtonProps_alias_2 }
+
+declare interface DropdownItem {
+    /** Unique key. Falls back to label when label is a string. */
+    key?: string;
+    label: React_2.ReactNode;
+    /** Disable this item. */
+    disabled?: boolean;
+    /** Divider rendered before this item. */
+    divider?: boolean;
+    onClick?: () => void;
+}
+export { DropdownItem }
+export { DropdownItem as DropdownItem_alias_1 }
+export { DropdownItem as DropdownItem_alias_2 }
+
+declare interface DropdownMultipleProps extends DropdownBaseProps {
+    /** Enable multi-select with checkboxes. */
+    multiple: true;
+    /** Currently selected values (controlled, multi mode). */
+    selected?: string[];
+    /** Default selected values (uncontrolled, multi mode). */
+    defaultSelected?: string[];
+    /** Callback fired when selection changes (multi mode). */
+    onSelectionChange?: (selected: string[]) => void;
+    /** Not used in multi mode. */
+    value?: never;
+    /** Not used in multi mode. */
+    defaultValue?: never;
+    /** Not used in multi mode. */
+    onChange?: never;
+}
+export { DropdownMultipleProps }
+export { DropdownMultipleProps as DropdownMultipleProps_alias_1 }
+export { DropdownMultipleProps as DropdownMultipleProps_alias_2 }
+
+declare interface DropdownOption {
+    /** Unique value for this option. */
+    value: string;
+    /** Display label. Defaults to value. */
+    label?: string;
+    /** Icon rendered before the label. */
+    icon?: React_2.ReactNode;
+    /** Disable this option. */
+    disabled?: boolean;
+    /** Nested children for cascading (hierarchical) menus. */
+    children?: DropdownOption[];
+}
+export { DropdownOption }
+export { DropdownOption as DropdownOption_alias_1 }
+export { DropdownOption as DropdownOption_alias_2 }
+
+declare type DropdownProps = DropdownSingleProps | DropdownMultipleProps;
+export { DropdownProps }
+export { DropdownProps as DropdownProps_alias_1 }
+export { DropdownProps as DropdownProps_alias_2 }
+
+declare interface DropdownSingleProps extends DropdownBaseProps {
+    /** Enable multi-select with checkboxes. @default false */
+    multiple?: false;
+    /** Currently selected value (controlled, single mode). */
+    value?: string;
+    /** Default selected value (uncontrolled, single mode). */
+    defaultValue?: string;
+    /** Callback fired when an option is selected (single mode). */
+    onChange?: (value: string, option: DropdownOption) => void;
+    /** Not used in single mode. */
+    selected?: never;
+    /** Not used in single mode. */
+    defaultSelected?: never;
+    /** Not used in single mode. */
+    onSelectionChange?: never;
+}
+export { DropdownSingleProps }
+export { DropdownSingleProps as DropdownSingleProps_alias_1 }
+export { DropdownSingleProps as DropdownSingleProps_alias_2 }
+
+declare const Extras: {
+    FilmReel: typeof FilmReel;
+    MiniPlayer: typeof MiniPlayer;
+    CinePlayer: typeof CinePlayer;
+    FileExplorer: typeof FileExplorer;
+    Masonry: typeof Masonry;
+};
+export { Extras }
+export { Extras as Extras_alias_1 }
+export { Extras as default_alias_3 }
+
+declare const Feedback: {
+    Alert: typeof Alert;
+    ProgressBar: typeof ProgressBar;
+    Spin: typeof Spin;
+};
+export { Feedback }
+export { Feedback as Feedback_alias_1 }
+export { Feedback as default_alias_4 }
+
+declare function FileExplorer({ files, title, accent, defaultView, initialPosition, initialSize, dockable, dockSide, visible: visibleProp, onFileOpen, onSelectionChange, onNavigate, onDelete, onClose, onMinimize, onPathSubmit, defaultInputMode, actions, resizable, minSize, className, }: FileExplorerProps): JSX.Element | null;
+export { FileExplorer }
+export { FileExplorer as FileExplorer_alias_1 }
+export { FileExplorer as FileExplorer_alias_2 }
+export { FileExplorer as FileExplorer_alias_3 }
+
+/** A custom action shown in the properties panel. */
+declare interface FileExplorerAction {
+    /** Unique key for the action. */
+    key: string;
+    /** Label displayed on the button. */
+    label: string;
+    /** Optional lucide icon component. */
+    icon?: React_2.ComponentType<{
+        className?: string;
+    }>;
+    /** Called when the action is clicked. */
+    onClick: (file: FileExplorerItem) => void;
+}
+export { FileExplorerAction }
+export { FileExplorerAction as FileExplorerAction_alias_1 }
+export { FileExplorerAction as FileExplorerAction_alias_2 }
+
+declare type FileExplorerDockSide = "left" | "right";
+export { FileExplorerDockSide }
+export { FileExplorerDockSide as FileExplorerDockSide_alias_1 }
+export { FileExplorerDockSide as FileExplorerDockSide_alias_2 }
+
+/** Toolbar input mode: filter current list or navigate to a path. */
+declare type FileExplorerInputMode = "search" | "navigate";
+export { FileExplorerInputMode }
+export { FileExplorerInputMode as FileExplorerInputMode_alias_1 }
+export { FileExplorerInputMode as FileExplorerInputMode_alias_2 }
+
+declare interface FileExplorerItem {
+    /** File or directory name (including extension). */
+    name: string;
+    /** Absolute or virtual path. */
+    path: string;
+    /** Item type. */
+    type: "file" | "directory";
+    /** Size in bytes (files only). */
+    size?: number;
+    /** File extension (e.g. '.tsx'). Auto-derived from name if omitted. */
+    extension?: string;
+    /** Last modified date. */
+    modifiedAt?: Date | string;
+    /** Creation date. */
+    createdAt?: Date | string;
+    /** MIME type string. */
+    mimeType?: string;
+    /** Whether this item is hidden. */
+    hidden?: boolean;
+}
+export { FileExplorerItem }
+export { FileExplorerItem as FileExplorerItem_alias_1 }
+export { FileExplorerItem as FileExplorerItem_alias_2 }
+
+declare interface FileExplorerProps {
+    /** Files / directories to display. */
+    files: FileExplorerItem[];
+    /** Window title. @default 'File Explorer' */
+    title?: string;
+    /** Accent color (any CSS color). @default '#8b5cf6' */
+    accent?: string;
+    /** Default view mode. @default 'list' */
+    defaultView?: FileExplorerViewMode;
+    /** Initial window position {x, y}. */
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    /** Initial window dimensions (px). */
+    initialSize?: {
+        width: number;
+        height: number;
+    };
+    /** Enable dock-to-edge behaviour. @default false */
+    dockable?: boolean;
+    /** Which edge to dock to. @default 'right' */
+    dockSide?: FileExplorerDockSide;
+    /** Whether the explorer starts visible. @default true */
+    visible?: boolean;
+    /** Called on double-click of a file. */
+    onFileOpen?: (file: FileExplorerItem) => void;
+    /** Called when selection changes. */
+    onSelectionChange?: (files: FileExplorerItem[]) => void;
+    /** Called when navigating into a directory. */
+    onNavigate?: (path: string) => void;
+    /** Called when the user confirms deletion of selected files via the Delete key. */
+    onDelete?: (files: FileExplorerItem[]) => void;
+    /** Called on close button. */
+    onClose?: () => void;
+    /** Called on minimize/dock. */
+    onMinimize?: () => void;
+    /** Called when user presses Enter in navigate mode. Receives the typed path. */
+    onPathSubmit?: (path: string) => void;
+    /** Default input mode. @default 'search' */
+    defaultInputMode?: FileExplorerInputMode;
+    /** Custom actions shown in the properties panel. Each receives the inspected file. */
+    actions?: FileExplorerAction[];
+    /** Whether the window is resizable. @default true */
+    resizable?: boolean;
+    /** Minimum window size when resizing. @default { width: 400, height: 300 } */
+    minSize?: {
+        width: number;
+        height: number;
+    };
+    /** Extra class on outermost wrapper. */
+    className?: string;
+}
+export { FileExplorerProps }
+export { FileExplorerProps as FileExplorerProps_alias_1 }
+export { FileExplorerProps as FileExplorerProps_alias_2 }
+
+declare type FileExplorerViewMode = "list" | "grid";
+export { FileExplorerViewMode }
+export { FileExplorerViewMode as FileExplorerViewMode_alias_1 }
+export { FileExplorerViewMode as FileExplorerViewMode_alias_2 }
+
+declare function FilmReel({ photos, layout, actions, onAction, className, showGrain, sheetTitle, sheetLabel, }: FilmReelProps): JSX.Element;
+export { FilmReel }
+export { FilmReel as FilmReel_alias_1 }
+export { FilmReel as FilmReel_alias_2 }
+export { FilmReel as FilmReel_alias_3 }
+
+declare interface FilmReelAction {
+    key: string;
+    icon: React_2.ReactNode;
+    activeIcon?: React_2.ReactNode;
+    label: string;
+    toggle?: boolean;
+}
+export { FilmReelAction }
+export { FilmReelAction as FilmReelAction_alias_1 }
+export { FilmReelAction as FilmReelAction_alias_2 }
+
+declare type FilmReelLayout = "strip" | "sheet" | "stack";
+export { FilmReelLayout }
+export { FilmReelLayout as FilmReelLayout_alias_1 }
+export { FilmReelLayout as FilmReelLayout_alias_2 }
+
+declare interface FilmReelPhoto {
+    src: string;
+    alt?: string;
+    title?: string;
+    /** A short memoir or description for this photo. */
+    description?: string;
+    metadata?: {
+        camera?: string;
+        lens?: string;
+        aperture?: string;
+        shutter?: string;
+        iso?: string;
+        date?: string;
+        location?: string;
+        [key: string]: string | undefined;
+    };
+}
+export { FilmReelPhoto }
+export { FilmReelPhoto as FilmReelPhoto_alias_1 }
+export { FilmReelPhoto as FilmReelPhoto_alias_2 }
+
+declare interface FilmReelProps {
+    photos: FilmReelPhoto[];
+    layout?: FilmReelLayout;
+    actions?: FilmReelAction[];
+    onAction?: (action: string, photo: FilmReelPhoto, index: number) => void;
+    className?: string;
+    showGrain?: boolean;
+    /** Left-side header text for the contact sheet layout. */
+    sheetTitle?: string;
+    /** Right-side label text for the contact sheet layout. */
+    sheetLabel?: string;
+}
+export { FilmReelProps }
+export { FilmReelProps as FilmReelProps_alias_1 }
+export { FilmReelProps as FilmReelProps_alias_2 }
+
+declare function Form({ children, className, intent, size, layout, title, description, footer, onValues, onSubmit, ...props }: FormProps): JSX.Element;
+export { Form }
+export { Form as Form_alias_1 }
+export { Form as Form_alias_2 }
+export { Form as Form_alias_3 }
+
+declare function FormItem({ label, layout: itemLayout, required, hint, validation, name, onValidate, className, children, }: FormItemProps): JSX.Element;
+export { FormItem }
+export { FormItem as FormItem_alias_1 }
+export { FormItem as FormItem_alias_2 }
+
+declare type FormItemProps = {
+    /** Label text or element. Pass a string for automatic htmlFor wiring. */
+    label?: React_2.ReactNode;
+    /**
+     * Override the inherited layout from Form.
+     * Useful when a specific item needs to differ from the rest.
+     */
+    layout?: FormLayout;
+    /** Whether the field is required (adds a red asterisk after the label). */
+    required?: boolean;
+    /** Additional hint text rendered below the control (below validation if both present). */
+    hint?: React_2.ReactNode;
+    /** Externally controlled validation result. Takes precedence over `onValidate`. */
+    validation?: FormValidation;
+    /**
+     * Field name used by the native FormData API when the Form's `onValues`
+     * callback is used. Injected into the first child element automatically.
+     */
+    name?: string;
+    /**
+     * Validation callback. Called with the current value on every change.
+     * Return `{ result: true, reason: "" }` for success or
+     * `{ result: false, reason: "Error message" }` for error.
+     */
+    onValidate?: ValidateCallback;
+    /** Extra class on the wrapper div. */
+    className?: string;
+    children: React_2.ReactNode;
+};
+export { FormItemProps }
+export { FormItemProps as FormItemProps_alias_1 }
+export { FormItemProps as FormItemProps_alias_2 }
+
+declare const formItemVariants: (props?: ({
+    layout?: "inline" | "stacked" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { formItemVariants }
+export { formItemVariants as formItemVariants_alias_1 }
+
+declare type FormLayout = "stacked" | "inline";
+export { FormLayout }
+export { FormLayout as FormLayout_alias_1 }
+export { FormLayout as FormLayout_alias_2 }
+
+declare type FormProps = React_2.FormHTMLAttributes<HTMLFormElement> & VariantProps<typeof formVariants> & {
+    /**
+     * Label + control layout for all FormItems.
+     * - "stacked"  — label above control (default; always used on narrow viewports)
+     * - "inline"   — label left, control right
+     * @default "stacked"
+     */
+    layout?: FormLayout;
+    /** Form heading rendered above all items. */
+    title?: React_2.ReactNode;
+    /** Optional descriptive text below the heading. */
+    description?: React_2.ReactNode;
+    /**
+     * Footer slot — typically holds submit / reset buttons.
+     * Rendered below all FormItems, separated by a top border.
+     */
+    footer?: React_2.ReactNode;
+    /**
+     * Called on form submit with a plain-object snapshot of all named
+     * FormItem inputs (via the native FormData API).
+     * Call `e.preventDefault()` inside this callback to prevent a page reload.
+     *
+     * May return (or resolve to) a `BulkValidationResult` to display
+     * per-field errors/successes — Form automatically routes each entry
+     * to the matching `<FormItem name="…">`.
+     * Supports async (return a Promise).
+     */
+    onValues?: (values: Record<string, FormDataEntryValue>, event: React_2.FormEvent<HTMLFormElement>) => BulkValidationResult | void | Promise<BulkValidationResult | void>;
+};
+export { FormProps }
+export { FormProps as FormProps_alias_1 }
+export { FormProps as FormProps_alias_2 }
+
+declare const Forms: {
+    Form: typeof Form;
+};
+export { Forms }
+export { Forms as Forms_alias_1 }
+export { Forms as default_alias_5 }
+
+declare function FormSection({ title, description, className, children }: FormSectionProps): JSX.Element;
+export { FormSection }
+export { FormSection as FormSection_alias_1 }
+export { FormSection as FormSection_alias_2 }
+
+/**
+ * Optional grouping element inside a Form.
+ * Renders a subtle heading + divider, then its children as a nested column.
+ */
+declare type FormSectionProps = {
+    title?: React_2.ReactNode;
+    description?: React_2.ReactNode;
+    className?: string;
+    children: React_2.ReactNode;
+};
+export { FormSectionProps }
+export { FormSectionProps as FormSectionProps_alias_1 }
+export { FormSectionProps as FormSectionProps_alias_2 }
+
+declare type FormSize = "sm" | "md" | "lg";
+export { FormSize }
+export { FormSize as FormSize_alias_1 }
+export { FormSize as FormSize_alias_2 }
+
+declare type FormValidation = {
+    /** Validation display status. Controls icon colour. */
+    status: FormValidationStatus;
+    /** Message text shown below the control. */
+    message: string;
+};
+export { FormValidation }
+export { FormValidation as FormValidation_alias_1 }
+export { FormValidation as FormValidation_alias_2 }
+
+declare type FormValidationStatus = "error" | "warning" | "success" | "hint";
+export { FormValidationStatus }
+export { FormValidationStatus as FormValidationStatus_alias_1 }
+export { FormValidationStatus as FormValidationStatus_alias_2 }
+
+declare const formValidationVariants: (props?: ({
+    status?: "warning" | "success" | "error" | "hint" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { formValidationVariants }
+export { formValidationVariants as formValidationVariants_alias_1 }
+
+declare const formVariants: (props?: ({
+    intent?: "default" | "inset" | "card" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { formVariants }
+export { formVariants as formVariants_alias_1 }
+
+declare function Header({ brand, onBrandClick, navItems, actions, linkComponent: Link, height, mobileMenu, navMenuIcon, actionsMenuIcon, className, children, }: HeaderProps): JSX.Element;
+export { Header }
+export { Header as Header_alias_1 }
+export { Header as Header_alias_2 }
+export { Header as Header_alias_3 }
+
+declare interface HeaderAction {
+    /** Unique key. Falls back to index. */
+    key?: string;
+    /** Icon or element to render. */
+    icon: React_2.ReactNode;
+    /** Accessible label for the button. */
+    "aria-label": string;
+    /** Click handler. */
+    onClick?: (e: React_2.MouseEvent) => void;
+    /** Render as a link instead of a button. */
+    href?: string;
+    /** Open in new tab (when href is set). */
+    external?: boolean;
+}
+export { HeaderAction }
+export { HeaderAction as HeaderAction_alias_1 }
+export { HeaderAction as HeaderAction_alias_2 }
+
+declare interface HeaderNavItem {
+    /** Display label. */
+    label: React_2.ReactNode;
+    /** URL or route path. */
+    href?: string;
+    /** Marks this item as currently active. */
+    active?: boolean;
+    /** Click handler (for SPA routing or custom behaviour). */
+    onClick?: (e: React_2.MouseEvent) => void;
+}
+export { HeaderNavItem }
+export { HeaderNavItem as HeaderNavItem_alias_1 }
+export { HeaderNavItem as HeaderNavItem_alias_2 }
+
+declare interface HeaderProps {
+    /** Brand text, logo element, or both. */
+    brand?: React_2.ReactNode;
+    /** Click handler on the brand element (e.g. navigate home). */
+    onBrandClick?: (e: React_2.MouseEvent) => void;
+    /** Primary navigation items displayed after the brand. */
+    navItems?: HeaderNavItem[];
+    /** Action buttons rendered on the right side (e.g. search, theme toggle, login). */
+    actions?: HeaderAction[];
+    /** Override the link component used for nav items (e.g. React-Router NavLink). */
+    linkComponent?: React_2.ComponentType<{
+        href: string;
+        className?: string;
+        onClick?: (e: React_2.MouseEvent) => void;
+        children: React_2.ReactNode;
+    }>;
+    /** Fixed height class. @default 'h-12' */
+    height?: string;
+    /** Additional class names for the root header element. */
+    className?: string;
+    /** Content rendered between nav items and actions (e.g. search bar). */
+    children?: React_2.ReactNode;
+    /** Show a hamburger menu button on small screens (< md) that reveals nav items. @default false */
+    mobileMenu?: boolean;
+    /** Custom icon for the mobile nav toggle (left side). @default <PanelLeft> */
+    navMenuIcon?: React_2.ReactNode;
+    /** Custom icon for the mobile actions toggle (right side). @default <MoreHorizontal> */
+    actionsMenuIcon?: React_2.ReactNode;
+}
+export { HeaderProps }
+export { HeaderProps as HeaderProps_alias_1 }
+export { HeaderProps as HeaderProps_alias_2 }
+
+declare function HorizontalCard({ intent, media, mediaPosition, stackOnMobile, className, children, ...props }: HorizontalCardProps): JSX.Element;
+export { HorizontalCard }
+export { HorizontalCard as HorizontalCard_alias_1 }
+export { HorizontalCard as HorizontalCard_alias_2 }
+
+declare type HorizontalCardMediaProps = {
+    /** Image source URL. */
+    src?: string;
+    /** Image alt text. */
+    alt?: string;
+    /** Render an icon or avatar instead of an image. */
+    icon?: React_2.ReactNode;
+    /** Width of the media area. @default '10rem' */
+    width?: string;
+};
+
+declare type HorizontalCardProps = Omit<React_2.HTMLAttributes<HTMLDivElement>, "children"> & VariantProps<typeof cardVariants> & {
+    /** Media placement. @default 'left' */
+    mediaPosition?: "left" | "right";
+    /** Media configuration. */
+    media: HorizontalCardMediaProps;
+    children: React_2.ReactNode;
+    /** Stack media above content on small screens. @default false */
+    stackOnMobile?: boolean;
+};
+
+declare function ImageCard({ src, alt, aspectRatio, className, children, ...props }: ImageCardProps): JSX.Element;
+export { ImageCard }
+export { ImageCard as ImageCard_alias_1 }
+export { ImageCard as ImageCard_alias_2 }
+export { ImageCard as ImageCard_alias_3 }
+
+declare function ImageCardActions({ className, ...props }: ImageCardActionsProps): JSX.Element;
+export { ImageCardActions }
+export { ImageCardActions as ImageCardActions_alias_1 }
+export { ImageCardActions as ImageCardActions_alias_2 }
+
+declare type ImageCardActionsProps = React_2.HTMLAttributes<HTMLDivElement>;
+export { ImageCardActionsProps }
+export { ImageCardActionsProps as ImageCardActionsProps_alias_1 }
+
+declare function ImageCardBody({ className, ...props }: ImageCardBodyProps): JSX.Element;
+export { ImageCardBody }
+export { ImageCardBody as ImageCardBody_alias_1 }
+export { ImageCardBody as ImageCardBody_alias_2 }
+
+declare type ImageCardBodyProps = React_2.HTMLAttributes<HTMLDivElement>;
+export { ImageCardBodyProps }
+export { ImageCardBodyProps as ImageCardBodyProps_alias_1 }
+
+declare function ImageCardDescription({ className, ...props }: ImageCardDescriptionProps): JSX.Element;
+export { ImageCardDescription }
+export { ImageCardDescription as ImageCardDescription_alias_1 }
+export { ImageCardDescription as ImageCardDescription_alias_2 }
+
+declare type ImageCardDescriptionProps = React_2.HTMLAttributes<HTMLParagraphElement>;
+export { ImageCardDescriptionProps }
+export { ImageCardDescriptionProps as ImageCardDescriptionProps_alias_1 }
+
+declare interface ImageCardProps extends React_2.HTMLAttributes<HTMLDivElement> {
+    /** Image source URL. */
+    src: string;
+    /** Image alt text. */
+    alt?: string;
+    /** Fixed aspect ratio for the image area. @default '16/9' */
+    aspectRatio?: string;
+}
+export { ImageCardProps }
+export { ImageCardProps as ImageCardProps_alias_1 }
+
+declare function ImageCardTitle({ className, ...props }: ImageCardTitleProps): JSX.Element;
+export { ImageCardTitle }
+export { ImageCardTitle as ImageCardTitle_alias_1 }
+export { ImageCardTitle as ImageCardTitle_alias_2 }
+
+declare type ImageCardTitleProps = React_2.HTMLAttributes<HTMLHeadingElement>;
+export { ImageCardTitleProps }
+export { ImageCardTitleProps as ImageCardTitleProps_alias_1 }
+
+declare function Indicator({ children, show, content, dot, intent, size, placement, pulse, className, }: IndicatorProps): JSX.Element;
+export { Indicator }
+export { Indicator as Indicator_alias_1 }
+export { Indicator as Indicator_alias_2 }
+export { Indicator as Indicator_alias_3 }
+
+declare interface IndicatorProps extends VariantProps<typeof indicatorVariants> {
+    children: React_2.ReactNode;
+    /** Show or hide the indicator. @default true */
+    show?: boolean;
+    /** Content to display. Numbers > 99 are shown as "99+". Ignored when dot=true. */
+    content?: React_2.ReactNode;
+    /** Show a pulsing ring animation (best for dot-only mode). @default false */
+    pulse?: boolean;
+    className?: string;
+}
+export { IndicatorProps }
+export { IndicatorProps as IndicatorProps_alias_1 }
+export { IndicatorProps as IndicatorProps_alias_2 }
+
+declare const indicatorVariants: (props?: ({
+    intent?: "primary" | "danger" | "warning" | "success" | "info" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    dot?: boolean | null | undefined;
+    placement?: "top-right" | "top-left" | "bottom-right" | "bottom-left" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { indicatorVariants }
+export { indicatorVariants as indicatorVariants_alias_1 }
+export { indicatorVariants as indicatorVariants_alias_2 }
+
+declare function Input({ state, inputSize, className, prefix, suffix, action, ...props }: InputProps): JSX.Element;
+export { Input }
+export { Input as Input_alias_1 }
+export { Input as Input_alias_2 }
+export { Input as Input_alias_3 }
+
+declare type InputProps = Omit<React_2.InputHTMLAttributes<HTMLInputElement>, "size" | "prefix"> & {
+    state?: InputVariants["state"];
+    inputSize?: InputVariants["size"];
+    /** Icon or label shown at the start of the input with a highlighted background */
+    prefix?: React_2.ReactNode;
+    /** Icon shown inside the input at the end (non-interactive decoration) */
+    suffix?: React_2.ReactNode;
+    /** Clickable action button rendered at the end of the input */
+    action?: {
+        icon: React_2.ReactNode;
+        onClick: () => void;
+        "aria-label"?: string;
+    };
+};
+
+declare type InputVariants = VariantProps<typeof inputVariants>;
+
+declare const inputVariants: (props?: ({
+    state?: "error" | "default" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { inputVariants }
+export { inputVariants as inputVariants_alias_1 }
+export { inputVariants as inputVariants_alias_2 }
+
+declare function Label({ intent, size, className, ...props }: LabelProps): JSX.Element;
+export { Label }
+export { Label as Label_alias_1 }
+export { Label as Label_alias_2 }
+export { Label as Label_alias_3 }
+
+declare type LabelProps = React_2.LabelHTMLAttributes<HTMLLabelElement> & VariantProps<typeof labelVariants>;
+
+declare const labelVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    intent?: "default" | "muted" | "required" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { labelVariants }
+export { labelVariants as labelVariants_alias_1 }
+export { labelVariants as labelVariants_alias_2 }
+
+declare const Layout: {
+    Card: typeof Card;
+    ImageCard: typeof ImageCard;
+    Panel: typeof Panel;
+};
+export { Layout }
+export { Layout as Layout_alias_1 }
+export { Layout as default_alias_6 }
+
+declare function List({ intent, size, className, ...props }: ListProps): JSX.Element;
+export { List }
+export { List as List_alias_1 }
+export { List as List_alias_2 }
+export { List as List_alias_3 }
+
+declare function ListItem({ actions, className, children, ...props }: ListItemProps): JSX.Element;
+export { ListItem }
+export { ListItem as ListItem_alias_1 }
+export { ListItem as ListItem_alias_2 }
+
+declare type ListItemProps = React_2.LiHTMLAttributes<HTMLLIElement> & {
+    /** Action buttons rendered on the right side of the item. */
+    actions?: React_2.ReactNode;
+};
+export { ListItemProps }
+export { ListItemProps as ListItemProps_alias_1 }
+export { ListItemProps as ListItemProps_alias_2 }
+
+declare const listItemVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { listItemVariants }
+export { listItemVariants as listItemVariants_alias_1 }
+export { listItemVariants as listItemVariants_alias_2 }
+
+declare type ListProps = React_2.HTMLAttributes<HTMLUListElement> & VariantProps<typeof listVariants> & {
+    /** Controls item text and icon sizing. @default 'md' */
+    size?: "sm" | "md" | "lg";
+};
+
+declare const listVariants: (props?: ({
+    intent?: "default" | "bordered" | "hover" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { listVariants }
+export { listVariants as listVariants_alias_1 }
+export { listVariants as listVariants_alias_2 }
+
+/**
+ * Pinterest-style waterfall / masonry layout with rich interactions.
+ *
+ * Items are measured and placed into the shortest column, producing
+ * an even distribution regardless of varying item heights.
+ * Fully responsive — column count adapts to parent width.
+ *
+ * Each item supports:
+ * - Hover: cursor pointer, enlarge + elevated shadow + glass-reflection sweep
+ * - Overlay: title / description / action buttons on hover
+ * - Click: ripple flash effect + `onItemClick` callback
+ */
+declare function Masonry({ columns: fixedColumns, columnWidth, gap, items, onItemClick, className, style, children, ...props }: MasonryProps): JSX.Element;
+export { Masonry }
+export { Masonry as Masonry_alias_1 }
+export { Masonry as Masonry_alias_2 }
+export { Masonry as Masonry_alias_3 }
+
+declare type MasonryItemData = {
+    key?: React_2.Key;
+    /** The visual content rendered inside the item. */
+    content: React_2.ReactNode;
+    /** Optional title shown in the hover overlay. */
+    title?: string;
+    /** Optional description shown in the hover overlay. */
+    description?: string;
+    /** Optional action buttons shown in the hover overlay. */
+    actions?: React_2.ReactNode;
+};
+export { MasonryItemData }
+export { MasonryItemData as MasonryItemData_alias_1 }
+export { MasonryItemData as MasonryItemData_alias_2 }
+
+declare type MasonryProps = Omit<React_2.HTMLAttributes<HTMLDivElement>, "onClick"> & {
+    /** Fixed number of columns. Overrides `columnWidth` when set. */
+    columns?: number;
+    /** Minimum column width in pixels. The actual column count is auto-calculated from the container width. @default 240 */
+    columnWidth?: number;
+    /** Gap between items in pixels (horizontal and vertical). @default 16 */
+    gap?: number;
+    /** Structured item list with overlay metadata. When provided, `children` is ignored. */
+    items?: MasonryItemData[];
+    /** Called when an item is clicked. Receives the item data (or undefined for plain children) and the index. */
+    onItemClick?: (item: MasonryItemData | undefined, index: number) => void;
+};
+export { MasonryProps }
+export { MasonryProps as MasonryProps_alias_1 }
+export { MasonryProps as MasonryProps_alias_2 }
+
+declare function MiniPlayer({ playlist, initialTrack, position, entrance: entranceProp, theme, docked: dockedProp, visible: visibleProp, onVisibleChange, onTrackChange, onLike, autoPlay, shuffle: shuffleProp, loop: loopProp, accent, className, }: MiniPlayerProps): JSX.Element;
+export { MiniPlayer }
+export { MiniPlayer as MiniPlayer_alias_1 }
+export { MiniPlayer as MiniPlayer_alias_2 }
+export { MiniPlayer as MiniPlayer_alias_3 }
+
+declare type MiniPlayerEntrance = "bottom" | "top" | "left" | "right";
+export { MiniPlayerEntrance }
+export { MiniPlayerEntrance as MiniPlayerEntrance_alias_1 }
+export { MiniPlayerEntrance as MiniPlayerEntrance_alias_2 }
+
+declare type MiniPlayerPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";
+export { MiniPlayerPosition }
+export { MiniPlayerPosition as MiniPlayerPosition_alias_1 }
+export { MiniPlayerPosition as MiniPlayerPosition_alias_2 }
+
+declare interface MiniPlayerProps {
+    /** Playlist of tracks. */
+    playlist: MiniPlayerTrack[];
+    /** Starting track index. @default 0 */
+    initialTrack?: number;
+    /** Position on screen. @default 'bottom-right' */
+    position?: MiniPlayerPosition;
+    /** Entrance animation direction. @default derived from position */
+    entrance?: MiniPlayerEntrance;
+    /** Theme override. Follows parent by default. */
+    theme?: "dark" | "light";
+    /** When true, player docks to the nearest edge and reveals on hover. @default false */
+    docked?: boolean;
+    /** When true, player is visible (managed externally or auto-shown on track change). */
+    visible?: boolean;
+    /** Called when visibility changes internally. */
+    onVisibleChange?: (v: boolean) => void;
+    /** Called on track change. */
+    onTrackChange?: (index: number, track: MiniPlayerTrack) => void;
+    /** Called on like toggle. */
+    onLike?: (index: number, track: MiniPlayerTrack, liked: boolean) => void;
+    /** Auto-play the first track when ready. @default true */
+    autoPlay?: boolean;
+    /** Initial shuffle state. @default false */
+    shuffle?: boolean;
+    /** Initial single-track loop state. @default false */
+    loop?: boolean;
+    /** Accent color (any CSS color value). @default '#8b5cf6' */
+    accent?: string;
+    /** Extra class name. */
+    className?: string;
+}
+export { MiniPlayerProps }
+export { MiniPlayerProps as MiniPlayerProps_alias_1 }
+export { MiniPlayerProps as MiniPlayerProps_alias_2 }
+
+declare interface MiniPlayerTrack {
+    /** Display title. */
+    title: string;
+    /** Artist name. */
+    artist?: string;
+    /** Album name. */
+    album?: string;
+    /** URL (http/blob/file) or local path for Electron. */
+    src: string;
+    /** Album art URL. Omit to show a placeholder. */
+    cover?: string;
+    /** Duration in seconds (auto-detected if not provided). */
+    duration?: number;
+}
+export { MiniPlayerTrack }
+export { MiniPlayerTrack as MiniPlayerTrack_alias_1 }
+export { MiniPlayerTrack as MiniPlayerTrack_alias_2 }
+
+declare const Navigation: {
+    SideNav: typeof SideNav;
+    Header: typeof Header;
+    NavLink: typeof NavLink;
+};
+export { Navigation }
+export { Navigation as Navigation_alias_1 }
+export { Navigation as default_alias_7 }
+
+declare function NavLink({ intent, size, underline, external, className, children, href, target, rel, ...props }: NavLinkProps): JSX.Element;
+export { NavLink }
+export { NavLink as NavLink_alias_1 }
+export { NavLink as NavLink_alias_2 }
+export { NavLink as NavLink_alias_3 }
+
+declare type NavLinkProps = React_2.AnchorHTMLAttributes<HTMLAnchorElement> & VariantProps<typeof navLinkVariants> & {
+    /** Show external-link icon. Defaults to `true` when `target="_blank"` or href starts with `http`. */
+    external?: boolean;
+};
+
+declare const navLinkVariants: (props?: ({
+    intent?: "secondary" | "default" | "muted" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    underline?: "none" | "always" | "hover" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { navLinkVariants }
+export { navLinkVariants as navLinkVariants_alias_1 }
+export { navLinkVariants as navLinkVariants_alias_2 }
+
+declare const Overlay: {
+    Dialog: typeof Dialog;
+    Tooltip: typeof Tooltip;
+};
+export { Overlay }
+export { Overlay as Overlay_alias_1 }
+export { Overlay as default_alias_8 }
+
+export declare function PageTitle({ children }: {
+    children: React_2.ReactNode;
+}): JSX.Element;
+
+declare function Panel({ intent, size, className, ...props }: PanelProps): JSX.Element;
+export { Panel }
+export { Panel as Panel_alias_1 }
+export { Panel as Panel_alias_2 }
+export { Panel as Panel_alias_3 }
+
+declare function PanelContent({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { PanelContent }
+export { PanelContent as PanelContent_alias_1 }
+export { PanelContent as PanelContent_alias_2 }
+
+declare function PanelHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { PanelHeader }
+export { PanelHeader as PanelHeader_alias_1 }
+export { PanelHeader as PanelHeader_alias_2 }
+
+declare type PanelProps = React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof panelVariants>;
+
+declare const panelVariants: (props?: ({
+    intent?: "default" | "inset" | "elevated" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { panelVariants }
+export { panelVariants as panelVariants_alias_1 }
+export { panelVariants as panelVariants_alias_2 }
+
+declare const Primitives: {
+    Button: typeof Button;
+    Dropdown: typeof Dropdown;
+    DropdownButton: typeof DropdownButton;
+    Badge: typeof Badge;
+    Indicator: typeof Indicator;
+    Label: typeof Label;
+    Input: typeof Input;
+    TextBox: typeof TextBox;
+    Switch: typeof Switch;
+    Checkbox: typeof Checkbox;
+    Radio: typeof Radio;
+    RadioGroup: typeof RadioGroup;
+};
+export { Primitives }
+export { Primitives as Primitives_alias_1 }
+export { Primitives as default_alias_9 }
+
+declare function ProgressBar({ value, size, intent, edge, showLabel, indeterminate, animated, duration, className, ...props }: ProgressBarProps): JSX.Element;
+export { ProgressBar }
+export { ProgressBar as ProgressBar_alias_1 }
+export { ProgressBar as ProgressBar_alias_2 }
+export { ProgressBar as ProgressBar_alias_3 }
+
+declare type ProgressBarProps = React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof progressBarVariants> & {
+    /** Current value 0–100 */
+    value?: number;
+    /** Show the percentage label inside the bar */
+    showLabel?: boolean;
+    /** Enable the indeterminate (loading) animation — ignores `value` */
+    indeterminate?: boolean;
+    /** Enable the shine / pulse glow animation on the fill */
+    animated?: boolean;
+    /** Duration of the value transition in ms @default 500 */
+    duration?: number;
+};
+export { ProgressBarProps }
+export { ProgressBarProps as ProgressBarProps_alias_1 }
+export { ProgressBarProps as ProgressBarProps_alias_2 }
+
+declare const progressBarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+    intent?: "primary" | "danger" | "warning" | "success" | null | undefined;
+    edge?: "none" | "bottom" | "top" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { progressBarVariants }
+export { progressBarVariants as progressBarVariants_alias_1 }
+export { progressBarVariants as progressBarVariants_alias_2 }
+
+declare function Radio({ value, intent: intentProp, size: sizeProp, label, id: propId, className, disabled: disabledProp, ...props }: RadioProps): JSX.Element;
+export { Radio }
+export { Radio as Radio_alias_1 }
+export { Radio as Radio_alias_2 }
+export { Radio as Radio_alias_3 }
+
+declare function RadioGroup({ name: nameProp, value: controlledValue, defaultValue, onValueChange, intent, size, disabled, orientation, className, children, }: RadioGroupProps): JSX.Element;
+export { RadioGroup }
+export { RadioGroup as RadioGroup_alias_1 }
+export { RadioGroup as RadioGroup_alias_2 }
+export { RadioGroup as RadioGroup_alias_3 }
+
+declare interface RadioGroupProps {
+    /** Form field name shared by all radios. */
+    name?: string;
+    /** Controlled selected value. */
+    value?: string;
+    /** Default selected value (uncontrolled). */
+    defaultValue?: string;
+    /** Callback when selection changes. */
+    onValueChange?: (value: string) => void;
+    /** Shared intent for all child radios. */
+    intent?: VariantProps<typeof radioVariants>["intent"];
+    /** Shared size for all child radios. */
+    size?: VariantProps<typeof radioVariants>["size"];
+    disabled?: boolean;
+    /** Layout direction of the radio buttons. @default 'vertical' */
+    orientation?: "vertical" | "horizontal";
+    className?: string;
+    children: React_2.ReactNode;
+}
+export { RadioGroupProps }
+export { RadioGroupProps as RadioGroupProps_alias_1 }
+export { RadioGroupProps as RadioGroupProps_alias_2 }
+
+declare type RadioProps = Omit<React_2.InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & Omit<VariantProps<typeof radioVariants>, "checked"> & {
+    /** The value of this radio option. */
+    value: string;
+    /** Accessible label text shown beside the radio. */
+    label?: string;
+};
+export { RadioProps }
+export { RadioProps as RadioProps_alias_1 }
+export { RadioProps as RadioProps_alias_2 }
+
+declare const radioVariants: (props?: ({
+    intent?: "primary" | "secondary" | "danger" | "warning" | "success" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    checked?: "on" | "off" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { radioVariants }
+export { radioVariants as radioVariants_alias_1 }
+export { radioVariants as radioVariants_alias_2 }
+
+declare function removeAlert(id: string): void;
+
+export declare function Section({ title, children }: {
+    title: string;
+    children: React_2.ReactNode;
+}): JSX.Element;
+
+declare type SelectionMode_2 = "none" | "single" | "multiple";
+export { SelectionMode_2 as SelectionMode }
+export { SelectionMode_2 as SelectionMode_alias_1 }
+export { SelectionMode_2 as SelectionMode_alias_2 }
+
+declare function SideNav({ items, title, basePath, onItemClick, LinkComponent, collapsible, collapseMode: controlledMode, defaultCollapseMode, onCollapseModeChange, showLines, expandedKeys: controlledExpandedKeys, defaultExpandedKeys, onExpandedKeysChange, className, responsive, mobileBreakpoint, mobileTopOffset, ...props }: SideNavProps): JSX.Element;
+export { SideNav }
+export { SideNav as SideNav_alias_1 }
+export { SideNav as SideNav_alias_2 }
+export { SideNav as SideNav_alias_3 }
+
+declare type SideNavCollapseMode = "expanded" | "icons" | "mini";
+export { SideNavCollapseMode }
+export { SideNavCollapseMode as SideNavCollapseMode_alias_1 }
+export { SideNavCollapseMode as SideNavCollapseMode_alias_2 }
+
+declare interface SideNavItem {
+    /** Unique key (falls back to `path` or `label`). */
+    key?: string;
+    /** Display label. */
+    label: string;
+    /** Route path — renders a link when provided. */
+    path?: string;
+    /** Nested children — renders a collapsible group. */
+    children?: SideNavItem[];
+    /** Icon element shown before the label. */
+    icon?: React_2.ReactNode;
+    /** Whether the group is expanded by default (only for items with children). */
+    defaultOpen?: boolean;
+}
+export { SideNavItem }
+export { SideNavItem as SideNavItem_alias_1 }
+export { SideNavItem as SideNavItem_alias_2 }
+
+/**
+ * Props for a custom link component.
+ * When using react-router, pass NavLink. When using plain HTML, an `<a>` wrapper.
+ */
+declare type SideNavLinkComponentProps = {
+    to: string;
+    className: string | ((props: {
+        isActive: boolean;
+    }) => string);
+    style?: React_2.CSSProperties;
+    children: React_2.ReactNode;
+};
+export { SideNavLinkComponentProps }
+export { SideNavLinkComponentProps as SideNavLinkComponentProps_alias_1 }
+export { SideNavLinkComponentProps as SideNavLinkComponentProps_alias_2 }
+
+declare interface SideNavProps extends React_2.HTMLAttributes<HTMLElement> {
+    /** Navigation items (supports nesting). */
+    items: SideNavItem[];
+    /** Section title rendered above the items. */
+    title?: string;
+    /** Base path prefix prepended to every item `path`. Defaults to `"/"`. */
+    basePath?: string;
+    /** When provided, renders buttons instead of links and calls this on click. */
+    onItemClick?: (item: SideNavItem, fullPath: string) => void;
+    /**
+     * Custom link component (e.g. react-router's NavLink).
+     * Falls back to a plain `<a>` tag if not provided.
+     */
+    LinkComponent?: React_2.ComponentType<SideNavLinkComponentProps>;
+    /** Show collapse / expand toggle. */
+    collapsible?: boolean;
+    /** Controlled collapse mode. */
+    collapseMode?: SideNavCollapseMode;
+    /** Default collapse mode (uncontrolled). @default 'expanded' */
+    defaultCollapseMode?: SideNavCollapseMode;
+    /** Fires when collapse mode changes. */
+    onCollapseModeChange?: (mode: SideNavCollapseMode) => void;
+    /** Show indentation guide lines for nested items. @default true */
+    showLines?: boolean;
+    /**
+     * Controlled set of expanded group keys.
+     * Each key is `item.key ?? item.label`.
+     */
+    expandedKeys?: Set<string>;
+    /** Default expanded keys (uncontrolled). When omitted all groups start open. */
+    defaultExpandedKeys?: Set<string> | "all";
+    /** Fires when a group is toggled. */
+    onExpandedKeysChange?: (keys: Set<string>) => void;
+    /**
+     * Enable built-in responsive behaviour: a floating action button toggles a slide-in
+     * overlay drawer on narrow viewports, so the nav never occupies layout space on mobile.
+     * @default true
+     */
+    responsive?: boolean;
+    /** Viewport width (px) below which mobile mode activates. @default 768 */
+    mobileBreakpoint?: number;
+    /**
+     * Distance (px) from the top of the viewport where the mobile drawer starts.
+     * Set this to the height of your app's top bar. @default 48
+     */
+    mobileTopOffset?: number;
+}
+export { SideNavProps }
+export { SideNavProps as SideNavProps_alias_1 }
+export { SideNavProps as SideNavProps_alias_2 }
+
+declare function SortableTable<T, K extends string = string>({ columns, data, sort: controlledSort, onSortChange, defaultSort, rowKey, rowActions, intent, density, className, empty, }: SortableTableProps<T, K>): JSX.Element;
+export { SortableTable }
+export { SortableTable as SortableTable_alias_1 }
+export { SortableTable as SortableTable_alias_2 }
+
+declare type SortableTableProps<T, K extends string = string> = {
+    columns: ColumnDef<T, K>[];
+    data: T[];
+    sort?: SortState<K>;
+    onSortChange?: (sort: SortState<K>) => void;
+    defaultSort?: SortState<K>;
+    rowKey?: (row: T, index: number) => React_2.Key;
+    /** Render action buttons for each row. Receives the row data object. */
+    rowActions?: (row: T) => React_2.ReactNode;
+    intent?: VariantProps<typeof tableVariants>["intent"];
+    density?: VariantProps<typeof tableVariants>["density"];
+    className?: string;
+    /** Custom empty state props (icon, text). Shown when data is empty. */
+    empty?: TableEmptyProps;
+};
+
+declare type SortDirection = "asc" | "desc";
+export { SortDirection }
+export { SortDirection as SortDirection_alias_1 }
+export { SortDirection as SortDirection_alias_2 }
+
+declare type SortState<K extends string = string> = {
+    column: K;
+    direction: SortDirection;
+} | null;
+export { SortState }
+export { SortState as SortState_alias_1 }
+export { SortState as SortState_alias_2 }
+
+/**
+ * Inline Spin overlay.
+ * Wraps children and covers them with a loading mask when `spinning` is true.
+ * Without children it renders a standalone spinner.
+ */
+declare function Spin({ spinning, tip, size, className, children, ...props }: SpinProps): JSX.Element | null;
+export { Spin }
+export { Spin as Spin_alias_1 }
+export { Spin as Spin_alias_2 }
+export { Spin as Spin_alias_3 }
+
+declare type SpinProps = React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof spinVariants> & {
+    /** Whether the spinner and overlay are active */
+    spinning?: boolean;
+    /** Tip text shown below the spinner */
+    tip?: string;
+};
+export { SpinProps }
+export { SpinProps as SpinProps_alias_1 }
+export { SpinProps as SpinProps_alias_2 }
+
+declare const spinVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { spinVariants }
+export { spinVariants as spinVariants_alias_1 }
+export { spinVariants as spinVariants_alias_2 }
+
+declare function Switch({ checked: controlledChecked, defaultChecked, onCheckedChange, checkedContent, uncheckedContent, intent, size, label, id: propId, className, disabled, ...props }: SwitchProps): JSX.Element;
+export { Switch }
+export { Switch as Switch_alias_1 }
+export { Switch as Switch_alias_2 }
+export { Switch as Switch_alias_3 }
+
+declare type SwitchProps = Omit<React_2.InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & Omit<VariantProps<typeof switchTrackVariants>, "checked"> & {
+    /** Controlled checked state. */
+    checked?: boolean;
+    /** Default checked state (uncontrolled). */
+    defaultChecked?: boolean;
+    /** Callback when the switch is toggled. */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Text/icon shown when checked (inside the track). */
+    checkedContent?: React_2.ReactNode;
+    /** Text/icon shown when unchecked (inside the track). */
+    uncheckedContent?: React_2.ReactNode;
+    /** Accessible label text shown beside the switch. */
+    label?: string;
+};
+export { SwitchProps }
+export { SwitchProps as SwitchProps_alias_1 }
+export { SwitchProps as SwitchProps_alias_2 }
+
+declare const switchTrackVariants: (props?: ({
+    intent?: "primary" | "secondary" | "danger" | "warning" | "success" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    checked?: "on" | "off" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { switchTrackVariants }
+export { switchTrackVariants as switchTrackVariants_alias_1 }
+export { switchTrackVariants as switchTrackVariants_alias_2 }
+
+declare function TabContent({ value, className, children, ...props }: TabContentProps): JSX.Element | null;
+export { TabContent }
+export { TabContent as TabContent_alias_1 }
+export { TabContent as TabContent_alias_2 }
+
+declare type TabContentProps = React_2.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+};
+
+declare function Table({ intent, density, className, ...props }: TableProps): JSX.Element;
+export { Table }
+export { Table as Table_alias_1 }
+export { Table as Table_alias_2 }
+export { Table as Table_alias_3 }
+
+declare function TableBody({ className, ...props }: React_2.HTMLAttributes<HTMLTableSectionElement>): JSX.Element;
+export { TableBody }
+export { TableBody as TableBody_alias_1 }
+export { TableBody as TableBody_alias_2 }
+
+declare function TableCell({ className, ...props }: React_2.TdHTMLAttributes<HTMLTableCellElement>): JSX.Element;
+export { TableCell }
+export { TableCell as TableCell_alias_1 }
+export { TableCell as TableCell_alias_2 }
+
+declare function TableEmpty({ icon, text, className }: TableEmptyProps): JSX.Element;
+export { TableEmpty }
+export { TableEmpty as TableEmpty_alias_1 }
+export { TableEmpty as TableEmpty_alias_2 }
+
+declare type TableEmptyProps = {
+    /** Custom icon to display. Defaults to Inbox. */
+    icon?: React_2.ReactNode;
+    /** Text shown below the icon. @default "No data" */
+    text?: React_2.ReactNode;
+    className?: string;
+};
+export { TableEmptyProps }
+export { TableEmptyProps as TableEmptyProps_alias_1 }
+export { TableEmptyProps as TableEmptyProps_alias_2 }
+
+declare function TableHead({ className, ...props }: React_2.ThHTMLAttributes<HTMLTableCellElement>): JSX.Element;
+export { TableHead }
+export { TableHead as TableHead_alias_1 }
+export { TableHead as TableHead_alias_2 }
+
+declare function TableHeader({ className, ...props }: React_2.HTMLAttributes<HTMLTableSectionElement>): JSX.Element;
+export { TableHeader }
+export { TableHeader as TableHeader_alias_1 }
+export { TableHeader as TableHeader_alias_2 }
+
+declare type TableProps = React_2.TableHTMLAttributes<HTMLTableElement> & VariantProps<typeof tableVariants>;
+
+declare function TableRow({ className, ...props }: React_2.HTMLAttributes<HTMLTableRowElement>): JSX.Element;
+export { TableRow }
+export { TableRow as TableRow_alias_1 }
+export { TableRow as TableRow_alias_2 }
+
+declare const tableVariants: (props?: ({
+    intent?: "default" | "striped" | "bordered" | null | undefined;
+    density?: "default" | "compact" | "relaxed" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { tableVariants }
+export { tableVariants as tableVariants_alias_1 }
+export { tableVariants as tableVariants_alias_2 }
+
+declare function TabList({ className, scrollable, ...props }: React_2.HTMLAttributes<HTMLDivElement> & {
+    scrollable?: boolean;
+}): JSX.Element;
+export { TabList }
+export { TabList as TabList_alias_1 }
+export { TabList as TabList_alias_2 }
+
+declare const tabListVariants: (props?: ({
+    intent?: "underline" | "line" | "pills" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { tabListVariants }
+export { tabListVariants as tabListVariants_alias_1 }
+export { tabListVariants as tabListVariants_alias_2 }
+
+declare function TabPanels({ className, children, ...props }: TabPanelsProps): JSX.Element | null;
+export { TabPanels }
+export { TabPanels as TabPanels_alias_1 }
+export { TabPanels as TabPanels_alias_2 }
+
+declare type TabPanelsProps = React_2.HTMLAttributes<HTMLDivElement>;
+
+declare function Tabs({ defaultValue, value, onValueChange, intent, children, className, }: TabsProps): JSX.Element;
+export { Tabs }
+export { Tabs as Tabs_alias_1 }
+export { Tabs as Tabs_alias_2 }
+export { Tabs as Tabs_alias_3 }
+
+declare type TabsProps = {
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    intent?: VariantProps<typeof tabListVariants>["intent"];
+    children: React_2.ReactNode;
+    className?: string;
+};
+
+declare function TabTrigger({ value, className, children, ...props }: TabTriggerProps): JSX.Element;
+export { TabTrigger }
+export { TabTrigger as TabTrigger_alias_1 }
+export { TabTrigger as TabTrigger_alias_2 }
+
+declare type TabTriggerProps = React_2.ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: string;
+};
+
+declare const tabTriggerVariants: (props?: ({
+    intent?: "underline" | "line" | "pills" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { tabTriggerVariants }
+export { tabTriggerVariants as tabTriggerVariants_alias_1 }
+export { tabTriggerVariants as tabTriggerVariants_alias_2 }
+
+declare function TextBox({ state, size, showWordCount, maxWords, className, value: controlledValue, defaultValue, onChange, disabled, ...props }: TextBoxProps): JSX.Element;
+export { TextBox }
+export { TextBox as TextBox_alias_1 }
+export { TextBox as TextBox_alias_2 }
+export { TextBox as TextBox_alias_3 }
+
+declare type TextBoxProps = Omit<React_2.TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> & {
+    /** Visual state. @default 'default' */
+    state?: "default" | "error";
+    /** Size variant. @default 'md' */
+    size?: "sm" | "md" | "lg";
+    /** Show a live word count below the textarea. @default false */
+    showWordCount?: boolean;
+    /** Maximum number of words. When exceeded the counter turns red. */
+    maxWords?: number;
+};
+export { TextBoxProps }
+export { TextBoxProps as TextBoxProps_alias_1 }
+export { TextBoxProps as TextBoxProps_alias_2 }
+
+declare function Tooltip({ content, position, intent, delay, maxWidth, children, className, }: TooltipProps): JSX.Element;
+export { Tooltip }
+export { Tooltip as Tooltip_alias_1 }
+export { Tooltip as Tooltip_alias_2 }
+export { Tooltip as Tooltip_alias_3 }
+
+declare type TooltipPosition = "top" | "bottom" | "left" | "right";
+
+declare type TooltipProps = VariantProps<typeof tooltipVariants> & {
+    content: React_2.ReactNode;
+    position?: TooltipPosition;
+    delay?: number;
+    children: React_2.ReactNode;
+    className?: string;
+    /** Maximum width of the tooltip. Allows text to wrap. @default undefined (no wrap) */
+    maxWidth?: string | number;
+};
+
+declare const tooltipVariants: (props?: ({
+    intent?: "default" | "light" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { tooltipVariants }
+export { tooltipVariants as tooltipVariants_alias_1 }
+export { tooltipVariants as tooltipVariants_alias_2 }
+
+declare function Tree({ showLines, showRoot, expandedKeys: controlledKeys, defaultExpandedKeys, onExpandedKeysChange, size, className, children, ...props }: TreeProps): JSX.Element;
+export { Tree }
+export { Tree as Tree_alias_1 }
+export { Tree as Tree_alias_2 }
+export { Tree as Tree_alias_3 }
+
+declare function TreeItem({ nodeKey, label, icon, actions, defaultExpanded, expanded: controlledExpanded, onToggle, children, className, }: TreeItemProps): JSX.Element;
+export { TreeItem }
+export { TreeItem as TreeItem_alias_1 }
+export { TreeItem as TreeItem_alias_2 }
+
+declare type TreeItemProps = {
+    /** Unique key for programmatic expand control. Falls back to label string. */
+    nodeKey?: string;
+    label: React_2.ReactNode;
+    icon?: React_2.ReactNode;
+    /** Action buttons shown on hover at the right side of the item row. */
+    actions?: React_2.ReactNode;
+    defaultExpanded?: boolean;
+    expanded?: boolean;
+    onToggle?: (expanded: boolean) => void;
+    children?: React_2.ReactNode;
+    className?: string;
+};
+
+declare const treeItemVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { treeItemVariants }
+export { treeItemVariants as treeItemVariants_alias_1 }
+export { treeItemVariants as treeItemVariants_alias_2 }
+
+declare type TreeProps = React_2.HTMLAttributes<HTMLUListElement> & {
+    /** Show indent guide lines between parent and children. @default true */
+    showLines?: boolean;
+    /** Render the root-level items. When false, only their children are shown. @default true */
+    showRoot?: boolean;
+    /**
+     * Controlled set of expanded node keys.
+     * Each key is `TreeItem.nodeKey` (falls back to label string).
+     */
+    expandedKeys?: Set<string>;
+    /** Default expanded keys (uncontrolled). Pass `'all'` to expand everything. */
+    defaultExpandedKeys?: Set<string> | "all";
+    /** Fires when a node is toggled. */
+    onExpandedKeysChange?: (keys: Set<string>) => void;
+    /** Controls item text and icon sizing. @default 'md' */
+    size?: "sm" | "md" | "lg";
+};
+
+declare function useAlert(): {
+    addAlert: typeof addAlert;
+    removeAlert: typeof removeAlert;
+};
+export { useAlert }
+export { useAlert as useAlert_alias_1 }
+export { useAlert as useAlert_alias_2 }
+
+/**
+ * Returns a `setSpin(target, tip?)` function.
+ * Each call returns a **close** function to dismiss that specific overlay.
+ */
+declare function useSpin(): typeof addSpin;
+export { useSpin }
+export { useSpin as useSpin_alias_1 }
+export { useSpin as useSpin_alias_2 }
+
+/** Callback type for FormItem's `onValidate` prop. */
+declare type ValidateCallback = (value: unknown) => ValidationResult;
+export { ValidateCallback }
+export { ValidateCallback as ValidateCallback_alias_1 }
+export { ValidateCallback as ValidateCallback_alias_2 }
+
+/** Return value of a FormItem validation callback. */
+declare type ValidationResult = {
+    result: boolean;
+    reason: string;
+};
+export { ValidationResult }
+export { ValidationResult as ValidationResult_alias_1 }
+export { ValidationResult as ValidationResult_alias_2 }
+
+export { }