import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
import * as AvatarPrimitive from '@radix-ui/react-avatar';
import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
import { ClassProp } from 'class-variance-authority/types';
import { ClassValue } from 'clsx';
import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
import { ComponentProps } from 'react';
import * as DialogPrimitive from '@radix-ui/react-dialog';
import { ElementType } from 'react';
import { ForwardRefExoticComponent } from 'react';
import { GroupProps } from 'react-resizable-panels';
import { HTMLAttributes } from 'react';
import { JSXElementConstructor } from 'react';
import * as LabelPrimitive from '@radix-ui/react-label';
import { MemoExoticComponent } from 'react';
import { PanelProps } from 'react-resizable-panels';
import * as ProgressPrimitive from '@radix-ui/react-progress';
import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
import * as React_2 from 'react';
import { ReactElement } from 'react';
import type { ReactNode } from 'react';
import { RefAttributes } from 'react';
import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
import * as SelectPrimitive from '@radix-ui/react-select';
import * as SeparatorPrimitive from '@radix-ui/react-separator';
import { SeparatorProps } from 'react-resizable-panels';
import * as SliderPrimitive from '@radix-ui/react-slider';
import { StickToBottom } from 'use-stick-to-bottom';
import * as TabsPrimitive from '@radix-ui/react-tabs';
import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
import * as TogglePrimitive from '@radix-ui/react-toggle';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { useStickToBottomContext } from 'use-stick-to-bottom';
import { VariantProps } from 'class-variance-authority';

export declare function Alert({ className, variant, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace Alert {
    var displayName: string;
}

export declare function AlertDescription({ className, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace AlertDescription {
    var displayName: string;
}

export declare const AlertDialog: React_2.FC<AlertDialogPrimitive.AlertDialogProps>;

export declare const AlertDialogAction: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const AlertDialogCancel: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare function AlertDialogContent({ className, onOpenAutoFocus, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Content> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof AlertDialogPrimitive.Content>>;
}): React_2.JSX.Element;

export declare namespace AlertDialogContent {
    var displayName: string | undefined;
}

export declare const AlertDialogDescription: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;

export declare function AlertDialogFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;

export declare namespace AlertDialogFooter {
    var displayName: string;
}

export declare function AlertDialogHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;

export declare namespace AlertDialogHeader {
    var displayName: string;
}

export declare function AlertDialogOverlay({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Overlay> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof AlertDialogPrimitive.Overlay>>;
}): React_2.JSX.Element;

export declare namespace AlertDialogOverlay {
    var displayName: string | undefined;
}

export declare const AlertDialogPortal: React_2.FC<AlertDialogPrimitive.AlertDialogPortalProps>;

export declare const AlertDialogTitle: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;

export declare const AlertDialogTrigger: React_2.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare const AlertTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLHeadingElement> & React_2.RefAttributes<HTMLHeadingElement>>;

declare const alertVariants: (props?: ({
    variant?: "default" | "destructive" | "info" | "success" | "warning" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Avatar({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof AvatarPrimitive.Root>>;
}): React_2.JSX.Element;

export declare namespace Avatar {
    var displayName: string | undefined;
}

export declare function AvatarFallback({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof AvatarPrimitive.Fallback>>;
}): React_2.JSX.Element;

export declare namespace AvatarFallback {
    var displayName: string | undefined;
}

export declare function AvatarImage({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof AvatarPrimitive.Image>>;
}): React_2.JSX.Element;

export declare namespace AvatarImage {
    var displayName: string | undefined;
}

export declare function Badge({ className, variant, ...props }: BadgeProps): React_2.JSX.Element;

declare interface BadgeProps extends React_2.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof badgeVariants> {
}

declare const badgeVariants: (props?: ({
    variant?: "default" | "destructive" | "draft" | "info" | "outline" | "secondary" | "success" | "warning" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Button({ className, variant, size, shape, asChild, type, ref, ...props }: ButtonProps): React_2.JSX.Element;

export declare namespace Button {
    var displayName: string;
}

export declare function ButtonGroup({ className, orientation, ...props }: Omit<React_2.ComponentProps<'div'>, 'ref'> & VariantProps<typeof buttonGroupVariants>): React_2.JSX.Element;

export declare function ButtonGroupSeparator({ className, orientation, ...props }: React_2.ComponentProps<typeof Separator>): React_2.JSX.Element;

export declare function ButtonGroupText({ className, asChild, ...props }: Omit<React_2.ComponentProps<'div'>, 'ref'> & {
    asChild?: boolean;
}): React_2.JSX.Element;

declare const buttonGroupVariants: (props?: ({
    orientation?: "horizontal" | "vertical" | null | undefined;
} & ClassProp) | undefined) => string;

export declare interface ButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
    isLoading?: boolean;
    ref?: React_2.Ref<HTMLButtonElement>;
}

declare const buttonVariants: (props?: ({
    variant?: "default" | "destructive" | "ghost" | "link" | "outline" | "secondary" | "tertiary" | null | undefined;
    size?: "compact" | "default" | "icon" | "icon-md" | "icon-sm" | "icon-xs" | "lg" | "sm" | null | undefined;
    shape?: "default" | "pill" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Card({ className, variant, ref, ...props }: CardProps & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace Card {
    var displayName: string;
}

export declare function CardContent({ className, padding, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof cardContentVariants> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace CardContent {
    var displayName: string;
}

declare const cardContentVariants: (props?: ({
    padding?: "default" | "none" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function CardDescription({ className, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace CardDescription {
    var displayName: string;
}

export declare function CardFooter({ className, padding, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof cardFooterVariants> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace CardFooter {
    var displayName: string;
}

declare const cardFooterVariants: (props?: ({
    padding?: "default" | "none" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function CardHeader({ className, padding, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof cardHeaderVariants> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace CardHeader {
    var displayName: string;
}

declare const cardHeaderVariants: (props?: ({
    padding?: "default" | "none" | null | undefined;
} & ClassProp) | undefined) => string;

declare interface CardProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardVariants> {
}

export declare function CardTitle({ className, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace CardTitle {
    var displayName: string;
}

declare const cardVariants: (props?: ({
    variant?: "default" | "transparent" | null | undefined;
} & ClassProp) | undefined) => string;

/** How long a pause can be before the next message starts a new group. */
export declare const CHAT_GROUPING_WINDOW_MS: number;

export declare interface ChatGroupableMessage {
    /**
     * Identity to group by. `null` never groups — use it for system notices and
     * anything else that should always stand alone.
     */
    readonly authorKey: string | null;
    /** When the message was sent, in epoch milliseconds. */
    readonly sentAt: number;
    /**
     * Set `false` to force a message to stand alone regardless of its author —
     * deleted, redacted, or otherwise structurally different rows.
     * @default true
     */
    readonly groupable?: boolean;
}

/**
 * A message log that follows new content, groups consecutive messages from one
 * speaker, and offers a way back to the bottom once the reader scrolls away.
 *
 * Structural chrome only. It never looks inside an item beyond the four fields
 * it needs to sequence them — identity, time, groupability, and a key — so the
 * body, avatar, actions, attachments, and every product concept stay with the
 * caller's `renderItem`. That is what lets one implementation of the sequencing
 * rules serve surfaces whose rows have nothing else in common.
 *
 * Layout contract: needs a definite height, like `Conversation`. Put the
 * composer *outside* this element, or every reply pushes it further down.
 */
export declare function ChatTranscript<TItem extends ChatTranscriptItem>({ contentClassName, emptyState, footer, grouping, header, items, renderDaySeparator, renderItem, scrollButtonLabel, windowMs, ...props }: ChatTranscriptProps<TItem>): React_2.JSX.Element;

export declare namespace ChatTranscript {
    var displayName: string;
}

export declare interface ChatTranscriptItem extends ChatGroupableMessage {
    /** Stable across renders — it is the React key and the memo boundary. */
    readonly id: string;
}

export declare interface ChatTranscriptItemContext {
    /** Position in the rendered list. */
    readonly index: number;
    /**
     * This item continues the group above it: the row should hide its avatar
     * and header.
     */
    readonly isGrouped: boolean;
    /** This item is the first of a new calendar day. */
    readonly isFirstOfDay: boolean;
}

export declare interface ChatTranscriptProps<TItem extends ChatTranscriptItem> extends Omit<React_2.ComponentProps<typeof Conversation>, 'children'> {
    /** Classes for the message list, not the scroller. */
    contentClassName?: string;
    /** Shown instead of the list when there are no items. */
    emptyState?: React_2.ReactNode;
    /** Inside the scroller, below the last item. Typing indicators go here. */
    footer?: React_2.ReactNode;
    /**
     * Turn off author grouping entirely — for transcripts where every row is a
     * distinct event rather than a person speaking.
     * @default true
     */
    grouping?: boolean;
    /** Inside the scroller, above the first item. "Show earlier messages". */
    header?: React_2.ReactNode;
    items: readonly TItem[];
    /**
     * Rendered before the first item of each new day. Omit for a transcript
     * short enough that the date never matters.
     */
    renderDaySeparator?: (context: {
        readonly index: number;
        readonly item: TItem;
    }) => React_2.ReactNode;
    renderItem: (item: TItem, context: ChatTranscriptItemContext) => React_2.ReactNode;
    /**
     * Visible text on the jump-to-latest control. Omit for the compact circular
     * icon; either form carries an accessible name.
     */
    scrollButtonLabel?: React_2.ReactNode;
    /** How long a pause can be before the next message starts a new group. */
    windowMs?: number;
}

export declare const Checkbox: React_2.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

/** Merge conditional classes while resolving Tailwind utility conflicts. */
export declare function cn(...inputs: ClassValue[]): string;

/**
 * CodeBlock component for displaying syntax-highlighted code.
 *
 * Uses prism-react-renderer for React-native syntax highlighting,
 * avoiding dangerouslySetInnerHTML for security and React 19 Compiler compatibility.
 *
 * Supports dark/light theme switching via CSS classes.
 *
 * @example
 * ```tsx
 * <CodeBlock code="const x = 1;" language="typescript" showLineNumbers>
 *   <CodeBlockCopyButton />
 * </CodeBlock>
 * ```
 */
export declare const CodeBlock: React_2.MemoExoticComponent<({ code, language, highlight, wrapLongLines, showLineNumbers, command, collapsible, defaultExpanded, className, children, ...props }: CodeBlockProps) => React_2.JSX.Element>;

export declare const CodeBlockCopyButton: React_2.MemoExoticComponent<({ onCopy, onError, timeout, children, className, ...props }: CodeBlockCopyButtonProps) => React_2.JSX.Element>;

declare type CodeBlockCopyButtonProps = ComponentProps<typeof Button> & {
    onCopy?: () => void;
    onError?: (error: Error) => void;
    timeout?: number;
};

declare type CodeBlockProps = HTMLAttributes<HTMLDivElement> & {
    code: string;
    language: SupportedLanguage;
    /** Disable Prism tokenization for unusually large payloads. */
    highlight?: boolean;
    /** Wrap long lines instead of requiring horizontal scrolling. */
    wrapLongLines?: boolean;
    showLineNumbers?: boolean;
    command?: string | string[];
    collapsible?: boolean;
    defaultExpanded?: boolean;
};

export declare const Collapsible: ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & RefAttributes<HTMLDivElement>>;

export declare const CollapsibleContent: ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & RefAttributes<HTMLDivElement>>;

export declare const CollapsibleTrigger: ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & RefAttributes<HTMLButtonElement>>;

/**
 * Scroll container for a message log that follows new content until the reader
 * scrolls away, then stays put until they come back.
 *
 * Layout contract — `Conversation` must be a flex child with a definite
 * height (`min-h-0 flex-1` inside a `flex flex-col` whose own height is
 * bounded). `StickToBottom` sizes its scrollport with `height: 100%`, which
 * collapses to `auto` against an indefinite parent; the log then grows without
 * bound and the *outer* element scrolls instead of the scrollport, so pinning
 * silently stops working while the page still looks scrollable.
 *
 * Three nested elements, only the middle one scrolls:
 *
 *   Conversation          → this element. `role="log"`, positioning context
 *                           for `ConversationScrollButton`.
 *     scrollport          → library-owned; the actual scrolling element.
 *                           Style it with `ConversationContent`'s
 *                           `scrollClassName`, not `className`.
 *       ConversationContent → the message list. `className` lands here.
 */
export declare const Conversation: ({ className, ...props }: ConversationProps) => React_2.JSX.Element;

/**
 * The message list. `className` styles the list; `scrollClassName` styles the
 * scrollport that wraps it — see `Conversation` for why they are different
 * elements.
 */
export declare const ConversationContent: ({ className, ...props }: ConversationContentProps) => React_2.JSX.Element;

export declare type ConversationContentProps = ComponentProps<typeof StickToBottom.Content>;

export declare const ConversationEmptyState: ({ className, title, description, icon, children, ...props }: ConversationEmptyStateProps) => React_2.JSX.Element;

export declare type ConversationEmptyStateProps = ComponentProps<'div'> & {
    title?: string;
    description?: string;
    icon?: React_2.ReactNode;
};

export declare type ConversationProps = ComponentProps<typeof StickToBottom>;

/**
 * "Jump to the newest message", rendered only while the log is scrolled away
 * from the bottom.
 *
 * Must be a descendant of `Conversation` — it reads `isAtBottom` from
 * `StickToBottom`'s context rather than taking it as a prop, so the caller
 * cannot desynchronise the button from the scroller it controls.
 *
 * Pass `children` for the labelled pill form; omit it for the compact circular
 * icon. Either way the control has an accessible name.
 */
export declare const ConversationScrollButton: ({ children, className, label, ...props }: ConversationScrollButtonProps) => React_2.JSX.Element | null;

export declare type ConversationScrollButtonProps = ComponentProps<typeof Button> & {
    /**
     * Accessible name for the icon-only form. Ignored when `children` supplies
     * visible text, because a visible label *is* the accessible name and
     * shadowing it with `aria-label` is what makes voice control miss the
     * control the user can see.
     */
    label?: string;
};

export declare const Dialog: React_2.FC<DialogPrimitive.DialogProps>;

export declare const DialogClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare function DialogContent({ className, children, ref, container, hideCloseButton, onOpenAutoFocus, onEscapeKeyDown, ...props }: React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof DialogPrimitive.Content>>;
    container?: HTMLElement | null;
    hideCloseButton?: boolean;
}): React_2.JSX.Element;

export declare namespace DialogContent {
    var displayName: string | undefined;
}

export declare function DialogDescription({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Description> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof DialogPrimitive.Description>>;
}): React_2.JSX.Element;

export declare namespace DialogDescription {
    var displayName: string | undefined;
}

export declare function DialogFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;

export declare namespace DialogFooter {
    var displayName: string;
}

export declare function DialogHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): React_2.JSX.Element;

export declare namespace DialogHeader {
    var displayName: string;
}

export declare function DialogOverlay({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof DialogPrimitive.Overlay>>;
}): React_2.JSX.Element;

export declare namespace DialogOverlay {
    var displayName: string | undefined;
}

export declare const DialogPortal: React_2.FC<DialogPrimitive.DialogPortalProps>;

export declare const DialogTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;

export declare const DialogTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

export declare function Empty({ className, ref, size, variant, ...props }: React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof emptyVariants> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace Empty {
    var displayName: string;
}

export declare function EmptyContent({ className, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace EmptyContent {
    var displayName: string;
}

export declare function EmptyDescription({ className, ref, ...props }: React_2.HTMLAttributes<HTMLParagraphElement> & {
    ref?: React_2.Ref<HTMLParagraphElement>;
}): React_2.JSX.Element;

export declare namespace EmptyDescription {
    var displayName: string;
}

export declare function EmptyHeader({ className, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace EmptyHeader {
    var displayName: string;
}

export declare function EmptyMedia({ className, variant, ref, ...props }: React_2.HTMLAttributes<HTMLDivElement> & VariantProps<typeof emptyMediaVariants> & {
    ref?: React_2.Ref<HTMLDivElement>;
}): React_2.JSX.Element;

export declare namespace EmptyMedia {
    var displayName: string;
}

declare const emptyMediaVariants: (props?: ({
    variant?: "default" | "icon" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function EmptyTitle(props: React_2.HTMLAttributes<HTMLHeadingElement>): React_2.JSX.Element;

export declare namespace EmptyTitle {
    var displayName: string;
}

declare const emptyVariants: (props?: ({
    size?: "compact" | "default" | null | undefined;
    variant?: "default" | "outline" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Field({ className, orientation, ...props }: React_2.ComponentProps<'div'> & VariantProps<typeof fieldVariants>): React_2.JSX.Element;

export declare function FieldContent({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function FieldDescription({ className, ...props }: React_2.ComponentProps<'p'>): React_2.JSX.Element;

export declare function FieldError({ className, children, errors, ...props }: React_2.ComponentProps<'div'> & {
    errors?: Array<{
        message?: string;
    } | undefined>;
}): React_2.JSX.Element | null;

export declare function FieldGroup({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function FieldLabel({ className, ...props }: React_2.ComponentProps<typeof Label>): React_2.JSX.Element;

export declare function FieldLegend({ className, variant, ...props }: React_2.ComponentProps<'legend'> & {
    variant?: 'label' | 'legend';
}): React_2.JSX.Element;

export declare function FieldSeparator({ children, className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function FieldSet({ className, ...props }: React_2.ComponentProps<'fieldset'>): React_2.JSX.Element;

export declare function FieldTitle({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

declare const fieldVariants: (props?: ({
    orientation?: "horizontal" | "responsive" | "vertical" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function H1({ asChild, className, ...props }: Omit<HeadingProps, 'level'>): React_2.JSX.Element;

export declare function H2({ asChild, className, ...props }: Omit<HeadingProps, 'level'>): React_2.JSX.Element;

export declare function H3({ asChild, className, ...props }: Omit<HeadingProps, 'level'>): React_2.JSX.Element;

export declare function H4({ asChild, className, ...props }: Omit<HeadingProps, 'level'>): React_2.JSX.Element;

export declare const H5: React_2.ForwardRefExoticComponent<Omit<HeadingProps, "level"> & React_2.RefAttributes<HTMLHeadingElement>>;

export declare function H6({ asChild, className, ...props }: Omit<HeadingProps, 'level'>): React_2.JSX.Element;

declare interface HeadingProps extends React_2.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof headingVariants> {
    asChild?: boolean;
    /** Render compact (14px) while keeping the heading's semantic level. */
    size?: HeadingSize;
}

declare type HeadingSize = keyof typeof headingSizeOverrides;

/**
 * Optional visual size overrides, decoupled from the semantic level so a
 * heading can keep its correct outline depth (e.g. h3) while rendering compact.
 * Applied after `headingVariants` in `cn`, so tailwind-merge always lets the
 * override win over the level's font-size/leading regardless of class order.
 */
declare const headingSizeOverrides: {
    readonly sm: 'text-sm leading-tight font-semibold tracking-normal';
};

declare const headingVariants: (props?: ({
    level?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | null | undefined;
} & ClassProp) | undefined) => string;

/**
 * Icon component for rendering Lucide React icons
 *
 * Uses Lucide's native `size` prop with em units so icons scale with text.
 * Default size follows text (1em). Use size="md" for 1.25em, size="lg" for 1.5em.
 *
 * @example
 * ```tsx
 * import { MessageSquare } from 'lucide-react';
 * import { Icon } from '@/components/ui/icon';
 *
 * <Icon icon={MessageSquare} />                    // 1em (default)
 * <Icon icon={MessageSquare} size="md" />          // 1.25em
 * <Icon icon={MessageSquare} size="lg" />          // 1.5em
 * <Icon icon={MessageSquare} size="lg" color="primary" />
 * ```
 */
export declare function Icon({ className, color, icon: IconComponent, size, ...props }: IconProps): React_2.JSX.Element;

/**
 * Patch-stable callable shape for Lucide-compatible icons.
 *
 * Lucide's public `LucideIcon` type embeds the physical React type instance
 * from its installation. Re-exporting it makes linked SDKs reject otherwise
 * compatible consumer Lucide/React patches. The never-argument callable
 * proves this is a component without coupling its props or return value.
 */
export declare type IconComponent = (...arguments_: never[]) => unknown;

export declare interface IconProps extends Omit<React_2.SVGProps<SVGSVGElement>, 'absoluteStrokeWidth' | 'color' | 'ref' | 'size'>, VariantProps<typeof iconVariants> {
    absoluteStrokeWidth?: boolean;
    icon: IconComponent;
}

/**
 * Icon variants for color only - NO size classes.
 * Size is handled by Lucide's native `size` prop.
 */
declare const iconVariants: (props?: ({
    color?: "default" | "destructive" | "inherit" | "muted" | "primary" | "secondary" | "success" | "warning" | null | undefined;
    size?: "default" | "lg" | "md" | "sm" | "xl" | "xs" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Input({ className, density, type, error, ref, onChange, ...props }: InputProps): React_2.JSX.Element;

export declare namespace Input {
    var displayName: string;
}

export declare function InputGroup({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function InputGroupAddon({ className, align, ...props }: React_2.ComponentProps<'div'> & VariantProps<typeof inputGroupAddonVariants>): React_2.JSX.Element;

declare const inputGroupAddonVariants: (props?: ({
    align?: "block-end" | "block-start" | "inline-end" | "inline-start" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React_2.ComponentProps<typeof Button>, 'size'> & VariantProps<typeof inputGroupButtonVariants>): React_2.JSX.Element;

/** Input-group actions keep desktop density while remaining 44pt on mobile. */
declare const inputGroupButtonVariants: (props?: ({
    size?: "icon-sm" | "icon-xs" | "sm" | "xs" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function InputGroupInput({ className, ...props }: React_2.ComponentProps<typeof Input>): React_2.JSX.Element;

export declare function InputGroupText({ className, ...props }: React_2.ComponentProps<'span'>): React_2.JSX.Element;

export declare function InputGroupTextarea({ className, ref, ...props }: React_2.ComponentProps<'textarea'> & {
    ref?: React_2.Ref<HTMLTextAreaElement>;
}): React_2.JSX.Element;

export declare namespace InputGroupTextarea {
    var displayName: string;
}

declare interface InputProps extends React_2.ComponentProps<'input'> {
    density?: 'compact' | 'default';
    error?: boolean;
    ref?: React_2.Ref<HTMLInputElement>;
}

export declare function Item({ className, variant, size, asChild, ...props }: React_2.ComponentProps<'div'> & VariantProps<typeof itemVariants> & {
    asChild?: boolean;
}): React_2.JSX.Element;

export declare function ItemActions({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemContent({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemDescription({ className, ...props }: React_2.ComponentProps<'p'>): React_2.JSX.Element;

export declare function ItemFooter({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemGroup({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemHeader({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function ItemMedia({ className, variant, ...props }: React_2.ComponentProps<'div'> & VariantProps<typeof itemMediaVariants>): React_2.JSX.Element;

declare const itemMediaVariants: (props?: ({
    variant?: "default" | "icon" | "image" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function ItemSeparator({ className, ...props }: React_2.ComponentProps<typeof Separator>): React_2.JSX.Element;

export declare function ItemTitle({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

declare const itemVariants: (props?: ({
    variant?: "default" | "muted" | "outline" | null | undefined;
    size?: "default" | "sm" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function Label({ className, ...props }: React_2.ComponentProps<typeof LabelPrimitive.Root>): React_2.JSX.Element;

export declare const Loader: ({ className, size, ...props }: LoaderProps) => React_2.JSX.Element;

export declare type LoaderProps = HTMLAttributes<HTMLDivElement> & {
    size?: number;
};

export declare const Message: ({ className, from, ...props }: MessageProps) => React_2.JSX.Element;

/**
 * Standardized muted-to-foreground hover treatment for icon-sized floating
 * controls so wrapped actions keep the same affordance across rows.
 */
export declare const MESSAGE_FLOATING_ACTION_BUTTON_CLASS = "text-muted-foreground hover:text-foreground hover:bg-muted/50 outline-none focus-visible:outline-none focus-visible:ring-0 focus-visible:ring-offset-0 focus-visible:ring-transparent";

/**
 * Shared interactive surface for opaque content sections (reasoning, tools,
 * etc.) so the row's hover treatment stays in sync with the parent row and
 * floating toolbar affordance.
 */
export declare const MESSAGE_ROW_SURFACE_CLASS = "relative -mx-3 rounded-lg px-3 py-0 transition-colors";

export declare const MessageAction: ({ tooltip, children, label, variant, size, ...props }: MessageActionProps) => React_2.JSX.Element;

export declare type MessageActionProps = ComponentProps<typeof Button> & {
    tooltip?: string;
    label?: string;
};

export declare const MessageActions: ({ className, children, ...props }: MessageActionsProps) => React_2.JSX.Element;

export declare type MessageActionsProps = ComponentProps<'div'>;

export declare const MessageContent: ({ children, className, ...props }: MessageContentProps) => React_2.JSX.Element;

export declare type MessageContentProps = HTMLAttributes<HTMLDivElement>;

/**
 * Standardized icon-only floating button with consistent surface styling,
 * optional tooltip copy, and a safe accessible-name fallback chain
 * (`aria-label` → `label` → string `tooltip`).
 */
export declare function MessageFloatingActionButton({ children, className, label, tooltip, variant, size, 'aria-label': ariaLabel, ...props }: MessageFloatingActionButtonProps): React_2.JSX.Element;

export declare interface MessageFloatingActionButtonProps extends ComponentProps<typeof Button> {
    label?: string;
    tooltip?: ReactNode;
}

/**
 * Positions a compact toolbar above the top-right edge of the parent
 * `MessageRow`. Reveals on hover or focus-within of the row; can be force-shown
 * via `isOpen` while a nested menu / popover is open.
 */
export declare function MessageFloatingActions({ children, className, isOpen, role, 'aria-label': ariaLabel, ...props }: MessageFloatingActionsProps): React_2.JSX.Element;

export declare interface MessageFloatingActionsProps extends ComponentProps<'div'> {
    /** Keeps the toolbar visible while a nested menu / popover owns focus. */
    isOpen?: boolean;
}

export declare type MessageProps = HTMLAttributes<HTMLDivElement> & {
    from: UIMessage['role'];
};

export declare function MessageRow({ avatar, authorName, timestamp, badge, headerActions, children, reactions, footer, actions, isGrouped, from, className, ...rest }: MessageRowProps): React_2.JSX.Element;

export declare interface MessageRowProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'role'> {
    /** Avatar element rendered in the gutter when not grouped. */
    avatar?: ReactNode;
    /** Author name slot. A string is rendered as bold text; any node is rendered as-is. */
    authorName?: ReactNode;
    /**
     * Timestamp slot. Rendered inline next to the author name when not grouped,
     * and as a hover-revealed gutter overlay (right-aligned with where the
     * avatar's right edge would be) when grouped.
     */
    timestamp?: ReactNode;
    /** Optional badge after the author name (e.g. an AI Agent chip). */
    badge?: ReactNode;
    /** Optional trailing header controls (right-justified in the header row). */
    headerActions?: ReactNode;
    /** The message body. */
    children: ReactNode;
    /**
     * Reaction pills slot — rendered inside the hover surface, immediately below
     * the message body, so hover/focus on reactions extends the row treatment.
     */
    reactions?: ReactNode;
    /**
     * Footer slot — rendered inside the hover surface, below the reactions row.
     * Typical usage: thread-reply indicators or read receipts that should be part
     * of the message's hover treatment.
     */
    footer?: ReactNode;
    /**
     * Floating actions slot — rendered outside the top edge of the row. Typical
     * usage is to pass a `<MessageFloatingActions>` element here.
     */
    actions?: ReactNode;
    /**
     * When true, the avatar and header are hidden; on hover/focus a small
     * timestamp appears right-aligned with where the avatar's right edge sits.
     */
    isGrouped?: boolean;
    /** Variant flag forwarded to the inner `Message` (sets `is-user` / `is-assistant`). */
    from?: 'user' | 'assistant' | 'system';
}

export declare const MessageToolbar: ({ className, children, ...props }: MessageToolbarProps) => React_2.JSX.Element;

export declare type MessageToolbarProps = ComponentProps<'div'>;

/**
 * Canonical "return to the previous view" affordance for mini-app screens.
 *
 * Full-screen mini-app views (for example a feedback form opened from a
 * course) must always expose a reliable way back to the surface that launched
 * them. Reusing this component keeps that affordance — icon, label, and
 * accessible name — consistent with the rest of the mini-app chrome instead of
 * each view hand-rolling (or forgetting) its own back control.
 */
export declare function MiniAppBackButton({ label, size, type, variant, ...props }: MiniAppBackButtonProps): React_2.JSX.Element;

export declare namespace MiniAppBackButton {
    var displayName: string;
}

export declare interface MiniAppBackButtonProps extends Omit<ButtonProps, 'asChild' | 'children'> {
    /**
     * Visible label for the control. Defaults to a generic "Back" so the
     * control always has an accessible name.
     */
    label?: string;
}

/**
 * Chrome that stays put while content scrolls past it: a sticky section
 * header, a table header, a composer pinned under a transcript.
 *
 * `'sticky'` rather than `'fixed'`, deliberately. A mini-app is mounted into a
 * host surface that is not the viewport, so `position: fixed` escapes the
 * surface and pins to the window — correct in a browser tab, wrong in every
 * docked panel. If a dock must escape its scroll container, that is a portal
 * with host-webview occlusion, not this.
 *
 * `z-10` by default, which clears ordinary content. A dock that must sit above
 * another positioned layer should say so through `className` rather than have
 * this template guess a stacking order it cannot see.
 */
export declare function MiniAppDock({ className, divider, edge, mode, tone, ...props }: MiniAppDockProps): React_2.JSX.Element;

export declare namespace MiniAppDock {
    var displayName: string;
}

export declare type MiniAppDockEdge = 'bottom' | 'top';

export declare type MiniAppDockMode = 
/** Pins to the edge of the nearest scroll container as content passes under. */
'sticky'
/** Not pinned; a flex row that refuses to shrink. */
| 'flex';

export declare interface MiniAppDockProps extends React_2.ComponentPropsWithRef<'div'> {
    /** @default 'top' */
    edge?: MiniAppDockEdge;
    /** @default 'sticky' */
    mode?: MiniAppDockMode;
    /** Draw the divider between the dock and the content. @default true */
    divider?: boolean;
    /** @default 'opaque' */
    tone?: MiniAppDockTone;
}

export declare type MiniAppDockTone = 
/** Solid. The only tone that is safe over arbitrary content. */
'opaque'
/** Translucent with a blur, so content shows through as it scrolls under. */
| 'frosted'
/** No background at all; the caller paints. */
| 'transparent';

export declare function MiniAppIconButton({ icon, label, size, tooltipSide, type, variant, ...props }: MiniAppIconButtonProps): React_2.JSX.Element;

export declare namespace MiniAppIconButton {
    var displayName: string;
}

export declare interface MiniAppIconButtonProps extends Omit<ButtonProps, 'children'> {
    icon: IconComponent;
    label: string;
    tooltipSide?: React_2.ComponentProps<typeof TooltipContent>['side'];
}

/**
 * A list beside a detail pane above a breakpoint; below it, either stacked or
 * one at a time.
 *
 * Scoped to the shape that is genuinely shared. It deliberately does *not*
 * cover: a draggable divider (compose `MiniAppSplit`), an off-canvas sheet
 * (compose `Sheet`, which needs host-webview occlusion this template has no
 * business owning), width persistence (an app-level storage-key decision), or
 * three panes. Mini-apps that need those differ from each other in ways a
 * shared component would have to re-expose as props one-for-one, which is a
 * config language, not an abstraction.
 *
 * Both panes stay mounted in `'swap'` mode — hidden, not unmounted — so scroll
 * position, form state, and imperative controllers holding element references
 * survive crossing the breakpoint.
 */
export declare function MiniAppListDetail({ activePane, backAffordance, className, collapse, detail, detailClassName, emptyDetail, list, listClassName, listWidth, ...props }: MiniAppListDetailProps): React_2.JSX.Element;

export declare namespace MiniAppListDetail {
    var displayName: string;
}

/** What happens below the breakpoint. */
export declare type MiniAppListDetailCollapse = 
/** Both panes stay visible, stacked vertically. */
'stack'
/** One pane at a time, chosen by `activePane`. */
| 'swap';

/** Only the widths in real use. Anything else goes through `listClassName`. */
export declare type MiniAppListDetailListWidth = 'lg' | 'md' | 'sm' | 'xl'
/** List flexes and the detail pane takes the fixed rail instead. */
| 'flex';

export declare interface MiniAppListDetailProps extends Omit<React_2.ComponentPropsWithRef<'div'>, 'children' | 'onSelect'> {
    /**
     * Which pane is showing below the breakpoint. Above it, both are showing and
     * this is ignored. Uncontrolled default: `'detail'` once `detail` is
     * non-null, so selecting a row reveals it without the caller wiring state.
     */
    activePane?: 'detail' | 'list';
    /**
     * Rendered above the detail pane, below the breakpoint only. Without a way
     * back, `collapse='swap'` strands the reader in the detail pane. Wire it to
     * whatever state feeds `activePane` — this template owns no interaction that
     * could change the pane itself, so it offers no change callback to mislead
     * you into thinking it does.
     */
    backAffordance?: React_2.ReactNode;
    /** @default 'swap' */
    collapse?: MiniAppListDetailCollapse;
    /** The detail pane. `null` shows `emptyDetail` above the breakpoint. */
    detail?: React_2.ReactNode;
    detailClassName?: string;
    /** Shown in place of an absent detail, above the breakpoint only. */
    emptyDetail?: React_2.ReactNode;
    /** The list or table pane. Always rendered. */
    list: React_2.ReactNode;
    listClassName?: string;
    /** @default 'md' */
    listWidth?: MiniAppListDetailListWidth;
}

/**
 * MiniAppMetric - a `Card`-based metric tile (label + value + detail).
 *
 * Why custom: shadcn/ui has no metric/stat-tile primitive. This is a thin,
 * named composition of `Card` parts that fixes the label/value/detail slots and
 * their token spacing, so miniapp dashboards render metrics consistently
 * instead of re-deriving the layout from raw `Card` each time.
 */
export declare function MiniAppMetric({ className, ...props }: React_2.ComponentProps<typeof Card>): React_2.JSX.Element;

export declare namespace MiniAppMetric {
    var displayName: string;
}

export declare function MiniAppMetricContent({ className, ...props }: React_2.ComponentProps<typeof CardContent>): React_2.JSX.Element;

export declare namespace MiniAppMetricContent {
    var displayName: string;
}

export declare function MiniAppMetricDetail({ className, ...props }: React_2.ComponentProps<'p'>): React_2.JSX.Element;

export declare namespace MiniAppMetricDetail {
    var displayName: string;
}

export declare function MiniAppMetricHeader({ className, ...props }: React_2.ComponentProps<typeof CardHeader>): React_2.JSX.Element;

export declare namespace MiniAppMetricHeader {
    var displayName: string;
}

export declare function MiniAppMetricLabel({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare namespace MiniAppMetricLabel {
    var displayName: string;
}

export declare function MiniAppMetricValue({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare namespace MiniAppMetricValue {
    var displayName: string;
}

/**
 * The root frame of a mini-app screen: full height, does not scroll, pins its
 * chrome and hands every remaining pixel to the body.
 *
 * This is deliberately the *common* shape, not every shape. Frames built on a
 * grid track, frames positioning a native webview, and frames rendered outside
 * React keep their own markup — an `as`/`layout`/`rows`/`cols` matrix that
 * covered all of them would be a class generator wearing a component's
 * clothes, and Tailwind cannot emit runtime-computed track strings anyway.
 *
 * The body wrapper is `min-h-0`, which is the whole point: without it a flex
 * child refuses to shrink below its content, and the frame scrolls instead of
 * the body — identical-looking until the toolbar starts sliding away. Each
 * chrome slot is wrapped in `shrink-0` for the mirror-image reason: chrome
 * that is allowed to shrink gets squeezed to nothing by a tall body rather
 * than staying put.
 */
export declare function MiniAppPage({ as: Component, bodyClassName, children, className, footer, height, minHeight, overflow, statusBar, style, surface, toolbar, ...props }: MiniAppPageProps): React_2.JSX.Element;

export declare namespace MiniAppPage {
    var displayName: string;
}

export declare function MiniAppPageHeader({ className, ref, ...props }: React_2.ComponentProps<'header'> & {
    ref?: React_2.Ref<HTMLElement>;
}): React_2.JSX.Element;

export declare namespace MiniAppPageHeader {
    var displayName: string;
}

export declare function MiniAppPageHeaderActions({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare namespace MiniAppPageHeaderActions {
    var displayName: string;
}

export declare function MiniAppPageHeaderContent({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare namespace MiniAppPageHeaderContent {
    var displayName: string;
}

export declare function MiniAppPageHeaderDescription({ className, ...props }: React_2.ComponentProps<'p'>): React_2.JSX.Element;

export declare namespace MiniAppPageHeaderDescription {
    var displayName: string;
}

export declare function MiniAppPageHeaderTitle({ className, ...props }: React_2.ComponentProps<typeof H1>): React_2.JSX.Element;

export declare namespace MiniAppPageHeaderTitle {
    var displayName: string;
}

/**
 * How the frame gets its height.
 *
 * These are not interchangeable, which is why the prop exists rather than a
 * single hard-coded class: a federated surface is sized by its host container
 * and wants `h-full`, while a mini-app that owns a browser tab wants a
 * viewport unit — and `h-screen` is wrong on mobile Safari, where `dvh`/`svh`
 * account for the retracting toolbar.
 */
export declare type MiniAppPageHeight = 'auto' | 'dvh' | 'fill' | 'svh';

/**
 * Who owns the scroll.
 *
 * `'hidden'` is the default and the shape this template is for: the frame is
 * fixed and the body scrolls. `'visible'` hands scrolling to the host
 * container above the frame, which a surface mounted into an already-scrolling
 * page needs.
 */
export declare type MiniAppPageOverflow = 'auto' | 'hidden' | 'visible';

export declare interface MiniAppPageProps extends Omit<React_2.ComponentPropsWithRef<'div'>, 'children'> {
    /** Rendered element. `'main'` when the frame is the document's main region. */
    as?: 'div' | 'main' | 'section';
    /** The scrolling body. Wrap it in `MiniAppScrollRegion` to make it scroll. */
    children?: React_2.ReactNode;
    /** Extra classes for the body wrapper, not the frame. */
    bodyClassName?: string;
    /** Pinned below the body. Never scrolls. */
    footer?: React_2.ReactNode;
    /** @default 'fill' */
    height?: MiniAppPageHeight;
    /**
     * Pixel floor below which the frame stops collapsing. An inline style rather
     * than a class, because the real values in use are arbitrary (320, 360, 420,
     * 520, 640) and Tailwind cannot emit a class it never sees as a literal.
     */
    minHeight?: number | string;
    /** @default 'hidden' */
    overflow?: MiniAppPageOverflow;
    /**
     * Paint the frame's own background and text colour. Turn this off when the
     * frame sits inside a surface that has already painted, so the two cannot
     * disagree. @default true
     */
    surface?: boolean;
    /** Pinned below the toolbar, above the body. For `MiniAppStatusBar`. */
    statusBar?: React_2.ReactNode;
    /** Pinned at the top. Never scrolls. For `MiniAppToolbar`. */
    toolbar?: React_2.ReactNode;
}

/**
 * The loading, error, and empty screens a mini-app shows before or instead of
 * its content.
 *
 * These are the most-copied blocks in any mini-app — usually three
 * near-identical early returns in the same file, drifting apart one padding
 * value at a time. Routing them through one component makes the three states
 * look like siblings and gives assistive tech a consistent live region:
 * `role="status"` while loading, `role="alert"` on error.
 */
export declare function MiniAppPageState({ action, className, description, fill, icon, kind, title, ...props }: MiniAppPageStateProps): React_2.JSX.Element;

export declare namespace MiniAppPageState {
    var displayName: string;
}

/** How the state block claims space. Mirrors `MiniAppScrollRegion`. */
export declare type MiniAppPageStateFill = 'flex' | 'full' | 'none';

export declare type MiniAppPageStateKind = 'empty' | 'error' | 'loading';

export declare interface MiniAppPageStateProps extends Omit<React_2.ComponentProps<typeof Empty>, 'children' | 'title'> {
    /** Buttons or links. Rendered below the description. */
    action?: React_2.ReactNode;
    description?: React_2.ReactNode;
    /** @default 'flex' */
    fill?: MiniAppPageStateFill;
    /**
     * Replaces the default media. `'loading'` supplies a spinner; the other
     * kinds render nothing unless given an icon.
     */
    icon?: React_2.ReactNode;
    /** @default 'loading' */
    kind?: MiniAppPageStateKind;
    title?: React_2.ReactNode;
}

/**
 * "The body scrolls, the chrome does not" — the one shape every mini-app needs
 * and every mini-app spells differently.
 *
 * The three parts that are easy to get wrong, and are fixed here:
 *   - `min-h-0` on a flex child. Without it the region refuses to shrink below
 *     its content and the *page* scrolls instead, which looks the same until
 *     the chrome starts sliding away.
 *   - `h-full` on the viewport. The Radix root is only `relative`; the viewport
 *     is the scrolling element, so height set on the root alone does nothing.
 *   - A stable hook for tests on the viewport rather than the root.
 */
export declare function MiniAppScrollRegion({ axis, children, className, fill, region, viewportClassName, viewportProps, ...props }: MiniAppScrollRegionProps): React_2.JSX.Element;

export declare namespace MiniAppScrollRegion {
    var displayName: string;
}

export declare type MiniAppScrollRegionAxis = 'x' | 'both' | 'y';

/**
 * The same sizing rules as a plain `className`, for the regions that must stay
 * native DOM — imperative surfaces, opaque webviews, and anywhere a Radix
 * portal is not worth the bytes.
 */
export declare function miniAppScrollRegionClassName(options?: {
    axis?: MiniAppScrollRegionAxis;
    className?: string;
    fill?: MiniAppScrollRegionFill;
}): string;

/** How the region claims space from its parent. */
export declare type MiniAppScrollRegionFill = 
/** Parent is a flex container: take the leftover space and allow shrinking. */
'flex'
/** Parent is a grid cell or already sized. */
| 'full'
/** Caller sizes the region entirely (fixed heights, min-heights). */
| 'none';

export declare interface MiniAppScrollRegionProps extends Omit<ScrollAreaProps, 'asChild' | 'dir'> {
    /** @default 'flex' */
    fill?: MiniAppScrollRegionFill;
    /** `'x'` and `'both'` also render a horizontal scrollbar. @default 'y' */
    axis?: MiniAppScrollRegionAxis;
    /**
     * Stamped on the root as `data-scroll-region` and on the viewport as
     * `data-scroll-region-viewport`. End-to-end tests need to script the element
     * that actually has `scrollTop`, which is the viewport, not the root.
     */
    region?: string;
}

export declare function MiniAppSectionHeader({ className, ...props }: React_2.ComponentProps<'header'>): React_2.JSX.Element;

export declare namespace MiniAppSectionHeader {
    var displayName: string;
}

export declare function MiniAppSectionHeaderActions({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare namespace MiniAppSectionHeaderActions {
    var displayName: string;
}

export declare function MiniAppSectionHeaderContent({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare namespace MiniAppSectionHeaderContent {
    var displayName: string;
}

export declare function MiniAppSectionHeaderDescription({ className, ...props }: React_2.ComponentProps<'p'>): React_2.JSX.Element;

export declare namespace MiniAppSectionHeaderDescription {
    var displayName: string;
}

export declare function MiniAppSectionHeaderTitle({ className, ...props }: React_2.ComponentProps<typeof H2>): React_2.JSX.Element;

export declare namespace MiniAppSectionHeaderTitle {
    var displayName: string;
}

/**
 * Two panes the reader can resize, with a keyboard-operable handle between
 * them.
 *
 * A named two-slot shape over the `Resizable*` primitives, which have been
 * available since before the SDK's first release and adopted almost nowhere —
 * mini-apps hand-roll pointer-capture splitters with their own persistence
 * instead. Those splitters are the reason this exists: the primitives were
 * available but not *reachable*, because using them means knowing to compose
 * three components and that panels clip by default.
 *
 * Costs no bundle bytes beyond what `Resizable*` already ships.
 *
 * Panes clip rather than scroll, per `ResizablePanel`'s default. Put a
 * `MiniAppScrollRegion` inside a pane that needs to scroll, so the scroll
 * owner is a deliberate choice rather than an accident of the drag shell.
 *
 * Persistence is the caller's: pass `defaultLayout` and `onLayoutChanged`
 * through to the underlying group and store the layout wherever the app
 * already stores its state. Baking in a storage key would have two mini-apps
 * mounted on one surface fight over the same entry.
 *
 * Sizes here are percentages, stated as numbers. The underlying library reads
 * a bare number as *pixels* and only a string as a percentage, so
 * `defaultSize={60}` passed straight through would silently produce a 60-pixel
 * pane. Converting at this boundary is most of why the primitives are worth
 * wrapping.
 */
export declare function MiniAppSplit({ className, defaultSize, direction, handle, minSize, primary, primaryClassName, secondary, secondaryClassName, secondaryMinSize, ...props }: MiniAppSplitProps): React_2.JSX.Element;

export declare namespace MiniAppSplit {
    var displayName: string;
}

export declare interface MiniAppSplitProps extends Omit<React_2.ComponentProps<typeof ResizablePanelGroup>, 'children'> {
    /** Starting size of the primary pane, in percent. @default 60 */
    defaultSize?: number;
    /** @default 'horizontal' */
    direction?: 'horizontal' | 'vertical';
    /** Show a grip on the handle. @default true */
    handle?: boolean;
    /** Smallest the primary pane may become, in percent. @default 20 */
    minSize?: number;
    /** The leading pane. */
    primary: React_2.ReactNode;
    /** Classes for the primary pane. */
    primaryClassName?: string;
    /** The trailing pane. */
    secondary: React_2.ReactNode;
    /** Classes for the secondary pane. */
    secondaryClassName?: string;
    /** Smallest the secondary pane may become, in percent. @default 20 */
    secondaryMinSize?: number;
}

export declare function MiniAppStatusBar({ children, className, tone, ...props }: MiniAppStatusBarProps): React_2.JSX.Element;

export declare namespace MiniAppStatusBar {
    var displayName: string;
}

export declare interface MiniAppStatusBarProps extends Omit<React_2.ComponentProps<typeof Alert>, 'children' | 'variant'> {
    children: React_2.ReactNode;
    tone?: 'error' | 'neutral' | 'success';
}

export declare function MiniAppToolbar({ className, ref, ...props }: React_2.ComponentProps<'header'> & {
    ref?: React_2.Ref<HTMLElement>;
}): React_2.JSX.Element;

export declare namespace MiniAppToolbar {
    var displayName: string;
}

/**
 * NativeSelect - a token-styled wrapper over the native `<select>` element.
 *
 * Why custom: shadcn/ui's canonical Select is the Radix listbox, which renders
 * a custom popover. This complements it for the cases where a real native
 * `<select>` is required instead — OS-native pickers (notably on mobile),
 * native form semantics, and very large/dynamic option sets where the Radix
 * popover is too heavy. It applies the same token-based input styling and
 * chevron affordance so the two stay visually consistent.
 */
export declare function NativeSelect({ className, density, ref, wrapperClassName, ...props }: React_2.ComponentProps<'select'> & {
    density?: 'compact' | 'default';
    ref?: React_2.Ref<HTMLSelectElement>;
    wrapperClassName?: string;
}): React_2.JSX.Element;

export declare namespace NativeSelect {
    var displayName: string;
}

export declare function NativeSelectOptGroup({ className, ref, ...props }: React_2.ComponentProps<'optgroup'> & {
    ref?: React_2.Ref<HTMLOptGroupElement>;
}): React_2.JSX.Element;

export declare namespace NativeSelectOptGroup {
    var displayName: string;
}

export declare function NativeSelectOption({ className, ref, ...props }: React_2.ComponentProps<'option'> & {
    ref?: React_2.Ref<HTMLOptionElement>;
}): React_2.JSX.Element;

export declare namespace NativeSelectOption {
    var displayName: string;
}

/**
 * Host adapter for native surfaces that render above browser content.
 * Browser-only miniapps intentionally run without an adapter.
 */
export declare interface NativeViewOcclusionAdapter {
    acquire(element: HTMLElement, claimId: string): NativeViewOcclusionRelease | Promise<NativeViewOcclusionRelease>;
}

export declare function NativeViewOcclusionProvider({ adapter, children, }: NativeViewOcclusionProviderProps): React_2.JSX.Element;

export declare interface NativeViewOcclusionProviderProps {
    adapter: NativeViewOcclusionAdapter | null;
    children: React_2.ReactNode;
}

export declare type NativeViewOcclusionRelease = () => void;

export declare function Progress({ className, value, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof ProgressPrimitive.Root>>;
}): React_2.JSX.Element;

export declare namespace Progress {
    var displayName: string | undefined;
}

export declare function RadioCard({ id, value, children, className, control, ref, ...props }: RadioCardProps & {
    ref?: React_2.Ref<HTMLLabelElement>;
}): React_2.JSX.Element;

export declare namespace RadioCard {
    var displayName: string;
}

/**
 * RadioCard - a full card surface that acts as a single radio option.
 *
 * Why custom: shadcn/ui ships `RadioGroup`/`RadioGroupItem` but no card-styled
 * option. This wraps `RadioGroupItem` in a `<label>` with token surface,
 * hover, and `has-[[data-state=checked]]` selected styling so an entire card is
 * the click/selection target rather than just the dot.
 */
declare interface RadioCardProps extends Omit<React_2.ComponentPropsWithoutRef<typeof RadioGroupItem>, 'id'>, VariantProps<typeof radioControlVariants> {
    id: string;
    children: React_2.ReactNode;
    className?: string;
}

declare const radioControlVariants: (props?: ({
    control?: "hidden" | "visible" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function RadioGroup({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof RadioGroupPrimitive.Root>>;
}): React_2.JSX.Element;

export declare namespace RadioGroup {
    var displayName: string | undefined;
}

export declare function RadioGroupItem({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof RadioGroupPrimitive.Item>>;
}): React_2.JSX.Element;

export declare namespace RadioGroupItem {
    var displayName: string | undefined;
}

export declare const ResizableHandle: ({ withHandle, className, ...props }: SeparatorProps & {
    withHandle?: boolean;
}) => React_2.JSX.Element;

export declare const ResizablePanel: ({ className, panelOverflow, style, ...props }: ResizablePanelProps) => React_2.JSX.Element;

export declare const ResizablePanelGroup: ({ className, direction, ...props }: ResizablePanelGroupProps) => React_2.JSX.Element;

declare interface ResizablePanelGroupProps extends Omit<GroupProps, 'orientation'> {
    /** Direction of the panel group (maps to orientation) */
    direction?: 'horizontal' | 'vertical';
}

declare type ResizablePanelOverflow = 'auto' | 'hidden' | 'visible';

declare interface ResizablePanelProps extends PanelProps {
    /**
     * Controls panel overflow. Panels default to clipping so nested layouts can
     * choose the real scroll owner instead of the resizable shell scrolling.
     */
    panelOverflow?: ResizablePanelOverflow;
}

/**
 * Indices that start a new calendar day, for placing date separators.
 *
 * Never includes 0 — the first message needs no separator above it unless the
 * caller wants one, which is its own decision.
 */
export declare function resolveChatDayBoundaries(messages: readonly ChatGroupableMessage[]): ReadonlySet<number>;

/**
 * For each message, whether it continues the group above it — i.e. whether its
 * avatar and header should be suppressed.
 *
 * Index-aligned with `messages`; index 0 is always `false`.
 *
 * `breakBefore` forces a new group at the given indices, for rows that have
 * something rendered above them: a date separator, an unread divider, or any
 * other interruption that would leave a grouped row visually orphaned from the
 * name it belongs to.
 */
export declare function resolveChatGroupContinuations(messages: readonly ChatGroupableMessage[], options?: {
    readonly breakBefore?: ReadonlySet<number>;
    readonly windowMs?: number;
}): readonly boolean[];

export declare function ScrollArea({ className, viewportClassName, viewportRef, viewportProps, children, ...props }: ScrollAreaProps): React_2.JSX.Element;

export declare interface ScrollAreaProps extends React_2.ComponentProps<typeof ScrollAreaPrimitive.Root> {
    viewportClassName?: string;
    viewportRef?: React_2.Ref<HTMLDivElement>;
    viewportProps?: React_2.ComponentProps<typeof ScrollAreaPrimitive.Viewport>;
}

export declare function ScrollBar({ className, orientation, ...props }: React_2.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): React_2.JSX.Element;

/**
 * The scrolling body of a secondary sidebar.
 *
 * A named alias for the default `MiniAppScrollRegion`, kept because the name
 * carries the intent at its call sites. It emits the same markup, and now
 * forwards the props those call sites were reaching around it for.
 */
export declare function SecondarySidebarContent(props: SecondarySidebarContentProps): React_2.JSX.Element;

export declare namespace SecondarySidebarContent {
    var displayName: string;
}

export declare type SecondarySidebarContentProps = Omit<MiniAppScrollRegionProps, 'axis' | 'fill'>;

export declare const Select: React_2.FC<SelectPrimitive.SelectProps>;

export declare function SelectContent({ className, children, position, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.Content> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof SelectPrimitive.Content>>;
}): React_2.JSX.Element;

export declare namespace SelectContent {
    var displayName: string | undefined;
}

export declare const SelectGroup: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React_2.RefAttributes<HTMLDivElement>>;

export declare function SelectItem({ className, children, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof SelectPrimitive.Item>>;
}): React_2.JSX.Element;

export declare namespace SelectItem {
    var displayName: string | undefined;
}

export declare function SelectLabel({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.Label> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof SelectPrimitive.Label>>;
}): React_2.JSX.Element;

export declare namespace SelectLabel {
    var displayName: string | undefined;
}

export declare function SelectScrollDownButton({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof SelectPrimitive.ScrollDownButton>>;
}): React_2.JSX.Element;

export declare namespace SelectScrollDownButton {
    var displayName: string | undefined;
}

export declare function SelectScrollUpButton({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof SelectPrimitive.ScrollUpButton>>;
}): React_2.JSX.Element;

export declare namespace SelectScrollUpButton {
    var displayName: string | undefined;
}

export declare function SelectSeparator({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof SelectPrimitive.Separator>>;
}): React_2.JSX.Element;

export declare namespace SelectSeparator {
    var displayName: string | undefined;
}

export declare function SelectTrigger({ className, children, density, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger> & {
    density?: 'compact' | 'default';
    ref?: React_2.Ref<React_2.ComponentRef<typeof SelectPrimitive.Trigger>>;
}): React_2.JSX.Element;

export declare namespace SelectTrigger {
    var displayName: string | undefined;
}

export declare const SelectValue: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React_2.RefAttributes<HTMLSpanElement>>;

export declare function Separator({ className, orientation, decorative, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof SeparatorPrimitive.Root>>;
}): React_2.JSX.Element;

export declare namespace Separator {
    var displayName: string | undefined;
}

export declare function Sheet(props: React_2.ComponentProps<typeof DialogPrimitive.Root>): React_2.JSX.Element;

export declare function SheetClose({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Close>): React_2.JSX.Element;

export declare function SheetContent({ className, children, occlusionEnabled, side, overlayClassName, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Content> & {
    /** Disable native-view occlusion while persistently mounted content is hidden. */
    occlusionEnabled?: boolean;
    side?: 'top' | 'right' | 'bottom' | 'left';
    overlayClassName?: string;
}): React_2.JSX.Element;

export declare function SheetDescription({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Description>): React_2.JSX.Element;

export declare function SheetFooter({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function SheetHeader({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function SheetTitle({ className, ...props }: React_2.ComponentProps<typeof DialogPrimitive.Title>): React_2.JSX.Element;

export declare function SheetTrigger({ ...props }: React_2.ComponentProps<typeof DialogPrimitive.Trigger>): React_2.JSX.Element;

export declare const Shimmer: MemoExoticComponent<typeof ShimmerComponent>;

/**
 * Sweeping text shimmer, driven by the `shimmer-sweep` keyframes in theme.css.
 *
 * This was a `motion.create()` component. It animated one property on a loop,
 * which CSS does natively — and `motion/react` bundles at ~310 KB, a ~79%
 * increase on the miniapp SDK's `dist/ui.js`. That cost is what kept this atom
 * out of the miniapp surface, so it is paid in CSS instead.
 *
 * Two deliberate differences from the motion version:
 *   - Reduced motion uses the `motion-reduce:` variant rather than
 *     `useReducedMotion()`, so it costs no JS and no re-render.
 *   - The offscreen pause (`onViewportEnter`/`onViewportLeave`) is gone. It
 *     existed because a JS-driven loop is wasteful when invisible; browsers
 *     already throttle offscreen CSS animations, and dropping it removes an
 *     IntersectionObserver per shimmer.
 */
declare const ShimmerComponent: ({ children, as: Component, className, duration, spread, }: TextShimmerProps) => ReactElement<any, string | JSXElementConstructor<any>>;

export declare function Skeleton({ className, ...props }: React_2.ComponentProps<'div'>): React_2.JSX.Element;

export declare function Slider({ className, ref, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledby, ...props }: React_2.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof SliderPrimitive.Root>>;
}): React_2.JSX.Element;

export declare namespace Slider {
    var displayName: string;
}

/**
 * Non-editable pill/chip component for displaying a mentioned specialist.
 *
 * **Features:**
 * - Displays @Name format with accent styling
 * - Optional remove button with hover effects
 * - Prevents text selection and editing
 * - Styled similar to Slack/Discord mention chips
 * - Accessible with ARIA labels
 *
 * @example
 * ```tsx
 * <SpecialistMentionChip
 *   specialistId="rust-expert"
 *   specialistName="Rust Expert"
 *   onRemove={() => handleRemove('rust-expert')}
 * />
 * ```
 */
export declare function SpecialistMentionChip({ specialistId, specialistName, onRemove, className, ...props }: SpecialistMentionChipProps): React_2.JSX.Element;

/**
 * Props for the SpecialistMentionChip component
 */
export declare interface SpecialistMentionChipProps extends HTMLAttributes<HTMLSpanElement> {
    /** Unique identifier for the specialist */
    specialistId: string;
    /** Display name of the specialist */
    specialistName: string;
    /** Optional callback when the remove button is clicked */
    onRemove?: () => void;
}

/**
 * StatusIndicator - A semantic status dot for compact status surfaces.
 *
 * @example
 * ```tsx
 * <StatusIndicator label="Service available" tone="success" size="sm" />
 * <StatusIndicator label="Action required" tone="warning" size="md" />
 * ```
 */
export declare function StatusIndicator({ className, label, ref, size, tone, ...props }: StatusIndicatorProps & {
    ref?: React_2.Ref<HTMLSpanElement>;
}): React_2.JSX.Element;

export declare namespace StatusIndicator {
    var displayName: string;
}

/**
 * Props for StatusIndicator component
 */
export declare interface StatusIndicatorProps extends React_2.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof statusIndicatorVariants> {
    /** Accessible description of the represented status. */
    label: string;
    /** Size variant */
    size?: 'sm' | 'md' | 'lg';
    /** Semantic status tone. */
    tone?: 'success' | 'warning' | 'destructive' | 'neutral';
}

/**
 * Status indicator variants
 */
declare const statusIndicatorVariants: (props?: ({
    tone?: "destructive" | "neutral" | "success" | "warning" | null | undefined;
    size?: "lg" | "md" | "sm" | null | undefined;
} & ClassProp) | undefined) => string;

/**
 * Supported languages for syntax highlighting.
 * Maps common language identifiers to prism-react-renderer compatible names.
 */
declare type SupportedLanguage = 'typescript' | 'tsx' | 'javascript' | 'jsx' | 'python' | 'bash' | 'shell' | 'json' | 'css' | 'html' | 'markdown' | 'yaml' | 'sql' | 'rust' | 'go' | 'java' | 'c' | 'cpp' | 'csharp' | 'ruby' | 'php' | 'swift' | 'kotlin' | 'scala' | 'r' | 'perl' | 'lua' | 'haskell' | 'elixir' | 'clojure' | 'diff' | 'graphql' | 'toml' | 'ini' | 'dockerfile' | 'makefile' | 'nginx' | 'xml' | 'regex' | 'plaintext' | (string & {});

/**
 * The host-sized vertical scroll owner for a full-page miniapp surface.
 *
 * This stays a native scroll container instead of composing the styled
 * `ScrollArea`: the surface root needs browser-native wheel, trackpad, touch,
 * and keyboard behavior, while nested regions can opt into custom scrollbars.
 */
export declare function SurfaceViewport({ as: Component, children, className, tabIndex, ...props }: SurfaceViewportProps): React_2.JSX.Element;

export declare namespace SurfaceViewport {
    var displayName: string;
}

export declare interface SurfaceViewportProps extends React_2.ComponentPropsWithRef<'div'> {
    /** The landmark rendered for the full-page surface. @default 'main' */
    as?: 'div' | 'main' | 'section';
}

export declare const Table: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableElement> & {
    density?: 'compact' | 'default';
} & React_2.RefAttributes<HTMLTableElement>>;

export declare const TableBody: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

export declare const TableCaption: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableCaptionElement> & React_2.RefAttributes<HTMLTableCaptionElement>>;

export declare const TableCell: React_2.ForwardRefExoticComponent<React_2.TdHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;

export declare const TableFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

export declare const TableHead: React_2.ForwardRefExoticComponent<React_2.ThHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;

export declare const TableHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;

export declare const TableRow: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableRowElement> & React_2.RefAttributes<HTMLTableRowElement>>;

export declare function Tabs({ className, orientation, ...props }: React_2.ComponentProps<typeof TabsPrimitive.Root>): React_2.JSX.Element;

export declare function TabsContent({ className, ...props }: React_2.ComponentProps<typeof TabsPrimitive.Content>): React_2.JSX.Element;

export declare function TabsList({ className, variant, ...props }: React_2.ComponentProps<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>): React_2.JSX.Element;

declare const tabsListVariants: (props?: ({
    variant?: "default" | "line" | null | undefined;
} & ClassProp) | undefined) => string;

export declare function TabsTrigger({ className, ...props }: React_2.ComponentProps<typeof TabsPrimitive.Trigger>): React_2.JSX.Element;

export declare function Textarea({ className, error, ref, onChange, ...props }: React_2.ComponentProps<'textarea'> & {
    error?: boolean;
    ref?: React_2.Ref<HTMLTextAreaElement>;
}): React_2.JSX.Element;

export declare namespace Textarea {
    var displayName: string;
}

export declare type TextShimmerProps = {
    children: string;
    as?: ElementType;
    className?: string;
    duration?: number;
    spread?: number;
};

export declare const Toggle: React_2.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
    variant?: "default" | "outline" | null | undefined;
    size?: "default" | "lg" | "sm" | null | undefined;
} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const ToggleGroup: React_2.ForwardRefExoticComponent<(Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React_2.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React_2.RefAttributes<HTMLDivElement>, "ref">) & React_2.RefAttributes<HTMLDivElement>>;

export declare const ToggleGroupItem: React_2.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;

export declare const Tooltip: React_2.FC<TooltipPrimitive.TooltipProps>;

export declare function TooltipContent({ className, sideOffset, variant, ref, ...props }: TooltipContentProps): React_2.JSX.Element;

export declare namespace TooltipContent {
    var displayName: string | undefined;
}

declare type TooltipContentProps = React_2.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> & {
    ref?: React_2.Ref<React_2.ComponentRef<typeof TooltipPrimitive.Content>>;
    /** `chrome`: light-on-dark chip for message hover toolbars; `default`: popover surface (sidebar, etc.). */
    variant?: 'chrome' | 'default';
};

export declare const TooltipProvider: React_2.FC<TooltipPrimitive.TooltipProviderProps>;

export declare const TooltipTrigger: React_2.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;

/**
 * Custom AI Types
 *
 * Type definitions for AI chat components, replacing Vercel AI SDK types.
 * These types are designed to work with our custom WebSocket-based chat system.
 */
/**
 * Base message type for UI components
 */
declare interface UIMessage {
    role: 'user' | 'assistant' | 'system' | 'tool';
    content: string;
    id: string;
    timestamp?: Date | number;
}

/**
 * Waits for an optional host adapter before revealing overlay content. With no
 * adapter, as in a normal browser miniapp, the hook is immediately ready.
 */
export declare function useNativeViewOcclusion<T extends HTMLElement = HTMLDivElement>({ enabled, }?: UseNativeViewOcclusionOptions): UseNativeViewOcclusionReturn<T>;

export declare interface UseNativeViewOcclusionOptions {
    /** When false, acquisition is skipped and `ready` is always true. */
    enabled?: boolean;
}

export declare interface UseNativeViewOcclusionReturn<T extends HTMLElement = HTMLDivElement> {
    ref: React_2.RefCallback<T>;
    ready: boolean;
}

export { useStickToBottomContext }

export { }