@danxbot/ui 1.0.0

package/dist/types/components/chat/Markdown.d.ts

@@ -0,0 +1,22 @@
+export interface CodeBlockProps {
+    code: string;
+    language?: string;
+    filename?: string;
+    /** Still filling — suppresses the copy button, which would copy a fragment. */
+    streaming?: boolean;
+    className?: string;
+}
+export declare function CodeBlock({ code, language, filename, streaming, className }: CodeBlockProps): import("react").JSX.Element;
+export interface MarkdownProps {
+    children: string;
+    className?: string;
+}
+/**
+ * Blocks are memoised individually.
+ *
+ * A response is re-parsed on every token, so without this the reconciler
+ * rebuilds every finished paragraph each time a word lands at the bottom —
+ * which is both wasteful and visible, because re-created DOM loses selection.
+ * Someone highlighting a sentence while the answer continues keeps it.
+ */
+export declare const Markdown: import("react").NamedExoticComponent<MarkdownProps>;

package/dist/types/components/chat/Message.d.ts

@@ -0,0 +1,59 @@
+import { type ReactNode, type Ref } from "react";
+import { Icon } from "../Icon";
+import type { ChatComponents, ChatFile, ChatMessage, MessagePart, PartRenderers, RenderContext, ToolPart } from "./types";
+export interface ToolCallProps {
+    part: ToolPart;
+    defaultOpen?: boolean;
+    className?: string;
+}
+/**
+ * A tool invocation, collapsed to one line.
+ *
+ * COLLAPSED BY DEFAULT because the transcript is a conversation and not a log:
+ * twenty lines of output between two sentences buries both of them. The summary
+ * carries enough to decide whether opening it is worth doing, which is the only
+ * decision anyone makes about a tool call they did not have to authorise.
+ */
+export declare function ToolCall({ part, defaultOpen, className }: ToolCallProps): import("react").JSX.Element;
+export interface MessagePartViewProps<TApp = unknown> {
+    part: MessagePart;
+    context: RenderContext<TApp>;
+    renderers?: PartRenderers<TApp>;
+    components?: ChatComponents<TApp>;
+    onPreviewFile?: (file: ChatFile) => void;
+    onDownloadFile?: (file: ChatFile) => void;
+}
+export declare function MessagePartView<TApp>({ part, context, renderers, components, onPreviewFile, onDownloadFile, }: MessagePartViewProps<TApp>): import("react").JSX.Element;
+export interface MessageAction {
+    id: string;
+    icon: Parameters<typeof Icon>[0]["name"];
+    label: string;
+    onClick: (message: ChatMessage) => void;
+    /** Latches on — a cast feedback vote, a saved message. */
+    active?: boolean;
+}
+export interface MessageProps<TApp = unknown> {
+    message: ChatMessage;
+    renderers?: PartRenderers<TApp>;
+    components?: ChatComponents<TApp>;
+    appContext?: TApp;
+    /** Row buttons under the body. Assistant turns only, unless `on` says otherwise. */
+    actions?: MessageAction[];
+    /** Hides the avatar and name — for consecutive turns from the same author. */
+    grouped?: boolean;
+    showAvatar?: boolean;
+    showTimestamp?: boolean;
+    onPreviewFile?: (file: ChatFile) => void;
+    onDownloadFile?: (file: ChatFile) => void;
+    className?: string;
+    ref?: Ref<HTMLElement>;
+}
+export declare function Message<TApp = unknown>({ message, renderers, components, appContext, actions, grouped, showAvatar, showTimestamp, onPreviewFile, onDownloadFile, className, ref, }: MessageProps<TApp>): import("react").JSX.Element;
+export interface ChatMarkerProps {
+    children: ReactNode;
+    /** A date break or a labelled rule rather than a status note. */
+    variant?: "rule" | "note";
+    className?: string;
+}
+/** A date break, a "context compacted" note, a model change mid-thread. */
+export declare function ChatMarker({ children, variant, className }: ChatMarkerProps): import("react").JSX.Element;

package/dist/types/components/chat/MessageScroller.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode, type Ref } from "react";
+export interface MessageScrollerProps {
+    children: ReactNode;
+    /** Distance from the bottom, in px, still counted as "at the bottom". */
+    threshold?: number;
+    /** Label for the return-to-newest button. */
+    jumpLabel?: string;
+    /** Fades content at the top edge so it reads as continuing past the frame. */
+    fade?: boolean;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function MessageScroller({ children, threshold, jumpLabel, fade, className, ref, }: MessageScrollerProps): import("react").JSX.Element;

package/dist/types/components/chat/ModelSelector.d.ts

@@ -0,0 +1,44 @@
+import { type ReactNode } from "react";
+export interface ChatModel {
+    id: string;
+    name: string;
+    /** One line under the name — what this model is FOR. */
+    description?: string;
+    /** "New", "Fastest", a context size — anything that fits in a chip. */
+    badge?: ReactNode;
+    disabled?: boolean;
+    /**
+     * Keeps the model out of the main list until "More models" is opened.
+     *
+     * The primary list should be short enough to read at a glance; everything
+     * an experienced user occasionally reaches for lives one click deeper. A
+     * flat list of fifteen models makes the three that matter harder to find.
+     */
+    secondary?: boolean;
+}
+export interface ModelSelectorProps {
+    models: ChatModel[];
+    value: string;
+    onValueChange: (id: string) => void;
+    /** Extra switches under a separator — fast mode, thinking, whatever applies. */
+    options?: Array<{
+        id: string;
+        label: ReactNode;
+        description?: ReactNode;
+        checked: boolean;
+        onCheckedChange: (checked: boolean) => void;
+        disabled?: boolean;
+    }>;
+    /**
+     * Number keys pick from the primary list while the menu is open.
+     *
+     * Only while OPEN — a bare digit is a legitimate character everywhere else,
+     * and a chat's composer is the last place to steal one.
+     */
+    numericShortcuts?: boolean;
+    side?: "top" | "bottom";
+    align?: "start" | "center" | "end";
+    disabled?: boolean;
+    className?: string;
+}
+export declare function ModelSelector({ models, value, onValueChange, options, numericShortcuts, side, align, disabled, className, }: ModelSelectorProps): import("react").JSX.Element;

package/dist/types/components/chat/types.d.ts

@@ -0,0 +1,155 @@
+import type { ReactNode } from "react";
+export type MessageRole = "user" | "assistant" | "system";
+/** Prose. Rendered through the streaming-aware markdown renderer. */
+export interface TextPart {
+    type: "text";
+    text: string;
+}
+export interface CodePart {
+    type: "code";
+    code: string;
+    language?: string;
+    filename?: string;
+}
+/**
+ * Model reasoning, shown collapsed.
+ *
+ * A separate type rather than styled text because it is a different KIND of
+ * content: usually hidden, summarised when collapsed, and never the answer.
+ */
+export interface ReasoningPart {
+    type: "reasoning";
+    text: string;
+    /** Shown on the collapsed row — "Thought for 8s". */
+    label?: string;
+    streaming?: boolean;
+}
+export type ToolStatus = "running" | "success" | "error";
+/**
+ * A tool invocation, collapsed to one line by default.
+ *
+ * Collapsed is the DEFAULT because the transcript is a conversation, not a
+ * log: fifteen lines of tool output between two sentences buries both. The
+ * summary carries enough to decide whether to open it.
+ */
+export interface ToolPart {
+    type: "tool";
+    name: string;
+    /** One line: "Ran 3 commands, used a tool". */
+    summary: string;
+    status: ToolStatus;
+    detail?: ReactNode;
+    /** Diff counts, rendered as +N −N beside the summary. */
+    stats?: {
+        added?: number;
+        removed?: number;
+    };
+}
+export interface FilePart {
+    type: "file";
+    file: ChatFile;
+}
+/**
+ * An application component, addressed BY NAME.
+ *
+ * This is the whole reason the registry exists: a message can carry a live
+ * approval form, a chart, a card with working buttons — real UI wired to the
+ * host application, not a picture of it.
+ *
+ * The name is a string and the props are plain data, so a message stays
+ * serialisable. Putting a component reference in the part would make a
+ * transcript impossible to persist, replay, or send over a wire — and a chat
+ * you cannot reload is not a chat.
+ */
+export interface ComponentPart {
+    type: "component";
+    /** Key into `ChatComponents`. */
+    component: string;
+    props?: Record<string, unknown>;
+}
+export type MessagePart = TextPart | CodePart | ReasoningPart | ToolPart | FilePart | ComponentPart;
+export type MessagePartType = MessagePart["type"];
+export interface ChatFile {
+    id: string;
+    name: string;
+    /** Bytes. Omitted while an upload is still in flight and the size is unknown. */
+    size?: number;
+    mimeType?: string;
+    /** Object URL or remote href. Absent means "not fetchable yet". */
+    url?: string;
+    /** Image thumbnail, when one exists. */
+    thumbnailUrl?: string;
+    status?: "uploading" | "ready" | "error";
+    /** 0–100, while uploading. */
+    progress?: number;
+    error?: string;
+}
+export interface ChatMessage {
+    id: string;
+    role: MessageRole;
+    parts: MessagePart[];
+    createdAt?: Date | string;
+    /** Files attached by the author, shown above the body. */
+    attachments?: ChatFile[];
+    /** True while this message is still arriving. */
+    streaming?: boolean;
+    /** Shown in place of the body — a failed turn is still part of the record. */
+    error?: string;
+    author?: {
+        name?: string;
+        avatarUrl?: string;
+    };
+}
+/**
+ * What a renderer is handed alongside its part.
+ *
+ * `app` is the answer to "how does a custom component reach application
+ * state". The registry is built ONCE, at module scope, with no closures over
+ * hooks or props — and every renderer receives the live application handle
+ * here, at call time. Closing over app state when building the registry would
+ * work exactly until someone defines it outside the component that owns the
+ * state, which is precisely where a registry is supposed to live.
+ */
+export interface RenderContext<TApp = unknown> {
+    message: ChatMessage;
+    /** True while THIS message is still streaming — renderers use it to hold
+        back anything that would thrash, and to show live affordances. */
+    streaming: boolean;
+    /** Whatever the application passed to `<Chat appContext>`. */
+    app: TApp;
+}
+export type PartRenderer<P extends MessagePart = MessagePart, TApp = unknown> = (part: P, context: RenderContext<TApp>) => ReactNode;
+/**
+ * Overrides for the built-in part renderers.
+ *
+ * Partial on purpose: an application replacing the code renderer should not
+ * have to re-implement the other five.
+ */
+export type PartRenderers<TApp = unknown> = {
+    text?: PartRenderer<TextPart, TApp>;
+    code?: PartRenderer<CodePart, TApp>;
+    reasoning?: PartRenderer<ReasoningPart, TApp>;
+    tool?: PartRenderer<ToolPart, TApp>;
+    file?: PartRenderer<FilePart, TApp>;
+};
+export type ChatComponentRenderer<TApp = unknown> = (props: Record<string, unknown>, context: RenderContext<TApp>) => ReactNode;
+/** Named application components a message may address. */
+export type ChatComponents<TApp = unknown> = Record<string, ChatComponentRenderer<TApp>>;
+/**
+ * An unrenderable part is shown, never swallowed.
+ *
+ * Two failure modes are possible and both are silent by default: a part whose
+ * `type` no renderer handles, and a `component` part naming something the
+ * registry does not contain. Dropping either produces a message that is
+ * missing content with nothing anywhere to say so — the same class of failure
+ * as the icon registry that optimised itself away and rendered nothing.
+ *
+ * Throwing is not the alternative. An uncaught throw in render unmounts the
+ * React tree, so one malformed message would blank the entire application.
+ * The part renders as a visible, labelled placeholder and logs once.
+ */
+export interface UnknownPartInfo {
+    reason: "unknown-type" | "missing-component";
+    /** The `type`, or the component name that was not found. */
+    name: string;
+}

package/dist/types/components/code-editor/context.d.ts

@@ -0,0 +1,32 @@
+/** How the content is presented. `split` is source and preview side by side. */
+export type CodeEditorView = "source" | "rendered" | "split";
+export interface CodeEditorContextValue {
+    /** The current text — the source of truth for copying and for the preview. */
+    value: string;
+    /** Language name as given, before registry resolution. Null when unset. */
+    language: string | null;
+    /** Caption for the toolbar, usually a filename. */
+    filename?: string;
+    /** True when there is no textarea and the surface is a viewer. */
+    readOnly: boolean;
+    /** Soft wrap on. */
+    wrap: boolean;
+    setWrap: (next: boolean) => void;
+    /** Current presentation. */
+    view: CodeEditorView;
+    setView: (next: CodeEditorView) => void;
+    /**
+     * The views THIS instance can offer. One entry means there is nothing to
+     * switch between, so the switch does not render — the configuration is the
+     * switch, not a `showViewSwitch` prop.
+     */
+    views: readonly CodeEditorView[];
+    /** Copies `value` to the clipboard. */
+    copy: () => void;
+    /** True for a moment after a successful copy. */
+    copied: boolean;
+    /** Lines in `value`, for the gutter and for the expand affordance's label. */
+    lineCount: number;
+}
+export declare const CodeEditorProvider: import("react").Provider<CodeEditorContextValue | null>;
+export declare function useCodeEditor(component: string): CodeEditorContextValue;

package/dist/types/components/code-editor/editing.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Writes `text` over `[start, end)` and leaves the caret at `caret`.
+ *
+ * Returns true when the browser's history recorded it — false when this fell
+ * through to the direct-write path and undo will not reach past this edit.
+ */
+export declare function applyEdit(el: HTMLTextAreaElement, start: number, end: number, text: string, caret?: readonly [number, number]): boolean;
+/** Offset of the first character of the line containing `at`. */
+export declare function lineStart(value: string, at: number): number;
+/** Offset of the newline ending the line containing `at`, or the length. */
+export declare function lineEnd(value: string, at: number): number;
+/**
+ * Tab / Shift+Tab.
+ *
+ * A selection that spans a line break indents or dedents the whole BLOCK —
+ * including when the selection is only partial on its first and last lines,
+ * because a person who dragged across four lines meant those four lines.
+ */
+export declare function indentSelection(el: HTMLTextAreaElement, indent: string, dedent: boolean): void;
+/**
+ * Enter. Copies the current line's indentation, adds one unit after an opener,
+ * and pushes a closer that was sitting right after the caret onto its own line.
+ *
+ * That last case is the only "clever" one and it earns its place: typing `{`
+ * then Enter is how a block is opened, and without it the caret lands on the
+ * same line as the `}` every single time.
+ */
+export declare function autoIndentNewline(el: HTMLTextAreaElement, indent: string): void;
+/**
+ * Bracket and quote handling for one printable character. Returns true when it
+ * consumed the key, false to let the browser type it normally.
+ *
+ * DELIBERATELY SMALL. Auto-pairing that tries to be smart is the feature people
+ * turn off: the rules below never delete anything, never act inside a word, and
+ * never insert a partner the caret is not immediately in front of.
+ */
+export declare function handleAutoPair(el: HTMLTextAreaElement, key: string): boolean;
+/** Backspace between an auto-inserted pair removes both halves. */
+export declare function handlePairBackspace(el: HTMLTextAreaElement): boolean;

package/dist/types/components/code-editor/highlight.d.ts

@@ -0,0 +1,20 @@
+import type { Token } from "../../lib/syntax";
+/** Tokens for `source`, recomputed only when the text or the language moves. */
+export declare function useTokens(source: string, language: string | null | undefined): Token[];
+export declare const CodeEditorTokens: import("react").NamedExoticComponent<{
+    source: string;
+    tokens: Token[];
+}>;
+/**
+ * The line-number column.
+ *
+ * NOT RENDERED WHILE SOFT WRAP IS ON, and that is deliberate rather than
+ * unfinished. A wrapped line occupies several visual rows, so a fixed column of
+ * numbers drifts one row further out of true for every line that wraps — and a
+ * number printed beside the wrong line is worse than no number, because it is
+ * believed. `CodeEditor` decides; this component just draws.
+ */
+export declare const CodeEditorGutterNumbers: import("react").NamedExoticComponent<{
+    count: number;
+    from: number;
+}>;

package/dist/types/components/code-editor/recipe.d.ts

@@ -0,0 +1,109 @@
+export declare const code: import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-variants").ClassValue | {
+            textarea?: import("tailwind-variants").ClassValue;
+            pre?: import("tailwind-variants").ClassValue;
+            caption?: import("tailwind-variants").ClassValue;
+            toolbar?: import("tailwind-variants").ClassValue;
+            body?: import("tailwind-variants").ClassValue;
+            footer?: import("tailwind-variants").ClassValue;
+            hint?: import("tailwind-variants").ClassValue;
+            root?: import("tailwind-variants").ClassValue;
+            control?: import("tailwind-variants").ClassValue;
+            rendered?: import("tailwind-variants").ClassValue;
+            layers?: import("tailwind-variants").ClassValue;
+            gutter?: import("tailwind-variants").ClassValue;
+            fade?: import("tailwind-variants").ClassValue;
+            scroller?: import("tailwind-variants").ClassValue;
+            expand?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-variants").ClassValue | {
+            textarea?: import("tailwind-variants").ClassValue;
+            pre?: import("tailwind-variants").ClassValue;
+            caption?: import("tailwind-variants").ClassValue;
+            toolbar?: import("tailwind-variants").ClassValue;
+            body?: import("tailwind-variants").ClassValue;
+            footer?: import("tailwind-variants").ClassValue;
+            hint?: import("tailwind-variants").ClassValue;
+            root?: import("tailwind-variants").ClassValue;
+            control?: import("tailwind-variants").ClassValue;
+            rendered?: import("tailwind-variants").ClassValue;
+            layers?: import("tailwind-variants").ClassValue;
+            gutter?: import("tailwind-variants").ClassValue;
+            fade?: import("tailwind-variants").ClassValue;
+            scroller?: import("tailwind-variants").ClassValue;
+            expand?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {}, {
+    root: string[];
+    toolbar: string;
+    caption: string;
+    control: string[];
+    body: string;
+    scroller: string[];
+    layers: string;
+    gutter: string;
+    pre: string;
+    textarea: string[];
+    rendered: string;
+    footer: string;
+    hint: string;
+    expand: string[];
+    fade: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-variants").ClassValue | {
+            textarea?: import("tailwind-variants").ClassValue;
+            pre?: import("tailwind-variants").ClassValue;
+            caption?: import("tailwind-variants").ClassValue;
+            toolbar?: import("tailwind-variants").ClassValue;
+            body?: import("tailwind-variants").ClassValue;
+            footer?: import("tailwind-variants").ClassValue;
+            hint?: import("tailwind-variants").ClassValue;
+            root?: import("tailwind-variants").ClassValue;
+            control?: import("tailwind-variants").ClassValue;
+            rendered?: import("tailwind-variants").ClassValue;
+            layers?: import("tailwind-variants").ClassValue;
+            gutter?: import("tailwind-variants").ClassValue;
+            fade?: import("tailwind-variants").ClassValue;
+            scroller?: import("tailwind-variants").ClassValue;
+            expand?: import("tailwind-variants").ClassValue;
+        };
+    };
+} | {}, {
+    root: string[];
+    toolbar: string;
+    caption: string;
+    control: string[];
+    body: string;
+    scroller: string[];
+    layers: string;
+    gutter: string;
+    pre: string;
+    textarea: string[];
+    rendered: string;
+    footer: string;
+    hint: string;
+    expand: string[];
+    fade: string;
+}, import("tailwind-variants").TVReturnTypeLike<unknown, {
+    root: string[];
+    toolbar: string;
+    caption: string;
+    control: string[];
+    body: string;
+    scroller: string[];
+    layers: string;
+    gutter: string;
+    pre: string;
+    textarea: string[];
+    rendered: string;
+    footer: string;
+    hint: string;
+    expand: string[];
+    fade: string;
+}>>;

package/dist/types/components/code-editor/state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * One value that may be driven from outside or kept here.
+ *
+ * WHY IT IS SHARED RATHER THAN WRITTEN FOUR TIMES: `CodeEditor` has four of
+ * these (text, wrap, view, expanded) and the subtle half is identical in all
+ * four — a controlled instance must NEVER write its own state, or it renders
+ * the consumer's value for one frame and its own for the next, which shows up
+ * as a control that flickers back after every change.
+ *
+ * `controlled === undefined` decides, once per render, exactly as React's own
+ * inputs do. Switching a prop from undefined to a value mid-life is a consumer
+ * bug everywhere in React and is not defended against here.
+ */
+export declare function useControllable<T>(controlled: T | undefined, initial: T, onChange?: (next: T) => void): [T, (next: T) => void];

package/dist/types/components/drag-drop/context.d.ts

@@ -0,0 +1,45 @@
+import type { DragAxis, DragId, ContainerId, DragSession } from "../../lib/dnd";
+import type { ContainerShift } from "./shift";
+export interface DragDropContextValue {
+    session: DragSession;
+    /**
+     * The id of THIS board's instructions paragraph, generated per board.
+     *
+     * Per board, not per page: the engine's `DRAG_INSTRUCTIONS_ID` is a module
+     * constant, so two boards on one page emit the same id twice and every
+     * handle's `aria-describedby` then resolves to whichever the browser saw
+     * first. A duplicate id is valid HTML that no check reads, and the symptom —
+     * one board's handles describing the other's — is invisible to everything
+     * except a screen reader.
+     */
+    instructionsId: string;
+    /**
+     * True while a `<DragDropOverlay>` is mounted, i.e. while something else is
+     * able to carry the card. It decides whether an item vacates its own slot.
+     */
+    lifted: boolean;
+    registerOverlay: () => () => void;
+    /** Items and containers publish their spoken names here at mount. */
+    registerLabel: (kind: "item" | "container", id: string, label: string | undefined) => () => void;
+}
+export interface DragDropContainerContextValue {
+    id: ContainerId;
+    axis: DragAxis;
+    /** Null when no drag is in flight — nothing moves and no gap is open. */
+    shift: ContainerShift | null;
+}
+export interface DragDropItemContextValue {
+    id: DragId;
+    /** The element the pointer and keyboard sensors attach to. */
+    setHandleRef: (el: HTMLElement | null) => void;
+    /** Spoken name, used to build the handle's accessible name. */
+    label: string | undefined;
+}
+export declare const DragDropProvider: import("react").Provider<DragDropContextValue | null>;
+export declare const DragDropContainerProvider: import("react").Provider<DragDropContainerContextValue | null>;
+export declare const DragDropItemProvider: import("react").Provider<DragDropItemContextValue | null>;
+export declare const DragDropCloneProvider: import("react").Provider<boolean>;
+export declare function useDragDropClone(): boolean;
+export declare function useDragDrop(component: string): DragDropContextValue;
+export declare function useDragDropContainer(component: string): DragDropContainerContextValue;
+export declare function useDragDropItem(component: string): DragDropItemContextValue;

package/dist/types/components/drag-drop/recipe.d.ts

@@ -0,0 +1,121 @@
+export declare const dnd: import("tailwind-variants").TVReturnType<{
+    axis: {
+        y: {
+            container: string;
+            item: string;
+            marker: string;
+            landing: string;
+            handle: string;
+        };
+        x: {
+            container: string;
+            item: string;
+            marker: string;
+            landing: string;
+            handle: string;
+        };
+    };
+    moving: {
+        true: {
+            shift: string[];
+        };
+        false: {};
+    };
+    mode: {
+        pointer: {
+            overlay: string;
+        };
+        keyboard: {
+            overlay: string[];
+        };
+    };
+}, {
+    root: string;
+    container: string;
+    item: string;
+    shift: string;
+    marker: string[];
+    landing: string;
+    handle: string[];
+    overlay: string[];
+}, undefined, {
+    axis: {
+        y: {
+            container: string;
+            item: string;
+            marker: string;
+            landing: string;
+            handle: string;
+        };
+        x: {
+            container: string;
+            item: string;
+            marker: string;
+            landing: string;
+            handle: string;
+        };
+    };
+    moving: {
+        true: {
+            shift: string[];
+        };
+        false: {};
+    };
+    mode: {
+        pointer: {
+            overlay: string;
+        };
+        keyboard: {
+            overlay: string[];
+        };
+    };
+}, {
+    root: string;
+    container: string;
+    item: string;
+    shift: string;
+    marker: string[];
+    landing: string;
+    handle: string[];
+    overlay: string[];
+}, import("tailwind-variants").TVReturnTypeLike<{
+    axis: {
+        y: {
+            container: string;
+            item: string;
+            marker: string;
+            landing: string;
+            handle: string;
+        };
+        x: {
+            container: string;
+            item: string;
+            marker: string;
+            landing: string;
+            handle: string;
+        };
+    };
+    moving: {
+        true: {
+            shift: string[];
+        };
+        false: {};
+    };
+    mode: {
+        pointer: {
+            overlay: string;
+        };
+        keyboard: {
+            overlay: string[];
+        };
+    };
+}, {
+    root: string;
+    container: string;
+    item: string;
+    shift: string;
+    marker: string[];
+    landing: string;
+    handle: string[];
+    overlay: string[];
+}>>;