x-ui-design 0.2.13 → 0.2.16

package/dist/esm/types/components/Button/Button.client.d.ts

@@ -0,0 +1,3 @@
+import { ButtonProps } from '../../types/button';
+declare const ButtonClient: (props: ButtonProps) => import("react").JSX.Element;
+export default ButtonClient;

package/dist/esm/types/components/Button/Button.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement, ReactNode } from 'react';
+import { ButtonProps } from '../../types/button';
+import './style.css';
+declare const Button: ({ type, variant, color, shape, size, htmlType, className, rootClassName, classNames: customClassNames, styles, prefixCls, iconPosition, disabled, ghost, danger, block, children, href, iconNode, isLoading, ...restProps }: ButtonProps & {
+    iconNode?: ReactNode;
+    isLoading?: boolean;
+}) => ReactElement;
+export default Button;

package/dist/esm/types/components/Button/index.d.ts

@@ -0,0 +1 @@
+export { default as Button } from './Button';

package/dist/esm/types/components/Checkbox/Checkbox.client.d.ts

@@ -0,0 +1,23 @@
+import { MouseEvent } from 'react';
+import './style.css';
+declare const CheckboxClient: import("react").ForwardRefExoticComponent<import("../../types").DefaultProps & {
+    disabled?: boolean;
+    onChange?: (e: MouseEvent<HTMLInputElement> & import("../../types").TargetProps) => void;
+    onClick?: import("react").MouseEventHandler<HTMLElement>;
+    onMouseEnter?: import("react").MouseEventHandler<HTMLElement>;
+    onMouseLeave?: import("react").MouseEventHandler<HTMLElement>;
+    onKeyPress?: import("react").KeyboardEventHandler<HTMLElement>;
+    onKeyDown?: import("react").KeyboardEventHandler<HTMLElement>;
+    value?: boolean;
+    tabIndex?: number;
+    name?: string;
+    children?: import("react").ReactNode;
+    id?: string;
+    autoFocus?: boolean;
+    type?: string;
+    skipGroup?: boolean;
+    required?: boolean;
+    defaultChecked?: boolean;
+    checked?: boolean;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export default CheckboxClient;

package/dist/esm/types/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+import { CheckboxProps } from '../../types/checkbox';
+declare const Checkbox: {
+    ({ prefixCls, className, defaultChecked, checked, style, disabled, onChange, onClick, onMouseEnter, onMouseLeave, onKeyPress, onKeyDown, tabIndex, name, children, id, autoFocus, type, value, required, noStyle }: CheckboxProps): ReactElement;
+    displayName: string;
+};
+export default Checkbox;

package/dist/esm/types/components/Checkbox/index.d.ts

@@ -0,0 +1 @@
+export { default as Checkbox } from './Checkbox';

package/dist/esm/types/components/Empty/Empty.d.ts

@@ -0,0 +1,4 @@
+import { EmptyContentProps } from '../../types/empty';
+import './style.css';
+declare const EmptyContent: ({ icon, style, className, title, description, prefixCls }: EmptyContentProps) => import("react").JSX.Element;
+export default EmptyContent;

package/dist/esm/types/components/Empty/index.d.ts

@@ -0,0 +1 @@
+export { default as Empty } from './Empty';

package/dist/esm/types/components/Form/Form.client.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { FormProps } from '../../types/form';
+declare const FormClient: FC<FormProps>;
+export default FormClient;

package/dist/esm/types/components/Form/Form.d.ts

@@ -0,0 +1,7 @@
+import { FormInstance, FormItemProps, FormProps } from '../../types/form';
+import { FC } from 'react';
+export declare const FormContext: import("react").Context<FormInstance | null>;
+declare const Form: FC<FormProps> & {
+    Item: FC<FormItemProps>;
+};
+export default Form;

package/dist/esm/types/components/Form/Item/FormItem.client.d.ts

@@ -0,0 +1,7 @@
+import { FormItemProps } from '../../../types/form';
+import './style.css';
+declare const FormItemClient: {
+    ({ prefixCls, name, label, rules, children, className, layout, style, valuePropName, dependencies, initialValue, feedbackIcons, ...props }: FormItemProps): import("react").JSX.Element;
+    displayName: string;
+};
+export default FormItemClient;

package/dist/esm/types/components/Form/Item/FormItem.d.ts

@@ -0,0 +1,6 @@
+import { FormItemProps } from '../../../types/form';
+declare const FormItem: {
+    ({ prefixCls, name, label, rules, children, className, layout, style, valuePropName, dependencies, initialValue, feedbackIcons, ...props }: FormItemProps): import("react").JSX.Element;
+    displayName: string;
+};
+export default FormItem;

package/dist/esm/types/components/Form/Item/index.d.ts

@@ -0,0 +1 @@
+export { default as Item } from './FormItem';

package/dist/esm/types/components/Form/index.d.ts

@@ -0,0 +1 @@
+export { default as Form } from './Form';

package/dist/esm/types/helpers/index.d.ts

@@ -0,0 +1,4 @@
+import { RuleType } from '../types';
+export declare const parseValue: (value: RuleType) => RuleType;
+export declare function createArray(length: number): number[];
+export declare function clsx(...args: RuleType[]): string;

package/dist/esm/types/hooks/useForm.d.ts

@@ -0,0 +1,4 @@
+import { RuleTypes } from '../types';
+import type { FieldData, FormInstance } from '../types/form';
+declare const useForm: (initialValues?: Record<string, RuleTypes>, onFieldsChange?: (changedFields: FieldData[]) => void, onValuesChange?: (changedValues: Record<string, RuleTypes>, allValues: Record<string, RuleTypes>) => void) => FormInstance;
+export { useForm };

package/dist/esm/types/hooks/useWatch.d.ts

@@ -0,0 +1,9 @@
+import { RuleType } from '../types';
+import { FormInstance } from '../types/form';
+type UseWatchProps = {
+    name?: string;
+    defaultValue?: RuleType;
+    form?: FormInstance;
+};
+export declare const useWatch: ({ name, defaultValue, form }: UseWatchProps) => any;
+export {};

package/dist/esm/types/index.d.ts

@@ -0,0 +1,4 @@
+import './styles/global.css';
+export { default as Empty } from "./components/Empty/Empty";
+export { default as Button } from "./components/Button/Button";
+export { default as Checkbox } from "./components/Checkbox/Checkbox";

package/dist/esm/types/types/button.d.ts

@@ -0,0 +1,42 @@
+import { ButtonHTMLAttributes, CSSProperties, ReactNode } from 'react';
+export declare const ButtonTypes: readonly ["default", "primary", "dashed", "link", "text", "ghost"];
+export declare const ButtonShapes: readonly ["default", "circle", "round"];
+export declare const ButtonVariantTypes: readonly ["outlined", "dashed", "solid", "filled", "text", "link"];
+export declare const ButtonColorTypes: readonly ["default", "primary", "danger", "blue", "purple", "cyan", "green", "magenta", "pink", "red", "orange", "yellow", "volcano", "geekblue", "lime", "gold"];
+export type ButtonType = (typeof ButtonTypes)[number];
+export type ButtonShape = (typeof ButtonShapes)[number];
+export type ButtonVariantType = (typeof ButtonVariantTypes)[number];
+export type ButtonColorType = (typeof ButtonColorTypes)[number];
+export type SizeType = 'small' | 'middle' | 'large' | undefined;
+export type ButtonHTMLType = 'button' | 'submit' | 'reset';
+export interface BaseButtonProps {
+    type?: ButtonType;
+    color?: ButtonColorType;
+    variant?: ButtonVariantType;
+    icon?: ReactNode;
+    iconPosition?: 'start' | 'end';
+    shape?: ButtonShape;
+    size?: SizeType;
+    disabled?: boolean;
+    loading?: boolean | {
+        delay?: number;
+        icon?: ReactNode;
+    };
+    prefixCls?: string;
+    className?: string;
+    rootClassName?: string;
+    ghost?: boolean;
+    danger?: boolean;
+    block?: boolean;
+    children?: ReactNode;
+    classNames?: {
+        icon?: string;
+    };
+    styles?: {
+        icon?: CSSProperties;
+    };
+}
+export interface ButtonProps extends BaseButtonProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'color' | 'type'> {
+    href?: string;
+    htmlType?: ButtonHTMLType;
+}

package/dist/esm/types/types/checkbox.d.ts

@@ -0,0 +1,22 @@
+import { KeyboardEventHandler, MouseEvent, MouseEventHandler, ReactNode } from 'react';
+import { DefaultProps, TargetProps } from '.';
+export type CheckboxProps = DefaultProps & {
+    disabled?: boolean;
+    onChange?: (e: MouseEvent<HTMLInputElement> & TargetProps) => void;
+    onClick?: MouseEventHandler<HTMLElement>;
+    onMouseEnter?: MouseEventHandler<HTMLElement>;
+    onMouseLeave?: MouseEventHandler<HTMLElement>;
+    onKeyPress?: KeyboardEventHandler<HTMLElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLElement>;
+    value?: boolean;
+    tabIndex?: number;
+    name?: string;
+    children?: ReactNode;
+    id?: string;
+    autoFocus?: boolean;
+    type?: string;
+    skipGroup?: boolean;
+    required?: boolean;
+    defaultChecked?: boolean;
+    checked?: boolean;
+};

package/dist/esm/types/types/datepicker.d.ts

@@ -0,0 +1,119 @@
+import { FocusEvent, ReactNode } from 'react';
+import { DefaultProps, RuleType, SizeType } from '.';
+export interface BaseInfo {
+    range?: 'start' | 'end';
+    source?: string;
+}
+export type CustomFormat<RuleType> = (value: RuleType) => string;
+export type FormatType<DateType = RuleType> = string | CustomFormat<DateType>;
+export type PanelMode = 'time' | 'date' | 'week' | 'month' | 'quarter' | 'year' | 'decade';
+export type TDatePickerProps = DefaultProps & {
+    value?: Date;
+    disabled?: boolean;
+    placeholder?: string;
+    error?: boolean;
+    feedbackIcons?: boolean;
+    locale?: Locale;
+    placement?: string;
+    defaultOpen?: boolean;
+    allowClear?: boolean | {
+        clearIcon?: ReactNode;
+    };
+    defaultValue?: Date;
+    disabledDate?: (date: RuleType, info: {
+        to: RuleType;
+        from?: RuleType;
+    }) => boolean;
+    suffixIcon?: ReactNode;
+    prefix?: ReactNode;
+    size?: SizeType;
+    format?: FormatType<RuleType> | FormatType<RuleType>[] | {
+        format: string;
+        type?: 'mask';
+    };
+    onChange?: (date: RuleType | RuleType[], dateString: string | string[]) => void;
+    onCalendarChange?: (date: RuleType | RuleType[], dateString: string | string[], info: BaseInfo) => void;
+    getPopupContainer?: (node: HTMLElement) => HTMLElement;
+    showToday?: boolean;
+    inputReadOnly?: boolean;
+    picker?: PanelMode;
+    bordered?: boolean;
+};
+export type TRangePickerProps = Omit<TDatePickerProps, 'placeholder' | 'value' | 'defaultValue'> & {
+    placeholder?: string[];
+    value?: Date[];
+    defaultValue?: Date[];
+    separator?: ReactNode;
+};
+export type Locale = {
+    locale: string;
+    dateFormat?: string;
+    dateTimeFormat?: string;
+    fieldDateTimeFormat?: string;
+    fieldDateFormat?: string;
+    fieldTimeFormat?: string;
+    fieldMonthFormat?: string;
+    fieldYearFormat?: string;
+    fieldWeekFormat?: string;
+    fieldQuarterFormat?: string;
+    monthBeforeYear?: boolean;
+    yearFormat?: string;
+    monthFormat?: string;
+    cellYearFormat?: string;
+    cellQuarterFormat?: string;
+    dayFormat?: string;
+    cellDateFormat?: string;
+    cellMeridiemFormat?: string;
+    today: string;
+    now: string;
+    backToToday: string;
+    ok: string;
+    timeSelect: string;
+    dateSelect: string;
+    weekSelect?: string;
+    clear: string;
+    week: string;
+    month: string;
+    year: string;
+    previousMonth: string;
+    nextMonth: string;
+    monthSelect: string;
+    yearSelect: string;
+    decadeSelect: string;
+    previousYear: string;
+    nextYear: string;
+    previousDecade: string;
+    nextDecade: string;
+    previousCentury: string;
+    nextCentury: string;
+    shortWeekDays?: string[];
+    shortMonths?: string[];
+};
+export interface DisabledTimes {
+    disabledHours?: () => number[];
+    disabledMinutes?: (hour: number) => number[];
+    disabledSeconds?: (hour: number, minute: number) => number[];
+}
+export type PickerFocusEventHandler = (e: FocusEvent<HTMLElement>, info: BaseInfo) => void;
+export type DisabledDate<DateType = RuleType> = (date: DateType, info: {
+    type: PanelMode;
+    from?: DateType;
+}) => boolean;
+export type TimePickerProps = DefaultProps & {
+    disabledTime?: (date: RuleType) => DisabledTimes;
+    inputReadOnly?: boolean;
+    format?: FormatType<RuleType> | FormatType<RuleType>[] | {
+        format: string;
+        type?: 'mask';
+    };
+    defaultValue?: RuleType | null;
+    value?: RuleType | null;
+    onChange?: (date: RuleType, dateString: string | string[]) => void;
+    onBlur?: PickerFocusEventHandler;
+    onSelect?: ((value: Date | null) => void) | undefined;
+    showNow?: boolean;
+    clearIcon?: ReactNode;
+    getPopupContainer?: (node: HTMLElement) => HTMLElement;
+    suffixIcon?: ReactNode;
+    placeholder?: string;
+};

package/dist/esm/types/types/empty.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+import { DefaultProps } from '.';
+export type EmptyContentProps = DefaultProps & {
+    title?: string;
+    description?: string;
+    icon?: ReactNode;
+};

package/dist/esm/types/types/form.d.ts

@@ -0,0 +1,106 @@
+import { ComponentClass, FC, FormEvent, ReactElement, ReactNode } from 'react';
+import { DefaultProps, RuleType, RuleTypes, SizeType, SyntheticBaseEvent } from '.';
+import { OptionProps } from './select';
+export type RuleRender = (form: FormInstance) => RuleObject;
+export type RuleObject = RuleRender | {
+    required?: boolean;
+    message?: string;
+    pattern?: RegExp;
+    min?: number;
+    max?: number;
+    warningPattern?: RegExp;
+    warningMessage?: string;
+    validator?: (rule: RuleObject, value: RuleTypes, callback: (error?: string) => void) => Promise<void> | void;
+};
+export interface FieldData {
+    name: string | string[];
+    value?: RuleTypes;
+    errors?: string[];
+}
+export type FieldInstancesInputRef = HTMLInputElement | null;
+export type FieldInstancesRef = {
+    input?: FieldInstancesInputRef;
+};
+export interface FieldError {
+    name: string;
+    errors: string[];
+}
+type FormLayoutTypes = 'horizontal' | 'vertical' | 'inline';
+export type FormProps = DefaultProps & {
+    name?: string;
+    layout?: FormLayoutTypes;
+    form?: FormInstance;
+    size?: SizeType;
+    initialValues?: Record<string, RuleTypes>;
+    children?: ReactNode;
+    component?: false | string | FC<ReactNode> | ComponentClass<ReactNode>;
+    fields?: FieldData[];
+    onChange?: (e: FormEvent<HTMLFormElement>) => void;
+    onFieldsChange?: (changedFields: FieldData[]) => void;
+    onSubmitCapture?: (changedFields: FieldData[]) => void;
+    onValuesChange?: (changedValues: Record<string, RuleTypes>, allValues: Record<string, RuleTypes>) => void;
+    onFinish?: (values: Record<string, RuleTypes>) => void;
+    onFinishFailed?: (errorInfo: {
+        values: Record<string, RuleTypes>;
+        errorFields: Pick<FieldError, 'errors' | 'name'>[];
+    }) => void;
+};
+export type FormItemProps = DefaultProps & {
+    name: string;
+    label?: string | ReactNode;
+    rules?: RuleObject[];
+    initialValue?: RuleType;
+    children: (ReactElement & {
+        props: {
+            value: RuleTypes;
+        };
+    }) | (ReactElement & {
+        props: {
+            value: RuleTypes;
+        };
+    })[];
+    layout?: FormLayoutTypes;
+    valuePropName?: string;
+    dependencies?: string[];
+    normalize?: (value: RuleType, prevValue: RuleType, allValues: RuleType) => RuleType;
+    feedbackIcons?: boolean;
+};
+export interface FormItemChildComponentProps {
+    child: React.ReactElement;
+    name: string;
+    error: boolean;
+    fieldValue: RuleTypes;
+    value: RuleType;
+    setFieldValue: (name: string, value: RuleType) => void;
+    onChange?: (e: SyntheticBaseEvent, option?: OptionProps) => void;
+    valuePropName?: string;
+    size?: SizeType;
+    normalize?: (value: RuleType, prevValue: RuleType, allValues: RuleType) => RuleType;
+    noStyle?: boolean;
+    feedbackIcons?: boolean;
+}
+export interface FormInstance {
+    submit: () => Promise<Record<string, RuleTypes> | undefined>;
+    setFields: (fields: FieldData[]) => void;
+    resetFields: (nameList?: string[]) => void;
+    getFieldError: (name: string) => string[];
+    registerField: (name: string, rules?: RuleObject[]) => void;
+    setFieldValue: (name: string, value: RuleTypes) => void;
+    getFieldValue: (name: string) => RuleTypes;
+    validateFields: (nameList?: string[]) => Promise<boolean>;
+    setFieldsValue: (values: Partial<Record<string, RuleTypes>>) => void;
+    getFieldsValue: (nameList?: string[]) => Record<string, RuleTypes>;
+    isFieldTouched: (name: string) => boolean;
+    getFieldsError: () => Pick<FieldError, 'errors' | 'name'>[];
+    isFieldsTouched: (nameList?: string[], allFieldsTouched?: boolean) => boolean;
+    getFieldWarning: (name: string) => string[];
+    subscribeToField: (name: string, callback: (value: RuleTypes) => void) => () => void;
+    subscribeToForm: (callback: (values: Record<string, RuleTypes>) => void) => () => void;
+    subscribeToFields: (names: string[], callback: (values: Record<string, RuleTypes>) => void) => () => void;
+    isFieldValidating: (name: string) => boolean;
+    onFieldsChange?: (changedFields: FieldData[]) => void;
+    onValuesChange?: (changedValues: Record<string, RuleTypes>, allValues: Record<string, RuleTypes>) => void;
+    getFieldInstance: (fieldName: string) => FieldInstancesRef;
+    isReseting: boolean;
+}
+export {};

package/dist/esm/types/types/index.d.ts

@@ -0,0 +1,25 @@
+import { CSSProperties, MouseEvent } from 'react';
+export type RuleType = any;
+export type RuleTypes = RuleType | RuleType[];
+export type SizeType = 'small' | 'middle' | 'large';
+export type MouseEventHandlerSelect = MouseEvent<HTMLDivElement> & TargetProps;
+export interface DefaultProps {
+    prefixCls?: string;
+    className?: string;
+    style?: CSSProperties;
+    noStyle?: boolean;
+}
+export type TargetProps = {
+    target: {
+        value: RuleType;
+    };
+};
+export type SyntheticBaseEvent = {
+    target: EventTarget & {
+        value: RuleType;
+    };
+    nativeEvent?: Event & {
+        data?: string | null;
+    };
+    currentTarget: EventTarget;
+};

package/dist/esm/types/types/input.d.ts

@@ -0,0 +1,47 @@
+import { CSSProperties, InputHTMLAttributes, KeyboardEvent, KeyboardEventHandler, MouseEventHandler, ReactElement, ReactNode, TextareaHTMLAttributes } from 'react';
+import { DefaultProps, SizeType, SyntheticBaseEvent } from '.';
+export type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'prefix'> & DefaultProps & {
+    addonBefore?: ReactNode;
+    addonAfter?: ReactNode;
+    size?: SizeType;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    disabled?: boolean;
+    allowClear?: boolean;
+    error?: boolean;
+    bordered?: boolean;
+    iconRender?: (visible: boolean) => ReactElement;
+    onChange?: (event: SyntheticBaseEvent) => void;
+    onClick?: MouseEventHandler<HTMLElement>;
+    onMouseEnter?: MouseEventHandler<HTMLElement>;
+    onMouseLeave?: MouseEventHandler<HTMLElement>;
+    onKeyPress?: KeyboardEventHandler<HTMLElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLElement>;
+    onPressEnter?: (event: KeyboardEvent<HTMLInputElement>) => void;
+    feedbackIcons?: boolean;
+};
+export type TextareaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'onResize'> & DefaultProps & {
+    value?: string;
+    className?: string;
+    style?: CSSProperties;
+    autoSize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    onPressEnter?: KeyboardEventHandler<HTMLTextAreaElement>;
+    onResize?: (size: {
+        width: number;
+        height: number;
+    }) => void;
+    styles?: {
+        textarea?: CSSProperties;
+        count?: CSSProperties;
+    };
+    bordered?: boolean;
+    size?: SizeType;
+    status?: 'success' | 'error';
+    rootClassName?: string;
+    variant?: 'outlined' | 'borderless' | 'filled' | 'underlined';
+    error?: boolean;
+    allowClear?: boolean;
+};

package/dist/esm/types/types/radio.d.ts

@@ -0,0 +1,57 @@
+import { CSSProperties, FocusEventHandler, KeyboardEventHandler, MouseEventHandler, ReactNode } from 'react';
+import { DefaultProps, RuleType, SizeType, SyntheticBaseEvent } from '.';
+export type RadioValueType = string | number | readonly string[] | undefined;
+export interface RadioGroupProps {
+    defaultValue?: RuleType;
+    value?: RuleType;
+    onChange?: (e: SyntheticBaseEvent) => void;
+    size?: SizeType;
+    disabled?: boolean;
+    onMouseEnter?: MouseEventHandler<HTMLDivElement>;
+    onMouseLeave?: MouseEventHandler<HTMLDivElement>;
+    name?: string;
+    children?: ReactNode;
+    id?: string;
+    optionType?: 'default' | 'button';
+    buttonStyle?: 'outline' | 'solid';
+    onFocus?: FocusEventHandler<HTMLDivElement>;
+    onBlur?: FocusEventHandler<HTMLDivElement>;
+    block?: boolean;
+    prefixCls?: string;
+    className?: string;
+    options?: Array<{
+        label: ReactNode;
+        value: RuleType;
+        disabled?: boolean;
+    }> | string[] | number[];
+    style?: CSSProperties;
+}
+export type RadioProps = DefaultProps & {
+    defaultChecked?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    title?: string;
+    onChange?: (e: SyntheticBaseEvent) => void;
+    onClick?: MouseEventHandler<HTMLElement>;
+    onMouseEnter?: MouseEventHandler<HTMLElement>;
+    onMouseLeave?: MouseEventHandler<HTMLElement>;
+    onKeyPress?: KeyboardEventHandler<HTMLElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLElement>;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    value?: RuleType;
+    tabIndex?: number;
+    name?: string;
+    children?: ReactNode;
+    id?: string;
+    autoFocus?: boolean;
+    type?: string;
+    skipGroup?: boolean;
+    required?: boolean;
+    button?: boolean;
+    error?: boolean;
+};
+export type RadioButtonProps = RadioProps & {
+    children?: ReactNode;
+    size?: SizeType;
+};

package/dist/esm/types/types/select.d.ts

@@ -0,0 +1,97 @@
+import { ChangeEventHandler, CSSProperties, FocusEventHandler, Key, KeyboardEventHandler, MouseEvent, MouseEventHandler, ReactElement, ReactEventHandler, ReactNode } from 'react';
+import { DefaultProps, RuleType, RuleTypes, TargetProps } from '.';
+export type SelectProps = DefaultProps & {
+    id?: string;
+    searchValue?: string;
+    onSearch?: (value: string) => void;
+    autoClearSearchValue?: boolean;
+    onSelect?: (value: RuleTypes, option?: OptionType) => void;
+    onDeselect?: (value: string, option?: OptionType) => void;
+    filterOption?: boolean | ((input: string, option: OptionType) => boolean);
+    optionFilterProp?: string;
+    options?: OptionType[];
+    children?: ReactNode;
+    defaultActiveFirstOption?: boolean;
+    listHeight?: number;
+    menuItemSelectedIcon?: ReactNode;
+    mode?: 'default' | 'multiple' | 'tags';
+    value?: RuleTypes;
+    defaultValue?: RuleTypes;
+    maxCount?: number;
+    onChange?: (e: RuleTypes, option?: OptionType) => void;
+    disabled?: boolean;
+    loading?: boolean;
+    placeholder?: string;
+    allowClear?: boolean;
+    filterable?: boolean;
+    defaultOpen?: boolean;
+    size?: 'small' | 'middle' | 'large';
+    onClear?: () => void;
+    error?: boolean;
+    showSearch?: boolean;
+    tagRender?: ((props: CustomTagProps) => ReactElement) | undefined;
+    maxTagPlaceholder?: ReactNode | ((omittedValues: DisplayValueType[]) => ReactNode);
+    dropdownClassName?: string;
+    showArrow?: boolean;
+    onBlur?: FocusEventHandler<HTMLElement> | undefined;
+    onDropdownVisibleChange?: ((open: boolean) => void) | undefined;
+    showAction?: ('click' | 'focus')[] | undefined;
+    suffixIcon?: ReactNode;
+    open?: boolean;
+    notFoundContent?: ReactNode;
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    dropdownRender?: (menu: ReactNode) => ReactNode;
+    feedbackIcons?: boolean;
+    placement?: 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+    removeIcon?: ReactNode;
+};
+export interface OptionType {
+    value: RuleType;
+    disabled?: boolean;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    onClick?: MouseEventHandler<HTMLDivElement>;
+    render?: (label: string) => ReactNode;
+    prefixCls?: string;
+    label?: RuleType;
+}
+export type CustomTagProps = DefaultProps & {
+    label?: ReactNode;
+    value: string;
+    onClose: (e: MouseEvent<HTMLSpanElement> & TargetProps) => void;
+    onMouseDown?: MouseEventHandler | undefined;
+    onLoadCapture?: ReactEventHandler | undefined;
+    closable?: boolean;
+    isMaxTag?: boolean;
+    color?: string;
+    icon?: ReactNode;
+};
+export type TagProps = DefaultProps & {
+    values?: string[];
+    onClose: (e: MouseEvent<HTMLSpanElement> & TargetProps) => void;
+    icon?: ReactNode;
+    closable?: boolean;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
+};
+export interface DisplayValueType {
+    key?: Key;
+    value?: RuleType;
+    label?: ReactNode;
+    title?: string | number;
+    disabled?: boolean;
+}
+export interface OptionProps {
+    value: RuleType;
+    disabled?: boolean;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    onClick?: MouseEventHandler<HTMLDivElement>;
+    render?: (label: string) => ReactNode;
+    onMouseEnter?: MouseEventHandler<HTMLDivElement>;
+    prefixCls?: string;
+    selected?: boolean;
+    title?: string;
+}