@mcp-elements/react 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mayur Rawte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,592 @@
+import * as react from 'react';
+import react__default from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _mcp_elements_core from '@mcp-elements/core';
+import { DialogConfig, TabItem, TabsConfig, AccordionItemConfig, AccordionConfig, SelectOption, SelectConfig, TooltipConfig, PopoverConfig, Toast, DrawerConfig, DropdownMenuItem, DropdownMenuConfig, ToolStateApi, JsonSchema, ScopeDescriptor, AppMessageEnvelope, ToolStateSnapshot, OAuthFlowSnapshot, OAuthFlowApi, FieldDescriptor } from '@mcp-elements/core';
+
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'primary' | 'secondary' | 'outline' | 'ghost' | 'destructive' | 'link';
+    size?: 'sm' | 'md' | 'lg' | 'icon';
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface BadgeProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'secondary' | 'outline' | 'destructive';
+}
+declare function Badge({ variant, className, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+declare const Card: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLHeadingElement> & react.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+}
+declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const Separator: react.ForwardRefExoticComponent<SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+
+interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare function Skeleton({ className, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+declare function useDialog(config?: Omit<DialogConfig, 'onOpenChange'>): {
+    id: string;
+    getTriggerProps: (isOpen: boolean) => {
+        "aria-haspopup": "dialog";
+        "aria-expanded": boolean;
+        onClick: () => void | undefined;
+    };
+    getContentProps: (isOpen: boolean) => {
+        role: "dialog";
+        "aria-modal": boolean;
+        "aria-labelledby": string;
+        "aria-describedby": string;
+        hidden: boolean | undefined;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+    getOverlayProps: () => {
+        "aria-hidden": true;
+        onClick: () => void | undefined;
+    };
+    getCloseProps: () => {
+        "aria-label": string;
+        onClick: () => void | undefined;
+    };
+    open: boolean;
+    setOpen: react.Dispatch<react.SetStateAction<boolean>>;
+};
+
+interface DialogProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+    children: React.ReactNode;
+}
+declare function Dialog({ open: controlledOpen, onOpenChange, modal, children }: DialogProps): react_jsx_runtime.JSX.Element | null;
+declare function DialogHeader({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DialogFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DialogTitle({ className, ...props }: React.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function DialogDescription({ className, ...props }: React.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+
+declare function useTabs(items: TabItem[], config?: Omit<TabsConfig, 'onValueChange'>): {
+    getListProps: () => {
+        role: "tablist";
+    };
+    getTriggerProps: (value: string, activeValue: string) => {
+        role: "tab";
+        "aria-selected": boolean;
+        "aria-controls": string;
+        id: string;
+        tabIndex: number;
+        disabled: boolean;
+        onClick: () => void;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+    getPanelProps: (value: string, activeValue: string) => {
+        role: "tabpanel";
+        id: string;
+        "aria-labelledby": string;
+        hidden: true | undefined;
+        tabIndex: number;
+    };
+    value: string;
+    setValue: react.Dispatch<react.SetStateAction<string>>;
+};
+
+interface TabsProps {
+    items: TabItem[];
+    defaultValue?: string;
+    children: (api: ReturnType<typeof useTabs>) => React.ReactNode;
+    className?: string;
+}
+declare function Tabs({ items, defaultValue, children, className }: TabsProps): react_jsx_runtime.JSX.Element;
+declare function TabsList({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+interface TabsTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    isActive?: boolean;
+}
+declare function TabsTrigger({ isActive, className, ...props }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+declare function useAccordion(items: AccordionItemConfig[], config?: Omit<AccordionConfig, 'onValueChange'>): {
+    getItemProps: (value: string) => {
+        "data-value": string;
+    };
+    getTriggerProps: (value: string, expandedValues: string[]) => {
+        "aria-expanded": boolean;
+        "aria-controls": string;
+        id: string;
+        disabled: boolean;
+        onClick: () => void;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+    getContentProps: (value: string, expandedValues: string[]) => {
+        role: "region";
+        id: string;
+        "aria-labelledby": string;
+        hidden: boolean | undefined;
+    };
+    expandedValues: string[];
+    setExpandedValues: react.Dispatch<react.SetStateAction<string[]>>;
+};
+
+interface AccordionProps {
+    items: AccordionItemConfig[];
+    type?: AccordionConfig['type'];
+    collapsible?: boolean;
+    children: (api: ReturnType<typeof useAccordion>) => React.ReactNode;
+    className?: string;
+}
+declare function Accordion({ items, type, collapsible, children, className }: AccordionProps): react_jsx_runtime.JSX.Element;
+declare function AccordionItem({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+interface AccordionTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    isExpanded?: boolean;
+}
+declare function AccordionTrigger({ isExpanded, className, children, ...props }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
+declare function AccordionContent({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+declare function useSelect(options: SelectOption[], config?: Omit<SelectConfig, 'onValueChange' | 'onOpenChange'>): {
+    getTriggerProps: (isOpen: boolean, selectedValue: string | null, highlightedIndex?: number) => {
+        role: "combobox";
+        "aria-expanded": boolean;
+        "aria-haspopup": "listbox";
+        "aria-label": string;
+        "aria-activedescendant": string | undefined;
+        onClick: () => void | undefined;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+    getListProps: () => {
+        role: "listbox";
+    };
+    getOptionProps: (option: SelectOption, isHighlighted: boolean, selectedValue: string | null, _highlightedIndex: number) => {
+        role: "option";
+        "aria-selected": boolean;
+        "aria-disabled": true | undefined;
+        "data-highlighted": true | undefined;
+        id: string;
+        onClick: () => void;
+    };
+    getContentProps: (isOpen: boolean) => {
+        hidden: boolean | undefined;
+    };
+    isOpen: boolean;
+    setIsOpen: react.Dispatch<react.SetStateAction<boolean>>;
+    selectedValue: string | null;
+    setSelectedValue: react.Dispatch<react.SetStateAction<string | null>>;
+    highlightedIndex: number;
+    setHighlightedIndex: react.Dispatch<react.SetStateAction<number>>;
+    handleKeyDown: (e: React.KeyboardEvent) => void;
+};
+
+interface SelectProps {
+    options: SelectOption[];
+    placeholder?: string;
+    className?: string;
+    onChange?: (value: string) => void;
+}
+declare function Select({ options, placeholder, className, onChange }: SelectProps): react_jsx_runtime.JSX.Element;
+
+declare function useTooltip(config?: Omit<TooltipConfig, 'onOpenChange'>): {
+    getTriggerProps: () => {
+        "aria-describedby": string;
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+        onFocus: () => void;
+        onBlur: () => void;
+    };
+    getContentProps: (isOpen: boolean) => {
+        id: string;
+        role: "tooltip";
+        hidden: boolean | undefined;
+    };
+    destroy: () => void;
+    open: boolean;
+    setOpen: react.Dispatch<react.SetStateAction<boolean>>;
+};
+
+interface TooltipProps {
+    content: React.ReactNode;
+    delay?: number;
+    children: React.ReactElement;
+    className?: string;
+    side?: 'top' | 'bottom';
+}
+declare function Tooltip({ content, delay, children, className, side }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+declare function usePopover(config?: Omit<PopoverConfig, 'onOpenChange'>): {
+    getTriggerProps: (isOpen: boolean) => {
+        "aria-haspopup": true;
+        "aria-expanded": boolean;
+        onClick: () => void | undefined;
+    };
+    getContentProps: (isOpen: boolean) => {
+        role: "dialog";
+        hidden: true | undefined;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+    open: boolean;
+    setOpen: react.Dispatch<react.SetStateAction<boolean>>;
+};
+
+interface PopoverProps {
+    trigger: React.ReactNode;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function Popover({ trigger, children, className }: PopoverProps): react_jsx_runtime.JSX.Element;
+
+declare function useToast(): {
+    toasts: Toast[];
+    dismiss: (id: string) => void;
+    toast: {
+        default: (title: string, description?: string) => string;
+        success: (title: string, description?: string) => string;
+        destructive: (title: string, description?: string) => string;
+        custom: (t: Omit<Toast, "id">) => string;
+        dismiss: (id: string) => void;
+        subscribe: (listener: (state: _mcp_elements_core.ToastState) => void) => () => void;
+        getState: () => _mcp_elements_core.ToastState;
+    };
+};
+
+interface ToasterProps {
+    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+    className?: string;
+}
+declare function Toaster({ position, className }: ToasterProps): react_jsx_runtime.JSX.Element;
+
+declare function useDrawer(config?: Omit<DrawerConfig, 'onOpenChange'>): {
+    getOverlayProps: () => {
+        "aria-hidden": true;
+        onClick: () => void | undefined;
+    };
+    getContentProps: (isOpen: boolean) => {
+        role: "dialog";
+        "aria-modal": boolean;
+        hidden: boolean | undefined;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+    getCloseProps: () => {
+        "aria-label": string;
+        onClick: () => void | undefined;
+    };
+    side: "left" | "right" | "top" | "bottom";
+    open: boolean;
+    setOpen: react.Dispatch<react.SetStateAction<boolean>>;
+};
+
+interface DrawerProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: 'left' | 'right' | 'top' | 'bottom';
+    children: React.ReactNode;
+}
+declare function Drawer({ open: controlledOpen, onOpenChange, side, children }: DrawerProps): react_jsx_runtime.JSX.Element | null;
+declare function DrawerHeader({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DrawerFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+declare function DrawerTitle({ className, ...props }: React.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function DrawerDescription({ className, ...props }: React.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+declare function DrawerBody({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): react_jsx_runtime.JSX.Element;
+
+declare function useDropdownMenu(items: DropdownMenuItem[], config?: Omit<DropdownMenuConfig, 'onOpenChange'>): {
+    getTriggerProps: (isOpen: boolean) => {
+        "aria-haspopup": "menu";
+        "aria-expanded": boolean;
+        onClick: () => void | undefined;
+    };
+    getContentProps: (isOpen: boolean) => {
+        role: "menu";
+        hidden: true | undefined;
+    };
+    getItemProps: (item: DropdownMenuItem, isHighlighted: boolean) => {
+        role: "menuitem";
+        "aria-disabled": true | undefined;
+        "data-highlighted": true | undefined;
+        tabIndex: number;
+        onClick: () => void;
+    };
+    isOpen: boolean;
+    setIsOpen: react.Dispatch<react.SetStateAction<boolean>>;
+    highlightedIndex: number;
+    setHighlightedIndex: react.Dispatch<react.SetStateAction<number>>;
+    handleKeyDown: (e: React.KeyboardEvent) => void;
+};
+
+interface DropdownMenuProps {
+    trigger: React.ReactNode;
+    items: DropdownMenuItem[];
+    className?: string;
+    align?: 'start' | 'end';
+}
+declare function DropdownMenu({ trigger, items, className, align }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
+
+interface SwitchProps {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+    name?: string;
+}
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    value?: number;
+    max?: number;
+}
+declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
+
+interface LoaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    variant?: 'primary' | 'muted';
+}
+declare function Loader({ size, variant, className, ...props }: LoaderProps): react_jsx_runtime.JSX.Element;
+
+interface ChipProps extends React.HTMLAttributes<HTMLSpanElement> {
+    variant?: 'default' | 'primary' | 'outline' | 'destructive';
+    onRemove?: () => void;
+}
+declare function Chip({ variant, onRemove, className, children, ...props }: ChipProps): react_jsx_runtime.JSX.Element;
+interface ChipsProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare function Chips({ className, ...props }: ChipsProps): react_jsx_runtime.JSX.Element;
+
+interface PasswordInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type'> {
+}
+declare const PasswordInput: react.ForwardRefExoticComponent<PasswordInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface CounterProps {
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+}
+declare function Counter({ value, onChange, min, max, step, disabled, className }: CounterProps): react_jsx_runtime.JSX.Element;
+
+interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'destructive' | 'success' | 'warning';
+}
+declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;
+declare function AlertTitle({ className, ...props }: React.HTMLAttributes<HTMLHeadingElement>): react_jsx_runtime.JSX.Element;
+declare function AlertDescription({ className, ...props }: React.HTMLAttributes<HTMLParagraphElement>): react_jsx_runtime.JSX.Element;
+
+declare const PromptInput: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+interface PromptInputTextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const PromptInputTextarea: react.ForwardRefExoticComponent<PromptInputTextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+declare const PromptInputFooter: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const PromptInputActions: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+interface PromptInputCharCountProps {
+    count: number;
+    max?: number;
+    className?: string;
+}
+declare function PromptInputCharCount({ count, max, className }: PromptInputCharCountProps): react_jsx_runtime.JSX.Element;
+declare const PromptInputAttachments: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+interface PromptInputAttachmentProps extends React.HTMLAttributes<HTMLSpanElement> {
+    onRemove?: () => void;
+}
+declare function PromptInputAttachment({ onRemove, className, children, ...props }: PromptInputAttachmentProps): react_jsx_runtime.JSX.Element;
+
+interface ChatBubbleProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'user' | 'ai';
+}
+declare const ChatBubble: react.ForwardRefExoticComponent<ChatBubbleProps & react.RefAttributes<HTMLDivElement>>;
+interface ChatBubbleAvatarProps {
+    src: string;
+    alt: string;
+    className?: string;
+}
+declare function ChatBubbleAvatar({ src, alt, className }: ChatBubbleAvatarProps): react_jsx_runtime.JSX.Element;
+declare const ChatBubbleContent: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const ChatBubbleTimestamp: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLSpanElement> & react.RefAttributes<HTMLSpanElement>>;
+declare function ChatBubbleTyping({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+interface AiBadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    variant?: 'default' | 'prominent' | 'subtle';
+    showIcon?: boolean;
+}
+declare function AiBadge({ variant, showIcon, className, children, ...props }: AiBadgeProps): react_jsx_runtime.JSX.Element;
+
+interface SuggestionChipsProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const SuggestionChips: react.ForwardRefExoticComponent<SuggestionChipsProps & react.RefAttributes<HTMLDivElement>>;
+interface SuggestionChipProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'default' | 'primary' | 'outline';
+}
+declare const SuggestionChip: react.ForwardRefExoticComponent<SuggestionChipProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface SourceCardsProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const SourceCards: react.ForwardRefExoticComponent<SourceCardsProps & react.RefAttributes<HTMLDivElement>>;
+interface SourceCardProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    favicon?: string;
+    title: string;
+    domain: string;
+    index?: number;
+}
+declare const SourceCard: react.ForwardRefExoticComponent<SourceCardProps & react.RefAttributes<HTMLAnchorElement>>;
+
+interface StreamingTextProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const StreamingText: react.ForwardRefExoticComponent<StreamingTextProps & react.RefAttributes<HTMLDivElement>>;
+declare const StreamingTextFadeIn: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLSpanElement> & react.RefAttributes<HTMLSpanElement>>;
+declare const StreamingTextWord: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLSpanElement> & react.RefAttributes<HTMLSpanElement>>;
+declare const StreamingTextLine: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const StreamingTextSkeleton: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const StreamingTextSkeletonLine: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+
+declare const Feedback: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+interface FeedbackButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type'> {
+    type: 'up' | 'down';
+    selected?: boolean;
+}
+declare function FeedbackButton({ type, selected, className, ...props }: FeedbackButtonProps): react_jsx_runtime.JSX.Element;
+declare function FeedbackSeparator({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare const FeedbackForm: react.ForwardRefExoticComponent<react.HTMLAttributes<HTMLDivElement> & react.RefAttributes<HTMLDivElement>>;
+declare const FeedbackInput: react.ForwardRefExoticComponent<react.InputHTMLAttributes<HTMLInputElement> & react.RefAttributes<HTMLInputElement>>;
+declare const FeedbackSubmit: react.ForwardRefExoticComponent<react.ButtonHTMLAttributes<HTMLButtonElement> & react.RefAttributes<HTMLButtonElement>>;
+
+type McpConnectionStatus = 'connected' | 'connecting' | 'disconnected' | 'error';
+interface McpServerStatusProps extends react__default.HTMLAttributes<HTMLSpanElement> {
+    status: McpConnectionStatus;
+    serverName?: string;
+}
+declare function McpServerStatus({ status, serverName, className, ...props }: McpServerStatusProps): react_jsx_runtime.JSX.Element;
+
+interface McpToolCallProps {
+    state: ToolStateApi;
+    toolName?: string;
+    args?: Record<string, unknown>;
+    onRetry?: () => void;
+    className?: string;
+}
+declare function McpToolCall({ state, toolName, args, onRetry, className }: McpToolCallProps): react_jsx_runtime.JSX.Element;
+
+interface McpToolFormProps {
+    schema: JsonSchema;
+    onSubmit: (args: Record<string, unknown>) => void;
+    loading?: boolean;
+    submitLabel?: string;
+    className?: string;
+}
+declare function McpToolForm({ schema, onSubmit, loading, submitLabel, className, }: McpToolFormProps): react_jsx_runtime.JSX.Element;
+
+interface McpConsentDialogProps {
+    open: boolean;
+    serverName: string;
+    serverIcon?: string;
+    scopes: string[];
+    onApprove: () => void;
+    onDeny: () => void;
+    className?: string;
+}
+declare function McpConsentDialog({ open, serverName, serverIcon, scopes, onApprove, onDeny, className, }: McpConsentDialogProps): react_jsx_runtime.JSX.Element;
+
+interface McpScopeInspectorProps {
+    /** Space-separated scope string OR pre-parsed array */
+    scopes: string | ScopeDescriptor[];
+    /** Human-readable descriptions keyed by scope raw string or resource */
+    descriptions?: Record<string, string>;
+    className?: string;
+}
+declare function McpScopeInspector({ scopes, descriptions, className }: McpScopeInspectorProps): react_jsx_runtime.JSX.Element;
+
+interface McpResource {
+    uri: string;
+    name: string;
+    mimeType?: string;
+    description?: string;
+}
+interface McpResourceBrowserProps {
+    resources: McpResource[];
+    selectedUri?: string;
+    onSelect?: (resource: McpResource) => void;
+    loading?: boolean;
+    className?: string;
+}
+declare function McpResourceBrowser({ resources, selectedUri, onSelect, loading, className, }: McpResourceBrowserProps): react_jsx_runtime.JSX.Element;
+
+interface McpAppFrameProps {
+    /** URL of the MCP App to load */
+    src: string;
+    /** Called when the app sends a message via postMessage */
+    onMessage?: (envelope: AppMessageEnvelope) => void;
+    /** Height of the iframe in pixels */
+    height?: number;
+    /** Additional iframe sandbox flags */
+    sandbox?: string;
+    className?: string;
+}
+declare function McpAppFrame({ src, onMessage, height, sandbox, className, }: McpAppFrameProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * React hook that wraps a ToolStateApi instance.
+ * Provides reactive access to tool call state.
+ */
+declare function useMcpToolState(): ToolStateSnapshot & ToolStateApi;
+
+/**
+ * React hook that wraps an OAuthFlowApi instance.
+ * Manages PKCE OAuth 2.1 flow state.
+ */
+declare function useMcpOAuth(): OAuthFlowSnapshot & OAuthFlowApi;
+
+interface UseMcpAppBridgeOptions {
+    /** Called when a message arrives from the iframe */
+    onMessage?: (envelope: AppMessageEnvelope) => void;
+}
+interface UseMcpAppBridgeReturn {
+    /** Send a message to the iframe */
+    send: (envelope: AppMessageEnvelope) => void;
+    /** Assign to <iframe ref={...}> */
+    frameRef: React.RefObject<HTMLIFrameElement | null>;
+}
+/**
+ * React hook that sets up a postMessage bridge with an MCP App iframe.
+ * Wire it up: <iframe ref={frameRef} src={...} />
+ *
+ * onMessage is stored in a ref so inline callbacks don't recreate the bridge.
+ */
+declare function useMcpAppBridge(options?: UseMcpAppBridgeOptions): UseMcpAppBridgeReturn;
+
+interface UseMcpSchemaFormReturn {
+    /** Derived field descriptors from the JSON Schema */
+    fields: FieldDescriptor[];
+    /** Current form values */
+    values: Record<string, unknown>;
+    /** Update a single field value (stable reference) */
+    setValue: (key: string, value: unknown) => void;
+    /** Reset values to defaults (stable when fields are unchanged) */
+    reset: () => void;
+}
+/**
+ * React hook that converts a JSON Schema into form field descriptors
+ * and manages form state.
+ */
+declare function useMcpSchemaForm(schema: JsonSchema): UseMcpSchemaFormReturn;
+
+export { Accordion, AccordionContent, AccordionItem, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, AiBadge, type AiBadgeProps, Alert, AlertDescription, type AlertProps, AlertTitle, Avatar, type AvatarProps, Badge, type BadgeProps, Button, type ButtonProps, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, ChatBubble, ChatBubbleAvatar, type ChatBubbleAvatarProps, ChatBubbleContent, type ChatBubbleProps, ChatBubbleTimestamp, ChatBubbleTyping, Chip, type ChipProps, Chips, type ChipsProps, Counter, type CounterProps, Dialog, DialogDescription, DialogFooter, DialogHeader, type DialogProps, DialogTitle, Drawer, DrawerBody, DrawerDescription, DrawerFooter, DrawerHeader, type DrawerProps, DrawerTitle, DropdownMenu, type DropdownMenuProps, Feedback, FeedbackButton, type FeedbackButtonProps, FeedbackForm, FeedbackInput, FeedbackSeparator, FeedbackSubmit, Input, type InputProps, Loader, type LoaderProps, McpAppFrame, type McpAppFrameProps, type McpConnectionStatus, McpConsentDialog, type McpConsentDialogProps, type McpResource, McpResourceBrowser, type McpResourceBrowserProps, McpScopeInspector, type McpScopeInspectorProps, McpServerStatus, type McpServerStatusProps, McpToolCall, type McpToolCallProps, McpToolForm, type McpToolFormProps, PasswordInput, type PasswordInputProps, Popover, type PopoverProps, Progress, type ProgressProps, PromptInput, PromptInputActions, PromptInputAttachment, type PromptInputAttachmentProps, PromptInputAttachments, PromptInputCharCount, type PromptInputCharCountProps, PromptInputFooter, PromptInputTextarea, type PromptInputTextareaProps, Select, type SelectProps, Separator, type SeparatorProps, Skeleton, type SkeletonProps, SourceCard, type SourceCardProps, SourceCards, type SourceCardsProps, StreamingText, StreamingTextFadeIn, StreamingTextLine, type StreamingTextProps, StreamingTextSkeleton, StreamingTextSkeletonLine, StreamingTextWord, SuggestionChip, type SuggestionChipProps, SuggestionChips, type SuggestionChipsProps, Switch, type SwitchProps, Tabs, TabsContent, TabsList, type TabsProps, TabsTrigger, type TabsTriggerProps, Textarea, type TextareaProps, Toaster, type ToasterProps, Tooltip, type TooltipProps, type UseMcpAppBridgeOptions, type UseMcpAppBridgeReturn, type UseMcpSchemaFormReturn, useAccordion, useDialog, useDrawer, useDropdownMenu, useMcpAppBridge, useMcpOAuth, useMcpSchemaForm, useMcpToolState, usePopover, useSelect, useTabs, useToast, useTooltip };