@nxgt/material 3.56.0 → 3.58.0

package/dist/lib/components/ui/selection/transfer-list/partials/transfer-list-row-props.d.ts

@@ -0,0 +1,283 @@
+import { MouseEvent } from 'react';
+import { TransferRowProps } from './transfer-list-item-row.js';
+/** The option semantics and clicks of a row, over the props the sortable hands it. */
+export declare function transferOptionProps({ id, ref, style, focused, checked, inert, onToggle, onMove, onFocus, item: _item, pane: _pane, canMoveUp: _canMoveUp, canMoveDown: _canMoveDown, onMoveUp: _onMoveUp, onMoveDown: _onMoveDown, className: _className, ...domProps }: TransferRowProps, dragging: boolean): {
+    readonly 'aria-roledescription': undefined;
+    readonly 'aria-describedby': undefined;
+    readonly 'aria-pressed': undefined;
+    readonly id: string;
+    readonly ref: (node: HTMLDivElement | null) => void;
+    readonly style: import('react').CSSProperties | undefined;
+    readonly role: "option";
+    readonly 'aria-selected': boolean;
+    readonly 'aria-disabled': true | undefined;
+    readonly tabIndex: -1;
+    readonly onMouseDown: (event: MouseEvent<HTMLDivElement>) => void;
+    readonly onClick: (event: MouseEvent<HTMLDivElement>) => void;
+    readonly onDoubleClick: (event: MouseEvent<HTMLDivElement>) => void;
+    readonly onFocus: (() => void) & import('react').FocusEventHandler<HTMLDivElement>;
+    readonly title?: string | undefined;
+    readonly content?: string | undefined;
+    readonly translate?: "yes" | "no" | undefined;
+    readonly color?: string | undefined;
+    readonly prefix?: string | undefined;
+    readonly slot?: string | undefined;
+    readonly onKeyDown?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+    readonly onKeyUp?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+    readonly key?: import('react').Key | null | undefined;
+    readonly defaultChecked?: boolean | undefined;
+    readonly defaultValue?: string | number | readonly string[] | undefined;
+    readonly suppressContentEditableWarning?: boolean | undefined;
+    readonly suppressHydrationWarning?: boolean | undefined;
+    readonly accessKey?: string | undefined;
+    readonly autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+    readonly autoFocus?: boolean | undefined;
+    readonly contentEditable?: (boolean | "false" | "true") | "inherit" | "plaintext-only" | undefined;
+    readonly contextMenu?: string | undefined;
+    readonly dir?: string | undefined;
+    readonly draggable?: (boolean | "false" | "true") | undefined;
+    readonly enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+    readonly hidden?: boolean | undefined;
+    readonly lang?: string | undefined;
+    readonly nonce?: string | undefined;
+    readonly spellCheck?: (boolean | "false" | "true") | undefined;
+    readonly radioGroup?: string | undefined;
+    readonly about?: string | undefined;
+    readonly datatype?: string | undefined;
+    readonly inlist?: any;
+    readonly property?: string | undefined;
+    readonly rel?: string | undefined;
+    readonly resource?: string | undefined;
+    readonly rev?: string | undefined;
+    readonly typeof?: string | undefined;
+    readonly vocab?: string | undefined;
+    readonly autoCorrect?: string | undefined;
+    readonly autoSave?: string | undefined;
+    readonly itemProp?: string | undefined;
+    readonly itemScope?: boolean | undefined;
+    readonly itemType?: string | undefined;
+    readonly itemID?: string | undefined;
+    readonly itemRef?: string | undefined;
+    readonly results?: number | undefined;
+    readonly security?: string | undefined;
+    readonly unselectable?: "on" | "off" | undefined;
+    readonly popover?: "" | "auto" | "manual" | "hint" | undefined;
+    readonly popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+    readonly popoverTarget?: string | undefined;
+    readonly inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+    readonly is?: string | undefined;
+    readonly exportparts?: string | undefined;
+    readonly part?: string | undefined;
+    readonly "aria-activedescendant"?: string | undefined;
+    readonly "aria-atomic"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+    readonly "aria-braillelabel"?: string | undefined;
+    readonly "aria-brailleroledescription"?: string | undefined;
+    readonly "aria-busy"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+    readonly "aria-colcount"?: number | undefined;
+    readonly "aria-colindex"?: number | undefined;
+    readonly "aria-colindextext"?: string | undefined;
+    readonly "aria-colspan"?: number | undefined;
+    readonly "aria-controls"?: string | undefined;
+    readonly "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+    readonly "aria-description"?: string | undefined;
+    readonly "aria-details"?: string | undefined;
+    readonly "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+    readonly "aria-errormessage"?: string | undefined;
+    readonly "aria-expanded"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-flowto"?: string | undefined;
+    readonly "aria-grabbed"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+    readonly "aria-hidden"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+    readonly "aria-keyshortcuts"?: string | undefined;
+    readonly "aria-label"?: string | undefined;
+    readonly "aria-labelledby"?: string | undefined;
+    readonly "aria-level"?: number | undefined;
+    readonly "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    readonly "aria-modal"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-multiline"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-multiselectable"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    readonly "aria-owns"?: string | undefined;
+    readonly "aria-placeholder"?: string | undefined;
+    readonly "aria-posinset"?: number | undefined;
+    readonly "aria-readonly"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+    readonly "aria-required"?: (boolean | "false" | "true") | undefined;
+    readonly "aria-rowcount"?: number | undefined;
+    readonly "aria-rowindex"?: number | undefined;
+    readonly "aria-rowindextext"?: string | undefined;
+    readonly "aria-rowspan"?: number | undefined;
+    readonly "aria-setsize"?: number | undefined;
+    readonly "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+    readonly "aria-valuemax"?: number | undefined;
+    readonly "aria-valuemin"?: number | undefined;
+    readonly "aria-valuenow"?: number | undefined;
+    readonly "aria-valuetext"?: string | undefined;
+    readonly dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    readonly onCopy?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+    readonly onCopyCapture?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+    readonly onCut?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+    readonly onCutCapture?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+    readonly onPaste?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+    readonly onPasteCapture?: import('react').ClipboardEventHandler<HTMLDivElement> | undefined;
+    readonly onCompositionEnd?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+    readonly onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+    readonly onCompositionStart?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+    readonly onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+    readonly onCompositionUpdate?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+    readonly onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLDivElement> | undefined;
+    readonly onFocusCapture?: import('react').FocusEventHandler<HTMLDivElement> | undefined;
+    readonly onBlur?: import('react').FocusEventHandler<HTMLDivElement> | undefined;
+    readonly onBlurCapture?: import('react').FocusEventHandler<HTMLDivElement> | undefined;
+    readonly onChange?: import('react').ChangeEventHandler<HTMLDivElement, Element> | undefined;
+    readonly onChangeCapture?: import('react').ChangeEventHandler<HTMLDivElement, Element> | undefined;
+    readonly onBeforeInput?: import('react').InputEventHandler<HTMLDivElement> | undefined;
+    readonly onBeforeInputCapture?: import('react').InputEventHandler<HTMLDivElement> | undefined;
+    readonly onInput?: import('react').InputEventHandler<HTMLDivElement> | undefined;
+    readonly onInputCapture?: import('react').InputEventHandler<HTMLDivElement> | undefined;
+    readonly onReset?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onResetCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onSubmit?: import('react').SubmitEventHandler<HTMLDivElement> | undefined;
+    readonly onSubmitCapture?: import('react').SubmitEventHandler<HTMLDivElement> | undefined;
+    readonly onInvalid?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onInvalidCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onLoad?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onLoadCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onError?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onErrorCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+    readonly onKeyPress?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+    readonly onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+    readonly onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLDivElement> | undefined;
+    readonly onAbort?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onAbortCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onCanPlay?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onCanPlayCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onCanPlayThrough?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onDurationChange?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onDurationChangeCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onEmptied?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onEmptiedCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onEncrypted?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onEncryptedCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onEnded?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onEndedCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onLoadedData?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onLoadedDataCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onLoadedMetadata?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onLoadStart?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onLoadStartCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onPause?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onPauseCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onPlay?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onPlayCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onPlaying?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onPlayingCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onProgress?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onProgressCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onRateChange?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onRateChangeCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onSeeked?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onSeekedCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onSeeking?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onSeekingCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onStalled?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onStalledCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onSuspend?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onSuspendCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onTimeUpdate?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onVolumeChange?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onWaiting?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onWaitingCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onAuxClick?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onAuxClickCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onClickCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onContextMenu?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onContextMenuCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onDoubleClickCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onDrag?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragEnd?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragEndCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragEnter?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragEnterCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragExit?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragExitCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragLeave?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragLeaveCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragOver?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragOverCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragStart?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDragStartCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDrop?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onDropCapture?: import('react').DragEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseDownCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseEnter?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseLeave?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseMove?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseMoveCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseOut?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseOutCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseOver?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseOverCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseUp?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onMouseUpCapture?: import('react').MouseEventHandler<HTMLDivElement> | undefined;
+    readonly onSelect?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onSelectCapture?: import('react').ReactEventHandler<HTMLDivElement> | undefined;
+    readonly onTouchCancel?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+    readonly onTouchCancelCapture?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+    readonly onTouchEnd?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+    readonly onTouchEndCapture?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+    readonly onTouchMove?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+    readonly onTouchMoveCapture?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+    readonly onTouchStart?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+    readonly onTouchStartCapture?: import('react').TouchEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerDown?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerDownCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerMove?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerMoveCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerUp?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerUpCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerCancel?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerCancelCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerEnter?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerLeave?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerOver?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerOverCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerOut?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onPointerOutCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onGotPointerCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onLostPointerCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLDivElement> | undefined;
+    readonly onScroll?: import('react').UIEventHandler<HTMLDivElement> | undefined;
+    readonly onScrollCapture?: import('react').UIEventHandler<HTMLDivElement> | undefined;
+    readonly onScrollEnd?: import('react').UIEventHandler<HTMLDivElement> | undefined;
+    readonly onScrollEndCapture?: import('react').UIEventHandler<HTMLDivElement> | undefined;
+    readonly onWheel?: import('react').WheelEventHandler<HTMLDivElement> | undefined;
+    readonly onWheelCapture?: import('react').WheelEventHandler<HTMLDivElement> | undefined;
+    readonly onAnimationStart?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+    readonly onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+    readonly onAnimationEnd?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+    readonly onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+    readonly onAnimationIteration?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+    readonly onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLDivElement> | undefined;
+    readonly onBeforeToggle?: import('react').ToggleEventHandler<HTMLDivElement> | undefined;
+    readonly onTransitionCancel?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+    readonly onTransitionCancelCapture?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+    readonly onTransitionEnd?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+    readonly onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+    readonly onTransitionRun?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+    readonly onTransitionRunCapture?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+    readonly onTransitionStart?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+    readonly onTransitionStartCapture?: import('react').TransitionEventHandler<HTMLDivElement> | undefined;
+};

package/dist/lib/components/ui/selection/transfer-list/transfer-list.keyboard.d.ts

@@ -25,13 +25,14 @@ type KeyEventLike = {
     shiftKey?: boolean;
     preventDefault: () => void;
 };
-export declare function handleTransferListKeyDown(event: KeyEventLike, ctx: {
+type KeyContext = {
     pane?: TransferPane;
     focusedValue: string | null;
     visibleValues: string[];
     otherPaneValues?: string[];
     transferable: string[];
-}): TransferListKeyCommand | null;
+};
+export declare function handleTransferListKeyDown(event: KeyEventLike, ctx: KeyContext): TransferListKeyCommand | null;
 export declare function runTransferListCommand(command: TransferListKeyCommand, pane: TransferPane, list: {
     chrome: {
         focusedValue: string | null;

package/dist/lib/components/ui/selection/transfer-list/use-transfer-list-actions.d.ts

@@ -29,7 +29,8 @@ export declare function useTransferListChrome(): readonly [TransferListChromeSta
     }) => void;
     clearPaneChecked: (payload: TransferPane) => void;
 }];
-type ChromeActions = ReturnType<typeof useTransferListChrome>[1];
+export type TransferListChromeActions = ReturnType<typeof useTransferListChrome>[1];
+type ChromeActions = TransferListChromeActions;
 export type TransferListActionsOptions = {
     items: TransferListItem[];
     selectedValues: string[];
@@ -44,10 +45,10 @@ export type TransferListActionsOptions = {
 };
 /** The model's commands: each checks `disabled`, then dispatches or emits. */
 export declare function useTransferListActions({ items, selectedValues, setSelectedValues, chrome, chromeActions, max, disabled, visible, transferable, checked, }: TransferListActionsOptions): {
-    moveValues: (pane: TransferPane, ids: string[]) => void;
     toggleChecked: (pane: TransferPane, id: string) => void;
     extendChecked: (pane: TransferPane, id: string) => void;
     selectAll: (pane: TransferPane) => void;
+    moveValues: (pane: TransferPane, ids: string[]) => void;
     reorder: (id: string, direction: "up" | "down") => void;
     dropValues: (dragged: string[], target: TransferDropTarget) => void;
 };

package/dist/lib/components/ui/selection/transfer-list/use-transfer-list-checks.d.ts

@@ -0,0 +1,18 @@
+import { TransferListChromeState, TransferListItem, TransferPane } from './types.js';
+import { TransferListChromeActions } from './use-transfer-list-actions.js';
+type PerPane<T> = Record<TransferPane, T>;
+type Checks = {
+    chrome: TransferListChromeState;
+    chromeActions: TransferListChromeActions;
+    disabled: boolean;
+    visible: PerPane<TransferListItem[]>;
+    transferable: PerPane<string[]>;
+    checked: PerPane<string[]>;
+};
+/** Ticking rows: one, a range (Shift), or all of a pane. */
+export declare function useTransferListChecks({ chrome, chromeActions, disabled, visible, transferable, checked, }: Checks): {
+    toggleChecked: (pane: TransferPane, id: string) => void;
+    extendChecked: (pane: TransferPane, id: string) => void;
+    selectAll: (pane: TransferPane) => void;
+};
+export {};

package/dist/lib/components/ui/selection/transfer-list/use-transfer-list-derived.d.ts

@@ -0,0 +1,14 @@
+import { TransferListChromeState, TransferListItem } from './types.js';
+/** Each pane's rows: split, filtered by its query, and what can move or is checked. */
+export declare function useTransferListDerived(items: TransferListItem[], selectedValues: string[], chrome: TransferListChromeState): {
+    partitioned: {
+        available: TransferListItem[];
+        selected: TransferListItem[];
+    };
+    availableVisible: TransferListItem[];
+    selectedVisible: TransferListItem[];
+    availableTransferable: string[];
+    selectedTransferable: string[];
+    availableChecked: string[];
+    selectedChecked: string[];
+};

package/dist/lib/components/ui/selection/transfer-list/use-transfer-list.d.ts

@@ -8,10 +8,10 @@ export type UseTransferListOptions = {
     disabled?: boolean;
 };
 export declare function useTransferList({ items, value, defaultValue, onValueChange, max, disabled, }: UseTransferListOptions): {
-    moveValues: (pane: import('./types.js').TransferPane, ids: string[]) => void;
     toggleChecked: (pane: import('./types.js').TransferPane, id: string) => void;
     extendChecked: (pane: import('./types.js').TransferPane, id: string) => void;
     selectAll: (pane: import('./types.js').TransferPane) => void;
+    moveValues: (pane: import('./types.js').TransferPane, ids: string[]) => void;
     reorder: (id: string, direction: "up" | "down") => void;
     dropValues: (dragged: string[], target: import('./transfer-list.dnd.js').TransferDropTarget) => void;
     selectedValues: string[];

package/dist/lib/components/ui/selection/tree-select-field/partials/tree-select-chips.d.ts

@@ -0,0 +1,9 @@
+import { RefObject } from 'react';
+import { TreeNode } from '../../../collections/tree/types.js';
+/** A tonal chip per picked node, each with its remove button. */
+export declare function TreeSelectChips({ nodes, box, disabled, onRemove, }: {
+    nodes: TreeNode[];
+    box: RefObject<HTMLDivElement | null>;
+    disabled?: boolean;
+    onRemove: (id: string) => void;
+}): import("react").JSX.Element[];

package/dist/lib/components/ui/selection/tree-select-field/partials/tree-select-trigger-button.d.ts

@@ -0,0 +1,15 @@
+import { ComponentProps, ReactNode } from 'react';
+type Props = {
+    name?: string;
+    disabled?: boolean;
+    /** The combobox's role, name, description and id (`pickerTriggerA11y`). */
+    a11y: ComponentProps<'button'>;
+    picked: boolean;
+    multiple?: boolean;
+    text: ReactNode;
+    /** Single mode: the picked node's ancestors, shown muted after it. */
+    path?: string;
+};
+/** The `combobox` button that opens the tree, its chevron turning over while open. */
+export declare function TreeSelectTriggerButton({ name, disabled, a11y, picked, multiple, text, path, }: Props): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/chat/chat-message.d.ts

@@ -2,4 +2,4 @@ import { ChatMessageProps } from './chat-message.types.js';
 import { ChatMessageVariant } from './chat-message.variants.js';
 import { ChatMessageStatus } from './chat-message-meta.js';
 export type { ChatMessageProps, ChatMessageStatus, ChatMessageVariant };
-export declare function ChatMessage({ variant, avatar, avatarFallback, avatarSrc, timestamp, toolName, isStreaming, isLoading, status, onRetry, footer, copyable, copyText, children, layout: ownLayout, density: ownDensity, groupPosition, author, edited, replyTo, onReply, onDelete, onReact, reactionSuggestions, reactions, onReactionToggle, menuItems, className, ...props }: ChatMessageProps): import("react").JSX.Element;
+export declare function ChatMessage({ layout: ownLayout, density: ownDensity, className, ...props }: ChatMessageProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/chat/chat-message.view.d.ts

@@ -0,0 +1,32 @@
+import { ChatLayoutValue } from './chat-layout-context.js';
+import { ChatMessageProps } from './chat-message.types.js';
+/** The props of a `ChatMessage` that shape its content; the others go to the row's `div`. */
+declare const CONTENT_KEYS: readonly ["variant", "avatar", "avatarFallback", "avatarSrc", "timestamp", "toolName", "isStreaming", "isLoading", "status", "onRetry", "footer", "copyable", "copyText", "children", "groupPosition", "author", "edited", "replyTo", "onReply", "onDelete", "onReact", "reactionSuggestions", "reactions", "onReactionToggle", "menuItems"];
+export type ChatMessageContent = Pick<ChatMessageProps, (typeof CONTENT_KEYS)[number]>;
+/** Splits a message's props into its content props and the `div` props. */
+export declare function splitChatMessageProps(props: Omit<ChatMessageProps, 'layout' | 'density'>): {
+    content: ChatMessageContent;
+    dom: Omit<ChatMessageProps, 'layout' | 'density' | keyof ChatMessageContent>;
+};
+/** What a message derives from its props and the list's layout, shared by its row and its body. */
+export declare function chatMessageView(content: ChatMessageContent, { layout, density }: ChatLayoutValue): {
+    variant: import('./chat-message.variants.js').ChatMessageVariant;
+    groupPosition: import('./chat-group.js').ChatGroupPosition;
+    status: import('./chat-message-meta.js').ChatMessageStatus;
+    layout: import('./chat-layout-context.js').ChatLayout;
+    density: import('./chat-layout-context.js').ChatDensity;
+    flat: boolean;
+    isUser: boolean;
+    lead: boolean;
+    tail: boolean;
+    failed: boolean;
+    metaTime: import('react').ReactNode;
+    isLoading: boolean;
+    edited: boolean;
+    alignEnd: boolean;
+    hasAvatar: boolean;
+    copyText: string | undefined;
+    hasMeta: boolean;
+};
+export type ChatMessageView = ReturnType<typeof chatMessageView>;
+export {};

package/dist/lib/components/ui/widgets/chat/partials/chat-composer-notices.d.ts

@@ -0,0 +1,8 @@
+import { ChatComposerProps } from '../chat-composer.js';
+import { useChatComposer } from '../use-chat-composer.js';
+type NoticesProps = Pick<ChatComposerProps, 'value' | 'onValueChange' | 'onSend' | 'suggestions' | 'onSuggestionSelect' | 'mentions'> & {
+    composer: ReturnType<typeof useChatComposer>;
+};
+/** What sits above the field: quick replies, the send error and the mention list. */
+export declare function ChatComposerNotices({ composer, value, onValueChange, onSend, suggestions, onSuggestionSelect, mentions, }: NoticesProps): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/chat/partials/chat-composer-surface.d.ts

@@ -0,0 +1,11 @@
+import { ChatComposerProps } from '../chat-composer.js';
+import { useChatComposer } from '../use-chat-composer.js';
+type SurfaceProps = Pick<ChatComposerProps, 'value' | 'onValueChange' | 'attachments' | 'onAttachmentsChange' | 'accept' | 'maxFiles' | 'maxLength' | 'actions' | 'emojis' | 'replyTo' | 'onCancelReply' | 'onStop' | 'isLoading' | 'onSend' | 'suggestions' | 'onSuggestionSelect' | 'mentions'> & {
+    composer: ReturnType<typeof useChatComposer>;
+    floating: boolean;
+};
+/** The composer's rounded field: the quoted reply, the attachments and the input row. */
+export declare function ChatComposerSurface({ composer, floating, ...props }: SurfaceProps): import("react").JSX.Element;
+/** The classes of the composer's form: docked under the list or floating. */
+export declare function composerFormClass(floating: boolean): string;
+export {};

package/dist/lib/components/ui/widgets/chat/partials/chat-conversation-item-skeleton.d.ts

@@ -0,0 +1,4 @@
+/** The placeholder row shown while a conversation loads. */
+export declare function ChatConversationItemSkeleton({ className, }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/chat/partials/chat-conversation-item-text.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+/** The title, timestamp, preview (or typing line) and unread badge of a conversation row. */
+export declare function ChatConversationItemText({ title, preview, timestamp, unreadCount, isActive, isTyping, }: {
+    title: ReactNode;
+    preview?: ReactNode;
+    timestamp?: ReactNode;
+    unreadCount?: number;
+    isActive: boolean;
+    isTyping: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/chat/partials/chat-inbox-list.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+/** The inbox's left column: an optional header and the scrolling conversation list. */
+export declare function ChatInboxList({ list, listHeader, hidden, }: {
+    list: ReactNode;
+    listHeader?: ReactNode;
+    /** Hides the column below the `md` container width (the thread is showing). */
+    hidden: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/chat/partials/chat-inbox-thread.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+/** The inbox's right column: the thread with its back bar, or the "pick a conversation" state. */
+export declare function ChatInboxThread({ thread, context, onBack, hidden, }: {
+    thread?: ReactNode;
+    context: {
+        back: () => void;
+    };
+    onBack: () => void;
+    /** Hides the column below the `md` container width (the list is showing). */
+    hidden: boolean;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/chat/partials/chat-message-action-menus.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+/** Classes of the toolbar's icon buttons. */
+export declare const BUTTON = "size-7 [&_svg]:size-3.5";
+type Side = 'start' | 'end' | 'row';
+/** The toolbar's reaction picker: a menu of emojis. */
+export declare function ChatReactMenu({ side, emojis, onReact, }: {
+    side: Side;
+    emojis: string[];
+    onReact: (emoji: string) => void;
+}): import("react").JSX.Element;
+/** The toolbar's "more" menu: the consumer's items, then delete. */
+export declare function ChatMoreMenu({ side, onDelete, children, }: {
+    side: Side;
+    onDelete?: () => void;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/widgets/chat/partials/chat-message-body.d.ts

@@ -0,0 +1,6 @@
+import { ChatMessageContent, ChatMessageView } from '../chat-message.view.js';
+/** The column of a message: heading, tool badge, bubble, reactions, status line and footer. */
+export declare function ChatMessageBody({ content, view, }: {
+    content: ChatMessageContent;
+    view: ChatMessageView;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/chat/partials/chat-scroll-to-latest.d.ts

@@ -0,0 +1,7 @@
+/** The floating "scroll to latest" button over the list's bottom edge. */
+export declare function ChatScrollToLatest({ visible, count, label, onClick, }: {
+    visible: boolean;
+    count: number;
+    label?: string;
+    onClick: () => void;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/chat/partials/chat-typing-row.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { ChatDensity, ChatLayout } from '../chat-layout-context.js';
+/** The "someone is typing" row at the end of the list, with the typer's avatar. */
+export declare function ChatTypingRow({ density, layout, avatar, label, }: {
+    density: ChatDensity;
+    layout: ChatLayout;
+    avatar?: ReactNode;
+    label?: string;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/chat/use-chat-inbox-pane.d.ts

@@ -0,0 +1,13 @@
+import { ChatInboxPane } from './chat-inbox.js';
+/** The inbox's pane (list or thread), controlled or not, and the context handed to the thread. */
+export declare function useChatInboxPane({ pane: controlled, defaultPane, onPaneChange, }: {
+    pane?: ChatInboxPane;
+    defaultPane?: ChatInboxPane;
+    onPaneChange?: (pane: ChatInboxPane) => void;
+}): {
+    pane: ChatInboxPane;
+    setPane: (next: ChatInboxPane) => void;
+    context: {
+        back: () => void;
+    };
+};

package/dist/lib/components/ui/widgets/chat/use-chat-widget-open.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The widget's open state (controlled or not) and its focus hand-off: opening
+ * focuses the message field, closing hands focus back to the launcher when it
+ * was inside the panel.
+ */
+export declare function useChatWidgetOpen({ open: controlled, defaultOpen, onOpenChange, }: {
+    open?: boolean;
+    defaultOpen: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): {
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    launcherRef: import('react').RefObject<HTMLButtonElement | null>;
+    panelRef: import('react').RefObject<HTMLDivElement | null>;
+};
+/** The launcher's name: the consumer's, else "Open chat" / "Close chat". */
+export declare function useLauncherLabel(launcherLabel: string | undefined, open: boolean): string;
+/** The classes of the widget's root: pinned to a corner, only its children take the pointer. */
+export declare function chatWidgetClass(strategy: 'fixed' | 'absolute', side: 'start' | 'end'): string;

package/dist/lib/components/ui/widgets/code-editor/toolbar/code-view-tools.d.ts

@@ -0,0 +1,10 @@
+export type CodeViewToolsProps = {
+    disabled?: boolean;
+    wordWrap: boolean;
+    onWordWrapChange: (wordWrap: boolean) => void;
+    fullscreen?: boolean;
+    onFullscreenChange?: (fullscreen: boolean) => void;
+    onFind: () => void;
+};
+/** The pill's View group: Find, Word wrap and, when offered, Full screen. */
+export declare function CodeViewTools({ disabled, wordWrap, onWordWrapChange, fullscreen, onFullscreenChange, onFind, }: CodeViewToolsProps): import("react").JSX.Element;

package/dist/lib/components/ui/widgets/code-editor/use-monaco-options.d.ts

@@ -0,0 +1,9 @@
+import { editor } from 'monaco-editor';
+import { CodeEditorOptionsInput } from './code-editor-options.js';
+/**
+ * Monaco's options, memoised on every field: a new label reaches Monaco
+ * through `updateOptions`, as every option does.
+ */
+export declare function useMonacoOptions(input: CodeEditorOptionsInput): editor.IStandaloneEditorConstructionOptions;
+/** The tab size is the model's: set again when it changes after mount. */
+export declare function useModelTabSize(mounted: editor.IStandaloneCodeEditor | undefined, tabSizeInput: number | undefined): void;

package/dist/lib/components/ui/widgets/editor/extensions/custom/accordion/accordion-item-actions.d.ts

@@ -0,0 +1,7 @@
+import { AccordionItemAttrs } from './const.js';
+export type AccordionItemActionsProps = Pick<AccordionItemAttrs, 'title' | 'content'> & {
+    onUpdate: (attrs: Partial<AccordionItemAttrs>) => void;
+    onRemove: () => void;
+};
+/** An item's Edit and Remove buttons, shown on hover of its header. */
+export declare function AccordionItemActions({ title, content, onUpdate, onRemove, }: AccordionItemActionsProps): import("react").JSX.Element;