@alfadocs/ui-kit 0.72.2 → 0.75.0

package/dist/components/face-scheme/face-scheme.d.ts

@@ -1,4 +1,5 @@
-import { type FaceAffine, type FaceChart, type FaceFindingType, type FaceRegistration, type FaceViewId, type Point } from './face-scheme-data';
+import { type MarkerShape, type MarkerTone } from '../annotation-marker';
+import { type FaceAffine, type FaceAnnotation, type FaceAnnotationInput, type FaceAnnotationKind, type FaceAnnotations, type FaceAnnotationTool, type FaceChart, type FaceFindingType, type FaceRegistration, type FaceViewId, type Point } from './face-scheme-data';
 export type FaceDetectStatus = 'idle' | 'loading' | 'detecting' | 'done' | 'no-face' | 'error';
 export interface FaceDetectOptions {
     /** FRONT view (MediaPipe): base URL for the wasm fileset (defaults to the jsDelivr CDN). */
@@ -37,8 +38,12 @@ export interface FaceSchemeProps {
     defaultView?: FaceViewId;
     /** Fired when the view switcher changes the active view. */
     onViewChange?: (view: FaceViewId) => void;
-    /** Show the built-in radio view switcher (default `true`). */
+    /** Show the built-in view switcher tabs (default `true`). */
     showViewSwitcher?: boolean;
+    /** Uncontrolled initial layout — `'all'` opens in the three-up view (every
+     *  face at once, focused view interactive). Default `'single'`. Only takes
+     *  effect with the view switcher shown, which owns the layout buttons. */
+    defaultLayout?: 'single' | 'all';
     /** `'interactive'` enables zone selection, finding edits and registration; `'display'` is read-only. */
     mode?: 'interactive' | 'display';
     /** Controlled findings — `Record<zoneId, FaceFinding[]>`. */
@@ -51,6 +56,68 @@ export interface FaceSchemeProps {
     onSelectZone?: (zoneId: string) => void;
     /** The finding type a zone-click applies in interactive mode (toggles it). */
     activeFinding?: FaceFindingType;
+    /**
+     * `'multi'` turns zone activation (click / Enter / Space) into selection
+     * toggling — one diagnosis can then be applied to every selected zone at
+     * once from the panel's Zones section, in a single `onChange` commit.
+     * `activeFinding` no longer stamps in this mode (it only pre-arms the
+     * section); the selection survives view switches. Default `'off'`.
+     */
+    zoneSelect?: 'off' | 'multi';
+    /** Controlled selected zone ids (with `zoneSelect="multi"`). */
+    selectedZones?: string[];
+    /** Uncontrolled initial selected zone ids. */
+    defaultSelectedZones?: string[];
+    /** Fired when the zone selection changes. */
+    onSelectedZonesChange?: (ids: string[]) => void;
+    /**
+     * Controlled per-view annotations — freehand marks (point-anywhere markers,
+     * pen / highlighter ink, arrows / lines / boxes / ellipses, text callouts)
+     * drawn in the photo's own coordinate space. Distinct from the zone-keyed
+     * `value` findings, and they do NOT ride the registration transform. PHI: a
+     * text annotation's `text` is rendered only — never logged, persisted,
+     * transmitted, or exposed via the agent snapshot.
+     */
+    annotations?: FaceAnnotations;
+    /** Uncontrolled initial annotations. */
+    defaultAnnotations?: FaceAnnotations;
+    /** Fired whenever the annotations change. */
+    onAnnotationsChange?: (next: FaceAnnotations) => void;
+    /**
+     * Fired when the annotation selection changes (`null` = cleared). Selection
+     * is pointer-mode-scoped: it clears on tool or view change, and a freshly
+     * committed mark auto-selects so its panel affordances target it at once.
+     */
+    onAnnotationSelect?: (id: string | null) => void;
+    /**
+     * Show the built-in Draw section (tool select, colour, marker shape, undo,
+     * clear) inside the edit panel. Requires `mode="interactive"`. Default
+     * `true` — pass `false` to opt a surface out of the drawing tools.
+     */
+    showAnnotationToolbar?: boolean;
+    /**
+     * Opt into figure zoom + pan: mouse-wheel / panel-button zoom on the focused
+     * figure, drag-pan from empty space while zoomed, plus a Zoom row in the edit
+     * panel. Requires `mode="interactive"`. Default `false` (MuscleScheme parity).
+     */
+    zoomable?: boolean;
+    /**
+     * Uncontrolled initial open state of the edit panel (Zones / Draw / Fit
+     * sections). Default `true`: the panel is visible everywhere; the control-bar
+     * toggle only collapses it.
+     */
+    defaultPanelOpen?: boolean;
+    /** Controlled active drawing tool — `null` = none (pointer falls through to
+     *  zone selection / registration). */
+    activeTool?: FaceAnnotationTool | null;
+    /** Uncontrolled initial tool (default `null`). */
+    defaultTool?: FaceAnnotationTool | null;
+    /** Fired when the active tool changes (built-in toolbar or handle). */
+    onToolChange?: (tool: FaceAnnotationTool | null) => void;
+    /** Initial marker shape for the marker tool (default `'circle'`). */
+    defaultAnnotationShape?: MarkerShape;
+    /** Initial annotation tone (default `'accent'`). */
+    defaultAnnotationColor?: MarkerTone;
     /** Controlled per-view registration affine. */
     registration?: FaceRegistration;
     /** Uncontrolled initial registration. */
@@ -137,6 +204,49 @@ export interface FaceSchemeHandle {
     getView: () => FaceViewId;
     /** Switch the active view. */
     setView: (view: FaceViewId) => void;
+    /** Read the current zoom factor (1 = base window). */
+    getZoom: () => number;
+    /** Set the zoom factor (clamped to 1–8), anchored on the window centre. */
+    setZoom: (factor: number) => void;
+    /** Reset zoom and pan to the base window. */
+    resetZoom: () => void;
+    /** Read the active-view annotations. */
+    getAnnotations: () => FaceAnnotation[];
+    /** Add an annotation to the active view; returns its (generated) id. */
+    addAnnotation: (annotation: FaceAnnotationInput) => string;
+    /** Remove an annotation from the active view by id. */
+    removeAnnotation: (id: string) => void;
+    /** Remove the most-recently-added annotation on the active view. */
+    undoAnnotation: () => void;
+    /** Clear every annotation from the active view. */
+    clearAnnotations: () => void;
+    /** Read the active drawing tool (`null` = none). */
+    getTool: () => FaceAnnotationTool | null;
+    /** Set the active drawing tool (`null` = none). */
+    setTool: (tool: FaceAnnotationTool | null) => void;
+    /** Read the selected annotation (id + kind), or `null` when none. */
+    getSelectedAnnotation: () => {
+        id: string;
+        kind: FaceAnnotationKind;
+    } | null;
+    /** Select an active-view annotation by id (`null` clears; unknown ids no-op). */
+    selectAnnotation: (id: string | null) => void;
+    /** Link / unlink an active-view annotation to a zone (`null` = no zone). */
+    setAnnotationZone: (id: string, zoneId: string | null) => void;
+    /** Read the selected zone ids (`zoneSelect="multi"`). */
+    getSelectedZones: () => string[];
+    /** Replace the zone selection (any view's zone ids). */
+    setSelectedZones: (ids: string[]) => void;
+    /** Clear the zone selection. */
+    clearZoneSelection: () => void;
+    /** Add a finding to every selected zone in ONE chart commit; the optional
+     *  note lands only on zones the finding is newly added to. */
+    applyFindingToSelection: (type: FaceFindingType, note?: string) => void;
+    /** Remove a finding type from every selected zone in ONE chart commit. */
+    removeFindingFromSelection: (type: FaceFindingType) => void;
+    /** Selection-independent bulk write — add a finding to each given zone in
+     *  ONE chart commit (the agent `set_finding_bulk` path). */
+    setFindingBulk: (ids: string[], type: FaceFindingType, note?: string) => void;
 }
 export type FaceCaptureState = 'idle' | 'requesting' | 'streaming' | 'error';
 export type FaceCaptureError = 'permission-denied' | 'no-camera' | 'not-readable' | 'insecure-context' | 'capture-failed';

package/dist/components/face-scheme/index.d.ts

@@ -1,6 +1,6 @@
 export * from './face-scheme';
-export { FACE_VIEWS, FACE_VIEW_IDS, FACE_FINDING_TYPES, FACE_FINDING_MARKER, IDENTITY_AFFINE, affineToString, applyAffine, composeAffine, decomposeAffine, solveAffine, } from './face-scheme-data';
-export type { FaceViewId, FaceSide, FaceZone, FaceLandmark, FaceView, FaceFinding, FaceFindingType, FaceChart, FaceAffine, FaceRegistration, AffineParts, Point, } from './face-scheme-data';
+export { FACE_VIEWS, FACE_VIEW_IDS, FACE_FINDING_TYPES, FACE_FINDING_MARKER, FACE_ANNOTATION_TOOLS, ANNOTATION_TOOL_KIND, isShapeTool, isInkTool, isPointTool, inkPath, shapePath, arrowHeadPath, annotationAnchor, annotationBBox, IDENTITY_AFFINE, affineToString, applyAffine, invertAffine, composeAffine, decomposeAffine, solveAffine, } from './face-scheme-data';
+export type { FaceViewId, FaceSide, FaceZone, FaceLandmark, FaceView, FaceFinding, FaceFindingType, FaceChart, FaceAnnotationTool, FaceAnnotationKind, FaceAnnotation, FaceAnnotationInput, FaceAnnotations, MarkerAnnotation, InkAnnotation, ShapeAnnotation, TextAnnotation, FaceAffine, FaceRegistration, AffineParts, Point, } from './face-scheme-data';
 export { detectFaceLandmarks } from './detect-face-landmarks';
 export type { DetectFaceLandmarksOptions } from './detect-face-landmarks';
 export { faceSchemeAgent } from './face-scheme.agent';

package/dist/components/face-scheme/index.js

@@ -1,17 +1,28 @@
-import { F as s, a as f, b as A, c as F, d as I, I as E, e as c, f as n, g as o, h as _, i, j as m, s as N } from "../../_chunks/face-scheme-BT9_KdL0.js";
+import { A as e, F as o, a as n, b as A, c as i, d as f, e as t, I, f as N, g as T, h as F, i as _, j as E, k as c, l as h, m as r, n as p, o as O, p as S, q as m, r as l, s as d, t as C, u as D } from "../../_chunks/face-scheme-C0rk21gg.js";
 export {
-  s as FACE_FINDING_MARKER,
-  f as FACE_FINDING_TYPES,
-  A as FACE_VIEWS,
-  F as FACE_VIEW_IDS,
-  I as FaceScheme,
-  E as IDENTITY_AFFINE,
-  c as affineToString,
-  n as applyAffine,
-  o as composeAffine,
-  _ as decomposeAffine,
-  i as detectFaceLandmarks,
-  m as faceSchemeAgent,
-  N as solveAffine
+  e as ANNOTATION_TOOL_KIND,
+  o as FACE_ANNOTATION_TOOLS,
+  n as FACE_FINDING_MARKER,
+  A as FACE_FINDING_TYPES,
+  i as FACE_VIEWS,
+  f as FACE_VIEW_IDS,
+  t as FaceScheme,
+  I as IDENTITY_AFFINE,
+  N as affineToString,
+  T as annotationAnchor,
+  F as annotationBBox,
+  _ as applyAffine,
+  E as arrowHeadPath,
+  c as composeAffine,
+  h as decomposeAffine,
+  r as detectFaceLandmarks,
+  p as faceSchemeAgent,
+  O as inkPath,
+  S as invertAffine,
+  m as isInkTool,
+  l as isPointTool,
+  d as isShapeTool,
+  C as shapePath,
+  D as solveAffine
 };
 //# sourceMappingURL=index.js.map

package/dist/components/fetal-weight/index.js

@@ -1,4 +1,4 @@
-import { F as a, e as i } from "../../_chunks/fetal-weight-CVAH8sJ3.js";
+import { F as a, e as i } from "../../_chunks/fetal-weight-1F9N4IMx.js";
 export {
   a as FetalWeight,
   i as estimateFetalWeight

package/dist/components/field-array/index.js

@@ -1,4 +1,4 @@
-import { F as e, f } from "../../_chunks/field-array-CDzc3hTM.js";
+import { F as e, f } from "../../_chunks/field-array-DH3Mb1i8.js";
 export {
   e as FieldArray,
   f as fieldArrayAgent

package/dist/components/file-manager/dialogs.d.ts

@@ -0,0 +1,48 @@
+import type { FileManagerItem, FileManagerUploadConfig } from './types';
+export interface CreateFolderDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSubmit: (name: string) => void;
+}
+export declare function CreateFolderDialog({ open, onOpenChange, onSubmit, }: CreateFolderDialogProps): import("react/jsx-runtime").JSX.Element;
+export interface UploadDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Bound to the destination folder by the parent. */
+    onUpload: (file: File, helpers: {
+        signal: AbortSignal;
+        onProgress: (percent: number) => void;
+    }) => Promise<void>;
+    /** Human-readable destination folder name (root label when at the root). */
+    destinationLabel: string;
+    config?: FileManagerUploadConfig;
+}
+export declare function UploadDialog({ open, onOpenChange, onUpload, destinationLabel, config, }: UploadDialogProps): import("react/jsx-runtime").JSX.Element;
+export interface RenameDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Current name of the item being renamed. */
+    initialName: string;
+    onSubmit: (name: string) => void;
+}
+export declare function RenameDialog({ open, onOpenChange, initialName, onSubmit, }: RenameDialogProps): import("react/jsx-runtime").JSX.Element;
+export interface DeleteDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    count: number;
+    onConfirm: () => void;
+}
+export declare function DeleteDialog({ open, onOpenChange, count, onConfirm, }: DeleteDialogProps): import("react/jsx-runtime").JSX.Element;
+export interface MoveDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Full item list — the destination tree is derived from its folders. */
+    items: FileManagerItem[];
+    /** Items being moved — they and their descendants are invalid targets. */
+    movingIds: string[];
+    /** Folder the mover starts from (pre-selected destination). */
+    currentFolderId: string | null;
+    onConfirm: (targetFolderId: string | null) => void;
+}
+export declare function MoveDialog({ open, onOpenChange, items, movingIds, currentFolderId, onConfirm, }: MoveDialogProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=dialogs.d.ts.map

package/dist/components/file-manager/file-manager.agent.d.ts

@@ -0,0 +1,4 @@
+import type { AgentAdapter } from '../../agent/types';
+import type { FileManagerHandle } from './types';
+export declare const fileManagerAgent: AgentAdapter<FileManagerHandle>;
+//# sourceMappingURL=file-manager.agent.d.ts.map

package/dist/components/file-manager/file-manager.d.ts

@@ -0,0 +1,82 @@
+import { type VariantProps } from 'class-variance-authority';
+import type { FileManagerAddMenuItem, FileManagerHandle, FileManagerItem, FileManagerItemAction, FileManagerPermissionsInput, FileManagerUploadConfig, FileManagerUploadHandler } from './types';
+declare const fileManagerVariants: (props?: ({
+    bordered?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface FileManagerProps extends VariantProps<typeof fileManagerVariants> {
+    /** Opaque instance id — emitted as `data-component-id` for the agent registry. */
+    id?: string;
+    /** Flat item list keyed by `parentId`. The host owns this data. */
+    items: FileManagerItem[];
+    /**
+     * Capability gates — a flat set or a per-item resolver. Default is all-true
+     * (see FileManagerPermissions); `delete` always routes through a confirm.
+     */
+    permissions?: FileManagerPermissionsInput;
+    /** Controlled current folder (`null` = root). */
+    folderId?: string | null;
+    /** @default null */
+    defaultFolderId?: string | null;
+    onNavigate?: (folderId: string | null) => void;
+    onSelectionChange?: (ids: string[]) => void;
+    /**
+     * Opt-in folder-tree nav pane, rendered as a sidebar (hidden below the md
+     * breakpoint). The default layout is the table full-width with the folder
+     * breadcrumb in the footer; when `groupByFolder` is on the tree data already
+     * surfaces folders in the list, so the sidebar is redundant unless a consumer
+     * explicitly wants it.
+     * @default false — opt-in nav pane
+     */
+    showTree?: boolean;
+    /** Render the Skeleton loading state instead of the folder contents. */
+    isLoading?: boolean;
+    /** Opening a file resolves here (folders navigate internally). */
+    onOpenFile?: (item: FileManagerItem) => void;
+    onCreateFolder?: (name: string, parentId: string | null) => void | Promise<void>;
+    onRenameItem?: (itemId: string, name: string) => void | Promise<void>;
+    onDeleteItems?: (itemIds: string[]) => void | Promise<void>;
+    onMoveItems?: (itemIds: string[], targetFolderId: string | null) => void | Promise<void>;
+    onDownloadItems?: (itemIds: string[]) => void;
+    /** Share affordance (kebab + toolbar). Hidden when absent. */
+    onShare?: (itemIds: string[]) => void;
+    /**
+     * Request a signature for a pending-signature item. The action only appears
+     * on items whose `signatureStatus` is `'pending'`; hidden when absent.
+     */
+    onRequestSignature?: (item: FileManagerItem) => void;
+    /** Per-file upload handler (host owns transport). Enables the upload UI. */
+    onUpload?: FileManagerUploadHandler;
+    /** Upload transport config forwarded to the kit FileUpload. */
+    uploadConfig?: FileManagerUploadConfig;
+    /**
+     * Fired when a **file** row is activated by a single click, or by keyboard
+     * Enter on the selected file when this handler is wired (folders navigate
+     * internally; double-click always resolves `onOpenFile`). The host is
+     * expected to render the kit `DocumentPreview` in response — typically inside
+     * the Control Room rail. When absent, single-click just selects the row and
+     * Enter falls back to `onOpenFile`.
+     */
+    onPreviewItem?: (item: FileManagerItem) => void;
+    /**
+     * Id of the file the host is currently previewing (e.g. open in the rail).
+     * When set, the matching list row reuses the DataTable's selected-row tint so
+     * the user can see which document is open. `null` clears the highlight.
+     */
+    previewedItemId?: string | null;
+    /** Consumer actions appended after the built-in per-item kebab entries. */
+    itemActions?: (item: FileManagerItem) => FileManagerItemAction[];
+    /** Consumer entries appended after the built-in action buttons. */
+    addMenuItems?: FileManagerAddMenuItem[];
+    /**
+     * Nest files under their folders (Finder/Explorer style) via AG Grid Tree
+     * Data. Requires the consumer to register the Enterprise `TreeDataModule`
+     * (`ModuleRegistry.registerModules([TreeDataModule])`); the `treeData` /
+     * `getDataPath` / `autoGroupColumnDef` flags set here are inert until it is.
+     * @default false
+     */
+    groupByFolder?: boolean;
+    className?: string;
+}
+export declare const FileManager: import("react").ForwardRefExoticComponent<FileManagerProps & import("react").RefAttributes<FileManagerHandle>>;
+export {};
+//# sourceMappingURL=file-manager.d.ts.map

package/dist/components/file-manager/folder-tree.d.ts

@@ -0,0 +1,12 @@
+import type { FileManagerItem } from './types';
+export interface FolderTreeProps {
+    items: FileManagerItem[];
+    /** Folder highlighted as selected — `null` selects the virtual root. */
+    selectedFolderId: string | null;
+    onSelectFolder: (folderId: string | null) => void;
+    'aria-label': string;
+    /** Folder ids to omit from the tree (move dialog: item + descendants). */
+    excludeIds?: Set<string>;
+}
+export declare function FolderTree({ items, selectedFolderId, onSelectFolder, 'aria-label': ariaLabel, excludeIds, }: FolderTreeProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=folder-tree.d.ts.map

package/dist/components/file-manager/index.d.ts

@@ -0,0 +1,5 @@
+export { FileManager } from './file-manager';
+export type { FileManagerProps } from './file-manager';
+export type { FileManagerHandle, FileManagerItem, FileManagerItemKind, FileManagerItemMeta, FileManagerSignatureStatus, FileManagerPermissions, FileManagerPermissionsInput, FileManagerItemAction, FileManagerAddMenuItem, FileManagerUploadConfig, FileManagerUploadHandler, FileManagerActiveAction, FileManagerActiveActionType, } from './types';
+export { fileManagerAgent } from './file-manager.agent';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/file-manager/index.js

@@ -0,0 +1,6 @@
+import { F as r, f } from "../../_chunks/file-manager-UF8dkQF1.js";
+export {
+  r as FileManager,
+  f as fileManagerAgent
+};
+//# sourceMappingURL=index.js.map

package/dist/components/file-manager/list-view.d.ts

@@ -0,0 +1,49 @@
+import { type ReactNode, type RefObject } from 'react';
+import { type DataTableHandle } from '../data-table';
+import type { FileManagerItem, FileManagerItemAction, FileManagerPermissions } from './types';
+export interface ListViewProps {
+    /** Items of the current folder (folders + files), locale-sorted. Filtering
+     *  is done by the DataTable's per-column floating filters (name + type). */
+    items: FileManagerItem[];
+    selectedIds: string[];
+    /** Id of the file open in the host preview (e.g. the rail). Reuses the
+     *  selected-row tint so the user sees which document is active. */
+    previewedItemId?: string | null;
+    onSelectionChange: (ids: string[]) => void;
+    onOpen: (item: FileManagerItem) => void;
+    /** Primary single-click / keyboard activation — folders navigate, files
+     *  select-single (which fires the host `onPreviewItem`). */
+    onRowActivate: (item: FileManagerItem) => void;
+    /** Resolves the gate set for a single item. */
+    can: (item: FileManagerItem) => Required<FileManagerPermissions>;
+    onRequestRename: (itemId: string) => void;
+    onRequestMove: (itemIds: string[]) => void;
+    onRequestDelete: (itemIds: string[]) => void;
+    onDownload?: (itemIds: string[]) => void;
+    onShare?: (itemIds: string[]) => void;
+    onRequestSignature?: (item: FileManagerItem) => void;
+    /** Consumer actions appended after the built-in kebab entries. */
+    itemActions?: (item: FileManagerItem) => FileManagerItemAction[];
+    /**
+     * Nest files under their folders via AG Grid Tree Data (`treeData` +
+     * `getDataPath`). Sets the tree gridOption / autoGroupColumnDef flags only —
+     * inert unless the consumer has registered the Enterprise `TreeDataModule`.
+     * When on, `items` must be the whole descendant subtree (see `descendantsOf`)
+     * and paths are built relative to `currentFolderId`. @default false
+     */
+    groupByFolder?: boolean;
+    /**
+     * Current folder id (`null` = root) — the anchor for tree-data path building.
+     * Paths run from this folder's direct child down to each item.
+     */
+    currentFolderId: string | null;
+    /** Forwarded as the DataTable `gridId` (namespaced by the caller). */
+    gridId?: string;
+    /** Handle to the composed DataTable — the FileManager proxies its
+     *  type-filter handle methods and agent `filter` action through this. */
+    tableRef: RefObject<DataTableHandle<FileManagerItem> | null>;
+    /** FileManager action cluster rendered in the DataTable's `Toolbar.Actions`. */
+    toolbarActions: ReactNode;
+}
+export declare function ListView({ items, selectedIds, previewedItemId, onSelectionChange, onOpen, onRowActivate, can, onRequestRename, onRequestMove, onRequestDelete, onDownload, onShare, onRequestSignature, itemActions, groupByFolder, currentFolderId, gridId, tableRef, toolbarActions, }: ListViewProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=list-view.d.ts.map

package/dist/components/file-manager/toolbar.d.ts

@@ -0,0 +1,15 @@
+import type { FileManagerAddMenuItem, FileManagerPermissions } from './types';
+export interface FileManagerToolbarProps {
+    selectedIds: string[];
+    permissions: Required<FileManagerPermissions>;
+    onRequestCreateFolder: () => void;
+    onRequestUpload?: () => void;
+    addMenuItems?: FileManagerAddMenuItem[];
+    onRequestRename: (itemId: string) => void;
+    onRequestMove: (itemIds: string[]) => void;
+    onRequestDelete: (itemIds: string[]) => void;
+    onDownload?: (itemIds: string[]) => void;
+    onShare?: (itemIds: string[]) => void;
+}
+export declare function FileManagerToolbar({ selectedIds, permissions, onRequestCreateFolder, onRequestUpload, addMenuItems, onRequestRename, onRequestMove, onRequestDelete, onDownload, onShare, }: FileManagerToolbarProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=toolbar.d.ts.map

package/dist/components/file-manager/types.d.ts

@@ -0,0 +1,167 @@
+import type { ReactNode } from 'react';
+export type FileManagerItemKind = 'file' | 'folder';
+/** Signature workflow state. `pending` surfaces the request-signature action. */
+export type FileManagerSignatureStatus = 'none' | 'pending' | 'signed';
+export interface FileManagerItem {
+    /** Stable unique id. Emitted on DOM nodes as `data-item-id` — never the name. */
+    id: string;
+    /** Display name. Treated as PHI by the agent contract (see file-manager.agent.ts). */
+    name: string;
+    kind: FileManagerItemKind;
+    /** Parent folder id, or `null` for items at the root. */
+    parentId: string | null;
+    /** Size in bytes — files only. */
+    size?: number;
+    /**
+     * MIME type — files only. Drives the file-type icon.
+     *
+     * The brief names this field `contentType`; the kit keeps `mimeType`
+     * because renaming would ripple through utils / list-view / preview for
+     * no behavioural gain (documented deviation).
+     */
+    mimeType?: string;
+    /** ISO 8601 timestamp of the last modification. */
+    updatedAt?: string;
+    /**
+     * Open domain string — AlfaDocs uses
+     * `'xray' | 'image' | 'text' | 'identification' | 'other' | …`.
+     * Drives the type Badge column, grid card badge, and the toolbar type filter.
+     */
+    documentType?: string;
+    /** Clinical document flag (host-defined semantics). */
+    clinical?: boolean;
+    /** Signature workflow state. `pending` unlocks the request-signature action. */
+    signatureStatus?: FileManagerSignatureStatus;
+    /** Whether the document is shared with the patient. */
+    sharedWithPatient?: boolean;
+    /** Thumbnail image URL — grid cards render it in place of the type icon. */
+    thumbnailUrl?: string;
+    /** ISO 8601 expiry (e.g. identification documents). */
+    expiresAt?: string;
+}
+/**
+ * Capability gates. Every entry point (toolbar button, keyboard shortcut,
+ * per-row action, bulk bar, upload overlay) checks its gate; a missing gate
+ * means the affordance is not rendered at all.
+ *
+ * Default is all-true (react-file-manager precedent; demo-friendly). `delete`
+ * defaults true too but ALWAYS routes through a confirmation dialog — the
+ * clinical-safe guard lives in the forced-choice confirm, not in the default.
+ */
+export interface FileManagerPermissions {
+    createFolder?: boolean;
+    upload?: boolean;
+    download?: boolean;
+    rename?: boolean;
+    move?: boolean;
+    delete?: boolean;
+    share?: boolean;
+}
+/**
+ * Either a flat gate set applied to every item, or a per-item resolver that
+ * returns the gates for a given item (react-file-manager precedent).
+ */
+export type FileManagerPermissionsInput = FileManagerPermissions | ((item: FileManagerItem) => FileManagerPermissions);
+/**
+ * Data-driven consumer action appended to a per-item kebab menu (after the
+ * built-in rename/move/download/delete entries). Rendered through the shared
+ * DropdownMenu / DataTable actions primitives — the kit never hardcodes
+ * platform-specific actions.
+ */
+export interface FileManagerItemAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    onSelect: (item: FileManagerItem) => void;
+    destructive?: boolean;
+}
+/** Data-driven consumer entry appended to the Add menu (after the built-ins). */
+export interface FileManagerAddMenuItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    onSelect: () => void;
+    destructive?: boolean;
+}
+/** Upload transport config — mirrors the kit `FileUpload` contract. */
+export interface FileManagerUploadConfig {
+    /** react-dropzone `accept` map (mime → extensions). */
+    accept?: Record<string, string[]>;
+    /** Max size per file in bytes. */
+    maxSize?: number;
+    /** Allow selecting multiple files at once. @default true */
+    multiple?: boolean;
+}
+/** Per-file upload handler — the host owns transport. */
+export type FileManagerUploadHandler = (file: File, helpers: {
+    signal: AbortSignal;
+    onProgress: (percent: number) => void;
+}, parentFolderId: string | null) => Promise<void>;
+/**
+ * Single-active-action state machine. Exactly one action dialog can be in
+ * flight; attempts to begin another while one is active are ignored.
+ */
+export type FileManagerActiveAction = {
+    type: 'none';
+} | {
+    type: 'create-folder';
+} | {
+    type: 'upload';
+} | {
+    type: 'rename';
+    itemId: string;
+} | {
+    type: 'delete';
+    itemIds: string[];
+} | {
+    type: 'move';
+    itemIds: string[];
+};
+export type FileManagerActiveActionType = FileManagerActiveAction['type'];
+/**
+ * PHI-safe projection of an item — structural metadata only, never the
+ * display name. This is the shape the agent's always-on state exposes.
+ * `documentType` / `signatureStatus` are non-identifying categories, safe to
+ * surface for filtering and reasoning.
+ */
+export interface FileManagerItemMeta {
+    id: string;
+    kind: FileManagerItemKind;
+    parentId: string | null;
+    size?: number;
+    updatedAt?: string;
+    documentType?: string;
+    signatureStatus?: FileManagerSignatureStatus;
+}
+/**
+ * Curated imperative handle — the only programmable surface (agent registry
+ * + `forwardRef`). Reads return identifiers and structural state; the sole
+ * name-returning read (`getItemNames`) is surfaced by the agent adapter as a
+ * `safety: 'phi'` action, never through always-on state.
+ */
+export interface FileManagerHandle {
+    getSelection: () => string[];
+    setSelection: (ids: string[]) => void;
+    clearSelection: () => void;
+    getCurrentFolderId: () => string | null;
+    navigateTo: (folderId: string | null) => void;
+    /** Document-type filter (empty = no filter). Proxies to the DataTable column filter. */
+    getTypeFilter: () => string[];
+    setTypeFilter: (documentTypes: string[]) => void;
+    /**
+     * Metadata for every item (no argument), or for the children of one folder
+     * (`null` = root). Never includes names — see `getItemNames`.
+     */
+    getItems: (folderId?: string | null) => FileManagerItemMeta[];
+    /** Name-returning read — PHI. Exposed by the agent only via a `phi` action. */
+    getItemNames: (ids: string[]) => Array<{
+        id: string;
+        name: string;
+    }>;
+    /** Folders navigate; files resolve through the host `onOpenFile` callback. */
+    openItem: (id: string) => void;
+    /** Open the inline-rename dialog for an item (no-op if rename is denied). */
+    startRename: (id: string) => void;
+    getActiveAction: () => FileManagerActiveActionType;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/components/file-manager/utils.d.ts

@@ -0,0 +1,34 @@
+import { type LucideIcon } from 'lucide-react';
+import type { FileManagerItem } from './types';
+export declare function formatFileSize(bytes: number, locale: string, t: (key: string, fallback: string) => string): string;
+/** Icon component per item — folders first, then a MIME-family lookup. */
+export declare function getItemIcon(item: FileManagerItem): LucideIcon;
+/** Children of a folder, folders first, then locale-aware by name. */
+export declare function childrenOf(items: FileManagerItem[], folderId: string | null, locale: string): FileManagerItem[];
+/**
+ * Every item whose ancestry passes through `folderId` (folders + files, any
+ * depth) — the full subtree beneath a folder, excluding the folder itself.
+ * Feeds AG Grid Tree Data when `groupByFolder` is on (the flat `childrenOf`
+ * only returns the immediate level). Sort order matches `childrenOf` — folders
+ * first, then locale-aware by name — so sibling order is stable at every depth.
+ */
+export declare function descendantsOf(items: FileManagerItem[], folderId: string | null, locale: string): FileManagerItem[];
+/**
+ * AG Grid Tree Data path for an item: the id-chain from the current folder's
+ * direct child down to (and including) the item. Walk `parentId` up, stopping
+ * at `currentFolderId` (exclusive), then reverse and append the item's own id.
+ * Every returned id is a real folder/file row, so AG Grid never synthesises
+ * filler group rows. `itemsById` need only cover the current subtree.
+ */
+export declare function pathWithinFolder(item: FileManagerItem, itemsById: Map<string, FileManagerItem>, currentFolderId: string | null): string[];
+/** Path from the root down to `folderId` (exclusive of the virtual root). */
+export declare function pathTo(items: FileManagerItem[], folderId: string | null): FileManagerItem[];
+/**
+ * Ids of the given folders plus every folder nested inside them. Used to
+ * exclude invalid targets from the move-destination tree (a folder can never
+ * be moved into itself or one of its descendants).
+ */
+export declare function withDescendantFolderIds(items: FileManagerItem[], ids: string[]): Set<string>;
+/** True when the two id lists contain the same set of ids. */
+export declare function sameIdSet(a: string[], b: string[]): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/components/file-upload/file-upload.d.ts

@@ -41,5 +41,6 @@ export interface FileUploadProps {
     showPreview?: boolean;
     className?: string;
 }
+export declare const browseButtonVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
 export declare const FileUpload: import("react").ForwardRefExoticComponent<FileUploadProps & import("react").RefAttributes<HTMLDivElement>>;
 //# sourceMappingURL=file-upload.d.ts.map