@rokkit/ui 1.1.18 → 1.2.0

package/dist/types/toolbar.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Toolbar Component Types
+ *
+ * Provides types for the data-driven Toolbar component.
+ * Field mapping and data access is handled by ProxyItem from @rokkit/states.
+ */
+/**
+ * Field mapping configuration for toolbar data.
+ * Maps custom data field names to the component's expected properties.
+ */
+export interface ToolbarFields {
+    /** Field for display text/tooltip - default: 'text' */
+    text?: string;
+    /** Field for the value to emit on click - default: 'value' */
+    value?: string;
+    /** Field for icon class name - default: 'icon' */
+    icon?: string;
+    /** Field for disabled state - default: 'disabled' */
+    disabled?: string;
+    /** Field for active/pressed state - default: 'active' */
+    active?: string;
+    /** Field for item type (button, toggle, separator, spacer, custom) - default: 'type' */
+    type?: string;
+    /** Field for custom snippet name - default: 'snippet' */
+    snippet?: string;
+    /** Field for aria-label override - default: 'label' */
+    label?: string;
+    /** Field for keyboard shortcut display - default: 'shortcut' */
+    shortcut?: string;
+}
+/**
+ * Default field mapping values
+ */
+export declare const defaultToolbarFields: Required<ToolbarFields>;
+/**
+ * Generic toolbar item - can be any object with mapped fields
+ */
+export type ToolbarItem = Record<string, unknown>;
+/**
+ * Built-in toolbar item types
+ */
+export type ToolbarItemType = 'button' | 'toggle' | 'separator' | 'spacer' | 'custom';
+/**
+ * Handlers passed to custom item snippets
+ */
+export interface ToolbarItemHandlers {
+    /** Call to trigger item action */
+    onclick: () => void;
+    /** Forward keyboard events for accessibility */
+    onkeydown: (event: KeyboardEvent) => void;
+}
+/**
+ * Snippet type for rendering toolbar items
+ */
+export type ToolbarItemSnippet = import('svelte').Snippet<[
+    ToolbarItem,
+    ToolbarFields,
+    ToolbarItemHandlers
+]>;
+/**
+ * Props for the Toolbar component
+ */
+export interface ToolbarProps {
+    /** Array of toolbar items */
+    items?: ToolbarItem[];
+    /** Field mapping configuration */
+    fields?: ToolbarFields;
+    /** Position of toolbar - affects border and sticky positioning */
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Width behaviour: full stretches to container, fit sizes to content */
+    width?: 'full' | 'fit';
+    /** Whether toolbar should stick to its position */
+    sticky?: boolean;
+    /** Compact mode with reduced padding */
+    compact?: boolean;
+    /** Show dividers between sections */
+    showDividers?: boolean;
+    /** Whether the entire toolbar is disabled */
+    disabled?: boolean;
+    /** Called when an item is clicked */
+    onclick?: (value: unknown, item: ToolbarItem) => void;
+    /** Additional CSS classes */
+    class?: string;
+    /** Custom snippet for rendering toolbar items */
+    item?: ToolbarItemSnippet;
+    /** Slot for start section content */
+    start?: import('svelte').Snippet;
+    /** Slot for center section content */
+    center?: import('svelte').Snippet;
+    /** Slot for end section content */
+    end?: import('svelte').Snippet;
+    /** Default slot for children */
+    children?: import('svelte').Snippet;
+}
+/**
+ * Props for the ToolbarGroup component
+ */
+export interface ToolbarGroupProps {
+    /** Accessibility label for the group */
+    label?: string;
+    /** Gap between items in the group */
+    gap?: 'none' | 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    class?: string;
+    /** Group content */
+    children?: import('svelte').Snippet;
+}

package/dist/types/tooltip.d.ts

@@ -0,0 +1,15 @@
+import type { Snippet } from 'svelte';
+export interface TooltipProps {
+    /** Tooltip text (alternative: use tooltipContent snippet for rich content) */
+    content?: string;
+    /** Preferred position — auto-flips when the preferred side overflows the viewport */
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    /** Show delay in ms (default: 300) */
+    delay?: number;
+    /** Additional CSS classes on the root wrapper */
+    class?: string;
+    /** Trigger element(s) */
+    children?: Snippet;
+    /** Rich tooltip content — overrides the content string */
+    tooltipContent?: Snippet;
+}

package/dist/types/tree-table.d.ts

@@ -0,0 +1,79 @@
+/**
+ * TreeTable Component Types
+ *
+ * Hierarchical analog of Table — accepts nested rows (each row may
+ * carry a `children: []` array) and renders the hierarchy in one
+ * designated column with chevron + indent + tree connectors.
+ *
+ * Reuses the column / sort / cell types from Table.
+ */
+import type { Snippet } from 'svelte';
+import type { TableColumn, TableSortIcons, SortState, TableFields } from './table.js';
+/**
+ * Column definition for TreeTable — adds an optional `hierarchy` flag
+ * to mark which column renders the chevron + indent connectors. When
+ * no column is flagged, the first column is treated as the hierarchy
+ * column by default.
+ */
+export interface TreeTableColumn extends TableColumn {
+    /** Render chevron + tree connectors in this column. Defaults to the first column. */
+    hierarchy?: boolean;
+}
+export type TreeTableHeaderSnippet = Snippet<[TreeTableColumn[], SortState[]]>;
+export type TreeTableRowSnippet = Snippet<[
+    Record<string, unknown>,
+    TreeTableColumn[],
+    number,
+    boolean
+]>;
+export type TreeTableCellSnippet = Snippet<[
+    unknown,
+    TreeTableColumn,
+    Record<string, unknown>
+]>;
+export type TreeTableEmptySnippet = Snippet<[]>;
+export interface TreeTableProps {
+    /** Nested row data — each row may carry a `children: []` array. */
+    data?: Record<string, unknown>[];
+    /** Column definitions (auto-derived from the first row if not provided). */
+    columns?: TreeTableColumn[];
+    /** Currently selected row value (single-select) */
+    value?: unknown;
+    /** Currently selected row values (multi-select, bindable) */
+    values?: unknown[];
+    /** Selection mode: 'single' (default), 'multi', or false (no selection) */
+    selectable?: 'single' | 'multi' | false;
+    /** Table caption for accessibility */
+    caption?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Enable alternating row colors */
+    striped?: boolean;
+    /** Whether the entire table is disabled */
+    disabled?: boolean;
+    /** Tree connector line style — same options as the Tree component */
+    lineStyle?: 'none' | 'solid' | 'dashed' | 'dotted';
+    /** Row-level field mapping (incl. the `children` field name). */
+    fields?: TableFields & {
+        children?: string;
+    };
+    /** Called when a row is selected */
+    onselect?: (value: unknown, row: Record<string, unknown>) => void;
+    /** Called when sort state changes */
+    onsort?: (sortState: SortState[]) => void;
+    /** Additional CSS classes */
+    class?: string;
+    /** Sort indicator icons */
+    icons?: TableSortIcons & {
+        opened?: string;
+        closed?: string;
+    };
+    /** Custom header snippet */
+    header?: TreeTableHeaderSnippet;
+    /** Custom row snippet */
+    row?: TreeTableRowSnippet;
+    /** Custom cell snippet */
+    cell?: TreeTableCellSnippet;
+    /** Empty state snippet */
+    empty?: TreeTableEmptySnippet;
+}

package/dist/types/tree.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Tree Component Types
+ *
+ * Provides types for the data-driven Tree component.
+ * Supports hierarchical data with expand/collapse, tree lines, and custom icons.
+ * Field mapping and data access is handled by ProxyItem from @rokkit/states.
+ */
+import type { Snippet } from 'svelte';
+/**
+ * Field mapping configuration for tree data — what the consumer passes
+ * to the Tree component. Both `expanded` and `level` are optional here
+ * because Tree falls back to `defaultTreeFields` for any field the
+ * consumer omits.
+ *
+ * Inside Tree the fields are merged with `defaultTreeFields` to produce
+ * a `ResolvedTreeFields` value where every key is guaranteed present.
+ * Downstream code that needs string field names without null-guards
+ * should use `ResolvedTreeFields` rather than `TreeFields`.
+ */
+export interface TreeFields {
+    [field: string]: string | undefined;
+    /**
+     * Name of the field on each tree item that holds its expanded state.
+     * The value at that field is expected to be a `boolean`.
+     *
+     * Optional — falls back to the default field name `'expanded'`. After
+     * `resolveTreeFields` is applied the resolved key is guaranteed present
+     * (see {@link ResolvedTreeFields}).
+     */
+    expanded?: string;
+    /**
+     * Name of the field on each tree item that holds its depth in the tree.
+     * The value at that field is expected to be a `number`.
+     *
+     * Optional — falls back to the default field name `'level'`. After
+     * `resolveTreeFields` is applied the resolved key is guaranteed present
+     * (see {@link ResolvedTreeFields}).
+     */
+    level?: string;
+}
+/**
+ * Tree fields after defaults have been applied — every field name is a
+ * non-null string. Use this type for any function or store that needs
+ * to read a field name without re-applying defaults.
+ *
+ * Construct from a `TreeFields` via `resolveTreeFields(fields)` (or by
+ * spreading `defaultTreeFields` first, e.g.
+ * `{ ...defaultTreeFields, ...userFields }`).
+ */
+export type ResolvedTreeFields = Required<TreeFields>;
+/**
+ * Default field mapping values for tree
+ */
+export declare const defaultTreeFields: Required<Omit<TreeFields, 'fields'>>;
+/**
+ * Merge consumer-provided field overrides with the default field
+ * mapping so every key resolves to a string. Tree calls this once on
+ * its `fields` prop before passing the result to ProxyTree / line
+ * builders.
+ */
+export declare function resolveTreeFields(fields?: TreeFields): ResolvedTreeFields;
+/**
+ * Generic tree item - can be any object with mapped fields
+ */
+export type TreeItem = Record<string, unknown>;
+/**
+ * Types of tree line connectors
+ */
+export type TreeLineType = 'child' | 'last' | 'sibling' | 'empty' | 'icon';
+/**
+ * Connector types (without 'icon' which is handled separately)
+ */
+export type ConnectorType = 'child' | 'last' | 'sibling' | 'empty';
+/**
+ * Icons configuration for tree expand/collapse states.
+ * Keys match the naming convention in @rokkit/core DEFAULT_STATE_ICONS.
+ */
+export interface TreeStateIcons {
+    /** Icon class for expanded/opened state */
+    opened?: string;
+    /** Icon class for collapsed/closed state */
+    closed?: string;
+}
+/**
+ * Default state icons — uses semantic names from @rokkit/core
+ * that get resolved to actual icon classes via UnoCSS shortcuts.
+ */
+export declare const defaultTreeStateIcons: TreeStateIcons;
+/**
+ * Handlers passed to custom item snippets
+ */
+export interface TreeItemHandlers {
+    /** Call to trigger item selection */
+    onclick: () => void;
+    /** Call to toggle expand/collapse */
+    ontoggle: () => void;
+    /** Forward keyboard events for accessibility */
+    onkeydown: (event: KeyboardEvent) => void;
+}
+/**
+ * Snippet type for rendering tree nodes.
+ * Parameters: item, fields, handlers, isActive, isExpanded, level
+ */
+export type TreeItemSnippet = Snippet<[
+    TreeItem,
+    TreeFields,
+    TreeItemHandlers,
+    boolean,
+    boolean,
+    number
+]>;
+/**
+ * Snippet type for rendering the expand/collapse icon
+ * Parameters: isExpanded, hasChildren, icons
+ */
+export type TreeToggleSnippet = Snippet<[boolean, boolean, TreeStateIcons]>;
+/**
+ * Snippet type for rendering tree line connectors
+ * Parameters: lineType
+ */
+export type TreeConnectorSnippet = Snippet<[TreeLineType]>;
+/**
+ * Props for the Tree component
+ */
+export interface TreeProps {
+    /** Array of tree items (hierarchical) */
+    items?: TreeItem[];
+    /** Field mapping configuration */
+    fields?: TreeFields;
+    /** Currently selected value */
+    value?: unknown;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg';
+    /** Tree line connector style — 'none' hides lines, 'solid'|'dashed'|'dotted' set the line style */
+    lineStyle?: 'none' | 'solid' | 'dashed' | 'dotted';
+    /** Enable multiple item selection (Ctrl+click toggle, Shift+click range) */
+    multiselect?: boolean;
+    /** Which nodes are expanded (bindable) - keyed by node value */
+    expanded?: Record<string, boolean>;
+    /** Selected items array (bindable) - populated in multiselect mode */
+    selected?: unknown[];
+    /** Expand all nodes by default */
+    expandAll?: boolean;
+    /** Active item value - Tree looks up item by this value to highlight it */
+    active?: unknown;
+    /** Icons for expand/collapse states */
+    icons?: TreeStateIcons;
+    /** Called when an item is selected */
+    onselect?: (value: unknown, item: TreeItem) => void;
+    /** Called when selected items change in multiselect mode */
+    onselectedchange?: (selected: unknown[]) => void;
+    /** Called when expanded state changes */
+    onexpandedchange?: (expanded: Record<string, boolean>) => void;
+    /** Called when a node is toggled */
+    ontoggle?: (value: unknown, item: TreeItem, isExpanded: boolean) => void;
+    /** Called when expanding a node with unloaded children (children: true). Returns the children array. */
+    onloadchildren?: (value: unknown, item: TreeItem) => Promise<TreeItem[]>;
+    /** Additional CSS classes */
+    class?: string;
+    /** Custom snippet for rendering tree items */
+    item?: TreeItemSnippet;
+    /** Custom snippet for rendering expand/collapse toggle */
+    toggle?: TreeToggleSnippet;
+    /** Custom snippet for rendering tree line connectors */
+    connector?: TreeConnectorSnippet;
+}
+/**
+ * Constructs an array of line types for tree visualization.
+ * This determines what connectors to show at each depth level.
+ *
+ * Algorithm from @rokkit/core getLineTypes:
+ * - For all but the last parent type, convert to continuation type
+ * - For the last parent type, use the current node's position
+ * - Append 'icon' for nodes with children, 'empty' for leaf nodes
+ *
+ * @param hasChildren - Whether the node has children
+ * @param parentTypes - Line types from parent nodes
+ * @param position - Current position type ('child' or 'last')
+ * @returns Array of line types for rendering connectors
+ */
+export declare function getLineTypes(hasChildren?: boolean, parentTypes?: TreeLineType[], position?: 'child' | 'last'): TreeLineType[];
+export declare const getTreeLineTypes: typeof getLineTypes;
+export { getSnippet } from './menu.js';

package/dist/types/upload-file-status.d.ts

@@ -0,0 +1,31 @@
+/**
+ * UploadFileStatus Component Types
+ *
+ * Renders a single file's upload status with progress bar, action buttons
+ * (cancel/retry/remove), and file metadata (icon, name, size, status label).
+ * Action button visibility driven by cancelWhen/retryWhen/removeWhen arrays.
+ */
+import type { ProxyItem } from '@rokkit/states';
+/**
+ * Props for the UploadFileStatus component
+ */
+export interface UploadFileStatusProps {
+    /** ProxyItem wrapping the file data */
+    proxy: ProxyItem;
+    /** Status values that show the cancel button */
+    cancelWhen?: string[];
+    /** Status values that show the retry button */
+    retryWhen?: string[];
+    /** Status values that show the remove button */
+    removeWhen?: string[];
+    /** Called when cancel is clicked */
+    oncancel?: (proxy: ProxyItem) => void;
+    /** Called when retry is clicked */
+    onretry?: (proxy: ProxyItem) => void;
+    /** Called when remove is clicked */
+    onremove?: (proxy: ProxyItem) => void;
+    /** Label overrides merged with messages.uploadProgress */
+    labels?: Record<string, string>;
+    /** Icon class overrides for action buttons (cancel, retry, remove) */
+    icons?: Record<string, string>;
+}

package/dist/types/upload-progress.d.ts

@@ -0,0 +1,71 @@
+/**
+ * UploadProgress Component Types
+ *
+ * File upload status orchestrator. Thin composition layer that renders
+ * a header + List or Grid layout. Default itemContent snippet renders
+ * UploadFileStatus for each file. Consumer can override with custom snippet.
+ */
+import type { Snippet } from 'svelte';
+import type { ProxyItem } from '@rokkit/states';
+/**
+ * Generic upload file item — any object with mapped fields
+ */
+export type UploadItem = Record<string, unknown>;
+/**
+ * Field mapping for upload file data.
+ * Maps semantic field names to keys in the data objects.
+ */
+export interface UploadFields {
+    /** Field for display text - default: 'text' */
+    label?: string;
+    /** Field for unique value - default: 'value' */
+    value?: string;
+    /** Field for icon class - default: 'icon' */
+    icon?: string;
+    /** Field for upload status key - default: 'status' */
+    status?: string;
+    /** Field for progress percentage (0-100) - default: 'progress' */
+    progress?: string;
+    /** Field for file size in bytes - default: 'size' */
+    size?: string;
+    /** Field for MIME type - default: 'type' */
+    type?: string;
+    /** Field for error message - default: 'error' */
+    error?: string;
+}
+/**
+ * Snippet for custom per-file rendering inside List/Grid.
+ * Receives the ProxyItem wrapping the file data.
+ */
+export type UploadItemSnippet = Snippet<[proxy: ProxyItem]>;
+/**
+ * Props for the UploadProgress component
+ */
+export interface UploadProgressProps {
+    /** Array of file data objects */
+    files?: UploadItem[];
+    /** Field mapping configuration */
+    fields?: UploadFields;
+    /** Layout mode */
+    view?: 'list' | 'grid';
+    /** Status values that show the cancel button */
+    cancelWhen?: string[];
+    /** Status values that show the retry button */
+    retryWhen?: string[];
+    /** Status values that show the remove button */
+    removeWhen?: string[];
+    /** Called when cancel is clicked (receives raw file object) */
+    oncancel?: (file: UploadItem) => void;
+    /** Called when retry is clicked (receives raw file object) */
+    onretry?: (file: UploadItem) => void;
+    /** Called when remove is clicked (receives raw file object) */
+    onremove?: (file: UploadItem) => void;
+    /** Called when clear all is clicked */
+    onclear?: () => void;
+    /** Label overrides merged with messages.uploadProgress */
+    labels?: Record<string, string>;
+    /** Additional CSS classes */
+    class?: string;
+    /** Custom snippet for per-file rendering (overrides default UploadFileStatus) */
+    itemContent?: UploadItemSnippet;
+}

package/dist/types/upload-target.d.ts

@@ -0,0 +1,46 @@
+/**
+ * UploadTarget Component Types
+ *
+ * Drop zone with file validation. Accepts drag-and-drop or click-to-browse.
+ * Validates files against accept (MIME/extension) and maxSize constraints.
+ */
+import type { Snippet } from 'svelte';
+/**
+ * File validation error returned via onerror callback
+ */
+export interface UploadError {
+    /** The file that failed validation */
+    file: File;
+    /** Why the file was rejected */
+    reason: 'type' | 'size';
+}
+/**
+ * Snippet for custom drop zone content.
+ * Receives the current dragging state.
+ */
+export type UploadTargetContentSnippet = Snippet<[dragging: boolean]>;
+/**
+ * Props for the UploadTarget component
+ */
+export interface UploadTargetProps {
+    /** Accepted file types (MIME types or extensions, comma-separated) */
+    accept?: string;
+    /** Maximum file size in bytes */
+    maxSize?: number;
+    /** Allow multiple file selection */
+    multiple?: boolean;
+    /** Disable the drop zone */
+    disabled?: boolean;
+    /** Label overrides merged with messages.uploadTarget */
+    labels?: Record<string, string>;
+    /** Called with validated files after drop or browse */
+    onfiles?: (files: File[]) => void;
+    /** Called for each file that fails validation */
+    onerror?: (err: UploadError) => void;
+    /** Size variant — full (default) fills available area; small shows only border + icon */
+    size?: 'full' | 'small';
+    /** Additional CSS classes */
+    class?: string;
+    /** Custom content snippet (replaces default drop zone UI) */
+    content?: UploadTargetContentSnippet;
+}

package/dist/utils/palette.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Palette Utilities
+ *
+ * Functions for color manipulation, shade generation, and runtime palette application.
+ */
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface HSL {
+    h: number;
+    s: number;
+    l: number;
+}
+export interface OKLCH {
+    L: number;
+    C: number;
+    H: number;
+}
+export type ColorSpace = 'rgb' | 'hsl' | 'oklch';
+export type ShadeKey = '50' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900' | '950';
+export type Shades = Record<ShadeKey, string>;
+export type ColorRole = 'primary' | 'secondary' | 'accent' | 'surface' | 'success' | 'warning' | 'danger' | 'info';
+/**
+ * Mapping of color roles to Tailwind color names or hex values
+ */
+export type ColorMapping = Partial<Record<ColorRole, string>>;
+/**
+ * Convert hex color to RGB
+ */
+export declare function hexToRgb(hex: string): RGB;
+/**
+ * Convert RGB to hex color
+ */
+export declare function rgbToHex(rgb: RGB): string;
+export declare function rgbToHsl(rgb: RGB): HSL;
+/**
+ * Convert HSL to RGB
+ */
+export declare function hslToRgb(hsl: HSL): RGB;
+/**
+ * Convert hex to HSL
+ */
+export declare function hexToHsl(hex: string): HSL;
+/**
+ * Convert HSL to hex
+ */
+export declare function hslToHex(hsl: HSL): string;
+/**
+ * Convert RGB to OKLCH (via XYZ D65 for precision)
+ */
+export declare function rgbToOklch(rgb: RGB): OKLCH;
+/**
+ * Convert OKLCH to RGB (via XYZ D65 for precision)
+ */
+export declare function oklchToRgb(oklch: OKLCH): RGB;
+/**
+ * Convert hex to OKLCH
+ */
+export declare function hexToOklch(hex: string): OKLCH;
+/**
+ * Convert OKLCH to hex
+ */
+export declare function oklchToHex(oklch: OKLCH): string;
+/**
+ * Generate Tailwind-like shades from a base hex color
+ * The input color is used as the 500 shade
+ */
+export declare function generateShades(hex: string): Shades;
+/**
+ * Check if a string is a valid hex color
+ */
+export declare function isHexColor(value: string): boolean;
+export declare const tailwindColors: Record<string, Shades>;
+/**
+ * Get shades for a color (either Tailwind preset or custom hex)
+ */
+export declare function getShades(color: string): Shades;
+/**
+ * Apply a color palette to the document root
+ * Sets CSS variables for each color role and shade
+ */
+export declare function applyPalette(mapping: Partial<Record<ColorRole, string>>, element?: HTMLElement, colorSpace?: ColorSpace): void;
+/**
+ * Remove custom palette CSS variables (reset to theme defaults)
+ */
+export declare function resetPalette(roles?: ColorRole[], element?: HTMLElement): void;
+/**
+ * Save palette to localStorage. SSR-safe.
+ */
+export declare function savePalette(key: string, mapping: Partial<Record<ColorRole, string>>): void;
+/**
+ * Load palette from localStorage. SSR-safe.
+ */
+export declare function loadPalette(key: string): Partial<Record<ColorRole, string>> | null;
+/**
+ * Get list of available Tailwind color names
+ */
+export declare function getTailwindColorNames(): string[];

package/dist/utils/shiki.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shiki syntax highlighting utility
+ */
+import { type BundledLanguage, type BundledTheme } from 'shiki';
+export interface HighlightOptions {
+    /** Language for syntax highlighting */
+    lang?: BundledLanguage | string;
+    /** Theme to use (defaults based on user preference) */
+    theme?: BundledTheme | 'light' | 'dark';
+}
+export declare function highlightCode(code: string, options?: HighlightOptions): Promise<string>;
+/**
+ * Preload the syntax highlighter for faster initial rendering
+ * Errors are silently ignored since preloading is optional
+ */
+export declare function preloadHighlighter(): Promise<void>;
+/**
+ * Get list of supported languages
+ */
+export declare function getSupportedLanguages(): readonly string[];

package/dist/utils/upload.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Check if a file matches an accept string (comma-separated MIME types and extensions).
+ * @param {{ type: string, name: string }} file
+ * @param {string | null | undefined} accept - e.g. 'image/*,.pdf,application/json'
+ * @returns {boolean}
+ */
+export function matchesAccept(file: {
+    type: string;
+    name: string;
+}, accept: string | null | undefined): boolean;
+export function validateFile(file: any, { accept, maxSize }?: {}): true | {
+    reason: string;
+};
+export function inferIcon(mimeType: any): string;
+/**
+ * Format a byte count as a human-readable size string.
+ * @param {number} bytes
+ * @returns {string}
+ */
+export function formatSize(bytes: number): string;
+export function groupByPath(items: any, pathField: any, childrenField: any): any[];