ikoncomponents 1.6.3 → 1.6.5

package/dist/vendor/assistant-ui-react/src/primitives/branchPicker/BranchPickerRoot.js

@@ -0,0 +1,38 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef } from "react";
+import { If } from "../message";
+/**
+ * The root container for branch picker components.
+ *
+ * This component provides a container for branch navigation controls,
+ * with optional conditional rendering based on the number of available branches.
+ * It integrates with the message branching system to allow users to navigate
+ * between different response variations.
+ *
+ * @example
+ * ```tsx
+ * <BranchPickerPrimitive.Root hideWhenSingleBranch={true}>
+ *   <BranchPickerPrimitive.Previous />
+ *   <BranchPickerPrimitive.Count />
+ *   <BranchPickerPrimitive.Next />
+ * </BranchPickerPrimitive.Root>
+ * ```
+ */
+export const BranchPickerPrimitiveRoot = forwardRef((_a, ref) => {
+    var { hideWhenSingleBranch } = _a, rest = __rest(_a, ["hideWhenSingleBranch"]);
+    return (_jsx(If, { hasBranches: hideWhenSingleBranch ? true : undefined, children: _jsx(Primitive.div, Object.assign({}, rest, { ref: ref })) }));
+});
+BranchPickerPrimitiveRoot.displayName = "BranchPickerPrimitive.Root";

package/dist/vendor/assistant-ui-react/src/primitives/branchPicker/index.d.ts

@@ -0,0 +1,5 @@
+export { BranchPickerPrimitiveNext as Next } from "./BranchPickerNext";
+export { BranchPickerPrimitivePrevious as Previous } from "./BranchPickerPrevious";
+export { BranchPickerPrimitiveCount as Count } from "./BranchPickerCount";
+export { BranchPickerPrimitiveNumber as Number } from "./BranchPickerNumber";
+export { BranchPickerPrimitiveRoot as Root } from "./BranchPickerRoot";

package/dist/vendor/assistant-ui-react/src/primitives/branchPicker/index.js

@@ -0,0 +1,5 @@
+export { BranchPickerPrimitiveNext as Next } from "./BranchPickerNext";
+export { BranchPickerPrimitivePrevious as Previous } from "./BranchPickerPrevious";
+export { BranchPickerPrimitiveCount as Count } from "./BranchPickerCount";
+export { BranchPickerPrimitiveNumber as Number } from "./BranchPickerNumber";
+export { BranchPickerPrimitiveRoot as Root } from "./BranchPickerRoot";

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerAddAttachment.d.ts

@@ -0,0 +1,16 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useComposerAddAttachment: ({ multiple, }?: {
+    /** allow selecting multiple files */
+    multiple?: boolean | undefined;
+}) => (() => void) | null;
+export declare namespace ComposerPrimitiveAddAttachment {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useComposerAddAttachment>;
+}
+export declare const ComposerPrimitiveAddAttachment: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & {
+    /** allow selecting multiple files */
+    multiple?: boolean | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerAddAttachment.js

@@ -0,0 +1,38 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useCallback } from "react";
+import { useAuiState, useAui } from "@assistant-ui/store";
+const useComposerAddAttachment = ({ multiple = true, } = {}) => {
+    const disabled = useAuiState(({ composer }) => !composer.isEditing);
+    const aui = useAui();
+    const callback = useCallback(() => {
+        const input = document.createElement("input");
+        input.type = "file";
+        input.multiple = multiple;
+        input.hidden = true;
+        const attachmentAccept = aui.composer().getState().attachmentAccept;
+        if (attachmentAccept !== "*") {
+            input.accept = attachmentAccept;
+        }
+        document.body.appendChild(input);
+        input.onchange = (e) => {
+            const fileList = e.target.files;
+            if (!fileList)
+                return;
+            for (const file of fileList) {
+                aui.composer().addAttachment(file);
+            }
+            document.body.removeChild(input);
+        };
+        input.oncancel = () => {
+            if (!input.files || input.files.length === 0) {
+                document.body.removeChild(input);
+            }
+        };
+        input.click();
+    }, [aui, multiple]);
+    if (disabled)
+        return null;
+    return callback;
+};
+export const ComposerPrimitiveAddAttachment = createActionButton("ComposerPrimitive.AddAttachment", useComposerAddAttachment, ["multiple"]);

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerAttachmentDropzone.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export declare namespace ComposerPrimitiveAttachmentDropzone {
+    type Element = HTMLDivElement;
+    type Props = React.HTMLAttributes<HTMLDivElement> & {
+        asChild?: boolean | undefined;
+        disabled?: boolean | undefined;
+    };
+}
+export declare const ComposerPrimitiveAttachmentDropzone: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerAttachmentDropzone.js

@@ -0,0 +1,68 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useCallback, useState } from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { useAui } from "@assistant-ui/store";
+export const ComposerPrimitiveAttachmentDropzone = forwardRef((_a, ref) => {
+    var { disabled, asChild = false, children } = _a, rest = __rest(_a, ["disabled", "asChild", "children"]);
+    const [isDragging, setIsDragging] = useState(false);
+    const aui = useAui();
+    const handleDragEnterCapture = useCallback((e) => {
+        if (disabled)
+            return;
+        e.preventDefault();
+        setIsDragging(true);
+    }, [disabled]);
+    const handleDragOverCapture = useCallback((e) => {
+        if (disabled)
+            return;
+        e.preventDefault();
+        if (!isDragging)
+            setIsDragging(true);
+    }, [disabled, isDragging]);
+    const handleDragLeaveCapture = useCallback((e) => {
+        if (disabled)
+            return;
+        e.preventDefault();
+        const next = e.relatedTarget;
+        if (next && e.currentTarget.contains(next)) {
+            return;
+        }
+        setIsDragging(false);
+    }, [disabled]);
+    const handleDrop = useCallback(async (e) => {
+        if (disabled)
+            return;
+        e.preventDefault();
+        setIsDragging(false);
+        for (const file of e.dataTransfer.files) {
+            try {
+                await aui.composer().addAttachment(file);
+            }
+            catch (error) {
+                console.error("Failed to add attachment:", error);
+            }
+        }
+    }, [disabled, aui]);
+    const dragProps = {
+        onDragEnterCapture: handleDragEnterCapture,
+        onDragOverCapture: handleDragOverCapture,
+        onDragLeaveCapture: handleDragLeaveCapture,
+        onDropCapture: handleDrop,
+    };
+    const Comp = asChild ? Slot : "div";
+    return (_jsx(Comp, Object.assign({}, (isDragging ? { "data-dragging": "true" } : null), { ref: ref }, dragProps, rest, { children: children })));
+});
+ComposerPrimitiveAttachmentDropzone.displayName =
+    "ComposerPrimitive.AttachmentDropzone";

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerAttachments.d.ts

@@ -0,0 +1,36 @@
+import { ComponentType, type FC } from "react";
+export declare namespace ComposerPrimitiveAttachments {
+    type Props = {
+        components: {
+            Image?: ComponentType | undefined;
+            Document?: ComponentType | undefined;
+            File?: ComponentType | undefined;
+            Attachment?: ComponentType | undefined;
+        } | undefined;
+    };
+}
+export declare namespace ComposerPrimitiveAttachmentByIndex {
+    type Props = {
+        index: number;
+        components?: ComposerPrimitiveAttachments.Props["components"];
+    };
+}
+/**
+ * Renders a single attachment at the specified index within the composer.
+ *
+ * This component provides direct access to render a specific attachment
+ * from the composer's attachment list using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.AttachmentByIndex
+ *   index={0}
+ *   components={{
+ *     Image: MyImageAttachment,
+ *     Document: MyDocumentAttachment
+ *   }}
+ * />
+ * ```
+ */
+export declare const ComposerPrimitiveAttachmentByIndex: FC<ComposerPrimitiveAttachmentByIndex.Props>;
+export declare const ComposerPrimitiveAttachments: FC<ComposerPrimitiveAttachments.Props>;

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerAttachments.js

@@ -0,0 +1,66 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useMemo } from "react";
+import { useAuiState } from "@assistant-ui/store";
+import { ComposerAttachmentByIndexProvider } from "../../context/providers";
+const getComponent = (components, attachment) => {
+    var _a, _b, _c;
+    const type = attachment.type;
+    switch (type) {
+        case "image":
+            return (_a = components === null || components === void 0 ? void 0 : components.Image) !== null && _a !== void 0 ? _a : components === null || components === void 0 ? void 0 : components.Attachment;
+        case "document":
+            return (_b = components === null || components === void 0 ? void 0 : components.Document) !== null && _b !== void 0 ? _b : components === null || components === void 0 ? void 0 : components.Attachment;
+        case "file":
+            return (_c = components === null || components === void 0 ? void 0 : components.File) !== null && _c !== void 0 ? _c : components === null || components === void 0 ? void 0 : components.Attachment;
+        default:
+            const _exhaustiveCheck = type;
+            throw new Error(`Unknown attachment type: ${_exhaustiveCheck}`);
+    }
+};
+const AttachmentComponent = ({ components }) => {
+    const attachment = useAuiState(({ attachment }) => attachment);
+    if (!attachment)
+        return null;
+    const Component = getComponent(components, attachment);
+    if (!Component)
+        return null;
+    return _jsx(Component, {});
+};
+/**
+ * Renders a single attachment at the specified index within the composer.
+ *
+ * This component provides direct access to render a specific attachment
+ * from the composer's attachment list using the provided component configuration.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.AttachmentByIndex
+ *   index={0}
+ *   components={{
+ *     Image: MyImageAttachment,
+ *     Document: MyDocumentAttachment
+ *   }}
+ * />
+ * ```
+ */
+export const ComposerPrimitiveAttachmentByIndex = memo(({ index, components }) => {
+    return (_jsx(ComposerAttachmentByIndexProvider, { index: index, children: _jsx(AttachmentComponent, { components: components }) }));
+}, (prev, next) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return prev.index === next.index &&
+        ((_a = prev.components) === null || _a === void 0 ? void 0 : _a.Image) === ((_b = next.components) === null || _b === void 0 ? void 0 : _b.Image) &&
+        ((_c = prev.components) === null || _c === void 0 ? void 0 : _c.Document) === ((_d = next.components) === null || _d === void 0 ? void 0 : _d.Document) &&
+        ((_e = prev.components) === null || _e === void 0 ? void 0 : _e.File) === ((_f = next.components) === null || _f === void 0 ? void 0 : _f.File) &&
+        ((_g = prev.components) === null || _g === void 0 ? void 0 : _g.Attachment) === ((_h = next.components) === null || _h === void 0 ? void 0 : _h.Attachment);
+});
+ComposerPrimitiveAttachmentByIndex.displayName =
+    "ComposerPrimitive.AttachmentByIndex";
+export const ComposerPrimitiveAttachments = ({ components }) => {
+    const attachmentsCount = useAuiState((s) => s.composer.attachments.length);
+    const attachmentElements = useMemo(() => {
+        return Array.from({ length: attachmentsCount }, (_, index) => (_jsx(ComposerPrimitiveAttachmentByIndex, { index: index, components: components }, index)));
+    }, [attachmentsCount, components]);
+    return attachmentElements;
+};
+ComposerPrimitiveAttachments.displayName = "ComposerPrimitive.Attachments";

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerCancel.d.ts

@@ -0,0 +1,27 @@
+import { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useComposerCancel: () => (() => void) | null;
+export declare namespace ComposerPrimitiveCancel {
+    type Element = ActionButtonElement;
+    /**
+     * Props for the ComposerPrimitive.Cancel component.
+     * Inherits all button element props and action button functionality.
+     */
+    type Props = ActionButtonProps<typeof useComposerCancel>;
+}
+/**
+ * A button component that cancels the current message composition.
+ *
+ * This component automatically handles the cancel functionality and is disabled
+ * when canceling is not available.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Cancel>
+ *   Cancel
+ * </ComposerPrimitive.Cancel>
+ * ```
+ */
+export declare const ComposerPrimitiveCancel: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerCancel.js

@@ -0,0 +1,28 @@
+"use client";
+import { createActionButton, } from "../../utils/createActionButton";
+import { useCallback } from "react";
+import { useAuiState, useAui } from "@assistant-ui/store";
+const useComposerCancel = () => {
+    const aui = useAui();
+    const disabled = useAuiState(({ composer }) => !composer.canCancel);
+    const callback = useCallback(() => {
+        aui.composer().cancel();
+    }, [aui]);
+    if (disabled)
+        return null;
+    return callback;
+};
+/**
+ * A button component that cancels the current message composition.
+ *
+ * This component automatically handles the cancel functionality and is disabled
+ * when canceling is not available.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Cancel>
+ *   Cancel
+ * </ComposerPrimitive.Cancel>
+ * ```
+ */
+export const ComposerPrimitiveCancel = createActionButton("ComposerPrimitive.Cancel", useComposerCancel);

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerDictate.d.ts

@@ -0,0 +1,22 @@
+import type { ActionButtonElement, ActionButtonProps } from "../../utils/createActionButton";
+declare const useComposerDictate: () => (() => void) | null;
+export declare namespace ComposerPrimitiveDictate {
+    type Element = ActionButtonElement;
+    type Props = ActionButtonProps<typeof useComposerDictate>;
+}
+/**
+ * A button that starts dictation to convert voice to text.
+ *
+ * Requires a DictationAdapter to be configured in the runtime.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Dictate>
+ *   <MicIcon />
+ * </ComposerPrimitive.Dictate>
+ * ```
+ */
+export declare const ComposerPrimitiveDictate: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerDictate.js

@@ -0,0 +1,29 @@
+"use client";
+import { useCallback } from "react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+import { createActionButton } from "../../utils/createActionButton";
+const useComposerDictate = () => {
+    const aui = useAui();
+    const disabled = useAuiState(({ thread, composer }) => composer.dictation != null ||
+        !thread.capabilities.dictation ||
+        !composer.isEditing);
+    const callback = useCallback(() => {
+        aui.composer().startDictation();
+    }, [aui]);
+    if (disabled)
+        return null;
+    return callback;
+};
+/**
+ * A button that starts dictation to convert voice to text.
+ *
+ * Requires a DictationAdapter to be configured in the runtime.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Dictate>
+ *   <MicIcon />
+ * </ComposerPrimitive.Dictate>
+ * ```
+ */
+export const ComposerPrimitiveDictate = createActionButton("ComposerPrimitive.Dictate", useComposerDictate);

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerDictationTranscript.d.ts

@@ -0,0 +1,24 @@
+import { Primitive } from "@radix-ui/react-primitive";
+import { type ComponentRef, ComponentPropsWithoutRef } from "react";
+export declare namespace ComposerPrimitiveDictationTranscript {
+    type Element = ComponentRef<typeof Primitive.span>;
+    type Props = ComponentPropsWithoutRef<typeof Primitive.span>;
+}
+/**
+ * Renders the current interim (partial) transcript while dictation is active.
+ *
+ * This component displays real-time feedback of what the user is saying before
+ * the transcription is finalized and committed to the composer input.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.If dictation>
+ *   <div className="dictation-preview">
+ *     <ComposerPrimitive.DictationTranscript />
+ *   </div>
+ * </ComposerPrimitive.If>
+ * ```
+ */
+export declare const ComposerPrimitiveDictationTranscript: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement> & {
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerDictationTranscript.js

@@ -0,0 +1,40 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Primitive } from "@radix-ui/react-primitive";
+import { forwardRef } from "react";
+import { useAuiState } from "@assistant-ui/store";
+/**
+ * Renders the current interim (partial) transcript while dictation is active.
+ *
+ * This component displays real-time feedback of what the user is saying before
+ * the transcription is finalized and committed to the composer input.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.If dictation>
+ *   <div className="dictation-preview">
+ *     <ComposerPrimitive.DictationTranscript />
+ *   </div>
+ * </ComposerPrimitive.If>
+ * ```
+ */
+export const ComposerPrimitiveDictationTranscript = forwardRef((_a, forwardRef) => {
+    var { children } = _a, props = __rest(_a, ["children"]);
+    const transcript = useAuiState(({ composer }) => { var _a; return (_a = composer.dictation) === null || _a === void 0 ? void 0 : _a.transcript; });
+    if (!transcript)
+        return null;
+    return (_jsx(Primitive.span, Object.assign({}, props, { ref: forwardRef, children: children !== null && children !== void 0 ? children : transcript })));
+});
+ComposerPrimitiveDictationTranscript.displayName =
+    "ComposerPrimitive.DictationTranscript";

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerIf.d.ts

@@ -0,0 +1,17 @@
+import type { FC, PropsWithChildren } from "react";
+import type { RequireAtLeastOne } from "../../utils/RequireAtLeastOne";
+type ComposerIfFilters = {
+    /** Whether the composer is in editing mode */
+    editing: boolean | undefined;
+    /** Whether dictation is currently active */
+    dictation: boolean | undefined;
+};
+export type UseComposerIfProps = RequireAtLeastOne<ComposerIfFilters>;
+export declare namespace ComposerPrimitiveIf {
+    type Props = PropsWithChildren<UseComposerIfProps>;
+}
+/**
+ * @deprecated Use `<AuiIf condition={({ composer }) => ...} />` instead.
+ */
+export declare const ComposerPrimitiveIf: FC<ComposerPrimitiveIf.Props>;
+export {};

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerIf.js

@@ -0,0 +1,36 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useAuiState } from "@assistant-ui/store";
+const useComposerIf = (props) => {
+    return useAuiState(({ composer }) => {
+        if (props.editing === true && !composer.isEditing)
+            return false;
+        if (props.editing === false && composer.isEditing)
+            return false;
+        const isDictating = composer.dictation != null;
+        if (props.dictation === true && !isDictating)
+            return false;
+        if (props.dictation === false && isDictating)
+            return false;
+        return true;
+    });
+};
+/**
+ * @deprecated Use `<AuiIf condition={({ composer }) => ...} />` instead.
+ */
+export const ComposerPrimitiveIf = (_a) => {
+    var { children } = _a, query = __rest(_a, ["children"]);
+    const result = useComposerIf(query);
+    return result ? children : null;
+};
+ComposerPrimitiveIf.displayName = "ComposerPrimitive.If";

package/dist/vendor/assistant-ui-react/src/primitives/composer/ComposerInput.d.ts

@@ -0,0 +1,58 @@
+import { type TextareaAutosizeProps } from "react-textarea-autosize";
+export declare namespace ComposerPrimitiveInput {
+    type Element = HTMLTextAreaElement;
+    type Props = TextareaAutosizeProps & {
+        /**
+         * Whether to render as a child component using Slot.
+         * When true, the component will merge its props with its child.
+         */
+        asChild?: boolean | undefined;
+        /**
+         * Whether to submit the message when Enter is pressed (without Shift).
+         * @default true
+         */
+        submitOnEnter?: boolean | undefined;
+        /**
+         * Whether to cancel message composition when Escape is pressed.
+         * @default true
+         */
+        cancelOnEscape?: boolean | undefined;
+        /**
+         * Whether to automatically focus the input when a new run starts.
+         * @default true
+         */
+        unstable_focusOnRunStart?: boolean | undefined;
+        /**
+         * Whether to automatically focus the input when scrolling to bottom.
+         * @default true
+         */
+        unstable_focusOnScrollToBottom?: boolean | undefined;
+        /**
+         * Whether to automatically focus the input when switching threads.
+         * @default true
+         */
+        unstable_focusOnThreadSwitched?: boolean | undefined;
+        /**
+         * Whether to automatically add pasted files as attachments.
+         * @default true
+         */
+        addAttachmentOnPaste?: boolean | undefined;
+    };
+}
+/**
+ * A text input component for composing messages.
+ *
+ * This component provides a rich text input experience with automatic resizing,
+ * keyboard shortcuts, file paste support, and intelligent focus management.
+ * It integrates with the composer context to manage message state and submission.
+ *
+ * @example
+ * ```tsx
+ * <ComposerPrimitive.Input
+ *   placeholder="Type your message..."
+ *   submitOnEnter={true}
+ *   addAttachmentOnPaste={true}
+ * />
+ * ```
+ */
+export declare const ComposerPrimitiveInput: import("react").ForwardRefExoticComponent<any>;