entangle-ui 0.8.2 → 0.10.0

package/dist/types/components/Icons/UsersIcon.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
 import { IconSize, IconColor } from '../primitives/Icon/Icon.js';
+import React from 'react';
 
 /**
  * Users icon component for groups, teams, and multi-user contexts.

package/dist/types/components/Icons/WarningIcon.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
 import { IconSize, IconColor } from '../primitives/Icon/Icon.js';
+import React from 'react';
 
 /**
  * Warning icon component for warning states.

package/dist/types/components/Icons/ZoomInIcon.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
 import { IconSize, IconColor } from '../primitives/Icon/Icon.js';
+import React from 'react';
 
 /**
  * Zoom In icon component for zoom in actions.

package/dist/types/components/Icons/ZoomOutIcon.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
 import { IconSize, IconColor } from '../primitives/Icon/Icon.js';
+import React from 'react';
 
 /**
  * Zoom Out icon component for zoom out actions.

package/dist/types/components/controls/CartesianPicker/CartesianPicker.types.d.ts

@@ -1,7 +1,7 @@
-import React from 'react';
-import { Prettify } from '../../../types/utilities.js';
-import { BaseComponent, Size } from '../../../types/common.js';
 import { Point2D, CanvasBackgroundInfo } from '../../primitives/canvas/canvas.types.js';
+import { BaseComponent, Size } from '../../../types/common.js';
+import { Prettify } from '../../../types/utilities.js';
+import React from 'react';
 
 type CartesianPickerSize = Size;
 interface CartesianPickerBaseProps extends Omit<BaseComponent, 'onChange' | 'value' | 'defaultValue'> {

package/dist/types/components/controls/ColorPicker/ColorPicker.types.d.ts

@@ -1,8 +1,8 @@
-import { Prettify } from '../../../types/utilities.js';
-import { BaseComponent, Size } from '../../../types/common.js';
 import { ColorFormat as ColorFormat$1 } from './colorUtils.js';
 import { Palette, PaletteColor } from './palettes/material.js';
 export { PaletteShade } from './palettes/material.js';
+import { BaseComponent, Size } from '../../../types/common.js';
+import { Prettify } from '../../../types/utilities.js';
 
 type ColorFormat = ColorFormat$1;
 type ColorPickerSize = Size;

package/dist/types/components/controls/ColorPicker/EyeDropper.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { Prettify } from '../../../types/utilities.js';
 import { BaseComponent, Size } from '../../../types/common.js';
+import { Prettify } from '../../../types/utilities.js';
 
 interface EyeDropperBaseProps extends Omit<BaseComponent<HTMLButtonElement>, 'onChange'> {
     /** Callback when a color is picked */

package/dist/types/components/controls/Combobox/Combobox.d.ts

@@ -0,0 +1,29 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ComboboxProps } from './Combobox.types.js';
+
+/**
+ * Single-value select with an editable input. Filters the option list as the
+ * user types (built-in fuzzy matcher, configurable via `filterFn`), supports
+ * controlled and uncontrolled modes, optional `freeSolo` typing, optional
+ * `creatable` mode for adding new entries, and an `loading` state for async
+ * data sources.
+ *
+ * @example
+ * ```tsx
+ * <Combobox
+ *   label="Framework"
+ *   options={[
+ *     { value: 'react', label: 'React' },
+ *     { value: 'vue', label: 'Vue' },
+ *   ]}
+ *   value={framework}
+ *   onChange={setFramework}
+ * />
+ * ```
+ */
+declare function Combobox<T extends string = string>({ value, defaultValue, options, placeholder, filterFn, emptyMessage, loading, loadingMessage, freeSolo, creatable, createLabel, openOnFocus, size, variant, label, helperText, error, errorMessage, disabled, required, readOnly, clearable, maxDropdownHeight, minDropdownWidth, name, onChange, onInputChange, onCreate, onOpenChange, className, style, testId, ref, id: idProp, ...rest }: ComboboxProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace Combobox {
+    var displayName: string;
+}
+
+export { Combobox };

package/dist/types/components/controls/Combobox/Combobox.types.d.ts

@@ -0,0 +1,109 @@
+import { BaseComponent, Size } from '../../../types/common.js';
+import { Prettify } from '../../../types/utilities.js';
+import React from 'react';
+
+type ComboboxSize = Size;
+type ComboboxVariant = 'default' | 'ghost' | 'filled';
+interface ComboboxOption<T extends string = string> {
+    /** Unique value used for selection */
+    value: T;
+    /** Display label (falls back to value when omitted) */
+    label?: string;
+    /** Optional description rendered next to the label */
+    description?: string;
+    /** Optional icon rendered before the label */
+    icon?: React.ReactNode;
+    /** Whether this option is disabled */
+    disabled?: boolean;
+}
+interface ComboboxBaseProps<T extends string = string> extends Omit<BaseComponent<HTMLInputElement>, 'onChange' | 'value' | 'defaultValue' | 'children'> {
+    /** Controlled selected value */
+    value?: T | null;
+    /** Default selected value (uncontrolled) */
+    defaultValue?: T;
+    /** Available options */
+    options: ComboboxOption<T>[];
+    /** Placeholder rendered when the input is empty */
+    placeholder?: string;
+    /**
+     * Custom filter function. Receives the raw query and the option, returns
+     * either a boolean (`true` to keep) or a numeric score (higher = better).
+     * When omitted, options are filtered by the built-in fuzzy matcher
+     * (`fuzzyScore`).
+     */
+    filterFn?: (option: ComboboxOption<T>, query: string) => boolean | number;
+    /** Message shown when filtering yields no results */
+    emptyMessage?: string;
+    /** Loading indicator state — replaces options with a spinner row */
+    loading?: boolean;
+    /** Message shown while loading */
+    loadingMessage?: string;
+    /**
+     * Allow values not present in `options`. The `onChange` handler still fires
+     * with the user-typed string when the input is blurred or `Enter` is pressed
+     * with no active suggestion.
+     * @default false
+     */
+    freeSolo?: boolean;
+    /**
+     * When true the user can create a brand new option by pressing Enter on a
+     * value that doesn't match any existing option. The `onCreate` callback (or
+     * `onChange` when omitted) is invoked. Implies `freeSolo`.
+     * @default false
+     */
+    creatable?: boolean;
+    /**
+     * Render the "create" row when `creatable` is true and the query has no
+     * exact match. Defaults to `'Create "<query>"'`.
+     */
+    createLabel?: (query: string) => React.ReactNode;
+    /**
+     * Open the dropdown automatically when the input gains focus, even when no
+     * query is typed yet.
+     * @default false
+     */
+    openOnFocus?: boolean;
+    /** Component size */
+    size?: ComboboxSize;
+    /** Visual variant */
+    variant?: ComboboxVariant;
+    /** Label rendered above the input */
+    label?: string;
+    /** Helper text rendered below */
+    helperText?: string;
+    /** Error state */
+    error?: boolean;
+    /** Error message — overrides `helperText` when `error` is true */
+    errorMessage?: string;
+    /** Disable the input */
+    disabled?: boolean;
+    /** Mark the field as required */
+    required?: boolean;
+    /** Read-only — input value is fixed */
+    readOnly?: boolean;
+    /** Show a clear button when a value is selected */
+    clearable?: boolean;
+    /** Maximum dropdown height in pixels */
+    maxDropdownHeight?: number;
+    /** Minimum dropdown width in pixels */
+    minDropdownWidth?: number;
+    /** Hidden form-input name */
+    name?: string;
+    /** Selection change handler. `null` is passed when the value is cleared. */
+    onChange?: (value: T | null) => void;
+    /**
+     * Free-text change handler. Fires every keystroke regardless of selection
+     * status. Useful for async option loading.
+     */
+    onInputChange?: (input: string) => void;
+    /**
+     * Called when the user creates a new option (only when `creatable` is set).
+     * Falls back to `onChange` with the typed string cast as `T` when omitted.
+     */
+    onCreate?: (input: string) => void;
+    /** Open state change handler */
+    onOpenChange?: (open: boolean) => void;
+}
+type ComboboxProps<T extends string = string> = Prettify<ComboboxBaseProps<T>>;
+
+export type { ComboboxBaseProps, ComboboxOption, ComboboxProps, ComboboxSize, ComboboxVariant };

package/dist/types/components/controls/CurveEditor/CurveEditor.types.d.ts

@@ -1,63 +1,12 @@
-import React from 'react';
-import { Prettify } from '../../../types/utilities.js';
-import { BaseComponent, Size } from '../../../types/common.js';
 import { CanvasBackgroundInfo, CanvasViewport } from '../../primitives/canvas/canvas.types.js';
+import { BaseComponent, Size } from '../../../types/common.js';
+import { CurveData, CurveKeyframe } from '../../../types/keyframe.js';
+export { TangentMode } from '../../../types/keyframe.js';
+import { Prettify } from '../../../types/utilities.js';
+import React from 'react';
 
 type CurveEditorSize = Size;
-/**
- * Tangent handle mode — controls how handles behave around a keyframe.
- * - `free`: Each handle moves independently
- * - `aligned`: Handles stay co-linear but can differ in length
- * - `mirrored`: Handles are symmetric (same angle and length)
- * - `auto`: Smooth catmull-rom style — handles auto-computed from neighbors
- * - `linear`: No handles — straight line segments
- * - `step`: Constant value until next keyframe (hold / step function)
- */
-type TangentMode = 'free' | 'aligned' | 'mirrored' | 'auto' | 'linear' | 'step';
-/**
- * Single control point (keyframe) on the curve.
- */
-interface CurveKeyframe {
-    /** X position in domain space (e.g., 0-1 for normalized, 0-100 for frames) */
-    x: number;
-    /** Y value at this position */
-    y: number;
-    /** Left tangent handle offset (relative to keyframe position) */
-    handleIn: {
-        x: number;
-        y: number;
-    };
-    /** Right tangent handle offset (relative to keyframe position) */
-    handleOut: {
-        x: number;
-        y: number;
-    };
-    /** Tangent mode for this keyframe */
-    tangentMode: TangentMode;
-    /** Optional unique ID (auto-generated if not provided) */
-    id?: string;
-}
-/**
- * Complete curve data model.
- */
-interface CurveData {
-    /** Ordered array of keyframes (sorted by x) */
-    keyframes: CurveKeyframe[];
-    /** Domain bounds — x range */
-    domainX: [number, number];
-    /** Domain bounds — y range */
-    domainY: [number, number];
-    /**
-     * Pre-infinity behavior — what happens before the first keyframe
-     * @default "constant"
-     */
-    preInfinity?: 'constant' | 'linear' | 'cycle' | 'pingpong';
-    /**
-     * Post-infinity behavior — what happens after the last keyframe
-     * @default "constant"
-     */
-    postInfinity?: 'constant' | 'linear' | 'cycle' | 'pingpong';
-}
+
 interface CurveEditorBaseProps extends Omit<BaseComponent, 'onChange' | 'value' | 'defaultValue'> {
     /**
      * Curve data (controlled)
@@ -286,4 +235,5 @@ interface CurveViewport extends CanvasViewport {
     panY: number;
 }
 
-export type { CurveBackgroundInfo, CurveBottomBarInfo, CurveData, CurveEditorBaseProps, CurveEditorProps, CurveEditorSize, CurveKeyframe, CurvePreset, CurveViewport, TangentMode };
+export { CurveData, CurveKeyframe };
+export type { CurveBackgroundInfo, CurveBottomBarInfo, CurveEditorBaseProps, CurveEditorProps, CurveEditorSize, CurvePreset, CurveViewport };

package/dist/types/components/controls/CurveEditor/curveUtils.d.ts

@@ -1,5 +1,6 @@
+import { CurveViewport } from './CurveEditor.types.js';
 import { CanvasViewport } from '../../primitives/canvas/canvas.types.js';
-import { CurveData, CurveViewport } from './CurveEditor.types.js';
+import { CurveData } from '../../../types/keyframe.js';
 
 /**
  * Evaluate the entire curve at a given X position.

package/dist/types/components/controls/FileTree/FileTree.d.ts

@@ -0,0 +1,34 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { FileTreeProps } from './FileTree.types.js';
+
+/**
+ * A file-system-flavored specialization of {@link TreeView}: it maps a
+ * file/folder model onto the tree, auto-assigns file-type icons (by extension)
+ * and open/closed folder glyphs, and adds drag-and-drop import of OS files onto
+ * a folder (or the root). Expansion, selection, keyboard navigation, and sizing
+ * are inherited from TreeView unchanged.
+ *
+ * @example
+ * ```tsx
+ * const nodes: FileTreeNode[] = [
+ *   { id: 'src', name: 'src', kind: 'folder', children: [
+ *     { id: 'btn', name: 'Button.tsx', kind: 'file' },
+ *     { id: 'logo', name: 'logo.svg', kind: 'file' },
+ *   ]},
+ * ];
+ *
+ * <FileTree
+ *   nodes={nodes}
+ *   defaultExpandedIds={['src']}
+ *   onImport={({ files, targetFolder }) =>
+ *     uploadInto(targetFolder?.id ?? 'root', files)
+ *   }
+ * />
+ * ```
+ */
+declare const FileTree: {
+    ({ nodes, expandedIds, defaultExpandedIds, onExpandedChange, selectedIds, defaultSelectedIds, selectionMode, onSelectionChange, size, indent, showChevrons, showGuideLines, expandOnClick, maxHeight, resolveIcon, renderNode, renderActions, emptyContent, onImport, onNodeClick, onNodeDoubleClick, onNodeContextMenu, labels: labelsProp, className, style, testId, ref, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, ...rest }: FileTreeProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+export { FileTree };

package/dist/types/components/controls/FileTree/FileTree.types.d.ts

@@ -0,0 +1,133 @@
+import { FileTreeLabels } from './fileTreeLabels.js';
+import { TreeSelectionMode, TreeViewSize, TreeNodeState } from '../TreeView/TreeView.types.js';
+import { BaseComponent } from '../../../types/common.js';
+import { Prettify } from '../../../types/utilities.js';
+import React from 'react';
+
+/** Whether an entry is a leaf file or a navigable folder. */
+type FileTreeNodeKind = 'file' | 'folder';
+/**
+ * A single file or folder in the tree. The file-system-flavored counterpart of
+ * TreeView's `TreeNodeData`: `name` instead of `label`, an explicit `kind`, and
+ * an optional `ext` that drives the auto-assigned file-type icon.
+ */
+interface FileTreeNode {
+    /** Stable unique id within the tree. */
+    id: string;
+    /** Display name, e.g. `"Button.tsx"` or `"components"`. */
+    name: string;
+    /** File vs. folder. Folders accept dropped files; files do not. */
+    kind: FileTreeNodeKind;
+    /**
+     * Extension override **without** the leading dot (e.g. `"tsx"`). Inferred from
+     * `name` when omitted. Drives the built-in file-type icon.
+     */
+    ext?: string;
+    /** Optional path (informational; surfaced unchanged to consumers). */
+    path?: string;
+    /** Child entries. Present on folders; ignored on files. */
+    children?: FileTreeNode[];
+    /** Dim + non-interactive. */
+    disabled?: boolean;
+    /** Arbitrary consumer payload (size, modified date, GUID, …). */
+    data?: Record<string, unknown>;
+}
+/** Per-node state handed to FileTree render/resolve props. */
+interface FileTreeNodeState extends TreeNodeState {
+    /** Convenience flag — `true` when the node is a folder. */
+    isFolder: boolean;
+}
+/** Payload for {@link FileTreeBaseProps.onImport}. */
+interface FileTreeImportPayload {
+    /** The OS files extracted from the drop's `DataTransfer`. */
+    files: File[];
+    /**
+     * The folder the files were dropped onto, or `null` for the tree root (a drop
+     * on empty space, or on a top-level file).
+     */
+    targetFolder: FileTreeNode | null;
+}
+interface FileTreeBaseProps extends Omit<BaseComponent, 'onChange'> {
+    /** Tree data — array of root-level files/folders. */
+    nodes: FileTreeNode[];
+    /** Expanded node IDs (controlled). */
+    expandedIds?: string[];
+    /** Default expanded node IDs (uncontrolled). */
+    defaultExpandedIds?: string[];
+    /** Fired when expanded nodes change. */
+    onExpandedChange?: (expandedIds: string[]) => void;
+    /** Selected node IDs (controlled). */
+    selectedIds?: string[];
+    /** Default selected node IDs (uncontrolled). */
+    defaultSelectedIds?: string[];
+    /**
+     * Selection mode.
+     * @default "single"
+     */
+    selectionMode?: TreeSelectionMode;
+    /** Fired when selected nodes change. */
+    onSelectionChange?: (selectedIds: string[]) => void;
+    /**
+     * Row size.
+     * @default "md"
+     */
+    size?: TreeViewSize;
+    /**
+     * Indentation per depth level in pixels.
+     * @default 16
+     */
+    indent?: number;
+    /**
+     * Whether to show expand/collapse chevrons for folders.
+     * @default true
+     */
+    showChevrons?: boolean;
+    /**
+     * Whether to show connecting guide lines.
+     * @default false
+     */
+    showGuideLines?: boolean;
+    /**
+     * Whether clicking anywhere on a folder row toggles it open/closed (not just
+     * the chevron). Files are unaffected.
+     * @default true
+     */
+    expandOnClick?: boolean;
+    /** Maximum height before the tree scrolls. */
+    maxHeight?: number | string;
+    /**
+     * Override the icon for a node. Return `undefined`/`null` to fall back to the
+     * built-in extension→icon map. Receives the live expansion state so folder
+     * open/closed glyphs can differ.
+     */
+    resolveIcon?: (node: FileTreeNode, state: {
+        expanded: boolean;
+    }) => React.ReactNode;
+    /** Fully replace a node's inner content (icon + label). */
+    renderNode?: (node: FileTreeNode, state: FileTreeNodeState) => React.ReactNode;
+    /** Render trailing actions on the right of a row. */
+    renderActions?: (node: FileTreeNode, state: FileTreeNodeState) => React.ReactNode;
+    /** Content shown when `nodes` is empty. */
+    emptyContent?: React.ReactNode;
+    /**
+     * Fired when OS files are dropped onto a folder (or the root). Presence of
+     * this callback enables the import drop zone. FileTree only reports intent —
+     * apply the change to your data and pass back fresh `nodes`.
+     */
+    onImport?: (payload: FileTreeImportPayload) => void;
+    /** Fired when a node is clicked. */
+    onNodeClick?: (node: FileTreeNode, event: React.MouseEvent) => void;
+    /** Fired when a node is double-clicked. */
+    onNodeDoubleClick?: (node: FileTreeNode, event: React.MouseEvent) => void;
+    /** Fired when a node is right-clicked. */
+    onNodeContextMenu?: (node: FileTreeNode, event: React.MouseEvent) => void;
+    /**
+     * Override the built-in English strings (the tree's accessible name and the
+     * empty-state text). Merged onto the defaults, so you can localize a subset.
+     * @see DEFAULT_FILE_TREE_LABELS
+     */
+    labels?: Partial<FileTreeLabels>;
+}
+type FileTreeProps = Prettify<FileTreeBaseProps>;
+
+export type { FileTreeBaseProps, FileTreeImportPayload, FileTreeNode, FileTreeNodeKind, FileTreeNodeState, FileTreeProps };

package/dist/types/components/controls/FileTree/fileTreeIcons.d.ts

@@ -0,0 +1,29 @@
+import { FileTreeNode } from './FileTree.types.js';
+
+/**
+ * The icon categories FileTree resolves a node to. Folders get an open/closed
+ * pair; files collapse to a small set of type buckets backed by the existing
+ * icon set. Rendering a kind into an actual icon element lives in the client
+ * component — this module is pure classification so it can be unit-tested
+ * without React.
+ */
+type FileIconKind = 'folder' | 'folder-open' | 'image' | 'media' | 'code' | 'archive' | 'text' | 'file';
+/**
+ * Extracts the lowercased extension (without the dot) from a file name, or
+ * `undefined` when there isn't one. Dotfiles such as `.env` / `.gitignore` are
+ * treated as having no extension (the leading dot is not a separator).
+ */
+declare function getFileExtension(name: string): string | undefined;
+/**
+ * Classifies an extension into an icon bucket. `undefined` / unknown → `file`.
+ */
+declare function classifyExtension(ext: string | undefined): FileIconKind;
+/**
+ * Resolves the icon kind for a node. Folders return `folder-open` when
+ * `expanded`, else `folder`. Files use the explicit `ext` when provided, falling
+ * back to the extension parsed from `name`.
+ */
+declare function getFileIconKind(node: Pick<FileTreeNode, 'kind' | 'name' | 'ext'>, expanded?: boolean): FileIconKind;
+
+export { classifyExtension, getFileExtension, getFileIconKind };
+export type { FileIconKind };

package/dist/types/components/controls/FileTree/fileTreeLabels.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Localizable strings for {@link FileTree}. Every user-facing / screen-reader
+ * string the component renders on its own goes through here so the whole
+ * component can be localized in one place (file and folder names come from your
+ * data, so they are already yours to localize).
+ *
+ * @see DEFAULT_FILE_TREE_LABELS for the English defaults.
+ */
+interface FileTreeLabels {
+    /** Accessible name for the tree region (`role="tree"` `aria-label`). */
+    treeLabel: string;
+    /** Text shown when the tree is empty (unless `emptyContent` is provided). */
+    emptyLabel: string;
+}
+/** English defaults for {@link FileTreeLabels}. Spread-and-tweak to localize. */
+declare const DEFAULT_FILE_TREE_LABELS: FileTreeLabels;
+
+export { DEFAULT_FILE_TREE_LABELS };
+export type { FileTreeLabels };

package/dist/types/components/controls/FileUploader/FileUploader.d.ts

@@ -0,0 +1,34 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { FileUploaderProps } from './FileUploader.types.js';
+
+/**
+ * Drag-and-drop file uploader with click-to-browse fallback. Renders a list
+ * of uploaded items with per-file status (`pending` / `uploading` / `done` /
+ * `error`) and an animated progress bar.
+ *
+ * The component itself is purely presentational around the file list — it
+ * does not perform the actual upload. The consumer is expected to:
+ *   1. Listen to `onFilesAdd` (or `onChange`) to know which files were
+ *      accepted by the uploader.
+ *   2. Drive the upload (fetch / XHR / SDK) externally.
+ *   3. Reflect progress back into the component by passing a controlled
+ *      `value` and updating the `status` / `progress` of each item.
+ *
+ * @example
+ * ```tsx
+ * const [items, setItems] = useState<FileUploaderItem[]>([]);
+ * <FileUploader
+ *   value={items}
+ *   onChange={setItems}
+ *   accept="image/*,.pdf"
+ *   maxSize={5 * 1024 * 1024}
+ *   onFilesAdd={files => uploadAll(files, setItems)}
+ * />
+ * ```
+ */
+declare function FileUploader({ value, defaultValue, onChange, onFilesAdd, onFileRemove, onReject, accept, multiple, maxFiles, maxSize, minSize, validate, renderItem, size, label, helperText, error, errorMessage, disabled, required, dropZoneText, dropZoneHint, name, className, style, testId, id: idProp, ref, ...rest }: FileUploaderProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploader {
+    var displayName: string;
+}
+
+export { FileUploader };

package/dist/types/components/controls/FileUploader/FileUploader.types.d.ts

@@ -0,0 +1,94 @@
+import { BaseComponent, Size } from '../../../types/common.js';
+import { Prettify } from '../../../types/utilities.js';
+import React from 'react';
+
+type FileUploaderSize = Size;
+type FileUploaderItemStatus = 'pending' | 'uploading' | 'done' | 'error';
+interface FileUploaderItem {
+    /** Stable identifier — generated for new items, preserved across renders */
+    id: string;
+    /** Underlying File object */
+    file: File;
+    /** Current status of the upload pipeline */
+    status: FileUploaderItemStatus;
+    /** Upload progress, 0-100. Optional in `pending` / `done` states. */
+    progress?: number;
+    /** Error message displayed when `status === 'error'` */
+    errorMessage?: string;
+}
+type FileUploaderRejectReason = 'too-large' | 'too-small' | 'wrong-type' | 'max-files' | 'invalid' | (string & {});
+interface FileUploaderRenderItemState {
+    item: FileUploaderItem;
+    index: number;
+    remove: () => void;
+    disabled: boolean;
+}
+interface FileUploaderBaseProps extends Omit<BaseComponent, 'onChange' | 'children' | 'defaultValue'> {
+    /** Controlled list of items */
+    value?: FileUploaderItem[];
+    /** Default list (uncontrolled) */
+    defaultValue?: FileUploaderItem[];
+    /** Called whenever the items list changes */
+    onChange?: (items: FileUploaderItem[]) => void;
+    /**
+     * Called with the raw `File` objects that were just accepted (after type/size
+     * validation, before they appear in the list as `pending`). The consumer
+     * should kick off the upload here and update `value` as progress changes.
+     */
+    onFilesAdd?: (files: File[]) => void;
+    /** Called when a single item is removed */
+    onFileRemove?: (item: FileUploaderItem) => void;
+    /** Called for files rejected by validation */
+    onReject?: (file: File, reason: FileUploaderRejectReason) => void;
+    /**
+     * Comma-separated list of accepted MIME types and/or extensions, e.g.
+     * `'image/*,.pdf'`. When omitted, every file type is accepted.
+     */
+    accept?: string;
+    /**
+     * Allow selecting more than one file at a time.
+     * @default true
+     */
+    multiple?: boolean;
+    /**
+     * Maximum number of files the uploader will hold. Additional files are
+     * rejected with reason `'max-files'`.
+     */
+    maxFiles?: number;
+    /** Maximum file size in bytes. Files above are rejected as `'too-large'`. */
+    maxSize?: number;
+    /** Minimum file size in bytes. Files below are rejected as `'too-small'`. */
+    minSize?: number;
+    /**
+     * Synchronous validator. Return `false` (or a string with a reason) to
+     * reject. Called after type/size checks pass.
+     */
+    validate?: (file: File) => boolean | string;
+    /**
+     * Custom renderer for a file row. When omitted the built-in row is used.
+     */
+    renderItem?: (state: FileUploaderRenderItemState) => React.ReactNode;
+    /** Component size */
+    size?: FileUploaderSize;
+    /** Label rendered above the dropzone */
+    label?: string;
+    /** Helper text rendered below */
+    helperText?: string;
+    /** Error state */
+    error?: boolean;
+    /** Error message — overrides `helperText` when `error` is true */
+    errorMessage?: string;
+    /** Disable interaction with the uploader */
+    disabled?: boolean;
+    /** Mark the field as required */
+    required?: boolean;
+    /** Primary text shown inside the dropzone */
+    dropZoneText?: React.ReactNode;
+    /** Secondary text shown inside the dropzone */
+    dropZoneHint?: React.ReactNode;
+    /** Hidden form-input name attribute (for native form submission) */
+    name?: string;
+}
+type FileUploaderProps = Prettify<FileUploaderBaseProps>;
+
+export type { FileUploaderBaseProps, FileUploaderItem, FileUploaderItemStatus, FileUploaderProps, FileUploaderRejectReason, FileUploaderRenderItemState, FileUploaderSize };