doui-react 1.0.0

package/es/radio/component/abstract-box.d.ts

@@ -0,0 +1,380 @@
+/// <reference types="react" />
+import { BaseBoxProps } from "..";
+import type { SerializedStyles } from '@emotion/utils';
+import { CheckboxChangeEvent } from 'antd/lib/checkbox/Checkbox';
+export declare function useAbstractBox({ refs, boxTooltip, value, onChange, inGroup, ...props }: BaseBoxProps): {
+    highlightTextProps: Partial<BaseBoxProps>;
+    tooltipProps: {
+        title?: import("react").ReactNode | import("antd/lib/tooltip").RenderFunction;
+        overlay?: import("react").ReactNode | import("antd/lib/tooltip").RenderFunction;
+        style?: import("react").CSSProperties | undefined;
+        className?: string | undefined;
+        color?: string | undefined;
+        placement?: import("antd/lib/tooltip").TooltipPlacement | undefined;
+        builtinPlacements?: import("rc-trigger").BuildInPlacements | undefined;
+        openClassName?: string | undefined;
+        arrowPointAtCenter?: boolean | undefined;
+        autoAdjustOverflow?: boolean | import("antd/lib/tooltip").AdjustOverflow | undefined;
+        getPopupContainer?: ((triggerNode: HTMLElement) => HTMLElement) | undefined;
+        children?: import("react").ReactNode;
+        visible?: boolean | undefined;
+        open?: boolean | undefined;
+        defaultVisible?: boolean | undefined;
+        defaultOpen?: boolean | undefined;
+        onVisibleChange?: ((visible: boolean) => void) | undefined;
+        onOpenChange?: ((visible: boolean) => void) | undefined;
+        afterVisibleChange?: ((visible: boolean) => void) | undefined;
+        afterOpenChange?: ((visible: boolean) => void) | undefined;
+        zIndex?: number | undefined;
+        animation?: string | undefined;
+        motion?: import("rc-motion").CSSMotionProps | undefined;
+        id?: string | undefined;
+        onPopupAlign?: ((element: HTMLElement, align: import("rc-trigger/lib/interface").AlignType) => void) | undefined;
+        trigger?: string | string[] | undefined;
+        transitionName?: string | undefined;
+        overlayStyle?: import("react").CSSProperties | undefined;
+        overlayClassName?: string | undefined;
+        prefixCls?: string | undefined;
+        mouseEnterDelay?: number | undefined;
+        mouseLeaveDelay?: number | undefined;
+        getTooltipContainer?: ((node: HTMLElement) => HTMLElement) | undefined;
+        destroyTooltipOnHide?: boolean | {
+            keepParent?: boolean | undefined;
+        } | undefined;
+        align: import("rc-trigger/lib/interface").AlignType;
+        showArrow?: boolean | undefined;
+        arrowContent?: import("react").ReactNode;
+        popupVisible?: boolean | undefined;
+        overlayInnerStyle?: import("react").CSSProperties | undefined;
+    } | {
+        title: import("react").ReactNode | import("antd/lib/tooltip").RenderFunction;
+        overlay?: import("react").ReactNode | import("antd/lib/tooltip").RenderFunction;
+        style?: import("react").CSSProperties | undefined;
+        className?: string | undefined;
+        color?: string | undefined;
+        placement?: import("antd/lib/tooltip").TooltipPlacement | undefined;
+        builtinPlacements?: import("rc-trigger").BuildInPlacements | undefined;
+        openClassName?: string | undefined;
+        arrowPointAtCenter?: boolean | undefined;
+        autoAdjustOverflow?: boolean | import("antd/lib/tooltip").AdjustOverflow | undefined;
+        getPopupContainer?: ((triggerNode: HTMLElement) => HTMLElement) | undefined;
+        children?: import("react").ReactNode;
+        visible?: boolean | undefined;
+        open?: boolean | undefined;
+        defaultVisible?: boolean | undefined;
+        defaultOpen?: boolean | undefined;
+        onVisibleChange?: ((visible: boolean) => void) | undefined;
+        onOpenChange?: ((visible: boolean) => void) | undefined;
+        afterVisibleChange?: ((visible: boolean) => void) | undefined;
+        afterOpenChange?: ((visible: boolean) => void) | undefined;
+        zIndex?: number | undefined;
+        animation?: string | undefined;
+        motion?: import("rc-motion").CSSMotionProps | undefined;
+        id?: string | undefined;
+        onPopupAlign?: ((element: HTMLElement, align: import("rc-trigger/lib/interface").AlignType) => void) | undefined;
+        trigger?: string | string[] | undefined;
+        transitionName?: string | undefined;
+        overlayStyle?: import("react").CSSProperties | undefined;
+        overlayClassName?: string | undefined;
+        prefixCls?: string | undefined;
+        mouseEnterDelay?: number | undefined;
+        mouseLeaveDelay?: number | undefined;
+        getTooltipContainer?: ((node: HTMLElement) => HTMLElement) | undefined;
+        destroyTooltipOnHide?: boolean | {
+            keepParent?: boolean | undefined;
+        } | undefined;
+        align: import("rc-trigger/lib/interface").AlignType;
+        showArrow?: boolean | undefined;
+        arrowContent?: import("react").ReactNode;
+        popupVisible?: boolean | undefined;
+        overlayInnerStyle?: import("react").CSSProperties | undefined;
+    };
+    boxProps: {
+        onChange(e: CheckboxChangeEvent): void;
+        children?: import("react").ReactNode;
+        text?: import("react").ReactNode;
+        search?: string | undefined;
+        value?: any;
+        boxTooltip?: import("react").ReactNode | import("antd").TooltipProps;
+        inGroup?: boolean | undefined;
+        style?: import("react").CSSProperties | undefined;
+        type?: string | undefined;
+        className?: string | undefined;
+        defaultChecked?: boolean | undefined;
+        autoFocus?: boolean | undefined;
+        id?: string | undefined;
+        tabIndex?: number | undefined;
+        onKeyDown?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyPress?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseEnter?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseLeave?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        name?: string | undefined;
+        prefixCls?: string | undefined;
+        checked?: boolean | undefined;
+        disabled?: boolean | undefined;
+        indeterminate?: boolean | undefined;
+        skipGroup?: boolean | undefined;
+        rows?: number | false | undefined;
+        tooltip?: import("react").ReactNode | import("antd").TooltipProps;
+        autoShowTooltip?: boolean | undefined;
+        slot?: string | undefined;
+        title?: string | undefined;
+        accessKey?: string | undefined;
+        dir?: string | undefined;
+        color?: string | undefined;
+        content?: string | undefined;
+        direction?: import("antd/lib/config-provider").DirectionType;
+        translate?: "no" | "yes" | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        autoCapitalize?: (string & {}) | "none" | "off" | "on" | "sentences" | "words" | "characters" | undefined;
+        contentEditable?: "inherit" | (boolean | "true" | "false") | undefined;
+        contextMenu?: string | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        enterKeyHint?: "search" | "done" | "enter" | "go" | "next" | "previous" | "send" | undefined;
+        hidden?: boolean | undefined;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        placeholder?: string | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        radioGroup?: string | undefined;
+        role?: import("react").AriaRole | undefined;
+        about?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        property?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "off" | "on" | undefined;
+        inputMode?: "search" | "text" | "none" | "email" | "tel" | "url" | "numeric" | "decimal" | undefined;
+        is?: string | undefined;
+        "aria-activedescendant"?: string | undefined;
+        "aria-atomic"?: (boolean | "true" | "false") | undefined;
+        "aria-autocomplete"?: "none" | "list" | "inline" | "both" | undefined;
+        "aria-busy"?: (boolean | "true" | "false") | undefined;
+        "aria-checked"?: boolean | "true" | "false" | "mixed" | undefined;
+        "aria-colcount"?: number | undefined;
+        "aria-colindex"?: number | undefined;
+        "aria-colspan"?: number | undefined;
+        "aria-controls"?: string | undefined;
+        "aria-current"?: boolean | "time" | "page" | "date" | "true" | "false" | "step" | "location" | undefined;
+        "aria-describedby"?: string | undefined;
+        "aria-details"?: string | undefined;
+        "aria-disabled"?: (boolean | "true" | "false") | undefined;
+        "aria-dropeffect"?: "link" | "none" | "copy" | "execute" | "move" | "popup" | undefined;
+        "aria-errormessage"?: string | undefined;
+        "aria-expanded"?: (boolean | "true" | "false") | undefined;
+        "aria-flowto"?: string | undefined;
+        "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+        "aria-haspopup"?: boolean | "dialog" | "menu" | "grid" | "listbox" | "tree" | "true" | "false" | undefined;
+        "aria-hidden"?: (boolean | "true" | "false") | undefined;
+        "aria-invalid"?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+        "aria-keyshortcuts"?: string | undefined;
+        "aria-label"?: string | undefined;
+        "aria-labelledby"?: string | undefined;
+        "aria-level"?: number | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined;
+        "aria-modal"?: (boolean | "true" | "false") | undefined;
+        "aria-multiline"?: (boolean | "true" | "false") | undefined;
+        "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+        "aria-orientation"?: "vertical" | "horizontal" | undefined;
+        "aria-owns"?: string | undefined;
+        "aria-placeholder"?: string | undefined;
+        "aria-posinset"?: number | undefined;
+        "aria-pressed"?: boolean | "true" | "false" | "mixed" | undefined;
+        "aria-readonly"?: (boolean | "true" | "false") | undefined;
+        "aria-relevant"?: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+        "aria-required"?: (boolean | "true" | "false") | undefined;
+        "aria-roledescription"?: string | undefined;
+        "aria-rowcount"?: number | undefined;
+        "aria-rowindex"?: number | undefined;
+        "aria-rowspan"?: number | undefined;
+        "aria-selected"?: (boolean | "true" | "false") | undefined;
+        "aria-setsize"?: number | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+        "aria-valuemax"?: number | undefined;
+        "aria-valuemin"?: number | undefined;
+        "aria-valuenow"?: number | undefined;
+        "aria-valuetext"?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onCopyCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onCut?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onCutCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onPaste?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onPasteCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+        onCompositionEnd?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionStart?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionUpdate?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+        onFocus?: import("react").FocusEventHandler<HTMLElement> | undefined;
+        onFocusCapture?: import("react").FocusEventHandler<HTMLElement> | undefined;
+        onBlur?: import("react").FocusEventHandler<HTMLElement> | undefined;
+        onBlurCapture?: import("react").FocusEventHandler<HTMLElement> | undefined;
+        onChangeCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onBeforeInput?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onBeforeInputCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onInput?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onInputCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onReset?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onResetCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onSubmit?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onSubmitCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onInvalid?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onInvalidCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+        onLoad?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onError?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onErrorCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyUp?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+        onAbort?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onAbortCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onCanPlay?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayThrough?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onDurationChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onDurationChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEmptied?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEmptiedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEncrypted?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEncryptedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEnded?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onEndedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadedData?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadedDataCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadedMetadata?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadStart?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onLoadStartCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPause?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPauseCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPlay?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPlayCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPlaying?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onPlayingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onProgress?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onProgressCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onRateChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onRateChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSeeked?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSeekedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSeeking?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSeekingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onStalled?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onStalledCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSuspend?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSuspendCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onTimeUpdate?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onVolumeChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onWaiting?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onWaitingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onAuxClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onAuxClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onContextMenu?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onContextMenuCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onDoubleClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onDoubleClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onDrag?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragEnd?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragEndCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragEnter?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragEnterCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragExit?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragExitCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragLeave?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragLeaveCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragOver?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragOverCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragStart?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDragStartCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDrop?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onDropCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+        onMouseDown?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseDownCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseMove?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseMoveCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseOut?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseOutCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseOver?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseOverCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseUp?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onMouseUpCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+        onSelect?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onSelectCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+        onTouchCancel?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchCancelCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchEnd?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchEndCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchMove?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchMoveCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchStart?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onTouchStartCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+        onPointerDown?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerDownCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerMove?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerMoveCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerUp?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerUpCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerCancel?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerCancelCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerEnter?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerEnterCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerLeave?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerOver?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerOverCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerOut?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onPointerOutCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onGotPointerCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onLostPointerCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+        onScroll?: import("react").UIEventHandler<HTMLElement> | undefined;
+        onScrollCapture?: import("react").UIEventHandler<HTMLElement> | undefined;
+        onWheel?: import("react").WheelEventHandler<HTMLElement> | undefined;
+        onWheelCapture?: import("react").WheelEventHandler<HTMLElement> | undefined;
+        onAnimationStart?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationEnd?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationIteration?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+        onTransitionEnd?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+        refs?: import("../../api").Refs | undefined;
+        ref: import("../../api").Refs | undefined;
+    };
+};
+interface AbstractBoxProps extends BaseBoxProps {
+    boxType: 'checkbox' | 'radio';
+    css?: SerializedStyles;
+}
+export declare function AbstractBox({ children, text, className, style, search, boxType, css: externalCss, ...props }: AbstractBoxProps): import("@emotion/react/jsx-runtime").JSX.Element;
+export {};

package/es/radio/component/abstract-box.js

@@ -0,0 +1,90 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children", "search"],
+  _excluded2 = ["refs", "boxTooltip", "value", "onChange", "inGroup"],
+  _excluded3 = ["children", "text", "className", "style", "search", "boxType", "css"];
+import { combineClassName, getClassName } from "../../api";
+import { HighlightText } from "../../highlight-text";
+import { generateTooltip } from "../../text";
+import { Tooltip } from "../../tooltip";
+import { Checkbox as AntdCheckbox, Radio as AntdRadio } from 'antd';
+import { isValidElement } from 'react';
+import styles from "../style";
+import { parseHighlightTextAndRestProps } from "./utils";
+import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+function BoxLabel(_ref) {
+  var children = _ref.children,
+    search = _ref.search,
+    props = _objectWithoutProperties(_ref, _excluded);
+  if (!children) {
+    return null;
+  }
+  var className = getClassName('box-label');
+  if ( /*#__PURE__*/isValidElement(children)) {
+    return _jsx("div", {
+      className: className,
+      children: children
+    });
+  }
+  return _jsx("div", {
+    className: className,
+    children: _jsx(HighlightText, _objectSpread(_objectSpread({}, props), {}, {
+      text: "".concat(children),
+      highlight: search
+    }))
+  });
+}
+export function useAbstractBox(_ref2) {
+  var refs = _ref2.refs,
+    boxTooltip = _ref2.boxTooltip,
+    value = _ref2.value,
+    _onChange = _ref2.onChange,
+    inGroup = _ref2.inGroup,
+    props = _objectWithoutProperties(_ref2, _excluded2);
+  var _parseHighlightTextAn = parseHighlightTextAndRestProps(props),
+    highlightTextProps = _parseHighlightTextAn.highlightTextProps,
+    restProps = _parseHighlightTextAn.restProps;
+  var tooltipProps = _objectSpread({
+    align: {
+      offset: [0, 1]
+    }
+  }, generateTooltip(boxTooltip));
+  var boxProps = _objectSpread(_objectSpread({
+    ref: refs
+  }, restProps), {}, _defineProperty(_defineProperty({}, inGroup ? 'value' : 'checked', value), "onChange", function onChange(e) {
+    _onChange === null || _onChange === void 0 || _onChange(inGroup ? e : e.target.checked);
+  }));
+  return {
+    highlightTextProps: highlightTextProps,
+    tooltipProps: tooltipProps,
+    boxProps: boxProps
+  };
+}
+export function AbstractBox(_ref3) {
+  var children = _ref3.children,
+    text = _ref3.text,
+    className = _ref3.className,
+    style = _ref3.style,
+    search = _ref3.search,
+    boxType = _ref3.boxType,
+    externalCss = _ref3.css,
+    props = _objectWithoutProperties(_ref3, _excluded3);
+  var _useAbstractBox = useAbstractBox(props),
+    highlightTextProps = _useAbstractBox.highlightTextProps,
+    tooltipProps = _useAbstractBox.tooltipProps,
+    boxProps = _useAbstractBox.boxProps;
+  var BoxComponent = boxType === 'checkbox' ? AntdCheckbox : AntdRadio;
+  return _jsxs("label", {
+    css: [styles.box(boxType), externalCss],
+    className: combineClassName(boxType, className),
+    style: style,
+    children: [_jsx(Tooltip, _objectSpread(_objectSpread({}, tooltipProps), {}, {
+      children: _jsx(BoxComponent, _objectSpread({}, boxProps))
+    })), _jsx(BoxLabel, _objectSpread(_objectSpread({
+      search: search
+    }, highlightTextProps), {}, {
+      children: children !== null && children !== void 0 ? children : text
+    }))]
+  });
+}

package/es/radio/component/index.d.ts

@@ -0,0 +1,2 @@
+import { RadioProps } from "..";
+export declare function Radio(props: RadioProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/es/radio/component/index.js

@@ -0,0 +1,10 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { InternalRadio } from "./radio";
+import { RadioGroup } from "./redio-group";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+export function Radio(props) {
+  if (props.options) {
+    return _jsx(RadioGroup, _objectSpread({}, props));
+  }
+  return _jsx(InternalRadio, _objectSpread({}, props));
+}

package/es/radio/component/radio.d.ts

@@ -0,0 +1,2 @@
+import { BaseBoxProps } from "..";
+export declare function InternalRadio(props: BaseBoxProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/es/radio/component/radio.js

@@ -0,0 +1,10 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import styles from "../style";
+import { AbstractBox } from "./abstract-box";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+export function InternalRadio(props) {
+  return _jsx(AbstractBox, _objectSpread(_objectSpread({}, props), {}, {
+    boxType: "radio",
+    css: styles.radio
+  }));
+}

package/es/radio/component/redio-group.d.ts

@@ -0,0 +1,2 @@
+import { RadioProps } from '../type';
+export declare function RadioGroup({ refs, vertical, gap, wrap, ...restProps }: RadioProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/es/radio/component/redio-group.js

@@ -0,0 +1,50 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["refs", "vertical", "gap", "wrap"],
+  _excluded2 = ["options"],
+  _excluded3 = ["label", "originLabel"];
+import { getClassName } from "../../api";
+import { cx } from '@emotion/css';
+import { Radio as AntdRadio } from 'antd';
+import _ from 'lodash';
+import styles from "../style";
+import { InternalRadio } from "./radio";
+import { useRadio } from "./use-radio";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+import { createElement as _createElement } from "@emotion/react";
+var Group = AntdRadio.Group;
+export function RadioGroup(_ref) {
+  var refs = _ref.refs,
+    vertical = _ref.vertical,
+    gap = _ref.gap,
+    wrap = _ref.wrap,
+    restProps = _objectWithoutProperties(_ref, _excluded);
+  var _useRadio = useRadio(restProps),
+    options = _useRadio.options,
+    props = _objectWithoutProperties(_useRadio, _excluded2);
+  if (props.optionType === 'button') {
+    return _jsx(Group, _objectSpread(_objectSpread({}, props), {}, {
+      options: options
+    }));
+  }
+  var classString = cx(_defineProperty({}, getClassName('radio-vertical'), vertical), props.className);
+  return _jsx(Group, _objectSpread(_objectSpread({
+    css: styles.wrapper({
+      vertical: vertical,
+      gap: gap,
+      wrap: wrap
+    }),
+    className: classString
+  }, props), {}, {
+    children: _.map(options, function (_ref2, index) {
+      var label = _ref2.label,
+        originLabel = _ref2.originLabel,
+        option = _objectWithoutProperties(_ref2, _excluded3);
+      return _createElement(InternalRadio, _objectSpread(_objectSpread({}, option), {}, {
+        inGroup: true,
+        key: index
+      }), label);
+    })
+  }));
+}

package/es/radio/component/use-box-options.d.ts

@@ -0,0 +1,6 @@
+import { BaseSelectProps } from "../../select";
+export declare function useBoxOptions<T = any>({ search, ...props }: BaseSelectProps): T & {
+    value: any;
+    options: import("../../select").SelectOptions | undefined;
+    displayOptions: any[];
+};

package/es/radio/component/use-box-options.js

@@ -0,0 +1,20 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["search"];
+import { useSelectOptions } from "../../select";
+import { generateOptionOnSearch } from "./utils";
+export function useBoxOptions(_ref) {
+  var search = _ref.search,
+    props = _objectWithoutProperties(_ref, _excluded);
+  return useSelectOptions(_objectSpread({
+    search: search,
+    presetProcessOption: function presetProcessOption(option) {
+      return _objectSpread({
+        autoShowTooltip: true
+      }, option);
+    },
+    finalProcessOption: function finalProcessOption(option) {
+      return search ? generateOptionOnSearch(option, search) : option;
+    }
+  }, props));
+}

package/es/radio/component/use-radio.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { RadioProps } from "..";
+import { RadioChangeEvent } from 'antd/lib/radio/interface';
+export declare function useRadio({ onChange, ...props }: RadioProps): {
+    options: any[];
+    onChange: (e: RadioChangeEvent) => void;
+    defaultValue?: any;
+    value: any;
+    size?: import("antd/lib/button").ButtonSize;
+    disabled?: import("antd/lib/config-provider/DisabledContext").DisabledType;
+    onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    name?: string | undefined;
+    children?: import("react").ReactNode;
+    id?: string | undefined;
+    optionType?: import("antd/lib/radio/interface").RadioGroupOptionType | undefined;
+    buttonStyle?: import("antd/lib/radio/interface").RadioGroupButtonStyle | undefined;
+    onFocus?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    onBlur?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    prefixCls?: string | undefined;
+    className?: string | undefined;
+    style?: import("react").CSSProperties | undefined;
+};

package/es/radio/component/use-radio.js

@@ -0,0 +1,21 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["onChange"],
+  _excluded2 = ["displayOptions"];
+import { useBoxOptions } from "./use-box-options";
+export function useRadio(_ref) {
+  var onChange = _ref.onChange,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var _useBoxOptions = useBoxOptions(_objectSpread({
+      sort: false
+    }, props)),
+    displayOptions = _useBoxOptions.displayOptions,
+    restProps = _objectWithoutProperties(_useBoxOptions, _excluded2);
+  function handleChange(e) {
+    onChange === null || onChange === void 0 || onChange(e.target.value);
+  }
+  return _objectSpread(_objectSpread({}, restProps), {}, {
+    options: displayOptions,
+    onChange: handleChange
+  });
+}

package/es/radio/component/utils.d.ts

@@ -0,0 +1,7 @@
+import { BaseBoxProps } from "..";
+import { DefaultOptionType } from 'rc-select/lib/Select';
+export declare function parseHighlightTextAndRestProps(props: BaseBoxProps): {
+    highlightTextProps: Partial<BaseBoxProps>;
+    restProps: Partial<BaseBoxProps>;
+};
+export declare function generateOptionOnSearch(option: DefaultOptionType, search: string): DefaultOptionType;