/// <reference types="react" />
import { Props } from 'react-svg';
import * as react from 'react';
import react__default, { ComponentPropsWithoutRef, ReactNode, MouseEventHandler, ComponentType, HTMLAttributeAnchorTarget, FC, SVGAttributes, HTMLAttributes, ComponentPropsWithRef, ElementType, MutableRefObject, PropsWithChildren, CSSProperties, Key, PointerEventHandler, ForwardedRef, ReactElement, InputHTMLAttributes, ComponentClass, MouseEvent, FocusEvent, KeyboardEventHandler, Dispatch, SetStateAction, KeyboardEvent } from 'react';
import { EventEmitter, EventHandler, Event } from '@billjs/event-emitter';
import { FloatingContext, ReferenceType, Placement, VirtualElement, MiddlewareArguments } from '@floating-ui/react-dom-interactions';
import * as react_select from 'react-select';
import { OptionsOrGroups, GroupBase, DropdownIndicatorProps, ClearIndicatorProps, SelectInstance } from 'react-select';
export { MultiValue, PropsValue, SelectInstance, SingleValue } from 'react-select';
import { ForwardRefComponent } from '@radix-ui/react-polymorphic';
import { AsyncCreatableProps } from 'react-select/async-creatable';
import { Locale } from 'rc-picker/lib/interface';
import { PickerTimeProps as PickerTimeProps$1, PickerDateProps as PickerDateProps$1, PickerBaseProps as PickerBaseProps$1 } from 'rc-picker/lib/Picker';
import { RangePickerTimeProps as RangePickerTimeProps$1, RangePickerBaseProps as RangePickerBaseProps$1, RangePickerDateProps as RangePickerDateProps$1 } from 'rc-picker/lib/RangePicker';
import { Dayjs } from 'dayjs';
import { ContentEditableEvent } from 'react-contenteditable';
import { UseFormReturn, ControllerProps, UseFormProps as UseFormProps$1, UseFormWatch, WatchObserver } from 'react-hook-form';
export { ControllerRenderProps, FieldArrayWithId, FieldValues, UseFormHandleSubmit, UseFormReset, UseFormResetField, UseFormReturn, UseFormSetValue, UseFormWatch, WatchObserver, useFieldArray } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { VariableSizeListProps } from 'react-window';
import { ItemInterface } from 'react-sortablejs';
import { Area, MediaSize } from 'react-easy-crop';

interface IconProps extends Omit<Props, 'src'> {
    /**
     * 图标名称，不用写前缀路径和后缀类型。
     * 文件保存在 `./public/icons/example.svg`，传参则为 `name="example"`
     */
    name?: string;
    /**
     * 图标宽度
     * @default 16
     */
    width?: number;
    /**
     * 图标高度
     * @default 16
     */
    height?: number;
    /**
     * 包裹 SVG 的容器元素
     * @default span
     */
    wrapper?: Props['wrapper'];
    className?: string;
}
/**
 * 对 ReactSVG 进行封装，更方便调用并增强对 A11y 的支持
 */
declare const Icon: {
    ({ name, width, height, className, ...props }: IconProps): JSX.Element;
    displayName: string;
};

declare const LoaderCircle: {
    ({ className }: {
        className?: string | undefined;
    }): JSX.Element;
    displayName: string;
};

declare const LoaderDot: {
    ({ className }: {
        className?: string | undefined;
    }): JSX.Element;
    displayName: string;
};

interface DividerProps extends ComponentPropsWithoutRef<'div'> {
    children?: ReactNode;
    className?: string;
    colorClassName?: string;
    margin?: boolean;
    intent?: 'default' | 'gradient';
    text?: string;
    textClassName?: string;
    thickness?: '1px' | '2px' | '3px';
    orientation?: 'vertical' | 'horizontal';
}
declare const Divider: {
    ({ children, className, colorClassName, margin, intent, text, textClassName, thickness, orientation, ...props }: DividerProps): JSX.Element;
    displayName: string;
};

interface AvatarProps {
    children?: ReactNode;
    character?: string;
    className?: string;
    useId?: string;
    image?: string;
    title?: string;
}
declare const Avatar: {
    ({ children, character, className, image, title, ...rest }: AvatarProps): JSX.Element;
    displayName: string;
};

interface BadgeProps extends ComponentPropsWithoutRef<'div'> {
    /**
     * 激活样式
     */
    active?: boolean;
    /**
     * 前缀
     */
    prefix?: string;
    /**
     * 前缀
     */
    indicators?: ReactNode;
    /**
     * 后缀
     */
    suffix?: ReactNode;
    /**
     * 子节点
     */
    children?: ReactNode;
    /**
     * 样式类
     */
    className?: string;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 是否hover
     */
    hover?: boolean;
    /**
     * 是否focus
     */
    bodyEvent?: boolean;
    /**
     * 前缀icon
     */
    icon?: string;
    /**
     * 样式主题
     */
    intent?: 'default' | 'primary' | 'danger' | 'success' | 'warning' | 'violet' | 'secondary' | 'dynamic';
    /**
     * 尺寸大小
     */
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    /**
     * 尺寸样式
     */
    sizeClassName?: string;
    /**
     * 圆角样式
     */
    roundedClassName?: string;
    /**
     * label容器类
     */
    labelContainerClassName?: string;
    /**
     * 文本内容
     */
    text?: ReactNode;
    /**
     * 样式变体
     */
    variant?: 'normal' | 'outlined' | 'minimal';
    /**
     * 是否显示移除按钮
     */
    removable?: boolean;
    /**
     * 移除按钮点击事件(removable为 true 时才生效)
     */
    onRemove?: MouseEventHandler;
    /**
     * 移除按钮属性(removable为 true 时才生效)
     */
    removeBtnProps?: ComponentPropsWithoutRef<'button'>;
}
declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLDivElement>>;

interface StepsProps {
    className?: string;
    textClassName?: string;
    stepSize?: string;
    intent?: 'default' | 'primary';
    orientation?: 'vertical' | 'horizontal';
    stepsOption?: {
        text?: string;
        active?: boolean;
    }[];
}
declare const Steps: {
    ({ className, stepsOption, intent, textClassName, orientation, stepSize, }: StepsProps): JSX.Element;
    displayName: string;
};

interface BreadcrumbLinkProps {
    text?: string;
    route?: string;
    icon?: string;
}
interface BreadcrumbsProps {
    className?: string;
    linkTag?: ComponentType;
    breadcrumbsOptions?: BreadcrumbLinkProps[];
}
declare function Breadcrumbs({ className, linkTag, breadcrumbsOptions, }: BreadcrumbsProps): JSX.Element;

interface MessagesProps {
    children?: ReactNode;
    className?: string;
    icon?: string;
    text?: ReactNode;
    intent?: 'default' | 'primary' | 'danger' | 'success' | 'warning' | 'violet' | 'secondary' | 'dynamic';
    variant?: 'normal' | 'outlined' | 'minimal';
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    sizeClassName?: string;
    textClassName?: string;
}
declare const Messages: react.ForwardRefExoticComponent<MessagesProps & react.RefAttributes<HTMLDivElement>>;

interface NavbarOption {
    disabled?: boolean;
    icon?: string;
    id: number;
    route?: string;
    target?: HTMLAttributeAnchorTarget;
    text?: string;
}
interface NavbarProps extends ComponentPropsWithoutRef<'div'> {
    active: NavbarOption;
    setActive?: (option: NavbarOption) => void;
    className?: string;
    indicatorWidthClassName?: string;
    intent?: 'default' | 'primary' | 'dynamic';
    navbarHeightClassName?: string;
    roundedClassName?: string;
    paddingClassName?: string;
    navbarOptions: NavbarOption[];
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    variant?: 'border' | 'block';
}
declare function Navbar({ active, setActive, className, indicatorWidthClassName, intent, variant, navbarHeightClassName, navbarOptions, setSize, roundedClassName, paddingClassName, }: NavbarProps): JSX.Element;
declare namespace Navbar {
    var displayName: string;
}

interface ProgressBarProps {
    className?: string;
    children(params: {
        progress: number;
    }): ReactNode;
    progress: number;
    colorClassName?: string;
    sizeClassName?: string;
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    text?: string;
    textClassName?: string;
    progressClassName?: string;
    low?: number;
    medium?: number;
}
declare const ProgressBar: {
    ({ className, children, colorClassName, progress, setSize, sizeClassName, low, medium, textClassName, progressClassName, }: ProgressBarProps): JSX.Element;
    displayName: string;
};

interface IProps {
    arialabel?: string;
    background?: string;
    center?: string;
    circumference?: number;
    className?: string;
    diameter?: number;
    font?: string;
    progress?: number;
    radius?: string;
    size?: number;
    strokeWidth?: number;
    text?: boolean;
    transform?: string;
}
declare const ProgressCircle: FC<IProps>;

interface ChoiceformLogoProps extends SVGAttributes<SVGAElement> {
    GradientId?: string;
    className?: string;
    sizeClassName?: string;
    construction?: 'icon' | 'wordmark';
    intent?: 'default' | 'dynamic';
    /**
     * TODO: 调查加载不到 tailwind 样式的原因
     * 生产环境下，SSR 渲染页面阶段会有一段时间，页面上的所有 tailwind 样式都加载不到
     * 导致整个 logo 变得巨大
     * 使用这个属性临时限制下 svg 的 size
     */
    limitMaxSizeForSSR__TEMP?: boolean;
}
declare const ChoiceformLogo: {
    ({ className, construction, sizeClassName, intent, limitMaxSizeForSSR__TEMP, }: ChoiceformLogoProps): JSX.Element;
    displayName: string;
};

interface FooterProps extends HTMLAttributes<HTMLDivElement> {
    children?: ReactNode;
    className?: string;
    footerOptions?: {
        ul?: {
            text?: string;
            title?: string;
            route?: string;
        }[];
    }[];
}
declare const Footer: {
    ({ children, className, footerOptions, ...rest }: FooterProps): JSX.Element;
    displayName: string;
};

declare type Nullable<T> = T | null;
interface Pane {
    /** 标识该窗格是否为主导窗格，主导窗格将优先占据可用空间 */
    dominant?: boolean;
    /** 是否隐藏 */
    isHidden: boolean;
    /** 最大宽度约束，单位：像素 */
    maxSize?: number;
    /** 最小宽度约束，单位：像素 */
    minSize?: number;
    /** 初始化时在容器内的尺寸占比 */
    proportion: number;
    /** 当接近 {@link minSize} 的距离达到此值时，自动吸附到 {@link minSize} */
    snap?: number;
}
declare type Orientation = 'horizontal' | 'vertical';
interface SplitterEngineParams {
    /** 分割窗格的拖动方 {@link Orientation} */
    orientation?: Orientation;
    /** 一组窗格对象 {@link Pane}，数量应与 UI 渲染的窗格数量匹配 */
    panes: Pane[];
    /** 窗框的尺寸，改值会被设置为 `--splitter-sash-size` CSS 变量 */
    sashSize?: number;
    /** 虚拟把手的宽度尺寸，改值会被设置为 `--splitter-indicator-width` CSS 变量 */
    indicatorWidth?: number;
    /** 虚拟把手的高度尺寸，改值会被设置为 `--splitter-indicator-height` CSS 变量 */
    indicatorHeight?: number;
    /** 虚拟把手的样式名 */
    indicatorClassName?: string;
    /** 尺寸调整区域的样式名 */
    resizerClassName?: string;
    /** 是否渲染跟随鼠标位置的指示器 */
    useIndicator?: boolean;
}
interface ContainerResizeEvent extends Event {
    type: 'container:resize';
    data: {
        width: number;
        height: number;
    };
}
interface PaneToggleEvent extends Event {
    type: 'pane:toggle';
    data: {
        pane: Pane;
        index: number;
    };
}
interface PanesResizeEvent extends Event {
    type: 'panes:resize';
    data: {
        sizes: number[];
        switchFlag: boolean;
    };
}
declare type SplitterEvents = ContainerResizeEvent | PaneToggleEvent | PanesResizeEvent;
declare type SplitterEventTypes = SplitterEvents['type'];
declare class SplitterEngine extends EventEmitter {
    /** An instance of `ResizeObserver` for monitoring the container */
    private observer?;
    /** The outer-most wrapper element of the `Splitter` component */
    private container;
    /**
     * The size of the dominant pane in the {@link container}, could be width or
     * height depends on the {@link orientation}
     */
    private containerSize;
    private sizes;
    private sizesBeforeOverrided;
    private initSizes;
    orientation: Orientation;
    get isHorizontal(): boolean;
    get isVertical(): boolean;
    panes: Pane[];
    get dominantIndex(): number;
    sashSize: number;
    indicatorWidth: number;
    indicatorHeight: number;
    indicatorClassName: string;
    resizerClassName: string;
    get numberOfSashes(): number;
    get totalSizeOfSashes(): number;
    get availableSize(): number;
    useIndicator: boolean;
    private layoutMode;
    /**
     * 布局模式：
     * 1. `fixed` 仅保留一个窗格，且宽度为固定撑满整个容器，多个窗格可以切换
     * 2. `fluid` 可以保留多个窗格，主导窗格自适应空余的宽度，其他窗格可以切换
     */
    get mode(): 'fixed' | 'fluid';
    set mode(value: 'fixed' | 'fluid');
    /**
     * A layout engine for the inner state management of the `Splitter` component.
     */
    constructor(container: HTMLElement | null, params: SplitterEngineParams);
    on(type: SplitterEventTypes, handler: EventHandler): boolean;
    private initial;
    /** A callback for resizings, emit {@link ContainerResizeEvent} at the same time */
    private onContainerResizing;
    private distributeSizes;
    /**
     * 重新计算并分派窗格的尺寸，通常这个方法会由 UI 事件触发，在计算完成之后会再
     * 发送 {@link PanesResizeEvent}
     * @param index 窗框序号
     * @param delta 鼠标移动的增量
     * @param total 鼠标移动的总量
     */
    redistributeSizes(index: number, delta: {
        x: number;
        y: number;
    }, total: {
        x: number;
        y: number;
    }): void;
    private getUpdatedSize;
    getDiffToInitSize(index: number): number;
    getProportions(): number[] | undefined;
    hidePane(index: number, silence?: boolean): Pane | undefined;
    hidePanes(indices: number[]): Pane[] | undefined;
    showPane(index: number, silence?: boolean): Pane | undefined;
    showPanes(indices: number[]): Pane[] | undefined;
    /**
     * 切换一个指定窗格的显隐
     * @param index 下标，对应 {@link panes} 列表里的下标
     * @param options.proportion 是否使用新的占比，一次性
     * @param options.silence 是否触发 {@link PaneToggleEvent}
     */
    togglePane(index: number, options?: {
        proportion?: number;
        silence?: boolean;
    }): Pane | undefined;
    /**
     * 切换多个窗格的显隐，成功后会触发 {@link_PanesToggleEvent}
     * @param indices 下标列表，对应 {@link panes} 列表里的下标
     * @param proportions 占比列表，可以使用 `Infinity`，注意总和不能超过 100
     */
    togglePanes(indices: number[], proportions?: number[]): Pane[] | undefined;
    /** 切换指定窗格，同时会隐藏其他窗格 */
    switchPane(index: number): void;
    /** 在两个窗格之间切换，如果都隐藏则默认先显示第一个 */
    eitherPane([aIndex, bIndex]: [aIndex: number, bIndex: number]): void;
    /** 检查指定窗格是否隐藏 */
    isPaneHidden(index: number): boolean;
    /** 通过下标检测是否附着于主导窗格 */
    isDominantPane(index: number): boolean;
    /**
     * 检查指定窗格是否是当前可见的第一个，这个检查用于复合条件的检查，例如：当第
     * 一个窗格（没有配套的窗框）隐藏时，第二个窗格（有用于分割第一个和第二个窗格
     * 的窗框）变成了第一个，但是它配套的窗框需要隐藏起来。
     */
    isTheFirstVisiblePane(index: number): boolean;
    isGrowablePane(index: number): boolean | undefined;
    destroy(): void;
}
declare function assertIsEngine(engine: unknown): asserts engine is SplitterEngine;
declare function assertIsNumber(number: unknown): asserts number is number;
declare function assertIsHTMLElement(element: unknown): asserts element is HTMLElement;

interface SplitterResizerProps extends HTMLAttributes<HTMLElement> {
    engine?: SplitterEngine;
    index?: number;
}

interface SplitterPaneProps extends HTMLAttributes<HTMLElement> {
    bodyClassName?: string;
    className?: string;
    engine?: SplitterEngine;
    headerComponent?: JSX.Element;
    index?: number;
    paddingClassName?: string | false;
    roundedClassName?: string | false;
}

interface SplitterProps extends HTMLAttributes<HTMLElement> {
    /** 用于持有 Splitter 最外层容器元素的引用 */
    containerRef: (container: Nullable<HTMLElement>) => void;
    /** Splitter 布局引擎 - 由 useSplitter 钩子生成 */
    engine: SplitterEngine;
}
declare const Splitter: {
    ({ engine, containerRef, className, children, ...props }: SplitterProps): JSX.Element;
    displayName: string;
} & {
    Pane: {
        ({ bodyClassName, children, className, engine, headerComponent, index, paddingClassName, roundedClassName, ...props }: SplitterPaneProps): JSX.Element | null;
        displayName: string;
    };
    Resizer: {
        ({ engine, index, className, ...props }: SplitterResizerProps): JSX.Element | null;
        displayName: string;
    };
};

declare const useSplitter: (params: SplitterEngineParams) => {
    engine: SplitterEngine;
    paneState: {
        isHidden: boolean;
    }[];
    splitterProps: SplitterProps;
};

interface SplitterPanelProps extends HTMLAttributes<HTMLElement> {
    children?: ReactNode;
    className?: string;
    bgClassName?: string;
    bodyClassName?: string;
    paddingClassName?: string | boolean;
    roundedClassName?: string | boolean;
    intent?: 'default' | 'dynamic';
    showPanelHeader?: boolean;
    initialSize?: number;
    minSize?: number;
    maxSize?: number;
    panelTabsOptions?: {
        active?: boolean;
        id?: string;
        icon?: string;
        text?: string;
        tabToggle?: boolean;
    }[];
    headerComponent?: JSX.Element;
}
declare const SplitterPanel: {
    ({ children, className, bodyClassName, bgClassName, paddingClassName, roundedClassName, intent, headerComponent, ...rest }: SplitterPanelProps): JSX.Element;
    displayName: string;
};

interface ButtonProps extends ComponentPropsWithRef<'button'> {
    active?: boolean;
    alignment?: 'left' | 'center' | 'right';
    beforeComponent?: ReactNode;
    afterComponent?: ReactNode;
    children?: ReactNode;
    className?: string;
    disabled?: boolean;
    icon?: string;
    intent?: 'default' | 'primary' | 'danger' | 'dynamic';
    intentClassName?: string;
    loading?: boolean;
    paddingClassName?: string;
    roundedClassName?: string;
    setSize?: 'xxs' | 'xs' | 'sm' | 'md' | 'lg';
    sizeClassName?: string;
    text?: string;
    textClassName?: string;
    type?: 'submit' | 'reset' | 'button';
    variant?: 'normal' | 'outlined' | 'solid' | 'minimal' | 'ghost' | 'fade' | 'link';
    variantClassName?: string;
    target?: HTMLAttributeAnchorTarget;
    Component?: ElementType;
}
declare const Button: react.ForwardRefExoticComponent<Pick<ButtonProps, "form" | "slot" | "style" | "title" | "text" | "key" | "autoFocus" | "disabled" | "formAction" | "formEncType" | "formMethod" | "formNoValidate" | "formTarget" | "name" | "type" | "value" | "defaultChecked" | "defaultValue" | "suppressContentEditableWarning" | "suppressHydrationWarning" | "accessKey" | "className" | "contentEditable" | "contextMenu" | "dir" | "draggable" | "hidden" | "id" | "lang" | "placeholder" | "spellCheck" | "tabIndex" | "translate" | "radioGroup" | "role" | "about" | "datatype" | "inlist" | "prefix" | "property" | "resource" | "typeof" | "vocab" | "autoCapitalize" | "autoCorrect" | "autoSave" | "color" | "itemProp" | "itemScope" | "itemType" | "itemID" | "itemRef" | "results" | "security" | "unselectable" | "inputMode" | "is" | "aria-activedescendant" | "aria-atomic" | "aria-autocomplete" | "aria-busy" | "aria-checked" | "aria-colcount" | "aria-colindex" | "aria-colspan" | "aria-controls" | "aria-current" | "aria-describedby" | "aria-details" | "aria-disabled" | "aria-dropeffect" | "aria-errormessage" | "aria-expanded" | "aria-flowto" | "aria-grabbed" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-keyshortcuts" | "aria-label" | "aria-labelledby" | "aria-level" | "aria-live" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-owns" | "aria-placeholder" | "aria-posinset" | "aria-pressed" | "aria-readonly" | "aria-relevant" | "aria-required" | "aria-roledescription" | "aria-rowcount" | "aria-rowindex" | "aria-rowspan" | "aria-selected" | "aria-setsize" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "children" | "dangerouslySetInnerHTML" | "onCopy" | "onCopyCapture" | "onCut" | "onCutCapture" | "onPaste" | "onPasteCapture" | "onCompositionEnd" | "onCompositionEndCapture" | "onCompositionStart" | "onCompositionStartCapture" | "onCompositionUpdate" | "onCompositionUpdateCapture" | "onFocus" | "onFocusCapture" | "onBlur" | "onBlurCapture" | "onChange" | "onChangeCapture" | "onBeforeInput" | "onBeforeInputCapture" | "onInput" | "onInputCapture" | "onReset" | "onResetCapture" | "onSubmit" | "onSubmitCapture" | "onInvalid" | "onInvalidCapture" | "onLoad" | "onLoadCapture" | "onError" | "onErrorCapture" | "onKeyDown" | "onKeyDownCapture" | "onKeyPress" | "onKeyPressCapture" | "onKeyUp" | "onKeyUpCapture" | "onAbort" | "onAbortCapture" | "onCanPlay" | "onCanPlayCapture" | "onCanPlayThrough" | "onCanPlayThroughCapture" | "onDurationChange" | "onDurationChangeCapture" | "onEmptied" | "onEmptiedCapture" | "onEncrypted" | "onEncryptedCapture" | "onEnded" | "onEndedCapture" | "onLoadedData" | "onLoadedDataCapture" | "onLoadedMetadata" | "onLoadedMetadataCapture" | "onLoadStart" | "onLoadStartCapture" | "onPause" | "onPauseCapture" | "onPlay" | "onPlayCapture" | "onPlaying" | "onPlayingCapture" | "onProgress" | "onProgressCapture" | "onRateChange" | "onRateChangeCapture" | "onSeeked" | "onSeekedCapture" | "onSeeking" | "onSeekingCapture" | "onStalled" | "onStalledCapture" | "onSuspend" | "onSuspendCapture" | "onTimeUpdate" | "onTimeUpdateCapture" | "onVolumeChange" | "onVolumeChangeCapture" | "onWaiting" | "onWaitingCapture" | "onAuxClick" | "onAuxClickCapture" | "onClick" | "onClickCapture" | "onContextMenu" | "onContextMenuCapture" | "onDoubleClick" | "onDoubleClickCapture" | "onDrag" | "onDragCapture" | "onDragEnd" | "onDragEndCapture" | "onDragEnter" | "onDragEnterCapture" | "onDragExit" | "onDragExitCapture" | "onDragLeave" | "onDragLeaveCapture" | "onDragOver" | "onDragOverCapture" | "onDragStart" | "onDragStartCapture" | "onDrop" | "onDropCapture" | "onMouseDown" | "onMouseDownCapture" | "onMouseEnter" | "onMouseLeave" | "onMouseMove" | "onMouseMoveCapture" | "onMouseOut" | "onMouseOutCapture" | "onMouseOver" | "onMouseOverCapture" | "onMouseUp" | "onMouseUpCapture" | "onSelect" | "onSelectCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onScroll" | "onScrollCapture" | "onWheel" | "onWheelCapture" | "onAnimationStart" | "onAnimationStartCapture" | "onAnimationEnd" | "onAnimationEndCapture" | "onAnimationIteration" | "onAnimationIterationCapture" | "onTransitionEnd" | "onTransitionEndCapture" | "active" | "alignment" | "beforeComponent" | "afterComponent" | "icon" | "intent" | "intentClassName" | "loading" | "paddingClassName" | "roundedClassName" | "setSize" | "sizeClassName" | "textClassName" | "variant" | "variantClassName" | "target" | "Component"> & react.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;

interface SwapButtonProps extends ComponentPropsWithRef<'button'> {
    className?: string;
    swapContentHeight?: string;
    widthClassName?: string;
    disabled?: boolean;
    state: {
        count: number;
        setCount: (count: number) => void;
    };
    swapOptions?: {
        content?: JSX.Element | string;
    }[];
}
declare const SwapButton: react.ForwardRefExoticComponent<Pick<SwapButtonProps, "form" | "slot" | "style" | "title" | "key" | "autoFocus" | "disabled" | "formAction" | "formEncType" | "formMethod" | "formNoValidate" | "formTarget" | "name" | "type" | "value" | "defaultChecked" | "defaultValue" | "suppressContentEditableWarning" | "suppressHydrationWarning" | "accessKey" | "className" | "contentEditable" | "contextMenu" | "dir" | "draggable" | "hidden" | "id" | "lang" | "placeholder" | "spellCheck" | "tabIndex" | "translate" | "radioGroup" | "role" | "about" | "datatype" | "inlist" | "prefix" | "property" | "resource" | "typeof" | "vocab" | "autoCapitalize" | "autoCorrect" | "autoSave" | "color" | "itemProp" | "itemScope" | "itemType" | "itemID" | "itemRef" | "results" | "security" | "unselectable" | "inputMode" | "is" | "aria-activedescendant" | "aria-atomic" | "aria-autocomplete" | "aria-busy" | "aria-checked" | "aria-colcount" | "aria-colindex" | "aria-colspan" | "aria-controls" | "aria-current" | "aria-describedby" | "aria-details" | "aria-disabled" | "aria-dropeffect" | "aria-errormessage" | "aria-expanded" | "aria-flowto" | "aria-grabbed" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-keyshortcuts" | "aria-label" | "aria-labelledby" | "aria-level" | "aria-live" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-owns" | "aria-placeholder" | "aria-posinset" | "aria-pressed" | "aria-readonly" | "aria-relevant" | "aria-required" | "aria-roledescription" | "aria-rowcount" | "aria-rowindex" | "aria-rowspan" | "aria-selected" | "aria-setsize" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "children" | "dangerouslySetInnerHTML" | "onCopy" | "onCopyCapture" | "onCut" | "onCutCapture" | "onPaste" | "onPasteCapture" | "onCompositionEnd" | "onCompositionEndCapture" | "onCompositionStart" | "onCompositionStartCapture" | "onCompositionUpdate" | "onCompositionUpdateCapture" | "onFocus" | "onFocusCapture" | "onBlur" | "onBlurCapture" | "onChange" | "onChangeCapture" | "onBeforeInput" | "onBeforeInputCapture" | "onInput" | "onInputCapture" | "onReset" | "onResetCapture" | "onSubmit" | "onSubmitCapture" | "onInvalid" | "onInvalidCapture" | "onLoad" | "onLoadCapture" | "onError" | "onErrorCapture" | "onKeyDown" | "onKeyDownCapture" | "onKeyPress" | "onKeyPressCapture" | "onKeyUp" | "onKeyUpCapture" | "onAbort" | "onAbortCapture" | "onCanPlay" | "onCanPlayCapture" | "onCanPlayThrough" | "onCanPlayThroughCapture" | "onDurationChange" | "onDurationChangeCapture" | "onEmptied" | "onEmptiedCapture" | "onEncrypted" | "onEncryptedCapture" | "onEnded" | "onEndedCapture" | "onLoadedData" | "onLoadedDataCapture" | "onLoadedMetadata" | "onLoadedMetadataCapture" | "onLoadStart" | "onLoadStartCapture" | "onPause" | "onPauseCapture" | "onPlay" | "onPlayCapture" | "onPlaying" | "onPlayingCapture" | "onProgress" | "onProgressCapture" | "onRateChange" | "onRateChangeCapture" | "onSeeked" | "onSeekedCapture" | "onSeeking" | "onSeekingCapture" | "onStalled" | "onStalledCapture" | "onSuspend" | "onSuspendCapture" | "onTimeUpdate" | "onTimeUpdateCapture" | "onVolumeChange" | "onVolumeChangeCapture" | "onWaiting" | "onWaitingCapture" | "onAuxClick" | "onAuxClickCapture" | "onClick" | "onClickCapture" | "onContextMenu" | "onContextMenuCapture" | "onDoubleClick" | "onDoubleClickCapture" | "onDrag" | "onDragCapture" | "onDragEnd" | "onDragEndCapture" | "onDragEnter" | "onDragEnterCapture" | "onDragExit" | "onDragExitCapture" | "onDragLeave" | "onDragLeaveCapture" | "onDragOver" | "onDragOverCapture" | "onDragStart" | "onDragStartCapture" | "onDrop" | "onDropCapture" | "onMouseDown" | "onMouseDownCapture" | "onMouseEnter" | "onMouseLeave" | "onMouseMove" | "onMouseMoveCapture" | "onMouseOut" | "onMouseOutCapture" | "onMouseOver" | "onMouseOverCapture" | "onMouseUp" | "onMouseUpCapture" | "onSelect" | "onSelectCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onScroll" | "onScrollCapture" | "onWheel" | "onWheelCapture" | "onAnimationStart" | "onAnimationStartCapture" | "onAnimationEnd" | "onAnimationEndCapture" | "onAnimationIteration" | "onAnimationIterationCapture" | "onTransitionEnd" | "onTransitionEndCapture" | "state" | "widthClassName" | "swapContentHeight" | "swapOptions"> & react.RefAttributes<HTMLButtonElement>>;

declare type SegmentedValue = string | number;
declare type SegmentedRawOption = SegmentedValue;
interface SegmentedLabeledOption {
    className?: string;
    disabled?: boolean;
    label: React.ReactNode;
    value: SegmentedRawOption;
    icon?: string;
    /**
     * html `title` property for label
     */
    title?: string;
}
interface SegmentedPickerProps {
    className?: string;
    defaultValue?: SegmentedValue;
    value?: SegmentedValue;
    onChange?: (value: SegmentedValue) => void;
    disabled?: boolean;
    options: SegmentedOptions;
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    indicatorClassName?: string;
}
declare type SegmentedOptions = (SegmentedRawOption | SegmentedLabeledOption)[];

declare const SegmentedPicker: react.ForwardRefExoticComponent<SegmentedPickerProps & react.RefAttributes<HTMLDivElement>>;

interface ContainerBoxProps {
    variant?: 'normal' | 'solid' | 'minimal';
    intent?: 'default' | 'dynamic';
    error?: boolean;
    disabled?: boolean;
}
declare const useContainerBoxClassName: (props: ContainerBoxProps) => string;

declare type ContainerBoxComponent = ForwardRefComponent<'div', ContainerBoxProps>;
declare type ContainerBoxEntireProps = ComponentPropsWithoutRef<typeof ContainerBox>;
declare const ContainerBox: ContainerBoxComponent;

interface ChoiceGroupContextProps {
    /**
     * 尺寸
     * TODO 缺少xs样式
     */
    setSize?: 'sm' | 'md' | 'lg';
    /**
     * 控制label显示在radio/checkbox的左/右
     */
    labelPosition?: 'left' | 'right';
    /**
     * 显示样式
     */
    intent?: 'default' | 'primary' | 'dynamic';
}

interface InputProps extends ComponentPropsWithoutRef<'input'>, ContainerBoxProps {
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    beforeComponent?: ReactNode;
    afterComponent?: ReactNode;
    containerRef?: MutableRefObject<HTMLDivElement | null>;
}
declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;

interface InputGroupProps extends InputProps {
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    children?: ReactNode;
}
declare const InputGroup: react.ForwardRefExoticComponent<InputGroupProps & react.RefAttributes<HTMLDivElement>>;

declare type InputAddonProps = PropsWithChildren<{
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
}>;
declare const InputAddon: (props: InputAddonProps) => JSX.Element;

interface TextareaProps extends ComponentPropsWithoutRef<'textarea'>, ContainerBoxProps {
    /**
     * textarea className
     */
    textareaClass?: string;
    /**
     * 大小
     */
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    /**
     * style的resize属性
     */
    resize?: CSSProperties['resize'];
    /**
     * 是否启用自动高度
     */
    autoSize?: boolean;
    /**
     * 最大行列行数，只有在autoSize为true是才有效
     */
    maxRows?: number;
    /**
     * 最小行列行数，只有在autoSize为true是才有效
     */
    minRows?: number;
}
declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;

interface NumericInputProps {
    className?: string;
    id?: string;
    beforeComponent?: JSX.Element;
    afterComponent?: JSX.Element;
    buttonPosition?: 'right' | 'left';
    placeholder?: string;
    label?: string;
    icon?: string;
    defaultValue?: number;
    minimumValue?: number;
    maximumValue?: number;
    stepSize?: number;
    minorStepSize?: number;
    majorStepSize?: number;
    setSize?: 'sm' | 'md' | 'lg';
    error?: boolean;
    disabled?: boolean;
    onChange?: (value: number | undefined) => void;
}
declare const NumericInput: react.ForwardRefExoticComponent<NumericInputProps & react.RefAttributes<HTMLInputElement>>;

interface IOptionsDataMap {
    [value: string]: IOptionData;
}
interface IOptionData {
    /**
     * 数据类型
     */
    type: 'option' | 'tag';
    /**
     * 展示文本
     */
    text: string;
    /**
     * 选项值
     */
    value: string;
    /**
     * 显示内容
     */
    content?: ReactNode;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 负载（暂时没啥用）
     */
    payload?: any;
    /**
     * icon
     */
    icon?: string;
}
interface IOptionGroupData {
    /**
     * 数据类型
     */
    type: 'group';
    /**
     * 显示文本，并且被用作key值，请确保该值是唯一的
     */
    title: string;
    /**
     * 是否启动折叠
     */
    collapse?: boolean;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 子选项数据
     */
    children: IOptionData[];
}
declare type TOptionsData = Array<IOptionData | IOptionGroupData>;

declare type TSelectValue<M> = M extends undefined | false ? string | null : string[];
interface IUseSelectionsProps<T extends boolean | undefined> {
    /**
     * 是否多选
     */
    multiple?: T;
    /**
     * 默认值
     */
    defaultValue?: TSelectValue<T>;
    /**
     * 选项值，单选时为string | null，多选时为string[]
     */
    value?: TSelectValue<T>;
    /**
     * 选中callback
     */
    onChange?: (newValue: TSelectValue<T>) => void;
}
/**
 * 根据传入的children转化，提取并转化为option的数据
 */
interface IUseOptions {
    (params: {
        children: ReactNode;
    }): {
        /**
         * option数据映射对象，可以通过option的value值获取更多option数据
         */
        optionMap: MutableRefObject<IOptionsDataMap>;
        /**
         * options 数据组
         */
        optionsData: TOptionsData;
        /**
         * 根据search value创建新的tag data
         */
        createTagData: (text: string) => IOptionData;
        /**
         * 根据tag data创建tag option
         */
        addTagData: (tag: IOptionData) => void;
        /**
         * 判断当前选项是否为新的tag选项
         */
        isNewTag: (optionData: IOptionData) => boolean;
        /**
         * 判断当前文本是否不在tag数组中
         */
        isExcludeTags: (text: string) => boolean;
    };
}

/**
 * select主题参数，select和trigger组件都会被使用
 */
interface ISelectThemeProps {
    setSize?: 'sm' | 'md' | 'lg';
    variant?: 'normal' | 'outlined' | 'solid' | 'minimal' | 'fade';
    intent?: 'default' | 'primary' | 'dynamic';
    tagIntent?: 'default' | 'primary' | 'danger' | 'success' | 'warning' | 'violet';
    tagVariant?: 'normal' | 'outlined' | 'minimal';
}
/**
 * select状态参数，select和trigger组件都会被使用
 */
interface ISelectStateProps {
    /**
     * 禁用Select
     */
    disabled?: boolean;
    /**
     * 选择模式
     *
     * @normal 正常默认模式（默认值）
     * @search 搜索模式，支持input输入
     * @tags 支持input输入，且支持把输入内容转为选项
     */
    mode?: 'search' | 'tags' | 'normal';
    /**
     * 错误状态
     */
    error?: boolean;
}

declare const MultipleSelectTrigger: ({ className, allowClear, clearAll, context, disabled, extendIconName, referenceProps, optionMap, placeholder, placeholderComponent, searchValue, value, setSize, tagIntent, tagVariant, selectActiveOption, setSearchValue, onChange, setSelectedValue: handleSelect, sortable, mode, error, Tag, }: TriggerProps<true>) => JSX.Element;

declare const SelectTrigger: ({ disabled, context, optionMap, value, referenceProps, placeholder, allowClear, clearAll, searchValue, setSearchValue, selectActiveOption, prefixComponent, suffixComponent, intent, variant, setSize, className, placeholderComponent, extendIconName, mode, error, }: TriggerProps<false>) => JSX.Element;

interface TagProps {
    onClick: MouseEventHandler;
    text: string;
    textClassName?: string;
    tagHandleCls: string;
    sortable?: boolean;
    icon?: string;
    className?: string;
    disabled?: boolean;
    active: boolean;
    intent?: 'default' | 'primary' | 'danger' | 'success' | 'warning' | 'violet' | 'secondary';
    variant?: 'normal' | 'outlined' | 'minimal';
    setSize?: 'sm' | 'md' | 'lg';
    style?: CSSProperties;
}
declare const Tag: ComponentType<TagProps>;

interface IListboxGroupItem {
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    title: string;
    children: ReactNode;
    disabled?: boolean;
    className?: string;
    open?: boolean;
    onClick?: MouseEventHandler;
}
declare const ListboxGroupItem: react.ForwardRefExoticComponent<IListboxGroupItem & react.RefAttributes<HTMLDivElement>>;

interface ListboxItemProps extends ComponentPropsWithoutRef<'div'> {
    /**
     * 尺寸大小
     */
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    /**
     * 是否使用子组件覆盖根节点
     */
    asChild?: boolean;
    /**
     * 是否选中
     */
    selected?: boolean;
    /**
     * 是否激活（hover）
     */
    active?: boolean;
    /**
     * 禁用状态
     */
    disabled?: boolean;
    /**
     * 是否显示后缀icon
     */
    extendIcon?: boolean;
    /**
     * 前缀icon
     */
    icon?: string;
    /**
     * 后缀icon class 名称
     */
    extendIconName?: string;
    /**
     * 样式
     */
    intent?: 'default' | 'primary';
    /**
     * padding 样式类
     */
    paddingClassName?: string;
    /**
     * 尺寸样式类
     */
    sizeClassName?: string;
    /**
     * 显示文本
     */
    text?: string;
    /**
     * 文本样式类
     */
    textClassName?: string;
    /**
     * title 文字
     */
    title?: string;
    /**
     * title 样式
     */
    titleClassName?: string;
    /**
     * title 组件
     */
    titleComponent?: ReactNode;
    /**
     * 间隙样式类
     */
    gapClassName?: string;
    /**
     * 选项样式类
     */
    optionClassName?: string;
    /**
     * 选项圆角样式类
     */
    roundedClassName?: string;
}
declare const ListboxItem: react.ForwardRefExoticComponent<ListboxItemProps & react.RefAttributes<HTMLDivElement>>;

interface UseCollapseProps {
    /**
     * 是否开启排他模式
     */
    exclusive?: boolean;
    /**
     * 默认展开的key列表
     */
    defaultActiveCollapseIds?: Key[];
}
/**
 * 创建一个折叠模块
 */
interface CreateCollapseFn {
    (key: Key): {
        toggle: () => void;
        isOpen: () => boolean;
        activeCollapseIds: Key[];
    };
}
declare const useCollapse: (props?: UseCollapseProps) => {
    createCollapse: CreateCollapseFn;
    activeCollapseIds: Key[];
    toggle: (key: Key) => void;
};

interface ListboxContainerProps {
    children?: ReactNode;
    containerClass?: string;
    containerRef?: MutableRefObject<HTMLDivElement>;
    emptyComponent?: ReactNode;
    gapClassName?: string;
    paddingClassName?: string;
    maxHeightClassName?: string;
}

interface ListboxProps extends UseCollapseProps, ListboxContainerProps {
    /**
     * id
     */
    id?: string;
    ariaLabel?: string;
    ariaLabelledby?: string;
    /**
     * 使用子组件为根组件
     */
    asChild?: boolean;
    /**
     * 尺寸大小
     */
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    /**
     * 列表顶部插槽
     */
    beforeComponent?: ReactNode;
    /**
     * 列表尾部插槽
     */
    afterComponent?: ReactNode;
    /**
     * 背景颜色类
     */
    bgClassName?: string;
    /**
     * 类样式
     */
    className?: string;
    /**
     * 圆角类样式
     */
    roundedClassName?: string;
    /**
     * 阴影类样式
     */
    shadowClassName?: string;
}
declare const _default$3: react.ForwardRefExoticComponent<ListboxProps & react.RefAttributes<HTMLDivElement>> & {
    Item: react.ForwardRefExoticComponent<ListboxItemProps & react.RefAttributes<HTMLDivElement>>;
    GroupItem: react.ForwardRefExoticComponent<IListboxGroupItem & react.RefAttributes<HTMLDivElement>>;
};

interface ListboxEmptyMessageProps {
    text?: string;
}
declare const ListboxEmptyMessage: ({ text, }: ListboxEmptyMessageProps) => JSX.Element;

/**
 * trigger基础参数，由select接受参数，再传递给trigger组件
 */
interface ITriggerBaseProps {
    /**
     * 控件className
     */
    className?: string;
    /**
     * 控件前缀插槽
     */
    prefixComponent?: ReactNode;
    /**
     * 控件后缀插槽
     */
    suffixComponent?: ReactNode;
    /**
     * 占位内容
     */
    placeholder?: string;
    /**
     * 占位内容，支持传入JSX，只在Trigger为不可输入状态时有效
     */
    placeholderComponent?: ReactNode;
    /**
     * 下拉箭头icon，支持传入icon名称进行替换
     */
    extendIconName?: string;
    /**
     * 是否显示清除所有按钮
     */
    allowClear?: boolean;
    /**
     * 是否开启拖拽排序
     */
    sortable?: boolean;
}
/**
 * trigger私有参数，由select中生成，并传递给trigger组件
 */
interface ITriggerPrivateProps<Multiple extends boolean | undefined> {
    /**
     * 参照dom的必要属性集合，请确保该参数正确赋值给参照dom；
     * 如果解构赋值的是自定义组件标签，请确保该组件被forwardRef包括，且正确传递ref
     *
     * @example <div {...referenceProps} />
     */
    referenceProps: HTMLAttributes<HTMLElement>;
    /**
     * floating-ui提供的上下文对象，该对象包括了：
     * open状态，onOpenChange（切换open状态），refs（reference ref 和 floating ref），
     * 更多信息请查看floating-ui文档
     */
    context: FloatingContext<ReferenceType>;
    /**
     * option数据映射对象，可以通过option的value值获取更多option数据
     */
    optionMap: MutableRefObject<IOptionsDataMap>;
    /**
     * 搜索内容
     */
    searchValue: string;
    /**
     * 设置搜索内容
     */
    setSearchValue: (value: string) => void;
    /**
     * 设置当前选中选项的数据
     */
    setSelectedValue: (value: string) => void;
    /**
     * 触发当前激活选项的点击事件
     * 若用keyboard操作select，在启动input时，选项并不能真正获得focus状态，所以需要用该方法来触发选中事件
     */
    selectActiveOption: () => void;
    /**
     * 清除所有选中项
     */
    clearAll: () => void;
    /**
     * 自定义Tag标签
     */
    Tag: Multiple extends undefined | false ? undefined : ComponentType<TagProps>;
}
declare type TriggerProps<Multiple extends boolean | undefined, T = {}> = T & ITriggerBaseProps & Required<Omit<IUseSelectionsProps<Multiple>, 'defaultValue'>> & ISelectStateProps & ISelectThemeProps & ITriggerPrivateProps<Multiple>;
interface ICustomComponents<Multiple extends boolean | undefined> {
    /**
     * 自定义Trigger控件
     */
    Trigger?: ComponentType<TriggerProps<Multiple>>;
    /**
     * 自定义搜索为空的提示组件
     */
    EmptyMessage?: ComponentType;
    /**
     * 自定义Tag标签
     */
    Tag?: ComponentType<TagProps>;
    /**
     * 自定义Option组件
     */
    Option?: ComponentType<ListboxItemProps & {
        payload?: any;
    }>;
}

interface ISelectPrivateProps<Multiple extends boolean | undefined> {
    /**
     * 选项列表上插槽
     */
    beforeComponent?: JSX.Element;
    /**
     * 选项列表下插槽
     */
    afterComponent?: JSX.Element;
    /**
     * 选项列表
     */
    children?: ReactNode;
    /**
     * 选项列表是否匹配控件宽度
     */
    matchTriggerWidth?: boolean;
    /**
     * 选项列表是否默认打开
     */
    defaultOpen?: boolean;
    /**
     * 选项列表定位位置
     */
    placement?: Placement;
    /**
     * 自定义控件
     */
    customComponents?: ICustomComponents<Multiple>;
    /**
     * 是否将弹层放置于 body 内，添加此属性，它将不受父级样式影响
     */
    transfer?: boolean;
}
declare type SelectProps<Multiple extends boolean | undefined = boolean | undefined> = ISelectStateProps & ISelectThemeProps & IUseSelectionsProps<Multiple> & ISelectPrivateProps<Multiple> & ITriggerBaseProps;

declare const Select: <Multiple extends boolean | undefined = undefined>(props: SelectProps<Multiple>) => JSX.Element;

interface SelectOptionProps {
    /**
     * 显示文本，也用于搜索
     */
    text: string;
    /**
     * 选项值，该值也会用作key，请保证唯一
     */
    value: string;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 负载（暂时用不到这个属性）
     */
    payload?: any;
    /**
     * 自定义选项渲染内容
     */
    children?: ReactNode;
    /**
     * icon
     */
    icon?: string;
}
declare const Option: (_: SelectOptionProps) => null;

interface ISelectOptionGroupProps {
    /**
     * 组名称，该值也会当key使用，请保证唯一
     */
    title: string;
    /**
     * option列表
     */
    children: ReactNode;
    /**
     * 是否禁用组
     */
    disabled?: boolean;
    /**
     * 是否启动组折叠
     */
    collapse?: boolean;
}
declare const OptionGroup: (_: ISelectOptionGroupProps) => null;

interface ValueTagProps extends BadgeProps {
    /**
     * 是否排序
     */
    sortable?: boolean;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 是否聚焦
     */
    focused?: boolean;
    /**
     * 是否拖拽中
     */
    dragging?: boolean;
    /**
     * handle的参数
     */
    handleProps?: ComponentPropsWithRef<'div'>;
    /**
     * 移除按钮的参数
     */
    removeProps?: ComponentPropsWithoutRef<'div'>;
    /**
     * 尺寸
     */
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    /**
     * tag的内容
     */
    children?: ReactNode;
    /**
     * 选项对象
     */
    data: OptionItem;
}

declare type AriaLiveMessages = {
    guidance?: () => string;
    onChange?: () => string;
    onFilter?: () => string;
    onFocus?: () => string;
};
declare type OptionItem<T extends object = {
    [key: string]: any;
}> = {
    /**
     * 显示文本
     */
    label: string;
    /**
     * 值
     */
    value: string;
    /**
     * 是否被禁用
     */
    isDisabled?: boolean;
} & T;
declare type OptionItems = OptionsOrGroups<OptionItem, GroupBase<OptionItem>>;
declare type ControlProps = ContainerBoxEntireProps;
interface SelectInputProps<Multiple extends boolean> extends ContainerBoxProps, Pick<AsyncCreatableProps<OptionItem, Multiple extends boolean ? Multiple : false, GroupBase<OptionItem>>, 'defaultValue' | 'value' | 'onChange' | 'loadingMessage' | 'cacheOptions' | 'loadOptions' | 'defaultOptions' | 'noOptionsMessage' | 'onMenuOpen' | 'onMenuClose' | 'inputValue' | 'onInputChange' | 'onKeyDown' | 'closeMenuOnSelect' | 'menuIsOpen'> {
    /**
     * 样式类
     */
    className?: string;
    /**
     * 容器样式类
     */
    containerClassName?: string;
    /**
     * 值容器样式类
     */
    valueContainerClassName?: string;
    /**
     * 是否多选
     */
    multiple?: Multiple;
    /**
     * 是否显示清除所有按钮
     */
    allowClear?: boolean;
    /**
     * 是否隐藏被选中的选项
     */
    hideSelectedOptions?: boolean;
    /**
     * 占位符
     */
    placeholder?: ReactNode;
    /**
     * 选项列表
     */
    options?: OptionItems;
    /**
     * 标签样式
     */
    tagIntent?: BadgeProps['intent'];
    /**
     * 标签变体
     */
    tagVariant?: BadgeProps['variant'];
    /**
     * 尺寸
     */
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    /**
     * 自定义选项样式
     */
    children?: ComponentType<{
        option: OptionItem;
    }>;
    /**
     * 是否匹配trigger宽度
     */
    matchTriggerWidth?: boolean;
    /**
     * 选项列表是否默认打开
     */
    defaultOpen?: boolean;
    /**
     * 是否开启拖拽排序
     */
    sortable?: boolean;
    /**
     * 是否支持搜索
     */
    searchable?: boolean;
    ariaLiveMessages?: AriaLiveMessages;
    /**
     * 是否可创建
     */
    creatable?: boolean;
    /**
     * 显示loading状态
     */
    isLoading?: boolean;
    /**
     * 前缀插槽
     */
    previousComponent?: ReactNode;
    /**
     * 后缀插槽
     */
    suffixComponent?: ReactNode;
    /**
     * 自定义下拉指示器
     */
    dropdownIndicator?: ComponentType<DropdownIndicatorProps<OptionItem>>;
    /**
     * 自定义清空按钮
     */
    clearIndicator?: ComponentType<ClearIndicatorProps<OptionItem>>;
    /**
     * 自定义容器组件
     */
    control?: ComponentType<ContainerBoxEntireProps>;
    /**
     * 自定义Tag标签
     */
    tag?: ComponentType<ValueTagProps>;
    /**
     * 是否挂
     */
    transfer?: boolean;
    /**
     * menu 位置
     */
    placement?: 'auto' | 'top' | 'bottom';
    /**
     * control 的 onPointerDown
     */
    onControlPointerDown?: PointerEventHandler<'div'>;
    /**
     * control 的 onClick
     */
    onControlClick?: MouseEventHandler<'div'>;
    /**
     * control 的 onDoubleClick
     */
    onControlDoubleClick?: MouseEventHandler<'div'>;
    menuPosition?: 'absolute' | 'fixed';
    /**
     * menu 挂载位置
     */
    menuPortalTarget?: HTMLElement;
    /**
     * menu 挂载位置
     */
    menuShouldBlockScroll?: boolean;
}

declare const SelectInput: <Multiple extends boolean | undefined = undefined>(props: SelectInputProps<Multiple extends boolean ? Multiple : false> & {
    ref?: ForwardedRef<SelectInstance<OptionItem<{
        [key: string]: any;
    }>, Multiple extends boolean ? Multiple : false, react_select.GroupBase<OptionItem<{
        [key: string]: any;
    }>>> | undefined> | undefined;
}) => ReactElement;

interface SwitchProps extends InputHTMLAttributes<HTMLInputElement> {
    alignIndicator?: 'left' | 'right';
    children?: ReactNode;
    className?: string;
    disabled?: boolean;
    hoverBackground?: boolean;
    id?: string;
    intent?: 'default' | 'primary' | 'success' | 'danger' | 'dynamic';
    label?: string | ReactNode;
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    textClassName?: string;
    error?: boolean;
}
declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;

interface CommonPickerMethods {
    focus: () => void;
    blur: () => void;
}
interface PickerComponentClass<P = Record<PropertyKey, unknown>, S = unknown> extends ComponentClass<P, S> {
    new (...args: ConstructorParameters<ComponentClass<P, S>>): InstanceType<ComponentClass<P, S>> & CommonPickerMethods;
}

interface TimePickerLocale {
    placeholder?: string;
    rangePlaceholder?: [string, string];
}
interface TimeRangePickerProps extends Omit<RangePickerTimeProps<Dayjs>, 'picker'> {
    popupClassName?: string;
}
declare const RangePicker: react.ForwardRefExoticComponent<TimeRangePickerProps & react.RefAttributes<any>>;
interface TimePickerProps extends Omit<PickerTimeProps<Dayjs>, 'picker'> {
    popupClassName?: string;
}
declare const TimePicker: react.ForwardRefExoticComponent<TimePickerProps & react.RefAttributes<any>>;
declare type MergedTimePicker = typeof TimePicker & {
    RangePicker: typeof RangePicker;
};
declare const _default$2: MergedTimePicker;

declare const DataPickerPlacements: ["bottomLeft", "bottomRight", "topLeft", "topRight"];
declare type DataPickerPlacement = typeof DataPickerPlacements[number];
declare type InjectDefaultProps<Props> = Omit<Props, 'locale' | 'generateConfig' | 'hideHeader' | 'components'> & {
    locale?: Locale;
    placement?: DataPickerPlacement;
    bordered?: boolean;
};
declare type PickerBaseProps<DateType> = InjectDefaultProps<PickerBaseProps$1<DateType>>;
declare type PickerDateProps<DateType> = InjectDefaultProps<PickerDateProps$1<DateType>>;
declare type PickerTimeProps<DateType> = InjectDefaultProps<PickerTimeProps$1<DateType>>;
declare type PickerProps<DateType> = PickerBaseProps<DateType> | PickerDateProps<DateType> | PickerTimeProps<DateType>;
declare type RangePickerBaseProps<DateType> = InjectDefaultProps<RangePickerBaseProps$1<DateType>>;
declare type RangePickerDateProps<DateType> = InjectDefaultProps<RangePickerDateProps$1<DateType>>;
declare type RangePickerTimeProps<DateType> = InjectDefaultProps<RangePickerTimeProps$1<DateType>>;
declare type RangePickerProps$1<DateType> = RangePickerBaseProps<DateType> | RangePickerDateProps<DateType> | RangePickerTimeProps<DateType>;

declare type DatePickerProps = PickerProps<Dayjs>;
declare type MonthPickerProps = Omit<PickerDateProps<Dayjs>, 'picker'>;
declare type WeekPickerProps = Omit<PickerDateProps<Dayjs>, 'picker'>;
declare type RangePickerProps = RangePickerProps$1<Dayjs>;
declare const DatePicker: PickerComponentClass<PickerProps<Dayjs> & {
    setSize?: "md" | "sm" | "lg" | undefined;
    sizeClassName?: string | undefined;
    variant?: "normal" | "solid" | "minimal" | "cell" | undefined;
    showPanelOnly?: boolean | undefined;
    error?: boolean | undefined;
}, unknown> & {
    WeekPicker: PickerComponentClass<Omit<PickerDateProps<Dayjs>, "picker">, unknown>;
    MonthPicker: PickerComponentClass<Omit<PickerDateProps<Dayjs>, "picker">, unknown>;
    YearPicker: PickerComponentClass<Omit<PickerDateProps<Dayjs>, "picker">, unknown>;
    RangePicker: PickerComponentClass<RangePickerProps$1<Dayjs> & {
        setSize?: "md" | "sm" | "lg" | undefined;
        sizeClassName?: string | undefined;
        variant?: "normal" | "solid" | "minimal" | "cell" | undefined;
        error?: boolean | undefined;
    }, unknown>;
    TimePicker: PickerComponentClass<Omit<PickerTimeProps<Dayjs>, "picker">, unknown>;
    QuarterPicker: PickerComponentClass<PickerTimeProps<Dayjs>, unknown>;
};

interface CssClasses {
    target: string;
    base: string;
    origin: string;
    handle: string;
    handleLower: string;
    handleUpper: string;
    touchArea: string;
    horizontal: string;
    vertical: string;
    background: string;
    connect: string;
    connects: string;
    ltr: string;
    rtl: string;
    textDirectionLtr: string;
    textDirectionRtl: string;
    draggable: string;
    drag: string;
    tap: string;
    active: string;
    tooltip: string;
    pips: string;
    pipsHorizontal: string;
    pipsVertical: string;
    marker: string;
    markerHorizontal: string;
    markerVertical: string;
    markerNormal: string;
    markerLarge: string;
    markerSub: string;
    value: string;
    valueHorizontal: string;
    valueVertical: string;
    valueNormal: string;
    valueLarge: string;
    valueSub: string;
}
interface Formatter extends PartialFormatter {
    from: (value: string) => number | false;
}
interface UpdatableOptions {
    range?: Range;
    start?: string | number | (string | number)[];
    margin?: number;
    limit?: number;
    padding?: number | number[];
    snap?: boolean;
    step?: number;
    pips?: Pips;
    format?: Formatter;
    tooltips?: boolean | PartialFormatter | (boolean | PartialFormatter)[];
    animate?: boolean;
}
declare type HandleAttributes = {
    [key: string]: string;
};
interface Options extends UpdatableOptions {
    range: Range;
    connect?: 'lower' | 'upper' | boolean | boolean[];
    orientation?: 'vertical' | 'horizontal';
    direction?: 'ltr' | 'rtl';
    behaviour?: string;
    keyboardSupport?: boolean;
    keyboardPageMultiplier?: number;
    keyboardMultiplier?: number;
    keyboardDefaultStep?: number;
    documentElement?: HTMLElement;
    cssPrefix?: string;
    cssClasses?: CssClasses;
    ariaFormat?: PartialFormatter;
    animationDuration?: number;
    handleAttributes?: HandleAttributes[];
}
declare type NextStepsForHandle = [
    number | false | null,
    number | false | null
];
declare type EventCallback = (this: API, values: (number | string)[], handleNumber: number, unencoded: number[], tap: boolean, locations: number[], slider: API) => void;
declare type GetResult = number | string | (string | number)[];
interface API {
    destroy: () => void;
    steps: () => NextStepsForHandle[];
    on: (eventName: string, callback: EventCallback) => void;
    off: (eventName: string) => void;
    get: (unencoded?: boolean) => GetResult;
    set: (input: number | string | (number | string)[], fireSetEvent?: boolean, exactInput?: boolean) => void;
    setHandle: (handleNumber: number, value: number | string, fireSetEvent?: boolean, exactInput?: boolean) => void;
    reset: (fireSetEvent?: boolean) => void;
    options: Options;
    updateOptions: (optionsToUpdate: UpdatableOptions, fireSetEvent: boolean) => void;
    target: HTMLElement;
    removePips: () => void;
    removeTooltips: () => void;
    getTooltips: () => {
        [handleNumber: number]: HTMLElement | false;
    };
    getOrigins: () => {
        [handleNumber: number]: HTMLElement;
    };
    pips: (grid: Pips) => HTMLElement;
}
interface TargetElement extends HTMLElement {
    noUiSlider?: API;
}
declare enum PipsMode {
    Range = "range",
    Steps = "steps",
    Positions = "positions",
    Count = "count",
    Values = "values"
}
declare enum PipsType {
    None = -1,
    NoValue = 0,
    LargeValue = 1,
    SmallValue = 2
}
interface BasePips {
    mode: PipsMode;
    density?: number;
    filter?: (value: number, type: PipsType) => PipsType;
    format?: PartialFormatter;
}
interface PositionsPips extends BasePips {
    mode: PipsMode.Positions;
    values: number[];
    stepped?: boolean;
}
interface ValuesPips extends BasePips {
    mode: PipsMode.Values;
    values: number[];
    stepped?: boolean;
}
interface CountPips extends BasePips {
    mode: PipsMode.Count;
    values: number;
    stepped?: boolean;
}
interface StepsPips extends BasePips {
    mode: PipsMode.Steps;
}
interface RangePips extends BasePips {
    mode: PipsMode.Range;
}
declare type Pips = PositionsPips | ValuesPips | CountPips | StepsPips | RangePips;
interface Range {
    min: number | [number] | [number, number];
    max: number | [number] | [number, number];
    [key: string]: number | [number] | [number, number];
}
interface PartialFormatter {
    to: (value: number) => string | number;
    from?: (value: string) => number | false;
}
interface EventProps {
    values: string[];
    handle: number;
    unencoded: any[];
    tap: boolean;
    positions: any[];
    noUiSlider: any;
}
interface PresetProps {
    targetSize?: string;
    targetRadius?: string;
    handleSize?: string;
    handleRadius?: string;
    markerNormalWidth?: string;
    markerLargeWidth?: string;
    markerSubWidth?: string;
    markerNormalSize?: string;
    markerLargeSize?: string;
    markerSubSize?: string;
    valueHeight?: string;
}
interface SliderProps {
    /** 初始默认值 0 */
    start: string | number | (string | number)[];
    /** 范围值 */
    range: Range;
    /**
     * 控制手柄或滑块边缘之间的条。
     * 如果使用一个手柄，则将值设置为 upper 或 lower
     * 对于2个或更多手柄的滑块，需传递一个带有布尔值 boolean 的数组 array。 该数组的长度必须为手柄数量+ 1。
     */
    connect?: 'lower' | 'upper' | boolean | boolean[];
    /**  设置手柄之间的最小距离。仅在线性滑块上可用 */
    margin?: number;
    /**
     * 必须有至少两个手柄，否则报错
     * 设置手柄之间的最大距离。仅在线性滑块上可用
     */
    limit?: number;
    /** 滑块距离手柄边缘的距离 */
    padding?: number | number[];
    /** 所有类名前缀 */
    cssPrefix?: string;
    /** 步进值，默认none */
    step?: number;
    /**
     * 定位
     * 垂直滑块必须设置属性verticalHeight。可以使用任何所需的单位，包括％或 px。
     */
    orientation?: 'vertical' | 'horizontal';
    /** 高度，在定位为'vertical'时设置必须设置 */
    verticalHeight?: string;
    /** 方向 */
    direction?: 'ltr' | 'rtl';
    /** 注册自己 给外部调用 */
    registerSlider?: (instance: TargetElement) => void;
    /** handle激活，开始drag */
    onStart?: (data: EventProps) => void;
    /**
     * handle 拖动中
     * connect 拖动中
     * slide被点击移动
     */
    onSlide?: (data: EventProps) => void;
    /**
     * handle 拖动中
     * connect 拖动中
     * slide被点击移动
     * set()方法触发
     */
    onUpdate?: (data: EventProps) => void;
    /**
     * handle拖动结束
     * slide被点击移动
     * set()方法触发
     */
    onSet?: (data: EventProps) => void;
    /**
     * handle拖动结束
     * slide被点击移动
     */
    onChange?: (data: EventProps) => void;
    /** hanle 拖动结束 */
    onEnd?: (data: EventProps) => void;
    /**
     * 可以响应的事件
     * 接受由"-"分隔的"drag", "drag-all", "tap", "fixed", "snap", "unconstrained" or "none"
     */
    behaviour?: string;
    /**
     * 提示文本 可定义
     * false为不显示提示，true为显示
     */
    tooltips?: boolean | PartialFormatter | (boolean | PartialFormatter)[];
    /** 只在手柄工作时显示,tooltips必须为true才有作用 */
    tooltipsShowBySliding?: boolean;
    /** 禁用 */
    disabled?: boolean;
    /** 刻度设置 */
    pips?: Pips;
    /** pips类名 */
    pipsColor?: string;
    /** 自定义 tooltip类名 */
    tooltipColor?: string;
    /** target 类名 */
    targetColor?: string;
    /** handle 类名 */
    handleColor?: string;
    /** connect 类名 */
    connectColor?: string;
    /** 刻度类型 */
    markerType?: 'dot' | 'line';
    /** active marker 类名 */
    markerActiveColor?: string;
    /** normal marker 类名 */
    markerNormalColor?: string;
    /** 大刻度线类名 */
    markerLargeColor?: string;
    /** 小刻度线类名 */
    markerSubColor?: string;
    /** 刻度 vale large 类名 */
    valueLargeColor?: string;
    /** 刻度 vale normal类名 */
    valueNormalColor?: string;
    /** 刻度 value sub 类名 */
    valueSubColor?: string;
    /** 自定义尺寸 */
    variant?: PresetProps;
    intent?: 'default' | 'primary';
}
declare const Slider: react__default.FC<SliderProps>;

/**
 * 这里的颜色是外部可传入的颜色格式，最好是string类型的
 * 尤其注意一下。外部如果想强制改变颜色，只能改成 string 类型
 */
declare type IColor = string | ColorResult | null;
declare type IColorChangeHandler = (color: ColorResult, event: React.ChangeEvent<HTMLInputElement>) => void;
interface IHSVColor {
    h: number;
    s: number;
    v: number;
}
interface HSLColor {
    a?: number | undefined;
    h: number;
    l: number;
    s: number;
}
interface RGBColor {
    a?: number | undefined;
    b: number;
    g: number;
    r: number;
}
interface ColorResult {
    hex: string;
    hexa: string;
    hsl: HSLColor;
    rgb: RGBColor;
}

/**
 * 最基本的颜色选择器 Props
 */
interface ICustomPickerProps {
    /**
     * 颜色
     */
    color?: IColor;
    /**
     * 颜色发生改变的回调
     */
    onChange?: IColorChangeHandler;
    /**
     * 颜色完全发生改变后的回调
     */
    onChangeComplete?: IColorChangeHandler;
    /**
     * 鼠标移动到颜色 swatch 上的回调
     */
    onSwatchHover?: (color: IColor, event: MouseEvent<Element>) => void;
}
/**
 * 通过高阶组件 CustomPicker 包装 后多出来的数据类型
 */
interface ICustomPickerInjectProps {
    rgb?: RGBColor;
    hex?: string;
    hexa?: string;
    hsv?: IHSVColor;
    hsl?: HSLColor;
    oldHue?: number;
    source?: string;
}
interface ICustomPickerWrapperProps extends ICustomPickerProps, ICustomPickerInjectProps {
}

interface IColorPickerBaseProps extends ICustomPickerWrapperProps {
    /**
     * 预设颜色列表
     */
    presetColors?: string[];
    /**
     * 外层的样式名
     */
    bgClassName?: string;
    children?: ReactNode;
    className?: string;
    containerClassName?: string;
    paddingClassName?: string;
    pickerWidth?: string;
    presetClassName?: string;
    roundedClassName?: string;
    shadowClassName?: string;
    sliderWidth?: string;
    throttleClassName?: string;
    /**
     * 是否启用饱和度组件
     */
    saturation?: boolean;
    /**
     * 是否启用色相组件
     */
    hue?: boolean;
    /**
     * 是否启用透明度选择组件
     */
    alpha?: boolean;
    /**
     * 是否启用色彩输入组件
     */
    fields?: boolean;
    /**
     * 是否启用预设颜色选择组件
     */
    preset?: boolean;
}

interface ColorPickerProps extends IColorPickerBaseProps {
    /**
     * 方向
     */
    placement?: Placement;
    /**
     * className
     */
    className?: string;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 是否需要 floating 显示
     */
    isFloating?: boolean;
}
declare function ColorPicker({ placement, className, disabled, isFloating, ...props }: ColorPickerProps): JSX.Element;

declare type TSegmentType = 'text' | 'variable';
/**
 * 片段集，可能是文本的片段，也可能是变量的片段,这是两者的最小数据集
 */
interface ISegment {
    /**
     * 类别
     */
    type: TSegmentType;
    /**
     * 文本
     */
    name?: string | null;
}

declare type VARIABLE_TYPE = 'string' | 'number';
/**
 * 内置变量的应有属性
 */
interface IVariable extends ISegment {
    /**
     * 变量的类型
     * 模拟设计端: 有字符、数字、媒体变量
     */
    varType?: VARIABLE_TYPE;
    /**
     * 变量的ID
     */
    id: string;
    /**
     * 变量的名称
     */
    name: string;
    /**
     * 挂载配置,可以是自定义很多配置
     * @todo 配置项
     */
    config?: IConfig;
    /**
     * 其他的关联节点的设置
     */
    identity?: IIdentity;
}
interface IConfig {
}
interface IIdentity {
    /**
     * 节点的id
     */
    nodeId: string;
}

/**
 * 可传入数据
 */
interface RichInputProps {
    /**
     * 是否禁用编辑器
     */
    disabled?: boolean;
    /**
     * 值
     */
    value: string;
    /**
     * 更改值以后
     */
    onChange: (event: ContentEditableEvent) => void;
    /**
     * placeholder
     */
    placeholder?: string;
    /**
     * 弹出的变量选择列表，自定义的
     */
    renderList?: IListRenderer;
    /**
     * 弹窗修改变量组件
     */
    renderDialog?: IDialogRenderer;
    /**
     * 样式名
     */
    className?: string;
    /**
     * 标签
     */
    label?: string;
    /**
     * required
     */
    required?: boolean;
    intent?: 'default' | 'dynamic';
    /**
     * 错误信息
     */
    error?: boolean;
    id?: string;
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    variant?: 'normal' | 'solid' | 'minimal';
    /**
     * 是否是只读
     */
    readonly?: boolean;
    /**
     * 文本
     */
    textClass?: string;
    paddingClassName?: string;
    inputClassName?: string;
}
interface IListPayload {
    insertVariable: (variable: IVariable, transform?: () => Element) => void;
    onClose: () => void;
}
/**
 */
interface IListRenderer {
    (payload: IListPayload): JSX.Element | null;
}
/**
 * 对话框用来修改节点的内容
 */
interface IDialogPayload {
    /**
     * 标记我已经更改相关节点了，不然输入框没法知道更改了
     */
    markModifier: () => void;
    /**
     * 目标变量标签
     */
    target: HTMLElement;
    /**
     * 变量信息
     */
    varInfo: IVariable;
}
interface IDialogRenderer {
    (payload: IDialogPayload): JSX.Element | null;
}
/**
 * 富文本编辑器
 */
declare function RichInput({ renderDialog, renderList, value, disabled, placeholder, onChange, className, label, id, error, setSize, readonly, required, intent, variant, inputClassName, ...rest }: RichInputProps): JSX.Element;

interface FormContextProps {
    /**
     * 禁用表单
     */
    disabled?: boolean;
    /**
     * 设置尺寸
     */
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    gapClassName?: string;
}

interface FormProps extends FormContextProps, ComponentPropsWithoutRef<'form'> {
    methods: UseFormReturn<any>;
}
declare const Form: react.ForwardRefExoticComponent<FormProps & react.RefAttributes<HTMLFormElement>>;

declare type ControllerRender = ControllerProps['render'];
interface FormItemProps {
    /**
     * 字段名称，用于绑定到formData上
     */
    name: string;
    /**
     * label前插槽
     */
    beforeLabel?: ReactNode;
    /**
     * 类样式
     */
    className?: string;
    /**
     * 当为array字段时的index
     */
    index?: number;
    /**
     * 显示的label
     */
    label?: string;
    /**
     * label的className
     */
    labelClassName?: string;
    /**
     * 绑定value时字段名，默认是'value'
     */
    valueKey?: string;
    /**
     * 是否必填（纯样式，没有校验能力）
     */
    required?: boolean;
    /**
     * 默认值类型，用于绑定初始值
     */
    type?: 'string' | 'number' | 'date' | 'array' | 'boolean';
    /**
     * 输入控件（必须包含ref,value,onChange）
     */
    children?: ReactElement | ControllerRender;
}
declare const FormItem: (props: FormItemProps) => JSX.Element | null;

interface FormLabelProps {
    beforeLabel?: ReactNode;
    className?: string;
    label?: string;
    labelClassName?: string;
    name?: string;
    required?: boolean;
}
declare const FormLabel: (props: FormLabelProps) => JSX.Element;

interface FormDividerProps {
    className?: string;
}
declare const FormDivider: (props: FormDividerProps) => JSX.Element;

interface FormToggleProps {
    className?: string;
    children?: ReactNode;
    label?: string;
    toggleExpandChildren?: (show: boolean) => void;
    checked?: boolean;
}
declare const FormToggle: (props: FormToggleProps) => JSX.Element;

declare type ValidationRules = Parameters<typeof zodResolver>[0];
declare type FormValues = Record<string, any>;
interface UseFormProps<T extends FormValues> extends Omit<UseFormProps$1<T>, 'context' | 'resolver'> {
    rules?: ValidationRules;
}
/**
 * form组件配置hook，返回的methods请提供给Form组件使用
 * methods包含trigger(触发校验)、watch（字段状态）、getValues（获取当前form数据）等实用函数
 * 具体可以看react-hook-form文档
 */
declare const useForm: <T extends FormValues>(props?: UseFormProps<T> | undefined) => UseFormReturn<T, any>;
/**
 * 监视form数据变化
 */
declare const useWatchObserver: <T extends FormValues>(watch: UseFormWatch<T>, watchObserver: WatchObserver<T>) => void;

interface RadioProps extends ComponentPropsWithoutRef<'input'>, ChoiceGroupContextProps {
    /**
     * hoverBackground 样式
     */
    hoverBackground?: boolean;
    /**
     * hoverBackground 样式
     */
    hoverBackgroundClassName?: string;
    /**
     * 类样式
     */
    className?: string;
    value: string;
    label?: string;
    /**
     * 隐藏 radio 按钮
     */
    hideRadioCircleIcon?: boolean;
}
declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLLabelElement>>;

interface RadioGroupCtrlRef {
    setValue: (value: string) => void;
}
interface RadioGroupProps extends Omit<ComponentPropsWithoutRef<'div'>, 'onChange'>, ChoiceGroupContextProps {
    name?: string;
    defaultValue?: string;
    value?: string;
    onChange?: (value: string) => void;
    orientation?: 'horizontal' | 'vertical';
    /**
     * gap样式属性
     */
    gapClassName?: string;
    error?: boolean;
    disabled?: boolean;
    readOnly?: boolean;
    ctrlRef?: MutableRefObject<RadioGroupCtrlRef | undefined>;
}
declare const RadioGroup: react.ForwardRefExoticComponent<RadioGroupProps & react.RefAttributes<HTMLDivElement>>;

interface CheckboxProps extends ChoiceGroupContextProps {
    /**
     * hoverBackground 样式
     */
    hoverBackground?: boolean;
    /**
     * hoverBackground 样式
     */
    hoverBackgroundClassName?: string;
    /**
     * 类样式
     */
    className?: string;
    /**
     * aria-label属性
     */
    label?: string;
    /**
     * 是否为半选
     */
    indeterminate?: boolean;
    /**
     * 值，CheckboxGroup中使用时必填
     */
    value?: string;
    /**
     * 值更新回调
     */
    onChange?: (value: boolean) => void;
    /**
     * 焦点变化回调
     */
    onFocusChange?: (isFocused: boolean) => void;
    /**
     * 聚焦事件
     */
    onFocus?: (e: FocusEvent<Element, Element>) => void;
    /**
     * 失焦事件
     */
    onBlur?: (e: FocusEvent<Element, Element>) => void;
    /**
     * 是否选中（非受控）
     */
    defaultChecked?: boolean;
    /**
     * 是否选中（受控）
     */
    checked?: boolean;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 是否只读
     */
    readOnly?: boolean;
    /**
     * 子内容
     */
    children?: ReactNode;
    /**
     * 表单名称
     */
    name?: string;
    /**
     * 键盘按下事件
     */
    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
    /**
     * 键盘抬起事件
     */
    onKeyUp?: KeyboardEventHandler<HTMLInputElement>;
    /**
     * 是否自动聚焦
     */
    autoFocus?: boolean;
    /**
     * aria-label
     */
    ariaLabel?: string;
    /**
     * aria-labeledby
     */
    ariaLabeledby?: string;
}
declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLLabelElement>>;

interface CheckboxGroupProps extends ChoiceGroupContextProps {
    /**
     * 类名称
     */
    className?: string;
    /**
     * 表单name属性
     */
    name?: string;
    /**
     * Checkbox Group 的值（受控）
     */
    value?: string[];
    /**
     * 默认值（非受控）
     */
    defaultValue?: string[];
    /**
     * 值变化回调
     */
    onChange?: (value: string[]) => void;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 是否只读
     */
    readOnly?: boolean;
    /**
     * id
     */
    id?: string;
    /**
     * aria-label属性
     */
    label?: string;
    /**
     * gap样式属性
     */
    gapClassName?: string;
    /**
     * 仅支持`<Checkbox />`为内容
     */
    children?: ReactNode;
    /**
     * 排列方向
     */
    orientation?: 'horizontal' | 'vertical';
    /**
     * 错误样式
     */
    error?: boolean;
}
declare const CheckboxGroup: react.ForwardRefExoticComponent<CheckboxGroupProps & react.RefAttributes<HTMLDivElement>>;

declare type keyList = {
    id: string | number;
}[];
interface DataType extends keyList {
}

interface VirtualListProps<T extends DataType> extends Omit<VariableSizeListProps, 'children' | 'width' | 'height' | 'itemCount' | 'itemSize' | 'itemData' | 'overscanCount' | 'onItemsRendered' | 'useIsScrolling'> {
    list: T;
    lineRender: (row: any, index: number) => ReactNode;
    scrollingRender?: (index: number) => ReactNode;
    nextPage: () => void;
    nextTrigger?: number;
    emptyNode?: ReactNode;
    wrapperClass?: string;
    lineClass?: (index: number) => string;
    lineStyle?: (index: number) => Partial<CSSProperties>;
}
declare const VirtualList: FC<VirtualListProps<DataType>>;

interface IHeaderTree {
    label: string;
    children?: IHeaderTree[];
}
interface IWidths {
    [key: string]: number;
}
declare type ListType = {
    id: string;
    children?: {
        id: string;
    }[];
};

interface VirtualTableProps<T> {
    list: T[];
    setList?: Dispatch<SetStateAction<T[]>>;
    groups?: {
        [key: string]: T[];
    };
    setGroups?: Dispatch<SetStateAction<{
        [key: string]: T[];
    }>>;
    widths: IWidths;
    changeWidths?: Dispatch<SetStateAction<IWidths>>;
    canChangeWidths?: boolean;
    canDragSortColumn?: boolean;
    canDragSortRow?: boolean;
    dragRowIcon?: string;
    textLayout?: 'left' | 'center';
    labels: string[];
    changeLabels?: Dispatch<SetStateAction<string[]>>;
    sortRenders?: {
        [key: string]: ReactNode;
    };
    filterRenders?: {
        [key: string]: ReactNode;
    };
    cellRenders: {
        [key: string]: (row: T, index: number) => ReactNode;
    };
    headRenders: {
        [key: string]: ReactNode;
    };
    headerTrees?: IHeaderTree[];
    scrollingRender?: (index: number) => ReactNode;
    nextPage?: () => void;
    nextTrigger?: number;
    titleHeight?: number;
    rowHeight?: number;
    wrapperClass?: string;
    wrapperStyle?: Partial<react__default.CSSProperties>;
    className?: string;
    tableStyle?: Partial<react__default.CSSProperties>;
    headerClass?: string;
    rowClass?: ({ index, row }: {
        index: number;
        row: T;
    }) => string;
    rowClick?: ({ event, index, row, }: {
        event: MouseEvent<HTMLDivElement>;
        index: number;
        row: T;
    }) => void;
    fixedTopCount?: number;
    fixedLeftCount?: number;
    fixedRightCount?: number;
    canChecked?: boolean;
    checked?: string[];
    setChecked?: Dispatch<SetStateAction<string[]>>;
    emptyNode?: ReactNode;
}
declare const VirtualTable: {
    <T extends ListType>({ list, setList, groups, setGroups, widths, labels, changeLabels, textLayout, sortRenders, filterRenders, cellRenders, headRenders, headerTrees, scrollingRender, changeWidths, canChangeWidths, canDragSortColumn, canDragSortRow, dragRowIcon, nextPage, nextTrigger, wrapperStyle, wrapperClass, className, tableStyle, titleHeight, rowHeight, headerClass, rowClass, rowClick, fixedTopCount, fixedLeftCount, fixedRightCount, canChecked, checked, setChecked, emptyNode, }: VirtualTableProps<T>): JSX.Element;
    displayName: string;
};

declare const inArray: (maxArr: string[], minArr: string[]) => boolean;

interface StatProps {
    className?: string;
    orientation?: 'vertical' | 'horizontal';
    statOptions?: {
        stat?: {
            title?: string;
            value?: string;
            desc?: string;
            figure?: ReactNode;
        }[];
    }[];
}
declare const Stat: {
    ({ className, statOptions, orientation, }: StatProps): JSX.Element;
    displayName: string;
};

interface PanelContainerProps {
    id?: string;
    className?: string;
    children?: ReactNode;
}

interface PanelSpacingProps {
    spacing?: 'sm' | 'md' | 'lg';
}

interface PanelSectionProps {
    children?: ReactNode;
    id?: string;
    label?: string;
    description?: string;
    enableFunction?: boolean;
    spacing?: 'sm' | 'md' | 'lg';
    toggleExpandChildren?: (show: boolean) => void;
    checked?: boolean;
}

interface PanelHeaderProps {
    icon?: string;
    title?: string;
    helpPanel?: boolean;
    children?: ReactNode;
    toggleHelpPanel?: () => void;
}

interface PanelProps {
    children?: ReactNode;
    className?: string;
    Component?: string | ComponentType<any>;
}
declare const _default$1: {
    ({ children, className, Component, }: PanelProps): JSX.Element;
    displayName: string;
} & {
    Header: {
        ({ icon, title, helpPanel, children, toggleHelpPanel, }: PanelHeaderProps): JSX.Element;
        displayName: string;
    };
    Section: {
        ({ children, id, label, description, enableFunction, spacing, toggleExpandChildren, checked, }: PanelSectionProps): JSX.Element;
        displayName: string;
    };
    Spacing: {
        ({ spacing }: PanelSpacingProps): JSX.Element;
        displayName: string;
    };
    Container: {
        ({ id, className, children, }: PanelContainerProps): JSX.Element;
        displayName: string;
    };
};

interface FieldGroupProps {
    className?: string;
    children?: ReactNode;
    wrap?: boolean;
}
declare const FieldGroup: react.ForwardRefExoticComponent<FieldGroupProps & react.RefAttributes<HTMLDivElement>>;

interface FieldGroupItemProps {
    grow?: boolean;
    className?: string;
}
declare const FieldGroupItem: ({ children, grow, className, }: PropsWithChildren<FieldGroupItemProps>) => JSX.Element;

interface TabsOption {
    id?: string | number;
    text?: string;
    disabled?: boolean;
}
interface TabsProps {
    active?: TabsOption;
    className?: string;
    setActive?: (option: TabsOption) => void;
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    tabsOptions?: TabsOption[];
    textClassName?: string;
    variant?: 'normal' | 'minimal';
    afterComponent?: (state: {
        active: boolean;
    }) => JSX.Element | false;
    beforeComponent?: JSX.Element;
}
declare const Tabs: {
    ({ className, afterComponent, beforeComponent, textClassName, setSize, tabsOptions, variant, active, setActive, }: TabsProps): JSX.Element;
    displayName: string;
};

interface AccordionProps extends UseCollapseProps {
    className?: string;
    gapClassName?: string;
    children?: ReactNode;
}
declare const Accordion: (props: AccordionProps) => JSX.Element;

interface AccordionHeaderProps {
    ariaExpanded?: boolean;
    className?: string;
    toggle: () => void;
    collapse: boolean;
    children?: ReactNode;
    id?: string;
    icon?: string;
    disabled?: boolean;
    paddingClass?: string;
    trigger?: string;
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    triggerSize?: 'xs' | 'sm' | 'md' | 'lg';
}
declare const AccordionHeader: (props: AccordionHeaderProps) => JSX.Element;

interface AccordionPanelProps {
    children?: ReactNode;
    className?: string;
    collapseId?: string;
    contentClass?: string;
    disabled?: boolean;
    dividerClassName?: string;
    dividerIntent?: 'default' | 'gradient';
    dividerThickness?: '1px' | '2px' | '3px';
    header?: ComponentType<AccordionHeaderProps> | string | ReactElement;
    headerClass?: string;
    icon?: string;
    keepExpanded?: boolean;
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
    showDivider?: boolean;
    trigger?: 'button' | 'header';
    triggerSize?: 'xs' | 'sm' | 'md' | 'lg';
}
declare const AccordionPanel: (props: AccordionPanelProps) => JSX.Element;

interface PanelStackItem<P> {
    renderPanel: (props: PanelItemProps<P>) => JSX.Element | null;
    props?: P;
    renderHeader: (props: PanelItemProps<P>) => JSX.Element | null;
}
interface PanelActions {
    closePanel(): void;
    openPanel<P>(panel: PanelStackItem<P>): void;
}
declare type PanelItemProps<P> = P & PanelActions & {
    prevPanel: PanelStackItem<any>;
};
interface PanelStackProps<T extends PanelStackItem<any>> {
    onClose?: (removedPanel: T) => void;
    onOpen?: (addedPanel: T) => void;
    renderActivePanelOnly?: boolean;
    showPanelHeader?: boolean;
    stack: readonly T[];
    className?: string;
}
declare const PanelStack: <T extends PanelStackItem<any>>({ renderActivePanelOnly, showPanelHeader, stack: propsStack, className, onOpen, onClose, }: PanelStackProps<T>) => JSX.Element | null;

declare type ActionCreator<A, S> = (state: S) => {
    [K in keyof A]: (payload?: any) => S;
};
declare type Action<A> = {
    [K in keyof A]: (...payload: any[]) => any;
};
declare function useActions<A, S>(creator: ActionCreator<A, S>, initial: S): readonly [S, Action<A>];

declare type ConditionType = 'and' | 'or';
interface ConditionData extends ItemInterface {
    type: 'condition';
    name: string;
    data?: any;
}
interface ConditionGroupData extends ItemInterface {
    type: 'condition-group';
    name: string;
    condition: ConditionType;
    group: ConditionsData[];
}
declare type ConditionsData = ConditionData | ConditionGroupData;
declare const useFilterConditions: (dataSource: ConditionGroupData, newConditionName: string, addConditionCb?: ((raw: ConditionData) => ConditionData) | undefined, onChange?: ((data: ConditionGroupData) => void) | undefined) => {
    data: ConditionGroupData;
    actions: Action<{
        sort: unknown;
        toggleConditionType: unknown;
        updateCondition: unknown;
        delete: unknown;
        clear: unknown;
        copy: unknown;
        addCondition: unknown;
        addConditionGroup: unknown;
    }>;
};

interface IRenderConditionControllerProps {
    conditionData: ConditionData;
    update: (cb: (item: ConditionData) => void) => void;
}
interface IRenderConditionController {
    (props: IRenderConditionControllerProps): JSX.Element;
}

interface ConditionsEditorProps {
    className?: string;
    /**
     * 数据源
     */
    dataSource: ConditionGroupData;
    /**
     * 渲染条件控件
     */
    children: IRenderConditionController;
    /**
     * 只能添加一级条件，不允许嵌套组
     */
    disableGroup?: boolean;
    /**
     * 添加条件
     */
    addCondition?: (raw: ConditionData) => ConditionData;
    /**
     * 数据更新回调
     */
    onChange?: (data: ConditionGroupData) => void;
    /**
     * 为空时的提示信息
     */
    emptyMessage?: string;
    conditions?: [string, string];
    newConditionName?: string;
    groupName?: string;
    conditionMenus?: [string, string];
    topMenus?: [string];
}
interface ConditionsEditorRef {
    getCurrentData: () => ConditionGroupData;
    delete: (id: string) => void;
    clear: () => void;
}
declare const ConditionsEditor: react.ForwardRefExoticComponent<ConditionsEditorProps & react.RefAttributes<unknown>>;

interface TooltipProps {
    label: React.ReactNode;
    tail?: boolean;
    /**
     * 方向
     */
    placement?: Placement;
    children: JSX.Element;
    /**
     * tooltip 容器类名
     */
    className?: string;
    /**
     * 延迟多久打开
     */
    delay?: number;
    /**
     * 延迟几秒后关闭
     */
    duration?: number;
    /**
     * 增加的偏移量
     */
    spacing?: number;
    /**
     * 事件触发的方式
     */
    trigger?: 'hover' | 'focus' | 'click';
    intent?: 'default' | 'primary';
    variant?: 'normal' | 'reverse';
    paddingClassName?: string;
    roundedClassName?: string;
    textClassName?: string;
}
declare const Tooltip: {
    ({ children, label, placement, tail, className, duration, delay, spacing, trigger, intent, variant, paddingClassName, roundedClassName, textClassName, }: TooltipProps): JSX.Element;
    displayName: string;
};

interface DrawerProps {
    /**
     * 抽屉框内容
     */
    children?: ReactNode;
    /**
     * 	抽屉的方向
     */
    placement?: 'left' | 'top' | 'right' | 'bottom';
    /**
     * 宽度
     */
    width?: string | number;
    /**
     * 高度
     */
    height?: string | number;
    /**
     * 显示状态切换回调
     */
    onChange?: (open?: boolean | undefined) => void;
    /**
     * 关闭显示状态回调
     */
    onClose?: (e: MouseEvent | KeyboardEvent) => void;
    /**
     * 抽屉展开后是否将焦点切换至其 Dom 节点
     */
    autoFocus?: boolean;
    /**
     * 对话框外层容器的类名
     */
    className?: string;
    /**
     * 是否展示遮罩
     */
    showMask?: boolean;
    /**
     * 点击蒙层是否允许关闭
     */
    maskClosable?: boolean;
    /**
     * 遮罩样式
     */
    maskStyle?: CSSProperties;
    /**
     * 可用于设置 Drawer 包裹内容部分的样式
     */
    contentWrapperStyle?: CSSProperties;
    /**
     * 指定 Drawer 挂载的节点，并在容器内展现，false 为挂载在当前位置
     */
    getContainer?: string | HTMLElement | (() => HTMLElement);
    /**
     * 切换抽屉时动画结束后的回调
     */
    afterVisibleChange?: (open: boolean) => void;
    /**
     * 是否支持键盘 esc 关闭
     */
    keyboard?: boolean;
    /**
     * 是否打开
     */
    open: boolean;
}
declare function Drawer({ ...rest }: DrawerProps): JSX.Element;

interface IDropdownTriggerProps {
    /**
     * 参照dom的必要属性集合，请确保该参数正确赋值给参照dom；
     * 如果解构赋值的是自定义组件标签，请确保该组件被forwardRef包括，且正确传递ref
     *
     * @example <div {...referenceProps} />
     */
    referenceProps: HTMLAttributes<HTMLElement>;
    /**
     * floating-ui提供的上下文对象，该对象包括了：
     * open状态，onOpenChange（切换open状态），refs（reference ref 和 floating ref），
     * 更多信息请查看floating-ui文档
     */
    context: FloatingContext<ReferenceType>;
}
declare type DropdownTriggerProps<E = Record<PropertyKey, unknown>> = IDropdownTriggerProps & E;
declare const DropdownTrigger: {
    (props: DropdownTriggerProps<ButtonProps>): JSX.Element;
    displayName: string;
};

interface IDropdownProps<T extends object> {
    /**
     * 自定义Trigger组件
     * 注意，使用自定义trigger组件时，请不要使用`DropdownTriggerProps`已声明属性；
     * 如果重复会被`DropdownTriggerProps`的属性所覆盖。
     */
    trigger?: ComponentType<DropdownTriggerProps<T>>;
    /**
     * 自定义 DropdownItem 不存在时的提示组件
     */
    emptyComponent?: ReactNode;
    /**
     * dropdown 选择项
     */
    children?: ReactNode;
    /**
     * 禁用Dropdown
     */
    disabled?: boolean;
    /**
     * 内容出现的位置 - 可参考 @floating-ui 的 `placement` 参数
     */
    placement?: Placement;
    /**
     * 宽度匹配
     */
    matchTriggerWidth?: boolean;
    /**
     * 尺寸大小
     */
    setSize?: 'xs' | 'sm' | 'md' | 'lg';
}
declare type DropdownProps<T extends object = ButtonProps> = IDropdownProps<T> & T;
declare const _default: (<T extends object = ButtonProps>(props: DropdownProps<T>) => JSX.Element) & {
    Item: react.ForwardRefExoticComponent<ListboxItemProps & react.RefAttributes<HTMLDivElement>>;
    Submenu: react.ForwardRefExoticComponent<{
        placement?: Placement | undefined;
        children?: ReactNode;
    } & ListboxItemProps & react.RefAttributes<HTMLButtonElement>>;
    Group: react.ForwardRefExoticComponent<IListboxGroupItem & react.RefAttributes<HTMLDivElement>>;
};

declare type DropdownSubmenu = {
    placement?: Placement;
    children?: ReactNode;
} & ListboxItemProps;
declare const DropdownSubmenu: react.ForwardRefExoticComponent<{
    placement?: Placement | undefined;
    children?: ReactNode;
} & ListboxItemProps & react.RefAttributes<HTMLButtonElement>>;

declare type PositionType = 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right';

interface NotificationPresetProps {
    /**
     * 是否自动关闭，单位为ms，
     * 0为不自动关闭，默认为0
     */
    autoClose?: number;
    /**
     * 自定义图标
     */
    icon?: string;
    /** className */
    className?: string;
    /**
     * customBgClass
     */
    customBgClass?: string;
    /** position, 默认top */
    position?: PositionType;
    /** 自定义closeButton */
    closeButton?: (props: {
        close: () => void;
    }) => ReactElement;
    /** 完全自定义item */
    customItem?: (props: any, closeItem: () => void) => ReactElement;
}
declare type NotificationType = 'info' | 'success' | 'error' | 'warning';
declare const NotificationApi: {
    info(message: string, variant?: NotificationPresetProps): void;
    success(message: string, variant?: NotificationPresetProps): void;
    error(message: string, variant?: NotificationPresetProps): void;
    warning(message: string, variant?: NotificationPresetProps): void;
    cleanAll(): void;
};

declare class DialogManager {
    private dialogs;
    constructor();
    add(dialogId: string): void;
    remove(dialogId: string): void;
    isBottomDialog(dialogId: string): boolean;
}

interface DialogProps {
    /** 头部 */
    header?: ((props: {
        close?: () => void;
    }) => JSX.Element) | string;
    /** 内容区域 */
    content: ReactNode;
    /** footer */
    footer?: (props: {
        close: () => void;
    }) => JSX.Element;
    backgroundClassName?: string;
    roundedClassName?: string;
    shadowClassName?: string;
    /** 点击backdrop是否关闭, 默认false */
    backdropClose?: boolean;
    backdropBlur?: boolean;
    backdropTranslucent?: boolean;
    setSize?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'fullscreen';
    /** backdrop */
    className?: string;
    footerClassName?: string;
    sizeClassName?: string;
    /**
     * dialog 状态
     */
    open?: boolean;
    /**
     * 设置dialog状态
     */
    setOpen?: (state: boolean) => void;
    manager?: DialogManager;
    scroll?: boolean;
}
declare function Dialog({ header, content, footer, footerClassName, setSize, sizeClassName, roundedClassName, shadowClassName, backgroundClassName, backdropClose, backdropBlur, backdropTranslucent, className, open, scroll, setOpen, manager, }: PropsWithChildren<DialogProps>): JSX.Element;
declare namespace Dialog {
    var displayName: string;
}

declare type DialogElement = ReactElement<{
    /**
     * dialog 状态
     */
    open?: boolean;
    /**
     * 设置dialog状态
     */
    setOpen?: (state: boolean) => void;
    [key: string]: unknown;
}>;
declare const mountDialog: (dialog: DialogElement) => {
    open: () => void;
    close: () => void | undefined;
};

declare type OffsetValue = number | {
    /**
     * The axis that runs along the side of the floating element.
     * @default 0
     */
    mainAxis?: number;
    /**
     * The axis that runs along the alignment of the floating element.
     * @default 0
     */
    crossAxis?: number;
    /**
     * When set to a number, overrides the `crossAxis` value for aligned
     * (non-centered/base) placements and works logically. A positive number
     * will move the floating element in the direction of the opposite edge
     * to the one that is aligned, while a negative number the reverse.
     * @default null
     */
    alignmentAxis?: number | null;
};
declare type OffsetFunction = (args: MiddlewareArguments) => OffsetValue;
declare type OffsetOptions = OffsetValue | OffsetFunction;
interface PopperProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
    /**
     * 参考的的目标元素
     */
    anchorEl?: null | VirtualElement;
    /**
     * 内部元素
     */
    children: ReactNode;
    /**
     * 方位
     */
    placement?: Placement;
    /**
     * 样式名
     */
    className?: string;
    /**
     * 是否打开
     */
    open?: boolean;
    /**
     * 设置打开状态
     */
    onOpenChange?: (state: boolean) => void;
    /**
     * 是否保持dom挂载, 开启后，dom不会被销毁
     */
    keepMounted?: boolean;
    /**
     * 样式
     */
    style?: React.CSSProperties;
    /**
     * Popper的偏移位置，可以外部是可以自行调整的
     */
    offset?: OffsetOptions;
    /**
     * 是否将弹层放置于 body 内，添加此属性，它将不受父级样式影响
     */
    transfer?: boolean;
    matchTriggerWidth?: boolean;
}
declare const Popper: react.ForwardRefExoticComponent<PopperProps & react.RefAttributes<HTMLDivElement>>;

interface PopperConfirmProps {
    /**
     * 触发的
     */
    children: JSX.Element;
    /**
     * 确认文字
     */
    okText?: string;
    /**
     * 取消文字
     */
    cancelText?: string;
    /**
     * 标题
     */
    title?: string;
    /**
     * 取消的回调
     */
    onCancel?: () => void;
    /**
     * 确认的回调
     */
    onConfirm?: () => void;
    /**
     * 头部的icon
     */
    icon?: string;
}
declare function PopperConfirm(props: PopperConfirmProps): JSX.Element;

interface OverlayProps {
    className: string;
    style?: CSSProperties;
}
declare function Overlay({ children, className, style, }: PropsWithChildren<OverlayProps>): JSX.Element;

interface RevolvingProps {
    className?: string;
    gap?: string;
    speed?: number;
    mask?: boolean;
    hoverPaused?: boolean;
    textOptions: {
        content?: JSX.Element | string;
    }[];
}
declare function Revolving({ className, speed, mask, hoverPaused, gap, textOptions, }: RevolvingProps): JSX.Element;
declare namespace Revolving {
    var displayName: string;
}

interface IUseDynamicColorProps {
    /**
     * 锚颜色，只支持十六进制
     */
    anchorColor: string;
    /**
     * 对比颜色类型名称 - 浅色
     */
    lightness?: string;
    /**
     * 对比颜色类型名称 - 深色
     */
    dimness?: string;
}
declare function useDynamicColor({ anchorColor, lightness, dimness, }: IUseDynamicColorProps): {
    hex: string;
    hsl: string;
    setColor: react.Dispatch<react.SetStateAction<string>>;
    contrast: string;
};

declare function usePresetStyle(color: string): void;

declare type ObservedSize = {
    width: number | undefined;
    height: number | undefined;
};
declare type ObservedChildren = {
    top: number;
    left: number;
    width: number;
    height: number;
    dom: HTMLElement;
}[];
interface IUseResizeObserverReturn<E extends HTMLElement> extends ObservedSize {
    ref: (instance: E | null) => void;
    children: ObservedChildren;
}
declare type Config = {
    type?: 'none';
} | {
    type?: 'debounce' | 'throttle';
    wait?: number;
};
declare function useResizeObserver<E extends HTMLElement, Type extends Config['type']>(...args: Extract<Config, {
    type?: Type;
}> extends {
    wait?: number;
} ? [type?: Type, wait?: number] : [type?: Type]): IUseResizeObserverReturn<E>;

interface UseSetAPI<T> {
    add(itemOrList: T | T[]): void;
    clear(initialValue?: T[]): void;
    remove(item: T): void;
    reset(): void;
}
declare const useSet: <T>(initialValue?: Iterable<T> | undefined, onSetUpdate?: ((set: Set<T>) => void) | undefined) => [set: Set<T>, api: UseSetAPI<T>];

interface UseTrackedStateOptions {
    /**
     * 指定 `state` 的默认值，若传入的 `value` 是 `null` 或者 `undefined` 返回此值
     */
    defaultValue?: any;
    /**
     * 指定当传入的 `value` 是 `false` 时 `state` 的值，缺省是 `''`
     */
    falsyValue?: string;
}
/**
 * 传入一个 `value` 和一个 `options`，创建并返回一个 `state`，它具备以下特点：
 *
 * 1. 若传入的 `value` 为 `false`，则 `state` 为
 *    `options.falsyValue`，`options.falsyValue` 默认是 `''`
 * 2. 若传入的 `value` 为 `null` 或 `undefined`，则 `state` 为
 *    `options.defaultValue`
 * 3. 其他情况 `state` 的值即为传入的 `value` 的值
 *
 * 另外还返回了`setState` 函数，可用于更新 `state` 的值。不过要注意，如果传入的
 * `value` 发生了变化，那么 `state` 会自动更新为 `value`，因此不要依赖`setState`
 * 会持久化 `state` 的值
 *
 * ```typescript
 * // value 可以来自于 props，若 value 更新则 state 会同步更新
 * const [state, setState] = useTrackedState(value, {
 *   defaultValue: 'foo', // 可选，不传则为 undefined
 *   falsyValue: 'bar',   // 可选，不传则为 ''
 * });
 * ```
 *
 * `useTrackedState` 和 `useState` 的根本区别就在于前者会自动跟踪传入 `value` 的
 * 变化，这意味着一旦 `value` 变化了就会重新渲染（因为 `state` 更新了）；而后者
 * 则需要在 `useEffect` 里手动调用 `setState` 才能造成重新渲染。虽然
 * `useTrackedState` 使用起来更加方便，但由于它的“反应性”是封装在内部且不可人为
 * 干预的，因此请谨慎使用以避免不必要的重新渲染。简言之： **如果要手动控制因更新
 * `state` 而引起的重新渲染，请用 `useState`；如果确信 `state` 的更新可以与依赖
 * 的 `value` 保持同步，则可以放心使用 `usetrackedState`**
 */
declare function useTrackedState(value: any, options?: UseTrackedStateOptions): readonly [any, react.Dispatch<any>];

declare type CropArea = Area;
interface CropperProps {
    className?: string;
    style?: {
        containerStyle?: React.CSSProperties;
        cropAreaStyle?: React.CSSProperties;
        mediaStyle?: React.CSSProperties;
    };
    /** 输入图像的地址 */
    image: string;
    /** 裁剪的中心位置，设为 { x: 0, y: 0 } 可令图像居中 */
    crop: {
        x: number;
        y: number;
    };
    /** 裁剪发生时的回调，用于更新 `crop` 状态 */
    onCropChange: (crop: {
        x: number;
        y: number;
    }) => void;
    /** 当前缩放值，介于 `minZoom` 和 `maxZoom` 之间。通常默认为 1 */
    zoom: number;
    /** 缩放发生时的回调，用于更新 `zoom` 状态 */
    onZoomChange: (zoom: number) => void;
    /** 裁剪框的形状 */
    cropShape?: 'rect' | 'round';
    /** 裁剪框的尺寸 */
    cropSize: {
        width: number;
        height: number;
    };
    /** 裁剪比例，默认：1，即正方形 */
    aspect?: number;
    /** 旋转角度，默认：0 */
    rotation?: number;
    /** 最小缩放值，默认：1.0 */
    minZoom?: number;
    /** 最大缩放值，默认：5.0 */
    maxZoom?: number;
    /** 缩放速度，取值范围 0-1，默认：1，可用于微调缩放速率 */
    zoomSpeed?: number;
    /** 是否显示辅助网格线 */
    showGrid?: boolean;
    /** 是否将图像边界限制在裁剪框内 */
    restrictPosition?: boolean;
    /** 图像填充裁剪容器的策略，默认：'auto-cover' */
    objectFit?: 'contain' | 'auto-cover' | 'horizontal-cover' | 'vertical-cover';
    /** 媒体资源加载成功的回调 */
    onMediaLoaded?: (media: MediaSize) => void;
    /**
     * 裁剪完成时的回调，用于获取裁剪后的结果。
     * 第一个回调参数是裁剪区域的百分比（相对于原始尺寸），第二个是裁剪区域的尺寸。
     */
    onCropComplete?: (areaInPercentage: CropArea, areaInPixel: CropArea) => void;
}
/**
 * 用于对输入的图片/视频进行裁剪，支持缩放、旋转等基本编辑功能
 *
 * @see [Cropper 交互文档](https://developer.choiceform.io/docs/components/cropper)
 */
declare function Cropper(props: CropperProps): JSX.Element;

declare function getCroppedImage(src: string, { x, y, width, height }: CropArea): Promise<HTMLCanvasElement>;

interface AvatarEditorProps extends Partial<Omit<CropperProps, 'onCropComplete'>> {
    /** 可上传的图片类型，默认：`['.jpeg', '.jpg', '.png']` */
    acceptTypes?: string[];
    /** 组件显示的大小，使用 tailwindcss 的样式类名，默认：'w-40 h-40' */
    containerSize?: string;
    /**
     * @param image 上传的原始图片
     * @param cropArea 以像素为单位的裁剪区域信息
     */
    onCropComplete?(image: string, cropArea: CropArea): void;
}
/**
 * `AvatarEditor` 是对 `Cropper` 的二次封装，为其提供了选取或拖拽文件的功能，在
 * 文件选择成功后，自动调用 `Cropper` 对其进行裁剪处理，同时它还代理了 `Cropper`
 * 组件的所有属性，并为其中一些设置了合理的默认值：
 *
 * - `crop`: `{ x: 0, y: 0 }`
 * - `zoom`: `1`
 * - `cropSize`: `{ width: 144, height: 144 }`
 *
 * @see [Cropper 交互文档](https://developer.choiceform.io/docs/components/cropper)
 */
declare function AvatarEditor(props: AvatarEditorProps): JSX.Element;

export { API, Accordion, AccordionHeader, AccordionHeaderProps, AccordionPanel, AccordionPanelProps, AccordionProps, Avatar, AvatarEditor, AvatarProps, Badge, BadgeProps, Breadcrumbs, BreadcrumbsProps, Button, ButtonProps, Checkbox, CheckboxGroup, CheckboxGroupProps, CheckboxProps, ChoiceformLogo, ChoiceformLogoProps, ColorPicker, ColorPickerProps, ConditionData, ConditionGroupData, ConditionType, ConditionsData, ConditionsEditor, ConditionsEditorProps, ConditionsEditorRef, ContainerBox, ContainerBoxEntireProps, ContainerBoxProps, ControlProps, CropArea, Cropper, CropperProps, DatePicker, DatePickerProps, Dialog, DialogProps, Divider, DividerProps, Drawer, DrawerProps, _default as Dropdown, DropdownProps, DropdownSubmenu, DropdownTrigger, DropdownTriggerProps, FieldGroup, FieldGroupItem, FieldGroupItemProps, FieldGroupProps, Footer, FooterProps, Form, FormDivider, FormDividerProps, FormItem, FormItemProps, FormLabel, FormLabelProps, FormProps, FormToggle, FormToggleProps, Formatter, ICustomComponents, IDialogPayload, IDialogRenderer, IListPayload, IListRenderer, IListboxGroupItem, IOptionData, IOptionGroupData, IOptionsDataMap, IProps, ISelectOptionGroupProps, ITriggerBaseProps, IUseOptions, IUseSelectionsProps, Icon, IconProps, Input, InputAddon, InputGroup, InputProps, _default$3 as Listbox, ListboxEmptyMessage, ListboxEmptyMessageProps, ListboxGroupItem, ListboxItem, ListboxItemProps, ListboxProps, LoaderCircle, LoaderDot, Messages, MessagesProps, MonthPickerProps, MultipleSelectTrigger, Navbar, NavbarOption, NavbarProps, NotificationPresetProps, NotificationType, Nullable, NumericInput, NumericInputProps, OffsetOptions, Option, OptionGroup, OptionItem, OptionItems, Options, Orientation, Overlay, OverlayProps, Pane, _default$1 as Panel, PanelActions, PanelContainerProps, PanelHeaderProps, PanelItemProps, PanelProps, PanelSectionProps, PanelSpacingProps, PanelStack, PanelStackItem, PanelStackProps, PipsMode, PipsType, Popper, PopperConfirm, PopperConfirmProps, PopperProps, PresetProps, ProgressBar, ProgressBarProps, ProgressCircle, Radio, RadioGroup, RadioGroupCtrlRef, RadioGroupProps, RadioProps, RangePickerProps, Revolving, RevolvingProps, RichInput, RichInputProps, SegmentedLabeledOption, SegmentedOptions, SegmentedPicker, SegmentedPickerProps, SegmentedRawOption, SegmentedValue, Select, SelectInput, SelectInputProps, SelectOptionProps, SelectProps, SelectTrigger, Slider, SliderProps, Splitter, SplitterEngine, SplitterEngineParams, SplitterPanel, SplitterPanelProps, SplitterProps, Stat, StatProps, Steps, StepsProps, SwapButton, SwapButtonProps, Switch, SwitchProps, TOptionsData, TSelectValue, Tabs, TabsOption, TabsProps, Tag, TagProps, Textarea, TextareaProps, _default$2 as TimePicker, TimePickerLocale, TimePickerProps, TimeRangePickerProps, Tooltip, TooltipProps, TriggerProps, UseFormProps, ValueTagProps, VirtualList, VirtualListProps, VirtualTable, VirtualTableProps, WeekPickerProps, assertIsEngine, assertIsHTMLElement, assertIsNumber, getCroppedImage, inArray, mountDialog, NotificationApi as notification, useActions, useCollapse, useContainerBoxClassName, useDynamicColor, useFilterConditions, useForm, usePresetStyle, useResizeObserver, useSet, useSplitter, useTrackedState, useWatchObserver };
