import * as React from 'react';
import { HTMLAttributes, FormEvent, ComponentProps } from 'react';
import { T as TextAreaProps } from './types-CMzZsL_J.js';
import * as react_jsx_runtime from 'react/jsx-runtime';

/**
 * Submission status the submit button reflects. The composer has no cancellation and no
 * intermediate "generating" state of its own — the consumer disables the button while busy — so
 * only the idle and error states are modeled here.
 */
declare const CHAT_STATUS: {
    /** Idle / ready to submit. */
    readonly READY: "ready";
    /** The last submission errored — the button shows a retry affordance. */
    readonly ERROR: "error";
};
/** Submission status the submit button reflects. */
type ChatStatus = (typeof CHAT_STATUS)[keyof typeof CHAT_STATUS];
/** Payload emitted by {@link PromptInput} on submit. v1 carries only text (attachments are cut). */
interface PromptInputMessage {
    /** The current textarea value at submit time. */
    text: string;
}
/** Props for the {@link PromptInput} form wrapper. */
type PromptInputProps = Omit<HTMLAttributes<HTMLFormElement>, "onSubmit"> & {
    /**
     * Fired when the form is submitted (Enter key or the submit button) with non-empty text.
     * Receives the captured message and the underlying form event.
     */
    onSubmit: (message: PromptInputMessage, event: FormEvent<HTMLFormElement>) => void;
    /**
     * Blocks submission across every trigger (Enter key, submit button, programmatic) when `true` —
     * e.g. while a generation is in flight. The single gate that keeps the Enter path in sync with a
     * disabled submit button. @default false
     */
    disabled?: boolean;
};
/** Props for {@link PromptInputTextarea} — clay `TextArea` props; `className` styles the wrapper. */
type PromptInputTextareaProps = TextAreaProps;
/** Props for {@link PromptInputFooter}. */
type PromptInputFooterProps = HTMLAttributes<HTMLDivElement>;
/** Props for {@link PromptInputTools}. */
type PromptInputToolsProps = HTMLAttributes<HTMLDivElement>;
/** Props for {@link PromptInputSubmit}. */
interface PromptInputSubmitProps {
    /** Button label — pass a localized string (i18n) from the consumer. @default "Submit" */
    label?: string;
    /** Drives the button color: `error` renders the red error intent, otherwise primary. @default "ready" */
    status?: ChatStatus;
    /** Whether the button is non-interactive (e.g. empty input or a generation in flight). */
    disabled?: boolean;
    /** Additional CSS class name. */
    className?: string;
}

/**
 * Form wrapper for a prompt composer. Renders a bordered, rounded surface; stacks its children
 * (textarea + footer) vertically. Reads the nested textarea's value on submit and forwards it to
 * `onSubmit`. Empty / whitespace-only submissions, and all submissions while `disabled`, are
 * ignored.
 */
declare const PromptInput: ({ className, onSubmit, disabled, children, ...props }: PromptInputProps) => react_jsx_runtime.JSX.Element;
/**
 * Auto-resizing textarea for the prompt composer. Wraps clay's `TextArea` and adds Enter-to-submit
 * (Shift+Enter inserts a newline; submission is suppressed while an IME composition is active). The
 * consumer's `onKeyDown` runs first and can `preventDefault()` to opt out of the built-in Enter
 * handling.
 *
 * Horizontal padding lives on the textarea itself (not the wrapper) so its overflow scrollbar sits
 * flush against the wrapper's right edge; the wrapper only owns the vertical padding.
 */
declare const PromptInputTextarea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;
/**
 * Footer row beneath the textarea — left tools and the right-aligned submit button. Horizontal
 * padding matches {@link PromptInputTextarea}'s (`px-4`) so the tools/submit align with the
 * textarea's text edges.
 */
declare const PromptInputFooter: ({ className, ...props }: PromptInputFooterProps) => react_jsx_runtime.JSX.Element;
/** Left-aligned cluster inside {@link PromptInputFooter} (e.g. the submit hint). */
declare const PromptInputTools: ({ className, ...props }: PromptInputToolsProps) => react_jsx_runtime.JSX.Element;
/**
 * Submit button for the prompt composer — a filled clay `Button` whose text is the consumer's
 * `label` (pass a localized string for i18n). Always submits the form via `form.requestSubmit()` on
 * click (clay buttons render `type="button"`); the consumer disables it while a generation is in
 * flight. `status` drives the color: `error` renders the error (red) intent, otherwise primary.
 */
declare const PromptInputSubmit: ({ label, status, disabled, className, }: PromptInputSubmitProps) => react_jsx_runtime.JSX.Element;

/** Props for the {@link MouseGrid} cursor-tracking backdrop. */
interface MouseGridProps {
    /**
     * Color of the cursor-following glow (any CSS color; include your own alpha for intensity).
     * Applied via the `--vibe-glow-color` CSS var. Defaults to a subtle violet accent when omitted.
     *
     * Pass an **array** of 2+ colors to make the blob smoothly crossfade through them, transitioning
     * to the next every {@link MouseGridProps.colorCycleMs} and looping back to the first. A single
     * string (or single-element array) is applied statically. Honors `prefers-reduced-motion`:
     * cycling is suppressed and the first color is applied statically.
     */
    glowColor?: string | string[];
    /**
     * Interval in milliseconds between color changes when {@link MouseGridProps.glowColor} is an array
     * of 2+ colors. The crossfade spans this whole interval, so the color is always smoothly in
     * transit. Defaults to `4000`. Ignored when `glowColor` isn't a cycling list.
     */
    colorCycleMs?: number;
    /**
     * When `true`, the glow drifts on its own around the area whenever the cursor is *outside* the
     * layer (idle state), tracing a slow looping path. As soon as the cursor re-enters the layer the
     * glow snaps back to following it; drift resumes once the cursor leaves again. Defaults to `false`
     * (glow only ever follows the cursor). Honors `prefers-reduced-motion` — drift is suppressed when
     * the user has requested reduced motion.
     */
    autoDrift?: boolean;
}

/**
 * Absolutely-positioned grid backdrop, confined to its nearest positioned ancestor (give the
 * parent `position: relative` + `overflow: hidden` to clip it). The grid is revealed only near the
 * cursor via a radial mask whose center is driven by the `--vibe-mx` / `--vibe-my` CSS vars,
 * updated by a rAF-throttled `mousemove` listener. Renders behind all content (`z-0`) and never
 * blocks pointer events.
 *
 * Cursor coordinates are translated from viewport space (`clientX` / `clientY`) into layer-local
 * space (minus the layer's `getBoundingClientRect()` origin) and written onto the layer element
 * itself — not the document root — so the glow tracks correctly even though the layer no longer
 * fills the viewport. The rect read happens inside the rAF so it batches with paint.
 *
 * Pure `useEffect` + `requestAnimationFrame`, no animation library. The `.vibe-mouse-grid-layer` /
 * `.vibe-mouse-grid` / `.vibe-mouse-glow` styles ship in `@shapesos/clay/blocks/styles.css`.
 *
 * With `autoDrift`, a second rAF loop wanders the glow center along a slow sum-of-sines path
 * whenever the cursor is outside the layer; it yields the moment the cursor re-enters (the
 * mousemove handler owns the vars then) and resumes on exit. Suppressed under `prefers-reduced-motion`.
 *
 * When `glowColor` is an array of 2+ colors, a `setInterval` cycles the `--vibe-glow-color` var
 * through the list every `colorCycleMs`; the `.vibe-mouse-glow` `background-color` transition
 * (duration = `--vibe-glow-cycle`) crossfades between them. Also suppressed under
 * `prefers-reduced-motion` (first color applied flat).
 */
declare function MouseGrid({ glowColor, colorCycleMs, autoDrift }?: MouseGridProps): react_jsx_runtime.JSX.Element;

/** Props for the {@link Suggestions} container — a wrapping, centered row of suggestion pills. */
type SuggestionsProps = ComponentProps<"div">;
/** Props for a single {@link Suggestion} pill. */
type SuggestionProps = Omit<ComponentProps<"button">, "onClick" | "type"> & {
    /** The suggestion text — used as the pill label (unless `children` is provided) and passed to `onClick`. */
    suggestion: string;
    /** Called with the `suggestion` string when the pill is clicked. */
    onClick?: (suggestion: string) => void;
};

/**
 * A centered, wrapping row of {@link Suggestion} pills — e.g. starter prompts beneath a composer.
 * Compose `Suggestion` children inside.
 */
declare const Suggestions: ({ className, ...props }: SuggestionsProps) => react_jsx_runtime.JSX.Element;
/**
 * A single tappable suggestion pill. Renders `children` if provided, otherwise the `suggestion`
 * text, and calls `onClick(suggestion)` when clicked.
 */
declare const Suggestion: ({ suggestion, onClick, className, children, ...props }: SuggestionProps) => react_jsx_runtime.JSX.Element;

export { CHAT_STATUS, type ChatStatus, MouseGrid, type MouseGridProps, PromptInput, PromptInputFooter, type PromptInputFooterProps, type PromptInputMessage, type PromptInputProps, PromptInputSubmit, type PromptInputSubmitProps, PromptInputTextarea, type PromptInputTextareaProps, PromptInputTools, type PromptInputToolsProps, Suggestion, type SuggestionProps, Suggestions, type SuggestionsProps };
