import { BarSeriesOption } from 'echarts/charts';
import { ChangeEvent } from 'react';
import { ClassNameType } from 'harpe';
import { ComponentType } from 'react';
import { CSSProperties } from 'react';
import { DatasetComponentOption } from 'echarts/components';
import { default as default_2 } from 'react';
import * as echarts from 'echarts/core';
import { EffectScatterSeriesOption } from 'echarts/charts';
import { GraphChart } from 'echarts/charts';
import { GridComponentOption } from 'echarts/components';
import { HTMLAttributes } from 'react';
import { LegendComponentOption } from 'echarts/components';
import { LineSeriesOption } from 'echarts/charts';
import { LinesSeriesOption } from 'echarts/charts';
import { MapSeriesOption } from 'echarts/charts';
import { ObjectType } from '0type';
import { ObjectType as ObjectType_2 } from 'abandonjs';
import { PieSeriesOption } from 'echarts/charts';
import { ReactNode } from 'react';
import { RouteObject } from 'react-router-dom';
import { TitleComponentOption } from 'echarts/components';
import { TooltipComponentOption } from 'echarts/components';
import { VisualMapComponentOption } from 'echarts/components';

export declare type Align = 'start' | 'end' | 'center' | 'between' | 'around';

export declare function Box(props: BoxProps): default_2.JSX.Element;

export declare type BoxProps = DivProps;

export declare function BrowserContainer(props: BrowserContainer): default_2.JSX.Element;

export declare interface BrowserContainer extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    menu: MenuObject[];
    basename?: string;
    location?: Partial<Location> | string;
    window?: Window;
}

export declare function Button(props: ButtonProps): default_2.JSX.Element;

export declare interface ButtonProps extends Omit<default_2.HTMLAttributes<HTMLButtonElement>, 'className'> {
    htmlType?: 'submit' | 'reset' | 'button';
    type?: 'primary' | 'default' | 'danger';
    disabled?: boolean;
    className?: ClassNameType;
    hidden?: boolean;
    none?: boolean;
}

export declare function Card(props: CardProps): default_2.JSX.Element;

export declare interface CardProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className' | 'title'> {
    className?: ClassNameType;
    header?: ReactNode;
    title?: ReactNode;
    headerStyle?: default_2.CSSProperties;
    footer?: ReactNode;
    footerStyle?: default_2.CSSProperties;
}

export declare function Chart(props: ChartProps): default_2.JSX.Element;

export declare type ChartProps = {
    className?: string;
    options: ObjectType;
    initCharFn?: (chart: any) => void;
    init?: (chart: any) => void;
    customEcharts?: any;
    [key: string]: any;
} & Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className' | 'children'>;

export declare function Checkbox(props: CheckboxProps): default_2.JSX.Element;

export declare type CheckboxChangeEvent = {
    target: {
        value: CheckboxValue | CheckboxValue[];
    };
};

export declare interface CheckboxGroupContextProps {
    name: string;
    groupProps?: CheckboxGroupProps;
    groupValue: CheckboxValue[];
    setGroupValue: (value: CheckboxValue, itemProps: CheckboxItemProps) => void;
    [key: string]: any;
}

export declare interface CheckboxGroupProps extends Props {
    value?: CheckboxValue[];
    onChange?: (event: CheckboxChangeEvent) => void;
    defaultValue?: CheckboxValue[];
    options?: (string | number | {
        value: CheckboxValue;
        label: string | number;
    } | CheckboxProps)[];
    children?: ReactNode;
}

export declare interface CheckboxItemProps extends Props {
    name?: string;
    value?: CheckboxValue;
    label?: string | number;
    disabled?: boolean;
    [key: string]: any;
}

export declare interface CheckboxProps extends Props {
    defaultValue?: boolean | CheckboxValue[];
    value?: boolean;
    label?: string | number;
    disabled?: boolean;
    options?: CheckboxItemProps[];
    onChange?: (event?: CheckboxChangeEvent) => void;
}

export declare type CheckboxValue = boolean | string | number | ObjectType_2;

export declare const Code: (props: CodeProps) => default_2.JSX.Element;

declare type CodeProps = {
    code: string;
    hidden?: boolean;
    none?: boolean;
    className?: ClassNameType;
    classNames?: ClassNameType;
    children?: default_2.ReactNode;
} & Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'>;

export declare function ColumnCount(props: ColumnCountProps): default_2.JSX.Element;

export declare namespace ColumnCount {
    var Item: typeof ColumnCountItem;
}

export declare function ColumnCountItem(props: ColumnCountItemProps): default_2.JSX.Element;

export declare interface ColumnCountItemProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className' | 'title'> {
    className?: ClassNameType;
    title?: default_2.ReactNode;
}

export declare interface ColumnCountProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    column?: number;
}

export declare type ColumnsType<DataType extends ObjectType_2 = ObjectType_2> = {
    title?: string;
    dataIndex?: string;
    prop?: string;
    key?: string | number;
    render?(text?: any, record?: DataType, index?: number): default_2.ReactNode;
}[];

export declare type DataListObjectProps = ExtendElement & Omit<default_2.HTMLAttributes<HTMLDataListElement>, 'className'>;

export declare function Dialog(props: DialogProps): default_2.JSX.Element;

export declare interface DialogProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className' | 'title'> {
    className?: ClassNameType;
    title?: ReactNode;
    open?: boolean;
    onCancel?: () => void;
    hiddenCancel?: boolean;
    onOk?: () => void;
    hiddenOk?: boolean;
    maskClosable?: boolean;
    children?: ReactNode;
}

export declare type Direction = 'vertical' | 'horizontal';

export declare function Div(props: DivProps): default_2.JSX.Element;

export declare type DivProps = ExtendElement & Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'>;

export declare function Docs(props: DocsProps): default_2.JSX.Element;

export declare namespace Docs {
    var Item: typeof DocsItem;
}

export declare function DocsItem(props: DocsItemProps): default_2.JSX.Element;

export declare interface DocsItemProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className' | 'title'> {
    className?: ClassNameType;
    title: default_2.ReactNode;
    defaultShowCode?: boolean;
    code?: string;
    children?: default_2.ReactNode;
    next?: boolean;
    items?: DocsItemProps[];
}

export declare interface DocsProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    items?: DocsItemProps[];
}

export { echarts }

export declare const echartsComponents: (typeof GraphChart)[];

export declare type ECOption = echarts.ComposeOption<BarSeriesOption | LineSeriesOption | PieSeriesOption | TitleComponentOption | TooltipComponentOption | GridComponentOption | DatasetComponentOption | LegendComponentOption | EffectScatterSeriesOption | MapSeriesOption | LinesSeriesOption | VisualMapComponentOption>;

export declare function Empty(props: EmptyProps): default_2.JSX.Element;

export declare interface EmptyProps extends DivProps {
    [key: string]: any;
}

declare type excludeInputType = 'children' | 'style' | 'defaultChecked' | 'value' | 'defaultValue' | 'className';

export declare interface ExtendElement {
    disabled?: boolean;
    hidden?: boolean;
    none?: boolean;
    className?: ClassNameType;
    classNames?: ClassNameType;
    children?: default_2.ReactNode;
}

export declare type FieldStatusRecord = Record<string, {
    errorStatus: boolean;
    errorMsg: any;
}>;

export declare function Flex(props: FlexProps): default_2.JSX.Element;

export declare interface FlexProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'>, DivProps {
    className?: ClassNameType;
    row?: boolean;
    column?: boolean;
    start?: boolean;
    end?: boolean;
    center?: boolean;
    alginCenter?: boolean;
    between?: boolean;
    around?: boolean;
    nowrap?: boolean;
    gap?: number | string;
    [key: string]: any;
}

export declare function Form(props: FormProps): default_2.JSX.Element;

export declare namespace Form {
    var Item: typeof FormItem;
}

export declare interface FormAction {
    values: FormRecord;
    setValues: (newValues: FormRecord) => void;
}

export declare const FormContext: default_2.Context<any>;

export declare type FormField = {
    defaultValue?: FormFieldValue;
    initialValue?: FormFieldValue;
    value?: FormFieldValue;
    rules?: Rule[];
};

export declare type FormFieldValue = any;

export declare type FormHandle = ((form: UseForm) => void | Promise<void>) | (() => void | Promise<void>);

export declare function FormItem(props: FormItemProps): default_2.JSX.Element;

export declare interface FormItemProps extends Omit<default_2.HTMLAttributes<HTMLInputElement>, 'className'> {
    name?: string;
    label?: ReactNode;
    rules?: Rule[];
    valueIndex?: 'value' | 'checked' | string;
    className?: ClassNameType;
    [key: string]: any;
}

export declare interface FormProps extends Omit<default_2.HtmlHTMLAttributes<HTMLFormElement>, 'className' | 'onReset' | 'onSubmit'> {
    form?: UseForm;
    layout?: 'horizontal' | 'vertical' | 'inline';
    onReset?: FormHandle;
    onSubmit?: FormHandle;
    initialValues?: ObjectType_2<any>;
    className?: ClassNameType;
    [key: string]: any;
}

export declare type FormRecord = ObjectType<any>;

export declare interface FormRule {
    required?: boolean;
}

export declare function Grid(props: GridProps): default_2.JSX.Element;

export declare interface GridProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'className'>, DivProps {
    className?: ClassNameType;
    childClassName?: ClassNameType;
    fillChildClassName?: ClassNameType;
    childStyle?: CSSProperties;
    columns?: number;
    rows?: number | 'auto';
    maxRows?: number | 'auto';
    fill?: boolean;
    merge?: Merge;
    children?: React.ReactNode | any;
}

export declare function Icon(props: IconProps): default_2.JSX.Element;

export declare interface IconProps extends Omit<default_2.HTMLAttributes<HTMLOrSVGElement>, 'className'> {
    className?: ClassNameType;
    type: IconType;
    size?: number;
    width?: number;
    height?: number;
    fill?: string;
    [key: string]: any;
}

declare type IconType = 'copy' | 'top' | 'bottom' | 'left' | 'right' | 'ellipsis' | 'yes' | 'no' | 'unFold' | 'fold' | 'loading' | 'home' | 'icon' | 'layout' | 'code' | string;

export declare function ImageUpload(): default_2.JSX.Element;

export declare function injectForm<T>(WrappedComponent: ComponentType<T>): any;

export declare function Input(props: InputProps<any>): default_2.JSX.Element;

export declare type InputChangeEvent = ChangeEvent<HTMLInputElement>;

declare type InputMode = 'text' | 'number' | 'tags' | 'password' | 'pwd' | 'textarea' | 'color' | string;

export declare function InputNumber(props: InputNumberProps): default_2.JSX.Element;

export declare type InputNumberEvent = {
    target: {
        value: number;
    };
};

export declare interface InputNumberProps extends Omit<InputProps<number>, 'onChange' | 'value'> {
    value?: number;
    onChange?(event?: InputNumberEvent): void;
    [key: string]: any;
}

export declare interface InputProps<T> extends Omit<React.HTMLAttributes<HTMLInputElement>, excludeInputType> {
    value?: T;
    defaultValue?: T;
    type?: InputMode;
    className?: ClassNameType;
    [key: string]: any;
}

export declare interface ItemCoreProps extends FormItemProps {
    __form__: UseForm;
}

export declare function Lazy(component: Promise<{
    default: default_2.ComponentType<any>;
}>, loading?: default_2.ReactNode): default_2.JSX.Element;

export declare interface MapAction<Key, Value> {
    set: (key: Key, value: Value, force?: boolean) => void;
    setAll: (newMap: Iterable<readonly [Key, Value]>, force?: boolean) => void;
    remove: (key: Key) => void;
    reset: (force?: boolean) => void;
    get: (key: Key) => Value | undefined;
}

export declare interface MenuObject extends Omit<RouteObject, 'children'> {
    id?: string;
    name: string;
    title?: ReactNode;
    icon?: ReactNode;
    children?: MenuObject[];
}

export declare interface MenuProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onSelect' | 'className'> {
    hook: any;
    lv?: number;
    className?: ClassNameType;
    [key: string]: any;
}

export declare interface MenuSelectRecord {
    name: string;
    names: string[];
    record: MenuObject;
}

declare type Merge = ObjectType_2<{
    row: number;
    column: number;
}>;

export declare const message: {
    success(content: default_2.ReactNode, timeout?: number): void;
    error(content: default_2.ReactNode, timeout?: number): void;
    info(content: default_2.ReactNode, timeout?: number): void;
    warning(content: default_2.ReactNode, timeout?: number): void;
    [key: string]: any;
};

export declare type MessageType = 'success' | 'error' | 'info' | 'warning' | string;

export declare function NextSubMenu(props: MenuProps): default_2.JSX.Element;

export declare function NumberScroll(props: NumberScroll): default_2.JSX.Element;

export declare interface NumberScroll extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'children' | 'className'> {
    value?: number;
    maxLength?: number;
    rootStyle?: default_2.CSSProperties;
    style?: default_2.CSSProperties;
    itemStyle?: default_2.CSSProperties;
    className?: ClassNameType;
}

export declare const OL: typeof Ol;

export declare function Ol(props: OListProps): default_2.JSX.Element;

export declare type OListProps = {
    items?: (string | DataListObjectProps)[];
} & ExtendElement & Omit<default_2.HTMLAttributes<HTMLOListElement>, 'className'>;

export declare function P(props: PProps): default_2.JSX.Element;

export declare function Paging(props: PagingProps): default_2.JSX.Element;

export declare interface PagingProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onChange' | 'className'> {
    className?: ClassNameType;
    current?: number;
    defaultCurrent?: number;
    showPageNum?: number;
    pageSize?: number;
    defaultPageSize?: number;
    pageSizeOptions?: number[];
    total?: number;
    showTotal?: boolean;
    quickJumper?: boolean;
    onChange?: (page: number, pageSize?: number) => void;
}

export declare function PopConfirm(props: PopConfirmProps): default_2.JSX.Element;

export declare interface PopConfirmProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'className' | 'content'> {
    className?: ClassNameType;
    open?: boolean;
    placement?: 'top' | 'left' | 'right' | 'bottom' | 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom';
    content?: React.ReactNode;
}

export declare type PProps = ExtendElement & Omit<default_2.HTMLAttributes<HTMLParagraphElement>, 'className'>;

export declare function Progress(props: ProgressProps): default_2.JSX.Element;

declare interface ProgressProps {
    [key: string]: any;
}

declare interface Props extends Omit<React.HTMLAttributes<HTMLDivElement>, 'className' | 'defaultValue' | 'onChange'> {
    className?: ClassNameType;
}

export declare function Radio(props: RadioProps): default_2.JSX.Element;

export declare type RadioChangeEvent = {
    target: {
        value: RadioValue;
    };
};

export declare interface RadioProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'className' | 'defaultValue' | 'onChange'> {
    className?: ClassNameType;
    name?: string;
    defaultValue?: boolean;
    value?: RadioValue;
    label?: string | number;
    disabled?: boolean;
    onChange?: (event: RadioChangeEvent) => void;
    options?: RadioProps[];
    [key: string]: any;
}

export declare type RadioValue = boolean | string | any;

export declare type Rule = {
    defaultField?: Rule[];
    enum?: any[];
    fields?: Record<string, Rule> | unknown[];
    len?: number | string | unknown[];
    max?: number | string | unknown[];
    message?: string | ReactNode;
    min?: number | string | unknown[];
    pattern?: RegExp;
    required?: boolean;
    transform?: (value: any) => any;
    type?: 'string' | 'number' | 'boolean' | 'url' | 'email' | 'regexp' | 'integer' | 'float' | 'array' | 'object' | 'date';
    validateTrigger?: ValidateTrigger | ValidateTrigger[];
    validator?: (rule: Rule, value: any) => Promise<boolean>;
    warningOnly?: boolean;
    whitespace?: boolean;
};

export declare function Select(props: Select): default_2.JSX.Element;

export declare type Select = SelectProps;

export declare namespace Select {
    var Option: new (text?: string, value?: string, defaultSelected?: boolean, selected?: boolean) => HTMLOptionElement;
}

declare interface SelectProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    prefix?: string;
    value?: string | string[];
    defaultValue?: string | string[];
    disabled?: boolean;
    options?: ({
        value: string;
        label: string;
        className?: ClassNameType;
    } & Omit<HTMLAttributes<HTMLDivElement>, 'className'>)[];
    mode?: 'multiple' | 'simple';
    children?: ReactNode;
    open?: boolean;
    placeholder?: string;
    onChange?: (e: any) => void;
    name?: string;
    [key: string]: any;
}

export declare function SimpleNumberScroll(props: SimpleNumberScrollProps): default_2.JSX.Element;

export declare interface SimpleNumberScrollProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'children' | 'className'> {
    className?: ClassNameType;
    value?: number;
    style?: CSSProperties;
    itemStyle?: CSSProperties;
}

export declare function Skeleton(props: SkeletonProps): default_2.JSX.Element;

export declare function SkeletonItem(props: SkeletonItemProps): default_2.JSX.Element;

export declare interface SkeletonItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    type?: 'square' | 'round' | 'circle' | 'round-circle';
}

export declare interface SkeletonProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    size?: 'small' | 'default' | 'large';
    active?: boolean;
}

export declare function Span(props: SpanProps): default_2.JSX.Element;

export declare type SpanProps = ExtendElement & Omit<default_2.HTMLAttributes<HTMLSpanElement>, 'className'>;

export declare function Split(props: SplitProps): default_2.JSX.Element;

export declare interface SplitProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    gap?: number;
    leftMinWidth?: string | number;
    rightMinWidth?: string | number;
    items?: [default_2.ReactNode, default_2.ReactNode];
    [key: string]: any;
}

export declare function Step(props: StepProps): default_2.JSX.Element;

export declare namespace Step {
    var Bar: typeof StepBar;
}

declare function StepBar(props: StepBarProps): default_2.JSX.Element;

declare interface StepBarProps {
    value?: number;
    items?: {
        value: number;
        label?: default_2.ReactNode;
        [key: string]: any;
    }[];
}

export declare interface StepProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    direction?: 'horizontal' | 'vertical';
    initial?: number;
    items: ({
        status?: 'wait' | 'process' | 'finish' | 'error';
        value?: any;
        className?: ClassNameType;
    } & Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'>[]) | string[];
}

export declare function SubMenu(props: MenuProps): default_2.JSX.Element;

export declare function Tab(props: TabProps): default_2.JSX.Element;

export declare interface TabItemProps {
    title: string | default_2.ReactNode;
    key: string;
    className?: ClassNameType;
    disabled?: boolean;
    style?: default_2.CSSProperties;
    children: default_2.ReactNode;
}

export declare function Table<DataType extends ObjectType_2 = ObjectType_2>(props: Table<ObjectType_2>): default_2.JSX.Element;

export declare interface Table<DataType extends ObjectType_2 = ObjectType_2> extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    serialNumber?: boolean;
    name?: string;
    marge?: ObjectType_2<{
        row?: number;
        col?: number;
    }>;
    noBorder?: boolean;
    columns: ColumnsType<DataType>;
    dataSource?: DataType[];
    rowSelection?: {
        onChange?: (selectedRowKeys: string[], selectedRows: DataType[]) => void;
        getCheckboxProps?: (record: ObjectType_2<any>) => {
            disabled: boolean;
        };
    };
}

export declare interface TabProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'children' | 'className' | 'onChange'> {
    className?: ClassNameType;
    items: TabItemProps[];
    defaultValue?: string;
    value?: string;
    onChange?(key: string): void;
    children?: never;
}

export declare function TextArea(props: TextAreaProps): default_2.JSX.Element;

export declare interface TextAreaProps extends Omit<default_2.HTMLAttributes<HTMLTextAreaElement>, 'className'> {
    className?: ClassNameType;
    [key: string]: any;
}

export declare function ThemeSwitch(): default_2.JSX.Element;

export declare const UL: typeof Ul;

export declare function Ul(props: UListProps): default_2.JSX.Element;

export declare type UListProps = {
    items?: (string | DataListObjectProps)[];
} & ExtendElement & Omit<default_2.HTMLAttributes<HTMLUListElement>, 'className'>;

export declare interface UseForm extends ObjectType {
    values: ObjectType;
    initialValues: ObjectType;
    fields: Map<string | number, ObjectType>;
    fieldAction: MapAction<string, ObjectType>;
    setInitialValues(params: ObjectType<any>): void;
    error: ObjectType;
    setError(params: ObjectType<any>): void;
    resetError(names?: string[]): void;
    rules: ObjectType<Rule[]>;
    getValue: (fieldName: string) => FormFieldValue;
    getValues: (fieldNames?: string[]) => Record<string, FormFieldValue | FormFieldValue[]>;
    setValue: (fieldName: string, value: any) => void;
    setValues: (record: FormRecord) => void;
    clearValues(fieldNames?: string[]): void;
    validateFields: (fieldNames?: string[]) => FormRecord;
    validateField(fieldName: string, value: any): FormRecord;
    resetFields: (fieldNames?: string[]) => void;
}

export declare function useForm(props?: UseFormProps): UseForm;

export declare interface UseFormProps {
    rules?: ObjectType<Rule[]>;
}

export declare interface UseFormProps {
    fields?: FormField[];
}

export declare const useMenu: (props?: useMenuProps) => {
    onSelect(item: MenuObject): void;
    state: Partial<any>;
    setState: (patch: Partial<any> | ((prevState: Partial<any>) => Partial<any>), cover?: boolean) => void;
};

export declare interface useMenuProps {
    onSelect?(target: MenuObject): void;
}

export declare const useTheme: () => {
    night: boolean;
    setNight: (status: boolean) => void;
};

declare type ValidateTrigger = 'onChange' | 'onFocus' | 'onBlur' | string;

export declare function VirtualList(props: any): default_2.JSX.Element;

export declare function Waterfall(props: WaterfallProps): default_2.JSX.Element;

export declare interface WaterfallProps extends Omit<default_2.HTMLAttributes<HTMLDivElement>, 'className'> {
    className?: ClassNameType;
    count?: number;
    type?: 'x';
    xGap?: number | string;
    yGap?: number | string;
}

export { }