export { ConfigProvider, ConfigProviderProps, Locale, Messages, ThemeProvider, ThemeProviderProps, TimeUIConfig, useConfig, useI18n, useTheme } from '@timeui/core';
export { ThemeMode, TimeUITheme, darkTheme, lightTheme, themes } from '@timeui/themes';
import * as react from 'react';
import { ElementType, ReactNode, Ref, ComponentPropsWithRef, ReactElement, HTMLAttributes, ButtonHTMLAttributes, CSSProperties, AnchorHTMLAttributes, InputHTMLAttributes, TextareaHTMLAttributes, MouseEvent, FC, MouseEventHandler } from 'react';
import * as _emotion_react_jsx_runtime from '@emotion/react/jsx-runtime';

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 定义 Button 模块的 TypeScript 类型约束。
 */

type ButtonVariant = 'solid' | 'bordered' | 'light' | 'flat' | 'faded' | 'shadow' | 'ghost' | 'primary' | 'secondary' | 'outline' | 'danger';
type ButtonColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type ButtonRadius = 'sm' | 'md' | 'lg' | 'full';
interface ButtonOwnProps {
    variant?: ButtonVariant;
    color?: ButtonColor;
    size?: ButtonSize;
    radius?: ButtonRadius;
    isLoading?: boolean;
    isDisabled?: boolean;
    isFullWidth?: boolean;
    /**
     * Render as a square icon-only button: width = height, no min-width and no
     * inner padding. Pass the icon either as `children` or via `startIcon`. When
     * enabled, `aria-label` (or `aria-labelledby`) is required for accessibility.
     */
    isIconOnly?: boolean;
    startIcon?: ReactNode;
    endIcon?: ReactNode;
    children?: ReactNode;
}
type ButtonProps<C extends ElementType = 'button'> = ButtonOwnProps & {
    as?: C;
    ref?: Ref<Element>;
} & Omit<ComponentPropsWithRef<C>, keyof ButtonOwnProps | 'as'>;

/** @jsxImportSource @emotion/react */
/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 实现 Button 组件的核心渲染与交互逻辑。
 */

declare const Button: <C extends ElementType = "button">(props: ButtonProps<C>) => ReactElement;

type CalloutVariant = 'info' | 'success' | 'warning' | 'danger' | 'tip';
interface CalloutProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
    variant?: CalloutVariant;
    title?: ReactNode;
    icon?: ReactNode | false;
    children: ReactNode;
}
declare const Callout: react.ForwardRefExoticComponent<CalloutProps & react.RefAttributes<HTMLDivElement>>;

type SearchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type SearchVariant = 'bordered' | 'flat';
interface SearchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
    placeholder?: string;
    shortcut?: string;
    size?: SearchSize;
    variant?: SearchVariant;
    icon?: ReactNode;
    isFullWidth?: boolean;
}
declare const Search: react.ForwardRefExoticComponent<SearchProps & react.RefAttributes<HTMLButtonElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Search 组件族的共享 TypeScript 类型。
 */

/** 单条搜索结果。 */
interface SearchDialogItem {
    /** 唯一标识。 */
    id: string;
    /** 主标签。 */
    label: ReactNode;
    /** 右侧辅助文本（如 URL、快捷键）。 */
    hint?: ReactNode;
    /** 左侧图标。 */
    icon?: ReactNode;
    /** 链接地址（提供时点击会优先走 onSelect，但消费方可基于此做导航）。 */
    href?: string;
    /** 单项禁用。 */
    isDisabled?: boolean;
    /** 用户自定义的额外字段（透传到 onSelect）。 */
    [key: string]: unknown;
}
/** 一组带标题的搜索结果。 */
interface SearchDialogSection {
    id: string;
    /** 区段标题（缺省则只渲染条目）。 */
    title?: ReactNode;
    items: ReadonlyArray<SearchDialogItem>;
}
interface SearchDialogCommonStyleProps {
    className?: string;
    style?: CSSProperties;
    id?: string;
}
interface SearchDialogProps extends SearchDialogCommonStyleProps {
    /** 受控打开状态。 */
    isOpen?: boolean;
    /** 非受控初始打开状态。 */
    defaultOpen?: boolean;
    /** 打开 / 关闭回调。 */
    onOpenChange?: (open: boolean) => void;
    /** 扁平列表。`sections` 优先于 `items`。 */
    items?: ReadonlyArray<SearchDialogItem>;
    /** 分组列表。 */
    sections?: ReadonlyArray<SearchDialogSection>;
    /** 受控查询字符串（用于异步搜索的常见场景）。 */
    query?: string;
    /** 非受控初始查询。 */
    defaultQuery?: string;
    /** 查询变化回调。 */
    onQueryChange?: (query: string) => void;
    /**
     * 自定义过滤函数。默认对 `label`（字符串化后）做大小写无关的子串匹配。
     * 当父组件已经做了远端过滤时返回 `() => true` 即可禁用本地过滤。
     */
    filter?: (item: SearchDialogItem, query: string) => boolean;
    /** 选中条目时触发（点击或 Enter）。 */
    onSelect?: (item: SearchDialogItem) => void;
    /** 选中后是否自动关闭对话框。默认 true。 */
    closeOnSelect?: boolean;
    /**
     * 全局快捷键，组件内置监听并切换 isOpen。
     * 支持简单语法：`mod+k`（mac=⌘ / 其它=Ctrl）/ `ctrl+k` / `alt+/` / `escape` 等。
     * 不传则不绑定。
     */
    shortcut?: string;
    placeholder?: string;
    emptyMessage?: ReactNode;
    /** 是否显示加载状态。 */
    isLoading?: boolean;
    loadingMessage?: ReactNode;
    /** 是否在输入框右侧显示 ESC chip。默认 true。 */
    showEscapeKey?: boolean;
    /** 自定义 ESC chip 文本。默认 'ESC'。 */
    escapeKeyLabel?: ReactNode;
    /** 底部状态栏。传入 false 隐藏；传入 ReactNode 替换默认快捷键提示。 */
    footer?: ReactNode | false;
    /** 自定义条目渲染。覆盖默认 (icon + label + hint) 布局。 */
    renderItem?: (item: SearchDialogItem, options: {
        isHighlighted: boolean;
        isDisabled: boolean;
    }) => ReactNode;
    /** 对话框宽度。默认 'min(620px, 92vw)'。 */
    width?: string | number;
    /** 结果列表最大高度（超过滚动）。默认 'min(420px, 52vh)'。 */
    maxListHeight?: string | number;
    /** 距离视口顶部的距离；不传时默认垂直居中，传入后切换为顶部偏移定位。 */
    topOffset?: string | number;
    'aria-label'?: string;
}

declare const SearchDialog: react.ForwardRefExoticComponent<SearchDialogProps & react.RefAttributes<HTMLDivElement>>;

type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type TextWeight = 'regular' | 'medium' | 'semibold' | 'bold';
interface TextProps extends HTMLAttributes<HTMLSpanElement> {
    size?: TextSize;
    weight?: TextWeight;
    isMuted?: boolean;
    isTruncated?: boolean;
}
declare const Text: react.ForwardRefExoticComponent<TextProps & react.RefAttributes<HTMLSpanElement>>;
interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
    level?: 1 | 2 | 3 | 4 | 5 | 6;
}
declare const Heading: react.ForwardRefExoticComponent<HeadingProps & react.RefAttributes<HTMLHeadingElement>>;
declare const Paragraph: react.ForwardRefExoticComponent<HTMLAttributes<HTMLParagraphElement> & react.RefAttributes<HTMLParagraphElement>>;
declare const Link: react.ForwardRefExoticComponent<AnchorHTMLAttributes<HTMLAnchorElement> & react.RefAttributes<HTMLAnchorElement>>;
declare const Code: react.ForwardRefExoticComponent<HTMLAttributes<HTMLElement> & react.RefAttributes<HTMLElement>>;

/** @jsxImportSource @emotion/react */
/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 实现 Layout 组件的核心渲染与交互逻辑。
 */

type SxProp = CSSProperties;
type PolyProps<C extends ElementType, P> = P & {
    as?: C;
    sx?: SxProp;
} & Omit<ComponentPropsWithRef<C>, keyof P | 'as'>;
type BoxProps<C extends ElementType = 'div'> = PolyProps<C, {}>;
declare const Box: <C extends ElementType = "div">(p: BoxProps<C>) => react.ReactElement;
interface FlexOwnProps {
    direction?: CSSProperties['flexDirection'];
    align?: CSSProperties['alignItems'];
    justify?: CSSProperties['justifyContent'];
    wrap?: CSSProperties['flexWrap'];
    gap?: number | string;
}
type FlexProps<C extends ElementType = 'div'> = PolyProps<C, FlexOwnProps>;
declare const Flex: <C extends ElementType = "div">(p: FlexProps<C>) => react.ReactElement;
interface GridOwnProps {
    columns?: number | string;
    gap?: number | string;
    rowGap?: number | string;
    columnGap?: number | string;
}
type GridProps<C extends ElementType = 'div'> = PolyProps<C, GridOwnProps>;
declare const Grid: <C extends ElementType = "div">(p: GridProps<C>) => react.ReactElement;
interface StackOwnProps {
    direction?: 'row' | 'column';
    spacing?: number | string;
    align?: CSSProperties['alignItems'];
    justify?: CSSProperties['justifyContent'];
}
type StackProps<C extends ElementType = 'div'> = PolyProps<C, StackOwnProps>;
declare const Stack: <C extends ElementType = "div">(p: StackProps<C>) => react.ReactElement;
interface ContainerOwnProps {
    maxWidth?: number | string;
    isPadded?: boolean;
}
type ContainerProps<C extends ElementType = 'div'> = PolyProps<C, ContainerOwnProps>;
declare const Container: <C extends ElementType = "div">(p: ContainerProps<C>) => react.ReactElement;

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 定义 FormField 模块的 TypeScript 类型约束。
 */

type FormFieldLabelPlacement = 'top' | 'start';
interface FormFieldInjectedChildProps {
    id?: string;
    'aria-describedby'?: string;
    'aria-invalid'?: boolean;
    'aria-required'?: boolean;
    required?: boolean;
    isDisabled?: boolean;
    isInvalid?: boolean;
    isRequired?: boolean;
}
interface FormFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
    label?: ReactNode;
    labelPlacement?: FormFieldLabelPlacement;
    description?: ReactNode;
    errorMessage?: ReactNode;
    isRequired?: boolean;
    isInvalid?: boolean;
    isDisabled?: boolean;
    id?: string;
    children: ReactElement;
}

declare const FormField: react.ForwardRefExoticComponent<FormFieldProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 实现 Utils 组件的核心渲染与交互逻辑。
 */

type FieldVariant = 'flat' | 'bordered' | 'faded' | 'underlined';
type FieldColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 定义 Input 模块的 TypeScript 类型约束。
 */

type InputVariant = FieldVariant;
type InputColor = FieldColor;
type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type InputRadius = 'sm' | 'md' | 'lg' | 'full';
type InputType = 'text' | 'email' | 'url' | 'tel' | 'password' | 'search' | 'number';
type StrippedNativeKeys$2 = 'value' | 'defaultValue' | 'onChange' | 'size' | 'type' | 'disabled' | 'readOnly' | 'required';
interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, StrippedNativeKeys$2> {
    variant?: InputVariant;
    color?: InputColor;
    size?: InputSize;
    radius?: InputRadius;
    type?: InputType;
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    onClear?: () => void;
    label?: ReactNode;
    description?: ReactNode;
    errorMessage?: ReactNode;
    startContent?: ReactNode;
    endContent?: ReactNode;
    isClearable?: boolean;
    clearOnEsc?: boolean;
    clearButtonTabIndex?: number;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isRequired?: boolean;
    isInvalid?: boolean;
    showPasswordToggle?: boolean;
    isFullWidth?: boolean;
    className?: string;
    style?: CSSProperties;
}

declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 定义 Textarea 模块的 TypeScript 类型约束。
 */

type TextareaVariant = FieldVariant;
type TextareaColor = FieldColor;
type TextareaSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type TextareaRadius = 'sm' | 'md' | 'lg' | 'full';
type StrippedNativeKeys$1 = 'value' | 'defaultValue' | 'onChange' | 'size' | 'disabled' | 'readOnly' | 'required' | 'rows';
interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, StrippedNativeKeys$1> {
    variant?: TextareaVariant;
    color?: TextareaColor;
    size?: TextareaSize;
    radius?: TextareaRadius;
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    label?: ReactNode;
    description?: ReactNode;
    errorMessage?: ReactNode;
    startContent?: ReactNode;
    endContent?: ReactNode;
    rows?: number;
    minRows?: number;
    maxRows?: number;
    isAutoSize?: boolean;
    showCount?: boolean;
    maxLength?: number;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isRequired?: boolean;
    isInvalid?: boolean;
    isFullWidth?: boolean;
    className?: string;
    style?: CSSProperties;
}

declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 定义 Checkbox 模块的 TypeScript 类型约束。
 */

type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type CheckboxRadius = 'sm' | 'md';
type CheckboxColor = ButtonColor;
type CheckboxGroupOrientation = 'horizontal' | 'vertical';
type OmittedNativeCheckboxProps = 'size' | 'type' | 'value' | 'checked' | 'defaultChecked' | 'onChange' | 'disabled' | 'readOnly' | 'required' | 'color';
interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, OmittedNativeCheckboxProps> {
    color?: CheckboxColor;
    size?: CheckboxSize;
    radius?: CheckboxRadius;
    value?: string;
    isSelected?: boolean;
    defaultIsSelected?: boolean;
    isIndeterminate?: boolean;
    onChange?: (checked: boolean) => void;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isRequired?: boolean;
    isInvalid?: boolean;
    children?: ReactNode;
    name?: string;
}
interface CheckboxGroupProps {
    label?: ReactNode;
    description?: ReactNode;
    errorMessage?: ReactNode;
    isRequired?: boolean;
    isInvalid?: boolean;
    isDisabled?: boolean;
    orientation?: CheckboxGroupOrientation;
    value?: string[];
    defaultValue?: string[];
    onChange?: (value: string[]) => void;
    color?: CheckboxColor;
    size?: CheckboxSize;
    radius?: CheckboxRadius;
    name?: string;
    id?: string;
    className?: string;
    style?: React.CSSProperties;
    children?: ReactNode;
}

declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;

declare const CheckboxGroup: react.ForwardRefExoticComponent<CheckboxGroupProps & react.RefAttributes<HTMLFieldSetElement>>;

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 定义 Radio 模块的 TypeScript 类型约束。
 */

type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type RadioColor = ButtonColor;
type RadioGroupOrientation = 'horizontal' | 'vertical';
type OmittedNativeRadioProps = 'size' | 'type' | 'value' | 'checked' | 'defaultChecked' | 'onChange' | 'disabled' | 'readOnly' | 'required' | 'color' | 'name';
interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, OmittedNativeRadioProps> {
    value: string;
    color?: RadioColor;
    size?: RadioSize;
    children?: ReactNode;
    description?: ReactNode;
    isDisabled?: boolean;
}
interface RadioGroupProps {
    label?: ReactNode;
    description?: ReactNode;
    errorMessage?: ReactNode;
    isRequired?: boolean;
    isInvalid?: boolean;
    isDisabled?: boolean;
    orientation?: RadioGroupOrientation;
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    color?: RadioColor;
    size?: RadioSize;
    name?: string;
    id?: string;
    className?: string;
    style?: React.CSSProperties;
    children?: ReactNode;
}

declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;

declare const RadioGroup: react.ForwardRefExoticComponent<RadioGroupProps & react.RefAttributes<HTMLFieldSetElement>>;

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 定义 Switch 模块的 TypeScript 类型约束。
 */

type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type SwitchColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
type InputPassthrough = Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'onChange' | 'value' | 'type' | 'role' | 'aria-checked' | 'checked' | 'defaultChecked' | 'children'>;
interface SwitchProps extends InputPassthrough {
    color?: SwitchColor;
    size?: SwitchSize;
    isSelected?: boolean;
    defaultIsSelected?: boolean;
    onChange?: (checked: boolean) => void;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isRequired?: boolean;
    isInvalid?: boolean;
    startContent?: ReactNode;
    endContent?: ReactNode;
    children?: ReactNode;
    value?: string;
    name?: string;
    className?: string;
    style?: React.CSSProperties;
}

declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Slider 模块的 TypeScript 类型约束。
 */

type SliderSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type SliderColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
type SliderOrientation = 'horizontal' | 'vertical';
/** 单值或范围（[min, max]）。是否为范围模式由 value/defaultValue 是否为数组推断。 */
type SliderValue = number | [number, number];
interface SliderProps {
    color?: SliderColor;
    size?: SliderSize;
    orientation?: SliderOrientation;
    min?: number;
    max?: number;
    step?: number;
    value?: SliderValue;
    defaultValue?: SliderValue;
    onChange?: (value: SliderValue) => void;
    /** 拖拽结束 / 键盘释放后触发，常用于"提交一次"的场景。 */
    onChangeEnd?: (value: SliderValue) => void;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isRequired?: boolean;
    isInvalid?: boolean;
    /** 顶部主标题（横向）/ 底部标题（纵向）。 */
    label?: ReactNode;
    /** 是否显示当前值；默认 false。 */
    showValue?: boolean;
    /** 自定义值的展示。范围模式接收 [a, b]。 */
    formatValue?: (value: SliderValue) => string;
    /** 横向时位于轨道左侧；纵向时位于上方。 */
    startContent?: ReactNode;
    /** 横向时位于轨道右侧；纵向时位于下方。 */
    endContent?: ReactNode;
    /** 单值模式提交字段名。 */
    name?: string;
    /** 范围模式：起始值字段名。 */
    minName?: string;
    /** 范围模式：结束值字段名。 */
    maxName?: string;
    /** 显式覆盖轨道长度，横向是 width，纵向是 height。 */
    trackLength?: string | number;
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-describedby'?: string;
}

declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 SegmentedControl 模块的 TypeScript 类型约束。
 */

type SegmentedControlSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type SegmentedControlColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
type SegmentedControlOrientation = 'horizontal' | 'vertical';
/** 单个分段配置：值 + 文本（可选图标 / 禁用 / 仅图标的可访问名）。 */
interface SegmentedControlOption<V extends string = string> {
    value: V;
    label: ReactNode;
    /** 文本前的图标（横向模式置于左侧）。 */
    icon?: ReactNode;
    /** 单独禁用该项。整体禁用请用顶层 `isDisabled`。 */
    isDisabled?: boolean;
    /** 当 `label` 为图标时提供可访问名。 */
    'aria-label'?: string;
}
interface SegmentedControlProps<V extends string = string> {
    /** 分段选项。顺序决定 indicator 位置。 */
    options: ReadonlyArray<SegmentedControlOption<V>>;
    value?: V;
    defaultValue?: V;
    onChange?: (value: V) => void;
    color?: SegmentedControlColor;
    size?: SegmentedControlSize;
    orientation?: SegmentedControlOrientation;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    isInvalid?: boolean;
    isRequired?: boolean;
    /** 横向时撑满父容器宽度。默认 false（按内容自适应）。 */
    isFullWidth?: boolean;
    /** 关联文本标签，渲染在控件上方（横向）/ 上方（纵向）。 */
    label?: ReactNode;
    /** 表单提交字段名（每个 segment 是同名 radio）。 */
    name?: string;
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-describedby'?: string;
}

/** @jsxImportSource @emotion/react */

declare const SegmentedControl: <V extends string = string>(props: SegmentedControlProps<V> & {
    ref?: React.Ref<HTMLDivElement>;
}) => React.ReactElement;

/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 定义 Select 模块的 TypeScript 类型约束。
 */

type SelectSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type SelectRadius = 'sm' | 'md' | 'lg' | 'full';
interface SelectItem {
    value: string;
    label: ReactNode;
    isDisabled?: boolean;
    description?: ReactNode;
}
type SelectPassthrough = Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'size' | 'onChange' | 'value' | 'defaultValue' | 'children' | 'type' | 'role' | 'disabled'>;
interface SelectProps extends SelectPassthrough {
    variant?: FieldVariant;
    color?: FieldColor;
    size?: SelectSize;
    radius?: SelectRadius;
    isFullWidth?: boolean;
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    placeholder?: string;
    items?: SelectItem[];
    children?: ReactNode;
    label?: ReactNode;
    description?: ReactNode;
    errorMessage?: ReactNode;
    isRequired?: boolean;
    isInvalid?: boolean;
    isDisabled?: boolean;
    startContent?: ReactNode;
    endContent?: ReactNode;
    isSearchable?: boolean;
    searchPlaceholder?: string;
    emptyMessage?: ReactNode;
    maxListHeight?: number | string;
    name?: string;
    className?: string;
    style?: CSSProperties;
}
interface SelectOptionProps {
    value: string;
    children?: ReactNode;
    isDisabled?: boolean;
    description?: ReactNode;
}

declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLButtonElement>>;

/** @jsxImportSource @emotion/react */
/**
 * @author Ryan He
 * @date 2026-04-16
 * @description 实现 Select 组件的核心渲染与交互逻辑。
 */

declare const SelectOption: (_props: SelectOptionProps) => null;

/**
 * @author Ryan He
 * @date 2026-04-18
 * @description 定义 Upload 模块的 TypeScript 类型约束。
 */

type UploadFileStatus = 'ready' | 'uploading' | 'success' | 'error' | 'removed';
interface UploadFile {
    id: string;
    name: string;
    size: number;
    type: string;
    status: UploadFileStatus;
    percent?: number;
    file?: File;
    previewUrl?: string;
    response?: unknown;
    error?: Error;
}
type UploadRejectReason = 'accept' | 'size' | 'count' | 'duplicate' | 'before-upload';
interface UploadRejection {
    file: File;
    reason: UploadRejectReason;
    message?: string;
}
interface UploadRequestHandlers {
    onProgress: (percent: number) => void;
    onSuccess: (response?: unknown) => void;
    onError: (error: Error) => void;
}
interface UploadRequestArgs {
    file: File;
    uploadFile: Readonly<UploadFile>;
    signal: AbortSignal;
}
type UploadRequest = (args: UploadRequestArgs, handlers: UploadRequestHandlers) => void | Promise<void> | (() => void);
type UploadVariant = 'button' | 'dropzone';
type UploadSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type UploadColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
type UploadRadius = 'sm' | 'md' | 'lg' | 'full';
type UploadListPosition = 'bottom' | 'top' | 'none';
interface UploadChangeMeta {
    trigger: 'add' | 'update' | 'remove' | 'reset';
    file?: UploadFile;
}
interface UploadHandle {
    open: () => void;
    submit: (ids?: string[]) => void;
    retry: (id: string) => void;
    abort: (id: string) => void;
    clear: () => void;
}
interface UploadClassNames {
    root?: string;
    trigger?: string;
    dropzone?: string;
    list?: string;
    item?: string;
    itemName?: string;
    itemSize?: string;
    itemProgress?: string;
    itemActions?: string;
    removeButton?: string;
    retryButton?: string;
}
type StrippedNativeKeys = 'onChange' | 'onDrop' | 'onDragEnter' | 'onDragLeave' | 'onDragOver' | 'children' | 'defaultValue';
interface UploadProps extends Omit<HTMLAttributes<HTMLDivElement>, StrippedNativeKeys> {
    value?: UploadFile[];
    defaultValue?: UploadFile[];
    onChange?: (value: UploadFile[], meta: UploadChangeMeta) => void;
    variant?: UploadVariant;
    size?: UploadSize;
    color?: UploadColor;
    radius?: UploadRadius;
    isFullWidth?: boolean;
    accept?: string;
    multiple?: boolean;
    maxSize?: number;
    maxCount?: number;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    customRequest?: UploadRequest;
    concurrency?: number;
    isAutoUpload?: boolean;
    beforeUpload?: (file: File, fileList: File[]) => boolean | Promise<boolean>;
    onReject?: (rejections: UploadRejection[]) => void;
    onRemove?: (file: UploadFile) => boolean | Promise<boolean> | void;
    allowDuplicates?: boolean;
    trigger?: ReactNode;
    dropzoneContent?: ReactNode | ((state: {
        isDragging: boolean;
        isRejecting: boolean;
    }) => ReactNode);
    showFileList?: boolean;
    renderItem?: (file: UploadFile, actions: {
        remove: () => void;
        retry: () => void;
    }) => ReactNode;
    emptyContent?: ReactNode;
    listPosition?: UploadListPosition;
    onUploadProgress?: (file: UploadFile, percent: number) => void;
    onUploadComplete?: (value: UploadFile[]) => void;
    dropzoneHeight?: number | string;
    disableClickToUpload?: boolean;
    disableDragAndDrop?: boolean;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-describedby'?: string;
    id?: string;
    label?: ReactNode;
    description?: ReactNode;
    errorMessage?: ReactNode;
    isRequired?: boolean;
    isInvalid?: boolean;
    name?: string;
    className?: string;
    style?: CSSProperties;
    classNames?: UploadClassNames;
}
interface UploadListProps extends HTMLAttributes<HTMLUListElement> {
    value: UploadFile[];
    onRemove?: (file: UploadFile) => void;
    onRetry?: (file: UploadFile) => void;
    renderItem?: (file: UploadFile, actions: {
        remove: () => void;
        retry: () => void;
    }) => ReactNode;
    size?: UploadSize;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    emptyContent?: ReactNode;
    classNames?: UploadClassNames;
}
interface UploadItemProps extends HTMLAttributes<HTMLLIElement> {
    file: UploadFile;
    onRemove?: (file: UploadFile) => void;
    onRetry?: (file: UploadFile) => void;
    size?: UploadSize;
    isDisabled?: boolean;
    isReadOnly?: boolean;
    classNames?: UploadClassNames;
}

declare const Upload: react.ForwardRefExoticComponent<UploadProps & react.RefAttributes<UploadHandle>>;

declare const UploadList: react.ForwardRefExoticComponent<UploadListProps & react.RefAttributes<HTMLUListElement>>;

declare const UploadItem: react.ForwardRefExoticComponent<UploadItemProps & react.RefAttributes<HTMLLIElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Chat 组件族的共享 TypeScript 类型。
 */

/** 消息角色：5 种内置 + 字符串扩展位以兼容自定义角色。 */
type ChatMessageRole = 'user' | 'assistant' | 'system' | 'tool' | 'knowledge' | (string & {});
/** 工具调用执行状态。 */
type ChatToolCallStatus = 'pending' | 'running' | 'success' | 'error';
/** 知识库引用条目。 */
interface ChatKnowledgeReference {
    id: string;
    /** 来源短标题（chip 上展示的文字）。 */
    title: string;
    /** 长标题或片段，hover/详情场景。 */
    snippet?: string;
    /** 跳转链接（可选）。 */
    href?: string;
    /** 文档来源类别（如 'pdf' / 'web' / 'note'）。 */
    source?: string;
}
/** 工具调用数据，用于驱动 ChatToolCall 卡片。 */
interface ChatToolCallData {
    /** 工具名（函数名）。 */
    name: string;
    /** 调用参数（结构化对象或已格式化字符串）。 */
    arguments?: unknown;
    /** 调用结果（结构化对象或字符串）。 */
    result?: unknown;
    status: ChatToolCallStatus;
    /** 错误信息，status='error' 时显示。 */
    error?: string;
}
/** 头像可接受的 source：图片 URL / 文字（首字母）/ 自定义节点。 */
type ChatAvatarSource = {
    kind: 'image';
    src: string;
    alt?: string;
} | {
    kind: 'text';
    text: string;
} | {
    kind: 'node';
    node: ReactNode;
};
/** 公共可选样式钩子。 */
interface ChatCommonStyleProps {
    className?: string;
    style?: CSSProperties;
    id?: string;
}

type ChatAvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface ChatAvatarProps extends ChatCommonStyleProps {
    /** 头像 source：image / text / node。 */
    source: ChatAvatarSource;
    /** 尺寸：xs 20px、sm 24px、md = tokens.avatarSize、lg 40px、xl 48px。 */
    size?: ChatAvatarSize;
    /** 角色，用于着色背景 tint。 */
    role?: ChatMessageRole;
    /** 无障碍标签（image 会覆盖 alt）。 */
    'aria-label'?: string;
}
declare const ChatAvatar: react.ForwardRefExoticComponent<ChatAvatarProps & react.RefAttributes<HTMLSpanElement>>;

type ChatTypingIndicatorSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface ChatTypingIndicatorProps extends ChatCommonStyleProps {
    /** 尺寸：xs / sm / md / lg / xl，默认 md。 */
    size?: ChatTypingIndicatorSize;
    /** ARIA-live 公告文本，默认 "AI is typing"。 */
    label?: string;
}
declare const ChatTypingIndicator: react.ForwardRefExoticComponent<ChatTypingIndicatorProps & react.RefAttributes<HTMLSpanElement>>;

type ChatVoiceWaveSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type ChatVoiceWaveColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
interface ChatVoiceWaveProps extends ChatCommonStyleProps {
    /** 是否激活动画。inactive 时 bars 静止在最小高度。默认 true。 */
    isActive?: boolean;
    /** Bar 数量，奇数视觉对称更好。默认 4。 */
    bars?: number;
    /** 配色。默认 primary。 */
    color?: ChatVoiceWaveColor;
    /** 尺寸：xs / sm / md / lg / xl。默认 md。 */
    size?: ChatVoiceWaveSize;
    /** 屏幕阅读器朗读文本，默认 "Recording"。 */
    'aria-label'?: string;
}
declare const ChatVoiceWave: react.ForwardRefExoticComponent<ChatVoiceWaveProps & react.RefAttributes<HTMLDivElement>>;

interface ChatMessageProps extends ChatCommonStyleProps {
    /** 消息角色。 */
    role: ChatMessageRole;
    /** 显示在气泡上方的名称（如 "Claude"、"Ryan"）。 */
    name?: ReactNode;
    /** Avatar source 覆盖；省略时根据 name 派生首字母（user / assistant）。 */
    avatar?: ChatAvatarSource;
    /** 是否渲染 avatar 槽位。默认：user / assistant 为 true，system 为 false。 */
    showAvatar?: boolean;
    /** 时间戳，可传 Date / number(ms) / string。 */
    timestamp?: Date | number | string;
    /** 流式标志：在内容末尾显示闪烁光标，并标记 data-streaming。 */
    isStreaming?: boolean;
    /** 气泡内附加内容（ToolCall / KnowledgeRefs 等子卡片）。 */
    attachments?: ReactNode;
    /** 主消息内容。 */
    children: ReactNode;
}
declare const ChatMessage: react.ForwardRefExoticComponent<ChatMessageProps & react.RefAttributes<HTMLDivElement>>;

interface ChatMessageListProps extends ChatCommonStyleProps {
    /** 子节点变化时自动滚到底部。默认 true。 */
    shouldAutoScrollToBottom?: boolean;
    /** 最大高度（启用滚动）；默认 'none'，由父级决定。 */
    maxHeight?: string | number;
    /** 子节点：通常是 <ChatMessage>。 */
    children: ReactNode;
    /** ARIA role；默认 'log'。 */
    role?: 'log' | 'list' | 'region';
    /** polite live region；默认 true。 */
    isLive?: boolean;
}
declare const ChatMessageList: react.ForwardRefExoticComponent<ChatMessageListProps & react.RefAttributes<HTMLDivElement>>;

interface ChatToolCallProps extends ChatCommonStyleProps, Partial<ChatToolCallData> {
    /** 工具名（必填，覆盖 data.name）。 */
    name: string;
    /** 默认折叠态。 */
    defaultExpanded?: boolean;
    /** 受控折叠态。 */
    isExpanded?: boolean;
    onExpandedChange?: (expanded: boolean) => void;
    /** 自定义参数渲染（覆盖默认 JSON 序列化）。 */
    renderArguments?: (args: unknown) => ReactNode;
    /** 自定义结果渲染。 */
    renderResult?: (result: unknown) => ReactNode;
    /** 隐藏头部右侧的展开图标（默认显示）。 */
    isCollapsible?: boolean;
}
declare const ChatToolCall: react.ForwardRefExoticComponent<ChatToolCallProps & react.RefAttributes<HTMLDivElement>>;

interface ChatKnowledgeRefsProps extends ChatCommonStyleProps {
    /** 引用列表。 */
    references: ReadonlyArray<ChatKnowledgeReference>;
    /** 顶部小标题，默认 "Sources"。传 false 隐藏。 */
    title?: ReactNode | false;
    /** 单个 chip 点击回调（href 缺失时仍触发）。 */
    onSelect?: (reference: ChatKnowledgeReference) => void;
    /** 是否对带 href 的 chip 加打开新窗口属性。默认 true。 */
    isExternal?: boolean;
}
declare const ChatKnowledgeRefs: react.ForwardRefExoticComponent<ChatKnowledgeRefsProps & react.RefAttributes<HTMLDivElement>>;

interface ChatComposerProps extends ChatCommonStyleProps {
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    onSubmit?: (value: string) => void;
    /** 禁用提交 + textarea。 */
    isDisabled?: boolean;
    /** 占位文字。 */
    placeholder?: string;
    /** Textarea 最小 / 最大行数（覆盖 token 默认值）。 */
    minRows?: number;
    maxRows?: number;
    /** 回车提交（Shift+Enter 换行）。默认 true。 */
    submitOnEnter?: boolean;
    /** Textarea 左侧 slot（如附件工具栏）。 */
    startContent?: ReactNode;
    /** Textarea 右侧 slot（如发送按钮 + 语音）。 */
    endContent?: ReactNode;
    /** 工具栏行上方、shell 内的 slot（如文件 chip）。 */
    topContent?: ReactNode;
    /** 工具栏行下方、shell 内的 slot（如模型选择器）。 */
    bottomContent?: ReactNode;
    /** Textarea 的 ARIA 标签。 */
    'aria-label'?: string;
    /** Form 集成：底层 textarea 的 name 属性。 */
    name?: string;
}
declare const ChatComposer: react.ForwardRefExoticComponent<ChatComposerProps & react.RefAttributes<HTMLDivElement>>;

interface ChatActionButtonProps extends ChatCommonStyleProps {
    /** 图标节点（建议 16x16 SVG）。 */
    children: ReactNode;
    onClick?: () => void;
    isDisabled?: boolean;
    /** 切换的"激活"状态（如麦克风正在录制）。默认 false。 */
    isActive?: boolean;
    /** ARIA 标签 — 纯图标按钮必填。 */
    'aria-label': string;
    /** 悬浮提示文字（原生 title）。可选。 */
    tooltip?: string;
    /** 默认 type=button。 */
    type?: 'button' | 'submit';
}
declare const ChatActionButton: react.ForwardRefExoticComponent<ChatActionButtonProps & react.RefAttributes<HTMLButtonElement>>;

interface ChatSendButtonProps extends ChatCommonStyleProps {
    onClick?: () => void;
    isDisabled?: boolean;
    /** 加载 / 流式状态 — 显示停止图标，点击触发 onStop。 */
    isStreaming?: boolean;
    onStop?: () => void;
    'aria-label'?: string;
    stopAriaLabel?: string;
}
declare const ChatSendButton: react.ForwardRefExoticComponent<ChatSendButtonProps & react.RefAttributes<HTMLButtonElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 实现 useChatStream hook：消费 async-iterable 的字符串分片并累积为完整文本。
 */
interface UseChatStreamOptions {
    /** 流开始时（status 变为 'streaming'）调用。 */
    onStart?: () => void;
    /** 每次新 chunk 到来时调用，传入*当前累积*的完整文本。 */
    onUpdate?: (text: string) => void;
    /** 流成功完成后调用一次。 */
    onComplete?: (finalText: string) => void;
    /** 流出错时调用一次。 */
    onError?: (error: unknown) => void;
}
interface UseChatStreamResult {
    /** 自上次 reset 以来累积的文本。 */
    text: string;
    /** start 之后、complete/error/cancel 之前为 true。 */
    isStreaming: boolean;
    /** 最近一次 error（下一次 start 时清空）。 */
    error: unknown | null;
    /**
     * 开始消费一个异步迭代器。
     * 每次 yield 的 string 会*追加*到 text。
     * 返回最终的累积文本。
     */
    start: (chunks: AsyncIterable<string>) => Promise<string>;
    /** 取消正在进行的流（把 isStreaming 置为 false）。 */
    cancel: () => void;
    /** 清空 text，不取消正在进行的流。 */
    reset: () => void;
}
declare function useChatStream(options?: UseChatStreamOptions): UseChatStreamResult;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Popover 组件的共享 TypeScript 类型。
 */

type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
type PopoverTrigger = 'click' | 'hover' | 'focus' | 'manual';
/**
 * 基础方位（从 placement 解析得到）。
 */
type PopoverSide = 'top' | 'bottom' | 'left' | 'right';
/**
 * anchor render-prop 接收的参数。
 */
interface PopoverAnchorRenderProps {
    isOpen: boolean;
    ref: Ref<HTMLElement>;
}
interface PopoverProps {
    /** 触发器节点（必需）。可以是 ReactElement（克隆注入事件 + ref）或 (props) => ReactNode 函数。 */
    anchor: ReactElement | ((opts: PopoverAnchorRenderProps) => ReactNode);
    /** 弹层内容。 */
    children: ReactNode;
    /** 受控开关。 */
    isOpen?: boolean;
    /** 非受控初始开关。 */
    defaultOpen?: boolean;
    /** 开关变化回调。 */
    onOpenChange?: (open: boolean) => void;
    /** 触发方式，默认 'click'。 */
    trigger?: PopoverTrigger;
    /** 弹层方位，默认 'bottom'。 */
    placement?: PopoverPlacement;
    /** anchor 与 popover 之间像素间距，默认读 theme.components.popover.offset。 */
    offset?: number;
    /** 显示箭头，默认 true。 */
    hasArrow?: boolean;
    /** 点击外部关闭，默认 true。 */
    closeOnBlur?: boolean;
    /** ESC 关闭，默认 true。 */
    closeOnEsc?: boolean;
    /** 顶部 header slot。 */
    header?: ReactNode;
    /** 底部 footer slot。 */
    footer?: ReactNode;
    /** hover 触发的进入延迟（ms），默认 0。 */
    openDelay?: number;
    /** hover 触发的离开延迟（ms），默认 100。 */
    closeDelay?: number;
    /** 透传到 panel 的 className。 */
    className?: string;
    /** 透传到 panel 的 inline style（会覆盖部分定位字段，请谨慎）。 */
    style?: CSSProperties;
    /** 透传到 panel 的 id。 */
    id?: string;
    /** A11y 标签。 */
    'aria-label'?: string;
}

declare const Popover: react.ForwardRefExoticComponent<PopoverProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Tooltip 组件的共享 TypeScript 类型。
 *              Tooltip 复用 Popover 的 placement 体系，但触发与配色策略不同：
 *              只支持 hover + focus，配色硬编码反色（与 surface 形成强对比）。
 */

/** Tooltip 的方位字面量 —— 直接复用 Popover 的 12 个枚举值，无需重复定义。 */
type TooltipPlacement = PopoverPlacement;
interface TooltipProps {
    /** 显示的内容（短文本或简单 ReactNode）。 */
    content: ReactNode;
    /**
     * 包裹的 anchor —— 必须是单个 ReactElement。
     * 会被 cloneElement 注入 ref + 事件 + aria-describedby，
     * 同时保留并合并 children 已有的 mouseenter / mouseleave / focus / blur 处理。
     */
    children: ReactElement;
    /** 默认 'top'。 */
    placement?: TooltipPlacement;
    /** anchor 与 tooltip 的间距，默认读 theme.components.tooltip.offset。 */
    offset?: number;
    /** 显示箭头，默认 true。 */
    hasArrow?: boolean;
    /** 整体禁用（不显示 portal）。 */
    isDisabled?: boolean;
    /** hover/focus 进入到 tooltip 显示的延迟（ms），默认读 openDelay；warm 状态时跳过。 */
    openDelay?: number;
    /** hover/focus 离开到 tooltip 关闭的延迟（ms），默认读 closeDelay。 */
    closeDelay?: number;
    /** 受控显隐（仅用于程序控制场景，可选）。一旦提供则忽略所有内部 hover/focus 触发逻辑。 */
    isOpen?: boolean;
    /** 非受控初始显隐。 */
    defaultOpen?: boolean;
    /** 开关变化回调。 */
    onOpenChange?: (open: boolean) => void;
    /** 透传到 tooltip panel 的 className（不是 anchor）。 */
    className?: string;
    /** 透传到 tooltip panel 的 inline style（不是 anchor）。 */
    style?: CSSProperties;
    /** 透传到 tooltip panel 的 id；同时也是注入到 anchor aria-describedby 的值。 */
    id?: string;
}

declare const Tooltip: react.ForwardRefExoticComponent<TooltipProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Modal 组件族的共享 TypeScript 类型。
 */

/** Modal 宽度档位。 */
type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
/** Modal 滚动行为：'inside' = body 区滚动；'outside' = panel 整体滚动。 */
type ModalScrollBehavior = 'inside' | 'outside';
interface ModalProps {
    /** 受控打开状态。 */
    isOpen?: boolean;
    /** 非受控初始打开状态。 */
    defaultOpen?: boolean;
    /** 打开 / 关闭回调。 */
    onOpenChange?: (open: boolean) => void;
    /** 宽度档位。默认 'md'。 */
    size?: ModalSize;
    /** 滚动行为。默认 'inside'。 */
    scrollBehavior?: ModalScrollBehavior;
    /** 内置 header 标题（含关闭按钮）；不传或传 false 时不渲染默认 header。 */
    title?: ReactNode;
    /** 底部按钮区。传 false 完全隐藏 footer；传 ReactNode 渲染。 */
    footer?: ReactNode | false;
    /** 是否显示关闭按钮，默认 true。 */
    showCloseButton?: boolean;
    /** ESC 关闭，默认 true。 */
    closeOnEsc?: boolean;
    /** 点击 overlay 关闭，默认 true。 */
    closeOnOverlayClick?: boolean;
    /** 锁定 body scroll，默认 true。 */
    shouldBlockScroll?: boolean;
    /** 自动 focus 第一个可聚焦元素，默认 true。 */
    autoFocus?: boolean;
    /** 关闭后归还焦点到打开前的元素，默认 true。 */
    shouldReturnFocus?: boolean;
    /** Modal 主体内容。 */
    children?: ReactNode;
    /** 透传到 panel 的 className。 */
    className?: string;
    /** 透传到 panel 的 style。 */
    style?: CSSProperties;
    /** 自定义 id（默认自动生成）。 */
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-describedby'?: string;
}
interface ModalHeaderProps {
    children?: ReactNode;
    className?: string;
    id?: string;
}
interface ModalBodyProps {
    children?: ReactNode;
    className?: string;
    id?: string;
}
interface ModalFooterProps {
    children?: ReactNode;
    className?: string;
    id?: string;
}

declare const ModalHeader: react.ForwardRefExoticComponent<ModalHeaderProps & react.RefAttributes<HTMLDivElement>>;
declare const ModalBody: react.ForwardRefExoticComponent<ModalBodyProps & react.RefAttributes<HTMLDivElement>>;
declare const ModalFooter: react.ForwardRefExoticComponent<ModalFooterProps & react.RefAttributes<HTMLDivElement>>;
declare const Modal: react.ForwardRefExoticComponent<ModalProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Tabs 模块的 TypeScript 类型约束。
 */

type TabsVariant = 'underline' | 'pills' | 'bordered';
type TabsSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type TabsOrientation = 'horizontal' | 'vertical';
/** 数据驱动模式下单个 Tab 的描述。 */
interface TabItem {
    /** 唯一 key，用于受控选中。 */
    itemKey: string;
    /** Tab 头显示内容（文本 / ReactNode）。 */
    label: ReactNode;
    /** 文本前的图标。 */
    icon?: ReactNode;
    /** 单独禁用该项。 */
    isDisabled?: boolean;
    /** 数据驱动模式下的面板内容。 */
    content?: ReactNode;
}
interface TabsProps {
    /** 受控选中 key。 */
    selectedKey?: string;
    /** 非受控初始选中 key。 */
    defaultSelectedKey?: string;
    /** 选中变更回调。 */
    onSelectionChange?: (key: string) => void;
    /** 数据驱动模式（优先级高于 children）。 */
    items?: ReadonlyArray<TabItem>;
    /** 声明式：<Tab itemKey="x" label="..."><TabPanel>...</TabPanel></Tab>。 */
    children?: ReactNode;
    /** 视觉变体。默认 'underline'。 */
    variant?: TabsVariant;
    /** 尺寸。默认 'md'。 */
    size?: TabsSize;
    /** 排列方向。默认 'horizontal'。 */
    orientation?: TabsOrientation;
    /** 是否懒加载 panel（仅当前激活的 mount）。默认 false。 */
    isLazy?: boolean;
    /** 全局禁用所有 tabs。 */
    isDisabled?: boolean;
    /** 一组 key，禁用这些 tabs。 */
    disabledKeys?: ReadonlyArray<string>;
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
}
interface TabProps {
    /** 真正参与选择的 key（避免与 React key 冲突）。 */
    itemKey: string;
    label: ReactNode;
    icon?: ReactNode;
    isDisabled?: boolean;
    /** 内嵌 TabPanel 或其他面板内容。 */
    children?: ReactNode;
}
interface TabPanelProps {
    itemKey: string;
    children?: ReactNode;
}

declare const Tab: (_props: TabProps) => null;
declare const TabPanel: (_props: TabPanelProps) => null;
declare const Tabs: react.ForwardRefExoticComponent<TabsProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Pagination 模块的 TypeScript 类型约束。
 */

type PaginationVariant = 'default' | 'simple' | 'mini';
type PaginationSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface PaginationLabels {
    prev?: string;
    next?: string;
    jumperLabel?: string;
    sizeChangerLabel?: string;
    /** "{n} / {total}" 模板，simple/mini 用 */
    summary?: (page: number, totalPages: number) => ReactNode;
}
interface PaginationProps {
    /** 总条数（必需） */
    total: number;
    /** 每页条数 */
    pageSize?: number;
    defaultPageSize?: number;
    onPageSizeChange?: (pageSize: number) => void;
    pageSizeOptions?: ReadonlyArray<number>;
    /** 当前页（1-based） */
    page?: number;
    defaultPage?: number;
    onPageChange?: (page: number) => void;
    /** 默认 'default' */
    variant?: PaginationVariant;
    /** 默认 'md'；mini 强制 sm */
    size?: PaginationSize;
    /** 当前页两侧显示的页码数，默认 1 */
    siblingCount?: number;
    /** 显示页面跳转输入，默认 false */
    showQuickJumper?: boolean;
    /** 显示 pageSize 切换器，默认 false */
    showSizeChanger?: boolean;
    /** 是否禁用 */
    isDisabled?: boolean;
    /** 隐藏 prev/next 按钮 */
    hideControls?: boolean;
    /** 文案自定义（i18n） */
    labels?: PaginationLabels;
    /** className / style / id 透传到根 nav */
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
}
type PaginationItem = {
    type: 'page';
    page: number;
} | {
    type: 'ellipsis';
    key: string;
};

/**
 * 生成页码列表（含 ellipsis 占位）。
 *
 * 算法：
 *   左边界 = max(2, page - siblingCount)
 *   右边界 = min(totalPages - 1, page + siblingCount)
 *   首页与末页恒在；左右与首页/末页之间若间隔 > 1 用 ellipsis 占位，
 *   若仅相邻则不插省略号（避免 "1 ... 2 3" 形式）。
 *
 * 边界情况：
 *   - totalPages <= 1：返回 [{ page: 1 }]
 *   - 总页数较少（<= 1 + siblingCount*2 + 4）：直接返回完整序列，不折叠
 */
declare function buildPaginationItems(totalPages: number, page: number, siblingCount: number): PaginationItem[];
declare const Pagination: react.ForwardRefExoticComponent<PaginationProps & react.RefAttributes<HTMLElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Table 模块的 TypeScript 类型约束。
 */

type TableDensity = 'compact' | 'default' | 'comfortable';
type SortDirection = 'asc' | 'desc';
type SelectionMode = 'none' | 'single' | 'multiple';
type TableAlign = 'left' | 'center' | 'right';
type TableFixed = 'left' | 'right';
/**
 * 视觉风格变体。
 *
 * - `enclosed`（默认）：外圆角 + hairline 容器 + header muted bg，Apple Settings 卡片风格
 * - `divided`：无外框，header 仅保留底部 hairline strong，letter-spacing 强化，Apple Mail 列表风格
 * - `grid`：行列双向 hairline，Numbers / 报表风格，适合密集数据
 * - `quiet`：无边无线无 bg，仅靠 row hover 揭示分隔，适合文档/阅读场景
 */
type TableVariant = 'enclosed' | 'divided' | 'grid' | 'quiet';
interface SortDescriptor {
    columnKey: string;
    direction: SortDirection;
}
interface TableColumn<T = unknown> {
    /** 唯一列 key */
    columnKey: string;
    /** 表头显示内容 */
    title: ReactNode;
    /** 列宽（数字 px 或 CSS 字符串） */
    width?: number | string;
    /** 列对齐 */
    align?: TableAlign;
    /** 是否可排序 */
    isSortable?: boolean;
    /** 自定义渲染单元格内容；默认显示 row[columnKey] */
    render?: (row: T, rowIndex: number) => ReactNode;
    /** 固定列；默认不固定 */
    fixed?: TableFixed;
    /** 单元格点击禁止冒泡到行选择 */
    isInteractive?: boolean;
}
interface TableProps<T = unknown> {
    /** 列定义（必需） */
    columns: ReadonlyArray<TableColumn<T>>;
    /** 行数据（必需） */
    data: ReadonlyArray<T>;
    /** 每行 key：可以是字段名或 (row) => string */
    rowKey?: keyof T | ((row: T, index: number) => string);
    /** 默认 'default' */
    density?: TableDensity;
    /** 视觉风格，默认 `'enclosed'`。 */
    variant?: TableVariant;
    /** sticky 表头，默认 false */
    isStickyHeader?: boolean;
    /** 斑马纹，默认 false */
    isStriped?: boolean;
    /** 容器边框，**仅对 `variant="enclosed"` 生效**，默认 true */
    hasBorder?: boolean;
    /** 加载态 */
    isLoading?: boolean;
    loadingMessage?: ReactNode;
    /** 空态 */
    emptyMessage?: ReactNode;
    /** 排序 */
    sortDescriptor?: SortDescriptor;
    defaultSortDescriptor?: SortDescriptor;
    onSortChange?: (sort: SortDescriptor | undefined) => void;
    /** 行选择 */
    selectionMode?: SelectionMode;
    selectedKeys?: ReadonlyArray<string>;
    defaultSelectedKeys?: ReadonlyArray<string>;
    onSelectionChange?: (keys: ReadonlyArray<string>) => void;
    /** 哪些 key 不可选（disabled） */
    disabledKeys?: ReadonlyArray<string>;
    /** 行点击 */
    onRowClick?: (row: T, rowIndex: number, e: MouseEvent) => void;
    /** 容器最大高度（启用滚动） */
    maxHeight?: number | string;
    /** className / style / id 透传到 .table-container */
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
}

declare function TableInner<T>(props: TableProps<T>, forwardedRef: React.ForwardedRef<HTMLDivElement>): _emotion_react_jsx_runtime.JSX.Element;
declare const Table: <T = unknown>(props: TableProps<T> & {
    ref?: React.Ref<HTMLDivElement>;
}) => ReturnType<typeof TableInner>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Drawer 组件族的共享 TypeScript 类型。
 */

/** Drawer 贴边方向。 */
type DrawerPlacement = 'left' | 'right' | 'top' | 'bottom';
/** Drawer 尺寸档位（横向用 width 系列、纵向用 height 系列）。 */
type DrawerSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
/** Drawer 滚动行为：'inside' = body 区滚动；'outside' = panel 整体滚动。 */
type DrawerScrollBehavior = 'inside' | 'outside';
interface DrawerProps {
    /** 受控打开状态。 */
    isOpen?: boolean;
    /** 非受控初始打开状态。 */
    defaultOpen?: boolean;
    /** 打开 / 关闭回调。 */
    onOpenChange?: (open: boolean) => void;
    /** 贴边方向。默认 'right'。 */
    placement?: DrawerPlacement;
    /** 尺寸档位。默认 'md'。 */
    size?: DrawerSize;
    /** 点击 overlay 是否关闭，默认 true。 */
    isDismissable?: boolean;
    /** 禁用 ESC 关闭，默认 false。 */
    disableKeyboardDismiss?: boolean;
    /** 隐藏右上角关闭按钮，默认 false。 */
    hideCloseButton?: boolean;
    /** 滚动行为，默认 'inside'。 */
    scrollBehavior?: DrawerScrollBehavior;
    /** Portal 容器，默认 document.body。 */
    portalContainer?: HTMLElement;
    /** 顶部 header 内容。 */
    header?: ReactNode;
    /** 底部 footer 内容。 */
    footer?: ReactNode;
    /** Drawer 主体内容。 */
    children?: ReactNode;
    /** 透传到 panel 的 className。 */
    className?: string;
    /** 透传到 panel 的 style。 */
    style?: CSSProperties;
    /** 自定义 id（默认自动生成）。 */
    id?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-describedby'?: string;
}
interface DrawerHeaderProps {
    children?: ReactNode;
    className?: string;
}
interface DrawerBodyProps {
    children?: ReactNode;
    className?: string;
}
interface DrawerFooterProps {
    children?: ReactNode;
    className?: string;
}

declare const DrawerHeader: react.ForwardRefExoticComponent<DrawerHeaderProps & react.RefAttributes<HTMLDivElement>>;
declare const DrawerBody: react.ForwardRefExoticComponent<DrawerBodyProps & react.RefAttributes<HTMLDivElement>>;
declare const DrawerFooter: react.ForwardRefExoticComponent<DrawerFooterProps & react.RefAttributes<HTMLDivElement>>;
declare const Drawer: react.ForwardRefExoticComponent<DrawerProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Toast / Notification 组件的对外类型契约（命令式 API）。
 */

type ToastPlacement = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
type ToastStatus = 'info' | 'success' | 'warning' | 'danger' | 'loading';
interface ToastAction {
    /** 按钮文案（可为任意 ReactNode） */
    label: ReactNode;
    /** 点击回调；回调返回后 toast 会被关闭 */
    onPress: () => void;
}
interface ToastOptions {
    /** 显式 id，便于 update / dismiss；不传则内部自增 */
    id?: string;
    /** 标题（粗体行） */
    title?: ReactNode;
    /** 正文描述（次级行） */
    description?: ReactNode;
    /** 决定 icon + 强调色，默认 'info' */
    status?: ToastStatus;
    /** ms；null = 不自动关；默认 5000 */
    duration?: number | null;
    /** 是否显示关闭按钮，默认 true */
    isClosable?: boolean;
    /** 覆盖默认 status icon */
    icon?: ReactNode;
    /** 操作按钮 */
    action?: ToastAction;
    /** toast 关闭时回调（无论原因） */
    onDismiss?: () => void;
    /** 覆盖 Provider 默认 placement */
    placement?: ToastPlacement;
}
interface ToastProviderProps {
    /** 默认 'top-right' */
    placement?: ToastPlacement;
    /** 默认 5；超出折叠（仅渲染最新 N 条，其余保留在队列） */
    maxToasts?: number;
    children: ReactNode;
}
/** 用户传给 promise 的消息字段 */
interface ToastPromiseMessages<T> {
    loading: ReactNode;
    success: ReactNode | ((value: T) => ReactNode);
    error: ReactNode | ((error: unknown) => ReactNode);
}
interface ToastApi {
    /** 通用入口 */
    show: (opts: ToastOptions) => string;
    success: (msg: ReactNode, opts?: Omit<ToastOptions, 'status' | 'description'>) => string;
    error: (msg: ReactNode, opts?: Omit<ToastOptions, 'status' | 'description'>) => string;
    warning: (msg: ReactNode, opts?: Omit<ToastOptions, 'status' | 'description'>) => string;
    info: (msg: ReactNode, opts?: Omit<ToastOptions, 'status' | 'description'>) => string;
    loading: (msg: ReactNode, opts?: Omit<ToastOptions, 'status' | 'description'>) => string;
    /** 局部更新一条 toast */
    update: (id: string, opts: Partial<ToastOptions>) => void;
    /** 关闭：不传 id 全清 */
    dismiss: (id?: string) => void;
    /** Promise 流：loading → success / error 自动切换 */
    promise: <T>(p: Promise<T>, msgs: ToastPromiseMessages<T>) => Promise<T>;
}
/** 内部 store 中保存的 toast 实例（已归一化） */
interface ToastInstance extends Required<Pick<ToastOptions, 'id' | 'status' | 'isClosable'>> {
    title?: ReactNode;
    description?: ReactNode;
    duration: number | null;
    icon?: ReactNode;
    action?: ToastAction;
    onDismiss?: () => void;
    placement: ToastPlacement;
    /** 内部递增计数，用于稳定排序（先进先出） */
    createdAt: number;
}

/** @jsxImportSource @emotion/react */

interface ToastItemProps {
    toast: ToastInstance;
    onClose: (id: string) => void;
}
declare const ToastItem: FC<ToastItemProps>;
declare const ToastProvider: FC<ToastProviderProps>;

declare function useToast(): ToastApi;
/** module-level 单例：代理到最近一次挂载的 Provider 的 store。 */
declare const toast: ToastApi;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Menu / Dropdown 模块的共享 TypeScript 类型。
 */

/**
 * 数据驱动模式下单个菜单项的描述。
 *
 * 注意：本轮不实现 submenu 的浮层渲染，但保留 `children` 字段作为类型占位，
 * 以便后续无破坏性升级。
 */
interface MenuItemDescriptor {
    /** 唯一标识。selection / onAction 都基于它。 */
    itemKey: string;
    /** 主标签内容。 */
    label: ReactNode;
    /** 左侧图标。 */
    icon?: ReactNode;
    /** 右侧快捷键提示（如 ⌘K）。 */
    shortcut?: ReactNode;
    /** 二级描述文本（在 label 下方）。 */
    description?: ReactNode;
    /** 是否禁用：键盘跳过、点击不触发。 */
    isDisabled?: boolean;
    /** 危险项：文字与 hover bg 走 danger 色板。 */
    isDanger?: boolean;
    /** 渲染为 `<a>` 而非 `<button>`。 */
    href?: string;
    /** submenu 子项（占位 — 本轮不渲染浮层）。 */
    subItems?: MenuItemDescriptor[];
}
/**
 * 数据驱动模式下的分组：包含一个可选 label 与一组 items。
 */
interface MenuSectionDescriptor {
    type: 'section';
    sectionKey: string;
    label?: ReactNode;
    items: MenuItemDescriptor[];
}
/** items 数组中允许的元素类型。 */
type MenuItemsEntry = MenuItemDescriptor | MenuSectionDescriptor;
type MenuSelectionMode = 'none' | 'single' | 'multiple';
/**
 * 触发器 render-prop 接收的参数。
 */
interface MenuTriggerRenderProps {
    isOpen: boolean;
    ref: Ref<HTMLElement>;
}
interface MenuProps {
    /** 触发器（必需）。可以是 ReactElement 或 render prop。 */
    trigger: ReactElement | ((opts: MenuTriggerRenderProps) => ReactNode);
    /** 数据驱动模式：传入扁平 items / sections 混合数组。优先级高于 children。 */
    items?: ReadonlyArray<MenuItemsEntry>;
    /** 声明式：<Menu.Item> / <Menu.Section> / <Menu.Divider> 子节点。 */
    children?: ReactNode;
    /** 受控开关。 */
    isOpen?: boolean;
    /** 非受控初始开关。 */
    defaultOpen?: boolean;
    /** 开关变化回调。 */
    onOpenChange?: (open: boolean) => void;
    /** 复用 Popover 的 12 种 placement。默认 'bottom-start'。 */
    placement?: PopoverPlacement;
    /** 选择模式。默认 'none'。 */
    selectionMode?: MenuSelectionMode;
    /** 受控选中集合。 */
    selectedKeys?: Iterable<string>;
    /** 非受控初始选中集合。 */
    defaultSelectedKeys?: Iterable<string>;
    /** 选中变更回调（始终接收新 Set）。 */
    onSelectionChange?: (keys: Set<string>) => void;
    /** 点击任意 item 触发，携带 key。 */
    onAction?: (key: string) => void;
    /**
     * 选中后是否关闭菜单。默认：single → true，multiple → false，none → true。
     */
    closeOnSelect?: boolean;
    /** 整个菜单禁用（trigger 仍可见但不打开）。 */
    isDisabled?: boolean;
    /** 自定义 portal 容器（透传给 Popover 时由 Popover 决定，本组件直接渲染在 Popover 内）。 */
    portalContainer?: HTMLElement;
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
}
/**
 * 复合子组件 `<Menu.Item>` 的 props。
 */
interface MenuItemProps {
    /** 唯一标识。selection / onAction 都基于它。 */
    itemKey: string;
    icon?: ReactNode;
    shortcut?: ReactNode;
    description?: ReactNode;
    isDisabled?: boolean;
    isDanger?: boolean;
    href?: string;
    /** 此项专属的 onAction 回调（优先于 Menu 顶层 onAction 触发，但都会被调用）。 */
    onAction?: () => void;
    /** 主标签内容。 */
    children?: ReactNode;
}
/**
 * 复合子组件 `<Menu.Section>` 的 props。
 */
interface MenuSectionProps {
    /** 分组 key（用于 React key；可选）。 */
    sectionKey?: string;
    label?: ReactNode;
    children?: ReactNode;
}
/**
 * 复合子组件 `<Menu.Divider>` 的 props。
 */
interface MenuDividerProps {
    /** 透传 className。 */
    className?: string;
}

interface MenuRowProps {
    item: MenuItemDescriptor;
    /** 当前是否被键盘高亮。 */
    isHighlighted: boolean;
    /** selection 状态（none → undefined；single/multiple → boolean）。 */
    isSelected?: boolean;
    /** 选择模式（影响右侧 indicator 与 aria role）。 */
    selectionMode: MenuSelectionMode;
    /** 行 click 处理。 */
    onSelect: () => void;
    /** 鼠标进入时同步键盘高亮。 */
    onHighlight?: () => void;
    /** 该 item 在扁平列表中的索引（用于 data-index / aria-activedescendant）。 */
    index: number;
    /** id 前缀（生成稳定 option id）。 */
    baseId: string;
}
/**
 * 单行菜单项的渲染。提取为独立组件以便：
 *   1. Menu 自身复用（items / children 两条解析路径都走同一份渲染）；
 *   2. DatePicker presets 浮层复用（共享高亮 / disabled / danger / href 视觉规则）。
 */
declare const MenuRow: ({ item, isHighlighted, isSelected, selectionMode, onSelect, onHighlight, index, baseId, }: MenuRowProps) => ReactElement;
declare const MenuItem: (_props: MenuItemProps) => null;
declare const MenuSection: (_props: MenuSectionProps) => null;
declare const MenuDivider: (_props: MenuDividerProps) => null;
declare const MenuSubMenu: (_props: MenuItemProps) => null;
declare const MenuImpl: react.ForwardRefExoticComponent<MenuProps & react.RefAttributes<HTMLDivElement>>;
type MenuComponent = typeof MenuImpl & {
    Item: typeof MenuItem;
    Section: typeof MenuSection;
    Divider: typeof MenuDivider;
    SubMenu: typeof MenuSubMenu;
};
declare const Menu: MenuComponent;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description DatePicker / DateRangePicker 的纯日期工具函数集合。
 *              所有函数 SSR-safe、零依赖、不依赖 date-fns/dayjs，避免增加 bundle size。
 *              输入 Date 实例不会被原地修改 —— 所有变换都返回新的 Date。
 */
type WeekStartsOn = 0 | 1 | 2 | 3 | 4 | 5 | 6;
/** 把任意 Date 规约到当天 0:00（保留时区，仅清空时分秒）。 */
declare const startOfDay: (d: Date) => Date;
/** 把任意 Date 规约到当月 1 号 0:00。 */
declare const startOfMonth: (d: Date) => Date;
/** 当月最后一天的 23:59:59.999。 */
declare const endOfMonth: (d: Date) => Date;
/** 当月天数（28/29/30/31）。 */
declare const getDaysInMonth: (d: Date) => number;
/** 加 n 天（n 可负）。返回新的 Date。 */
declare const addDays: (d: Date, n: number) => Date;
/** 加 n 月（n 可负）。日期超出新月份时自动归到该月最后一天。 */
declare const addMonths: (d: Date, n: number) => Date;
/** 加 n 年。 */
declare const addYears: (d: Date, n: number) => Date;
/** 两个 Date 是否同一天（忽略时分秒）。null/undefined 永远返回 false。 */
declare const isSameDay: (a: Date | null | undefined, b: Date | null | undefined) => boolean;
/** 两个 Date 是否同一个月。 */
declare const isSameMonth: (a: Date | null | undefined, b: Date | null | undefined) => boolean;
/** date 是否落在 [start, end] 闭区间（按天比较，忽略时分秒）。end 可早于 start，函数会自动交换。 */
declare const isInRange: (date: Date, start: Date | null | undefined, end: Date | null | undefined) => boolean;
/** date 是否严格在区间内部（不含端点）。 */
declare const isInRangeExclusive: (date: Date, start: Date | null | undefined, end: Date | null | undefined) => boolean;
/** 比较两个日期（按天）：a < b 返回负值，a > b 正值，相等 0。 */
declare const compareDays: (a: Date, b: Date) => number;
/** 把 Date clamp 到 [min, max]（按天比较）。min/max 可为空。 */
declare const clampDate: (d: Date, min?: Date | null, max?: Date | null) => Date;
/** 给定 weekStartsOn，返回 [day0, day1, …, day6] 索引数组（每项为 0..6 对应 Sun..Sat）。 */
declare const buildWeekDayOrder: (weekStartsOn: WeekStartsOn) => number[];
/** 把当月起点回退到 weekStartsOn 对应的星期几（生成日历网格起点）。 */
declare const startOfCalendarGrid: (monthAnchor: Date, weekStartsOn: WeekStartsOn) => Date;
interface CalendarCell {
    date: Date;
    /** 是否属于 monthAnchor 所在月。 */
    isCurrentMonth: boolean;
}
/**
 * 生成 6×7 = 42 个连续日期格子。从 weekStartsOn 调整后的起点开始向后填。
 * 用于日历网格渲染 — 始终 42 格保证布局稳定，避免月份切换时高度跳变。
 */
declare const buildCalendarMatrix: (monthAnchor: Date, weekStartsOn: WeekStartsOn) => CalendarCell[];
/** date 是否落在 [min, max]（任意一端为空视作不限制）。 */
declare const isWithinBounds: (date: Date, min?: Date | null, max?: Date | null) => boolean;
/** 默认格式化：本地化的 short date。 */
declare const defaultFormat: (d: Date, locale?: string) => string;
/** 默认解析：宽容 ISO（YYYY-MM-DD）+ Date 构造器兜底。失败返回 null。 */
declare const defaultParse: (s: string) => Date | null;
/** 月份英文名（fallback；优先使用 toLocaleDateString({month:'long'})）。 */
declare const monthLabel: (d: Date, locale?: string) => string;
/** 给定 weekStartsOn，返回长度 7 的星期几短标签（如 ['Su','Mo',…]）。 */
declare const weekdayLabels: (weekStartsOn: WeekStartsOn, locale?: string) => string[];
/** 把 range 规范化：若 end < start，则交换。 */
declare const normalizeRange: <T extends {
    start: Date;
    end: Date;
}>(range: T) => T;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 DatePicker / DateRangePicker 模块的共享 TypeScript 类型。
 */

type DatePickerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type DatePickerPanelSize = 'sm' | 'md' | 'lg';
type DateValue = Date;
interface DateRangeValue {
    start: DateValue;
    end: DateValue;
}
/** Range 中间过程的状态：已选 start 但未确认 end 时使用。 */
interface DateRangeWorking {
    start: DateValue | null;
    end: DateValue | null;
}
interface DatePickerCommonProps {
    isOpen?: boolean;
    defaultOpen?: boolean;
    onOpenChange?: (open: boolean) => void;
    /** Popover placement，默认 'bottom-start'。 */
    placement?: PopoverPlacement;
    /** 触发器尺寸，跟随 Input。 */
    size?: DatePickerSize;
    /** 弹出日历面板尺寸，默认 'md'。 */
    panelSize?: DatePickerPanelSize;
    minValue?: DateValue;
    maxValue?: DateValue;
    /** 自定义某天禁用（如周末禁选）。 */
    isDateUnavailable?: (date: DateValue) => boolean;
    /** 周首日：0=Sun, 1=Mon, ... ；默认 0。 */
    weekStartsOn?: WeekStartsOn;
    locale?: string;
    /** 输入框显示格式。 */
    format?: (d: DateValue) => string;
    /** 字符串解析回 Date（用户键入时）。 */
    parse?: (s: string) => DateValue | null;
    placeholder?: string;
    isReadOnly?: boolean;
    isDisabled?: boolean;
    isInvalid?: boolean;
    /** 显示清除按钮。 */
    isClearable?: boolean;
    /** 底部 [Today] 按钮。 */
    showTodayButton?: boolean;
    startContent?: ReactNode;
    endContent?: ReactNode;
    portalContainer?: HTMLElement;
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
}
interface DatePickerProps extends DatePickerCommonProps {
    value?: DateValue | null;
    defaultValue?: DateValue | null;
    onChange?: (value: DateValue | null) => void;
}
interface DateRangePresetEntry {
    label: ReactNode;
    value: DateRangeValue;
}
interface DateRangePickerProps extends DatePickerCommonProps {
    value?: DateRangeValue | null;
    defaultValue?: DateRangeValue | null;
    onChange?: (value: DateRangeValue | null) => void;
    /** 同时显示几个月，默认 2。 */
    visibleMonths?: 1 | 2;
    /** 预设范围（如 "Last 7 days"）。 */
    presets?: DateRangePresetEntry[];
}

declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLDivElement>>;

declare const DateRangePicker: react.ForwardRefExoticComponent<DateRangePickerProps & react.RefAttributes<HTMLDivElement>>;

type CalendarMode = 'single' | 'range';
interface CalendarPanelProps {
    /** 模式：single 仅单选高亮；range 渲染区间高亮 + hover preview。 */
    mode?: CalendarMode;
    /** single 模式下当前选中。 */
    selected?: Date | null;
    /** range 模式下确认的区间。 */
    range?: {
        start: Date | null;
        end: Date | null;
    };
    /** range 模式下，hover preview 的目标 end（与 range.start 配合）。 */
    hoverEnd?: Date | null;
    /** 月份 anchor（受控）。 */
    monthAnchor?: Date;
    /** 月份 anchor（非受控初值）。 */
    defaultMonthAnchor?: Date;
    /** 月份 anchor 变更回调。 */
    onMonthAnchorChange?: (next: Date) => void;
    /** 单元格点击回调（已过滤 disabled / unavailable）。 */
    onSelectDate?: (date: Date) => void;
    /** range 模式下：cell hover 回调，用于驱动消费者维护 hoverEnd。 */
    onHoverDate?: (date: Date | null) => void;
    /** today 按钮点击。 */
    onToday?: () => void;
    /** clear 按钮点击。 */
    onClear?: () => void;
    /** 键盘 focus 的日期（受控/非受控均可由消费者覆盖；此处兜底）。 */
    focusedDate?: Date;
    /** focusedDate 变更回调（roving tabindex）。 */
    onFocusedDateChange?: (next: Date) => void;
    minValue?: Date;
    maxValue?: Date;
    isDateUnavailable?: (date: Date) => boolean;
    weekStartsOn?: WeekStartsOn;
    locale?: string;
    /** 是否渲染 footer 区域（[Today][Clear]）。 */
    showFooter?: boolean;
    /** 是否显示 Today 按钮（footer 上）。 */
    showTodayButton?: boolean;
    /** 是否显示 Clear 按钮（footer 上）。 */
    showClearButton?: boolean;
    /** 是否隐藏 prev/next（DateRangePicker 双月时左/右面板分别用得上）。 */
    hidePrevButton?: boolean;
    hideNextButton?: boolean;
    /** 面板尺寸预设，默认 'md'。 */
    panelSize?: DatePickerPanelSize;
    /**
     * 是否隐藏相邻月份的 outside-month cell（保留 grid 占位但不渲染数字 / 不可交互）。
     * DateRangePicker 双月视图用它避免两个 panel 重复显示同一天，视觉更克制。
     */
    hideOutsideMonth?: boolean;
    /** 自定义 footer 区域内容（覆盖默认按钮）。 */
    footer?: ReactNode;
    /** 整体 a11y label。 */
    'aria-label'?: string;
    className?: string;
    style?: CSSProperties;
    id?: string;
}
declare const CalendarPanel: react.ForwardRefExoticComponent<CalendarPanelProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-24
 * @description 定义 DateTimePicker 模块的共享 TypeScript 类型。
 *              在 DatePickerCommonProps 的基础上扩展 time 面板控制项 —— showMinute/showSecond
 *              允许消费者按需开放分/秒粒度，未开放的字段在 value 中恒定为 0。
 */

interface DateTimePickerProps extends DatePickerCommonProps {
    value?: DateValue | null;
    defaultValue?: DateValue | null;
    onChange?: (value: DateValue | null) => void;
    /** 是否开放分钟列；默认 true。设为 false 时 value 的分钟恒为 0。 */
    showMinute?: boolean;
    /** 是否开放秒钟列；默认 false。设为 true 才出现秒列，否则 value 的秒恒为 0。 */
    showSecond?: boolean;
    /** 小时步进，默认 1。 */
    hourStep?: number;
    /** 分钟步进，默认 1。 */
    minuteStep?: number;
    /** 秒钟步进，默认 1。 */
    secondStep?: number;
    /** 12 小时制（AM/PM）；默认 false（24 小时制）。 */
    is12Hour?: boolean;
    /** 底部 [Now] 按钮是否显示，默认 true —— 点击填入当前日期时间。 */
    showNowButton?: boolean;
    /** 底部 [OK] 按钮是否显示，默认 true —— 点击确认并关闭面板。 */
    showConfirmButton?: boolean;
    /** Now 按钮文案覆盖。 */
    nowLabel?: string;
    /** OK 按钮文案覆盖。 */
    confirmLabel?: string;
}

declare const DateTimePicker: react.ForwardRefExoticComponent<DateTimePickerProps & react.RefAttributes<HTMLDivElement>>;

interface TimePanelProps {
    /** 当前选中的 hour（24 小时制；0-23）。 */
    hour: number;
    minute: number;
    second: number;
    /** hour 变更回调；传回的依旧是 24 小时制。 */
    onHourChange: (next: number) => void;
    onMinuteChange: (next: number) => void;
    onSecondChange: (next: number) => void;
    showMinute?: boolean;
    showSecond?: boolean;
    is12Hour?: boolean;
    hourStep?: number;
    minuteStep?: number;
    secondStep?: number;
    locale?: string;
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
}
declare const TimePanel: react.ForwardRefExoticComponent<TimePanelProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-24
 * @description DateTimePicker 的纯时间工具函数集合。零依赖，SSR-safe，不修改入参 Date。
 *              与 DatePicker/date-utils.ts 互补：后者聚焦于"天 / 月 / 年"，此处聚焦于"时 / 分 / 秒"。
 */
/** 把任意 Date 规约到整小时（保留 y/m/d，mm/ss/ms 清零）。 */
declare const startOfHour: (d: Date) => Date;
/** 把任意 Date 规约到整分钟（ss/ms 清零）。 */
declare const startOfMinute: (d: Date) => Date;
/** 合并日期部分与时间部分 —— 取 datePart 的 y/m/d + timePart 的 h/m/s/ms，返回新 Date。 */
declare const withTime: (datePart: Date, hour: number, minute: number, second: number, ms?: number) => Date;
/** 用给定 h/m/s 覆盖目标 Date 的时间部分。 */
declare const setTime: (target: Date, hour: number, minute: number, second: number, ms?: number) => Date;
/** 同日（忽略时分秒）+ 完全相等的时分秒。null/undefined 一律 false。 */
declare const isSameDateTime: (a: Date | null | undefined, b: Date | null | undefined) => boolean;
/** 按 step 生成 [0, max) 范围内的整数数组（含 0）。step<=0 视作 1，max<=0 返回空。 */
declare const buildTimeOptions: (max: number, step: number) => number[];
/** 把 n 补到两位（"9" → "09"）。 */
declare const pad2: (n: number) => string;
/** 24 小时制 → 12 小时制的 hour 数字（0→12，1..12→1..12，13..23→1..11）。 */
declare const to12Hour: (hour24: number) => number;
/** 12 小时制 hour + period → 24 小时制。hour12 ∈ [1, 12]，period ∈ 'am'|'pm'。 */
declare const from12Hour: (hour12: number, period: "am" | "pm") => number;
/** 判断 24 小时制时刻是否 AM。 */
declare const isAm: (hour24: number) => boolean;
/**
 * DateTimePicker 的默认格式化。根据 showMinute/showSecond/is12Hour 组合输出：
 * - 默认 24 小时制 "YYYY-MM-DD HH:mm"。
 * - showSecond=true 时追加 ":ss"。
 * - showMinute=false 时省略 ":mm"（此时也不会有秒）。
 * - is12Hour=true 时后缀 " AM"/" PM"。
 */
declare const defaultDateTimeFormat: (d: Date, opts?: {
    showMinute?: boolean;
    showSecond?: boolean;
    is12Hour?: boolean;
    locale?: string;
}) => string;
/**
 * DateTimePicker 的默认解析。宽容接收：
 * - "YYYY-MM-DD HH[:mm[:ss]]"（可带尾部空格）
 * - "YYYY-MM-DD HH[:mm] AM/PM"
 * - 直接的 ISO 8601 字符串兜底
 * 任一失败返回 null。
 */
declare const defaultDateTimeParse: (s: string) => Date | null;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Avatar / AvatarGroup 组件的对外类型契约。
 */

type AvatarShape = 'circle' | 'square';
type AvatarStatus = 'online' | 'offline' | 'busy' | 'away';
type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type AvatarColor = 'neutral' | 'primary' | 'success' | 'warning' | 'danger' | 'auto';
interface AvatarProps {
    src?: string;
    alt?: string;
    name?: string;
    fallbackIcon?: ReactNode;
    size?: AvatarSize | number;
    shape?: AvatarShape;
    color?: AvatarColor;
    status?: AvatarStatus;
    isBordered?: boolean;
    onError?: () => void;
    className?: string;
}
type AvatarGroupSpacing = 'tight' | 'normal' | 'loose';
interface AvatarGroupProps {
    max?: number;
    total?: number;
    size?: AvatarProps['size'];
    spacing?: AvatarGroupSpacing;
    renderSurplus?: (count: number) => ReactNode;
    children?: ReactNode;
    className?: string;
}

declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLSpanElement>>;

declare const AvatarGroup: react.ForwardRefExoticComponent<AvatarGroupProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Tag 组件的对外类型契约。
 */

type TagColor = 'neutral' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
type TagVariant = 'solid' | 'soft' | 'outline';
type TagSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type TagShape = 'rounded' | 'pill';
interface TagProps {
    color?: TagColor;
    variant?: TagVariant;
    size?: TagSize;
    shape?: TagShape;
    isClosable?: boolean;
    isDisabled?: boolean;
    isInteractive?: boolean;
    startContent?: ReactNode;
    endContent?: ReactNode;
    onClose?: (e: MouseEvent) => void;
    onPress?: () => void;
    children?: ReactNode;
    className?: string;
    'aria-label'?: string;
}

/** @jsxImportSource @emotion/react */

declare const Tag: <T extends HTMLElement = HTMLElement>(props: TagProps & {
    ref?: React.Ref<T>;
}) => ReactElement;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Badge 组件的对外类型契约。
 */

type BadgeColor = 'neutral' | 'primary' | 'success' | 'warning' | 'danger';
type BadgeVariant = 'standard' | 'dot';
type BadgePlacement = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
interface BadgeProps {
    content?: ReactNode | number;
    variant?: BadgeVariant;
    color?: BadgeColor;
    placement?: BadgePlacement;
    max?: number;
    showZero?: boolean;
    isInvisible?: boolean;
    isOneCharacter?: boolean;
    isPulse?: boolean;
    showOutline?: boolean;
    children?: ReactNode;
    className?: string;
    'aria-label'?: string;
}

declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLSpanElement>>;

/**
 * @author Ryan He
 * @date 2026-04-18
 * @description 定义 Card 组件族的对外类型契约。
 */

type CardVariant = 'flat' | 'bordered' | 'elevated';
type CardColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
type CardSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type CardRadius = 'none' | 'sm' | 'md' | 'lg';
type CardAccentBar = 'start' | 'top' | 'none';
type CardFooterJustify = 'start' | 'end' | 'between';
interface CardClassNames {
    root?: string;
    header?: string;
    body?: string;
    footer?: string;
}
/**
 * onClick / color 与 native HTMLDivElement 同名但语义不同，剥出再声明。
 */
type StrippedDivKeys = 'onClick' | 'color';
interface CardProps extends Omit<HTMLAttributes<HTMLDivElement>, StrippedDivKeys> {
    variant?: CardVariant;
    color?: CardColor;
    size?: CardSize;
    radius?: CardRadius;
    isFullWidth?: boolean;
    isPressable?: boolean;
    isHoverable?: boolean;
    isDisabled?: boolean;
    accentBar?: CardAccentBar;
    as?: ElementType;
    href?: string;
    target?: string;
    rel?: string;
    onPress?: (e: MouseEvent<HTMLElement>) => void;
    onClick?: MouseEventHandler<HTMLElement>;
    className?: string;
    style?: CSSProperties;
    classNames?: CardClassNames;
    children?: ReactNode;
    'aria-label'?: string;
}
interface CardHeaderProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
    title?: ReactNode;
    subtitle?: ReactNode;
    startContent?: ReactNode;
    endContent?: ReactNode;
    as?: ElementType;
    className?: string;
    classNames?: Pick<CardClassNames, 'header'>;
    children?: ReactNode;
}
interface CardBodyProps extends HTMLAttributes<HTMLElement> {
    as?: ElementType;
    className?: string;
    children?: ReactNode;
}
interface CardFooterProps extends HTMLAttributes<HTMLElement> {
    as?: ElementType;
    justify?: CardFooterJustify;
    className?: string;
    children?: ReactNode;
}

/** @jsxImportSource @emotion/react */

declare const Card: <T extends HTMLElement = HTMLElement>(props: CardProps & {
    ref?: React.Ref<T>;
}) => ReactElement;

/** @jsxImportSource @emotion/react */

declare const CardHeader: <T extends HTMLElement = HTMLElement>(props: CardHeaderProps & {
    ref?: React.Ref<T>;
}) => ReactElement;

/** @jsxImportSource @emotion/react */

declare const CardBody: <T extends HTMLElement = HTMLElement>(props: CardBodyProps & {
    ref?: React.Ref<T>;
}) => ReactElement;

/** @jsxImportSource @emotion/react */

declare const CardFooter: <T extends HTMLElement = HTMLElement>(props: CardFooterProps & {
    ref?: React.Ref<T>;
}) => ReactElement;

/**
 * @author Ryan He
 * @date 2026-04-18
 * @description 定义 StatCard 组件的对外类型契约。
 */

type StatCardDeltaDirection = 'up' | 'down' | 'flat';
type StatCardDeltaPolarity = 'positive' | 'negative' | 'neutral' | 'auto';
interface StatCardDelta {
    value: ReactNode;
    direction?: StatCardDeltaDirection;
    polarity?: StatCardDeltaPolarity;
}
type StatCardEmphasis = 'subtle' | 'default' | 'strong';
type StatCardValueAlign = 'start' | 'center';
type StatCardIconPlacement = 'start' | 'end';
interface StatCardClassNames extends CardClassNames {
    label?: string;
    value?: string;
    delta?: string;
    icon?: string;
    description?: string;
    trend?: string;
}
interface StatCardSrLabels {
    valueLabel?: string;
    deltaLabel?: string;
}
interface StatCardProps {
    variant?: CardVariant;
    color?: CardColor;
    size?: CardSize;
    radius?: CardRadius;
    isFullWidth?: boolean;
    isPressable?: boolean;
    isHoverable?: boolean;
    isDisabled?: boolean;
    accentBar?: CardAccentBar;
    as?: ElementType;
    href?: string;
    target?: string;
    rel?: string;
    onPress?: (e: MouseEvent<HTMLElement>) => void;
    onClick?: MouseEventHandler<HTMLElement>;
    className?: string;
    style?: CSSProperties;
    'aria-label'?: string;
    label: ReactNode;
    value: ReactNode;
    description?: ReactNode;
    icon?: ReactNode;
    iconPlacement?: StatCardIconPlacement;
    delta?: StatCardDelta;
    trend?: ReactNode;
    hasTrendBleed?: boolean;
    isLoading?: boolean;
    emphasis?: StatCardEmphasis;
    valueAlign?: StatCardValueAlign;
    sr?: StatCardSrLabels;
    classNames?: StatCardClassNames;
}

/** @jsxImportSource @emotion/react */

declare const StatCard: <T extends HTMLElement = HTMLElement>(props: StatCardProps & {
    ref?: React.Ref<T>;
}) => ReactElement;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Skeleton / SkeletonGroup 组件的对外类型契约。
 */

type SkeletonShape = 'rect' | 'circle' | 'text';
type SkeletonAnimation = 'shimmer' | 'pulse' | 'none';
interface SkeletonProps {
    shape?: SkeletonShape;
    width?: number | string;
    height?: number | string;
    lines?: number;
    radius?: number | string;
    animation?: SkeletonAnimation;
    isLoaded?: boolean;
    children?: ReactNode;
    className?: string;
    'aria-label'?: string;
}
interface SkeletonGroupProps {
    isLoaded?: boolean;
    animation?: SkeletonAnimation;
    children?: ReactNode;
    className?: string;
}

declare const Skeleton: react.ForwardRefExoticComponent<SkeletonProps & react.RefAttributes<HTMLSpanElement>>;

declare const SkeletonGroup: react.ForwardRefExoticComponent<SkeletonGroupProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Empty 组件的对外类型契约。
 */

type EmptySize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type EmptyImagePreset = 'default' | 'search' | 'error' | 'no-data';
interface EmptyProps {
    image?: ReactNode | EmptyImagePreset;
    title?: ReactNode;
    description?: ReactNode;
    actions?: ReactNode;
    size?: EmptySize;
    variant?: 'default' | 'inline';
    className?: string;
    children?: ReactNode;
}

declare const Empty: react.ForwardRefExoticComponent<EmptyProps & react.RefAttributes<HTMLDivElement>>;

/**
 * @author Ryan He
 * @date 2026-04-17
 * @description 定义 Steps 模块的 TypeScript 类型约束。
 */

type StepStatus = 'wait' | 'process' | 'finish' | 'error';
type StepsDirection = 'horizontal' | 'vertical';
type StepsVariant = 'default' | 'dot' | 'navigation';
type StepsSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface StepItem {
    /** 唯一 key（缺省时回退到 index）。 */
    itemKey?: string;
    /** 标题，必需。 */
    title: ReactNode;
    /** 描述，可选。 */
    description?: ReactNode;
    /** 自定义 indicator 图标（覆盖 default 编号 / dot / 勾）。 */
    icon?: ReactNode;
    /** 显式状态覆盖自动推断（最高优先级）。 */
    status?: StepStatus;
    /** 单独禁用该 step（不可点击 / 视觉淡化）。 */
    isDisabled?: boolean;
}
interface StepsProps {
    /** 步骤数据。 */
    items: StepItem[];
    /** 受控当前 step 索引（0-based）。 */
    activeIndex?: number;
    /** 非受控初始当前 step 索引（0-based），默认 0。 */
    defaultActiveIndex?: number;
    /** 当前 step 变更回调。 */
    onActiveIndexChange?: (index: number) => void;
    /** 当前 step 的整体状态，默认 'process'。仅影响 current step 的视觉。 */
    status?: StepStatus;
    /** 排列方向，默认 'horizontal'。 */
    direction?: StepsDirection;
    /** 渲染变体，默认 'default'。 */
    variant?: StepsVariant;
    /** 尺寸，默认 'md'。 */
    size?: StepsSize;
    /** 是否允许点击 step 跳转（navigation 默认 true）。 */
    isClickable?: boolean;
    /** indicator 之前的自定义渲染前缀（如步骤计数 chip）。 */
    startContent?: ReactNode;
    className?: string;
    style?: CSSProperties;
    id?: string;
    'aria-label'?: string;
}

declare const Steps: react.ForwardRefExoticComponent<StepsProps & react.RefAttributes<HTMLOListElement>>;

export { Avatar, type AvatarColor, AvatarGroup, type AvatarGroupProps, type AvatarGroupSpacing, type AvatarProps, type AvatarShape, type AvatarSize, type AvatarStatus, Badge, type BadgeColor, type BadgePlacement, type BadgeProps, type BadgeVariant, Box, type BoxProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, type CalendarCell, type CalendarMode, CalendarPanel, type CalendarPanelProps, Callout, type CalloutProps, type CalloutVariant, Card, type CardAccentBar, CardBody, type CardBodyProps, type CardClassNames, type CardColor, CardFooter, type CardFooterJustify, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, type CardRadius, type CardSize, type CardVariant, ChatActionButton, type ChatActionButtonProps, ChatAvatar, type ChatAvatarProps, type ChatAvatarSource, type ChatCommonStyleProps, ChatComposer, type ChatComposerProps, type ChatKnowledgeReference, ChatKnowledgeRefs, type ChatKnowledgeRefsProps, ChatMessage, ChatMessageList, type ChatMessageListProps, type ChatMessageProps, type ChatMessageRole, ChatSendButton, type ChatSendButtonProps, ChatToolCall, type ChatToolCallData, type ChatToolCallProps, type ChatToolCallStatus, ChatTypingIndicator, type ChatTypingIndicatorProps, ChatVoiceWave, type ChatVoiceWaveColor, type ChatVoiceWaveProps, type ChatVoiceWaveSize, Checkbox, type CheckboxColor, CheckboxGroup, type CheckboxGroupOrientation, type CheckboxGroupProps, type CheckboxProps, type CheckboxRadius, type CheckboxSize, Code, Container, type ContainerProps, DatePicker, type DatePickerCommonProps, type DatePickerPanelSize, type DatePickerProps, type DatePickerSize, DateRangePicker, type DateRangePickerProps, type DateRangePresetEntry, type DateRangeValue, type DateRangeWorking, DateTimePicker, type DateTimePickerProps, type DateValue, Drawer, DrawerBody, type DrawerBodyProps, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerPlacement, type DrawerProps, type DrawerScrollBehavior, type DrawerSize, Empty, type EmptyImagePreset, type EmptyProps, type EmptySize, Flex, type FlexProps, FormField, type FormFieldInjectedChildProps, type FormFieldLabelPlacement, type FormFieldProps, Grid, type GridProps, Heading, type HeadingProps, Input, type InputColor, type InputProps, type InputRadius, type InputSize, type InputType, type InputVariant, Link, Menu, MenuDivider, type MenuDividerProps, MenuItem, type MenuItemDescriptor, type MenuItemProps, type MenuItemsEntry, type MenuProps, MenuRow, type MenuRowProps, MenuSection, type MenuSectionDescriptor, type MenuSectionProps, type MenuSelectionMode, MenuSubMenu, type MenuTriggerRenderProps, Modal, ModalBody, type ModalBodyProps, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalProps, type ModalScrollBehavior, type ModalSize, Pagination, type PaginationItem, type PaginationLabels, type PaginationProps, type PaginationSize, type PaginationVariant, Paragraph, Popover, type PopoverAnchorRenderProps, type PopoverPlacement, type PopoverProps, type PopoverSide, type PopoverTrigger, Radio, type RadioColor, RadioGroup, type RadioGroupOrientation, type RadioGroupProps, type RadioProps, type RadioSize, Search, SearchDialog, type SearchDialogItem, type SearchDialogProps, type SearchDialogSection, type SearchProps, type SearchSize, type SearchVariant, SegmentedControl, type SegmentedControlColor, type SegmentedControlOption, type SegmentedControlOrientation, type SegmentedControlProps, type SegmentedControlSize, Select, type SelectItem, SelectOption, type SelectOptionProps, type SelectProps, type SelectRadius, type SelectSize, type SelectionMode, Skeleton, type SkeletonAnimation, SkeletonGroup, type SkeletonGroupProps, type SkeletonProps, type SkeletonShape, Slider, type SliderColor, type SliderOrientation, type SliderProps, type SliderSize, type SliderValue, type SortDescriptor, type SortDirection, Stack, type StackProps, StatCard, type StatCardClassNames, type StatCardDelta, type StatCardDeltaDirection, type StatCardDeltaPolarity, type StatCardEmphasis, type StatCardIconPlacement, type StatCardProps, type StatCardSrLabels, type StatCardValueAlign, type StepItem, type StepStatus, Steps, type StepsDirection, type StepsProps, type StepsSize, type StepsVariant, Switch, type SwitchColor, type SwitchProps, type SwitchSize, Tab, type TabItem, TabPanel, type TabPanelProps, type TabProps, Table, type TableAlign, type TableColumn, type TableDensity, type TableFixed, type TableProps, Tabs, type TabsOrientation, type TabsProps, type TabsSize, type TabsVariant, Tag, type TagColor, type TagProps, type TagShape, type TagSize, type TagVariant, Text, type TextProps, type TextSize, type TextWeight, Textarea, type TextareaColor, type TextareaProps, type TextareaRadius, type TextareaSize, type TextareaVariant, TimePanel, type TimePanelProps, type ToastAction, type ToastApi, type ToastInstance, ToastItem, type ToastOptions, type ToastPlacement, type ToastPromiseMessages, ToastProvider, type ToastProviderProps, type ToastStatus, Tooltip, type TooltipPlacement, type TooltipProps, Upload, type UploadColor, type UploadFile, type UploadFileStatus, type UploadHandle, UploadItem, type UploadItemProps, UploadList, type UploadListProps, type UploadProps, type UploadRejectReason, type UploadRequest, type UploadRequestArgs, type UploadRequestHandlers, type UploadSize, type UploadVariant, type UseChatStreamOptions, type UseChatStreamResult, type WeekStartsOn, addDays, addMonths, addYears, buildCalendarMatrix, buildPaginationItems, buildTimeOptions, buildWeekDayOrder, clampDate, compareDays, defaultDateTimeFormat, defaultDateTimeParse, defaultFormat, defaultParse, endOfMonth, from12Hour, getDaysInMonth, isAm, isInRange, isInRangeExclusive, isSameDateTime, isSameDay, isSameMonth, isWithinBounds, monthLabel, normalizeRange, pad2, setTime, startOfCalendarGrid, startOfDay, startOfHour, startOfMinute, startOfMonth, to12Hour, toast, useChatStream, useToast, weekdayLabels, withTime };
