import React$1, { HTMLAttributes, Component, ReactNode, FC } from 'react';
import { InputProps, BreadcrumbProps, MenuProps, CheckboxProps, ColorPickerProps, PopconfirmProps, ButtonProps, DatePickerProps, InputNumberProps, RadioGroupProps, RateProps, SelectProps, SliderSingleProps, SwitchProps, TableProps, TimePickerProps, TransferProps, TreeProps, TreeSelectProps, UploadProps, UploadFile, SpaceProps } from 'antd';
import { NavigateFunction } from 'react-router-dom';
import { SizeType } from 'antd/es/config-provider/SizeContext';
import { CheckableTagProps } from 'antd/es/tag';
import { CheckboxGroupProps } from 'antd/es/checkbox';
import * as rc_input_lib_interface from 'rc-input/lib/interface';
import { ValueType } from 'rc-input/lib/interface';
import MarkdownEditor from '@uiw/react-markdown-editor';
import { RangePickerProps } from 'antd/es/date-picker';
import { SearchProps, TextAreaProps } from 'antd/es/input';
import { SliderRangeProps } from 'antd/es/slider';
import * as antd_es__util_type from 'antd/es/_util/type';
import { EventMittNamespace } from '@jswork/event-mitt';
import UrlSyncFlat from '@jswork/url-sync-flat';
import { ColumnsType } from 'antd/es/table';
import dayjs from 'dayjs';
import { DraggerProps } from 'antd/es/upload';
import { UploadChangeParam } from 'antd/es/upload/interface';
import { ReactComponent } from '@ebay/nice-form-react';
import { ReactAntStatusSwitchProps } from '@jswork/react-ant-status-switch/dist/components';

/**
 * Common TypeScript types for antd-components
 * Shared types used across multiple components
 */

/**
 * Supported locale languages
 * @example
 * lang?: AppLocale;
 */
type AppLocale = 'zh-CN' | 'en-US';
/**
 * Custom event target for input components
 * @description This is a custom type that wraps onChange values in a standard format.
 * Antd components don't always return standard React events, so we normalize
 * all onChange callbacks to use this consistent { target: { value } } structure.
 * @example
 * const handleChange = (event: StdEventTarget) => {
 *   console.log(event.target.value);
 * };
 * @template T The type of the value
 */
type StdEventTarget<T = any> = {
    target: {
        value: T;
    };
};
/**
 * Standard callback function for value changes
 * @description Normalized onChange callback that accepts our custom event format.
 * @example
 * onChange?: (inEvent: StdEventTarget) => void;
 * @template T The type of the value
 */
type StdCallback<T = any> = (inEvent: StdEventTarget<T>) => void;
/**
 * Template callback for rendering items
 * @example
 * renderItem?: (item: { item: any; index: number }) => React.ReactNode;
 */
type TemplateCallback<T = any> = (item: {
    item: T;
    index: number;
}, options?: any) => React.ReactNode;
/**
 * API fetcher parameters
 */
interface FetcherParams {
    current: number;
    pageSize: number;
    params?: Record<string, any>;
}
/**
 * API fetcher response
 */
type FetcherResponse<T = any> = Promise<{
    data: T[];
    total: number;
}>;
declare global {
    interface NxStatic {
        $event: any;
        $api: Record<string, any>;
        $nav: NavigateFunction;
        err: (msg: string) => any;
        msg: (msg: string) => any;
        info: (msg: string) => any;
        alert: (msg: string, title?: String) => any;
        confirm: (msg: string, title?: String) => any;
        prompt: (msg: string, options?: InputProps) => any;
    }
}

type AcBreadcrumbProps = {
    className?: string;
    items?: any[];
    template?: (args: {
        item: any;
        index: number;
        data: any[];
    }) => React$1.ReactNode;
    value?: number;
    onChange?: StdCallback;
} & BreadcrumbProps;
declare class AcBreadcrumb extends React$1.Component<AcBreadcrumbProps> {
    static displayName: string;
    static defaultProps: {
        template: ({ item, index, data }: {
            item: any;
            index: any;
            data: any;
        }) => React$1.JSX.Element;
    };
    render(): React$1.JSX.Element;
}

type AcCheckableDropdownProps = {
    className?: string;
    lang?: AppLocale;
    items?: any[];
    value?: any[];
    width?: number;
    size?: SizeType;
    disabled?: boolean;
    onChange?: StdCallback;
};
declare class AcCheckableDropdown extends React$1.Component<AcCheckableDropdownProps> {
    static displayName: string;
    static formSchema: string;
    static id: number;
    static defaultProps: {
        lang: string;
        items: never[];
        value: never[];
        width: number;
    };
    private readonly overlayClass;
    state: {
        visible: boolean;
        value: any[] | undefined;
    };
    private overlayRes;
    private winBlankRes;
    get indeterminate(): boolean;
    get label(): any;
    get menuItems(): MenuProps["items"];
    t: (inKey: string) => any;
    doChange: (inValue: any) => void;
    componentDidMount(): void;
    componentDidUpdate(): void;
    componentWillUnmount(): void;
    /**
     * todo: 有朝一日，找出原因
     * 这里的 button disabled 不能生效，除非在 dropdown 内层套一个 Fragment。
     */
    render(): React$1.JSX.Element;
}

/**
 * @see https://ant.design/components/tag-cn/#Tag.CheckableTag
 */
type AcCheckableTagProps = {
    className?: string;
    value?: boolean;
    disabled?: boolean;
    closeable?: boolean;
    toggleable?: boolean;
    propagation?: boolean;
    onChange?: StdCallback;
    onCloseClick?: StdCallback;
} & Omit<CheckableTagProps, 'checked'>;
declare class AcCheckableTag extends React$1.Component<AcCheckableTagProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        value: boolean;
        closeable: boolean;
        disabled: boolean;
        toggleable: boolean;
        propagation: boolean;
    };
    state: {
        value: boolean;
    };
    get closeIcon(): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>> | null;
    shouldComponentUpdate(nextProps: Readonly<AcCheckableTagProps>): boolean;
    handleChange: (inEvent: any) => void;
    handleCloseClick: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcCheckableTagFc: (props: AcCheckableTagProps) => React$1.JSX.Element;

type AcCheckableTagListProps = {
    /**
     * Main className.
     */
    className?: string;
    /**
     * The language key.
     */
    lang?: AppLocale;
    /**
     * The component data soruce.
     */
    items?: any[];
    /**
     * Runtime value.
     */
    value?: any[];
    /**
     * The event handler for `change`.
     */
    onChange?: StdCallback;
    /**
     * The disabled state.
     */
    disabled?: boolean;
};
declare class AcCheckableTagList extends React$1.Component<AcCheckableTagListProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        lang: string;
        value: never[];
    };
    state: {
        value: any[] | undefined;
    };
    t: (inKey: string) => any;
    shouldComponentUpdate(nextProps: Readonly<AcCheckableTagListProps>): boolean;
    handleChange: (inEvent: any) => void;
    handleClearAll: () => void;
    render(): React$1.JSX.Element;
}
declare const AcCheckableTagListFc: (props: AcCheckableTagListProps) => React$1.JSX.Element;

type AcCheckboxProps = {
    className?: string;
    value?: boolean;
    onChange?: StdCallback;
} & CheckboxProps & HTMLAttributes<any>;
declare class AcCheckbox extends React$1.Component<AcCheckboxProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    state: {
        value: any;
    };
    shouldComponentUpdate(nextProps: Readonly<AcCheckboxProps>): boolean;
    handleChange: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcCheckboxFc: (props: AcCheckboxProps) => React$1.JSX.Element;

type AcCheckboxGroupProps = {
    className?: string;
    value?: any[];
    items?: any[];
    onChange?: StdCallback;
    onSearch?: StdCallback;
    template?: TemplateCallback;
} & CheckboxGroupProps;
declare class AcCheckboxGroup extends React$1.Component<AcCheckboxGroupProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        items: never[];
        value: never[];
        template: (args: any) => React$1.JSX.Element;
    };
    state: {
        value: any[] | undefined;
    };
    shouldComponentUpdate(nextProps: Readonly<AcCheckboxGroupProps>): boolean;
    handleChange: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcCheckboxGroupFc: (props: AcCheckboxGroupProps) => React$1.JSX.Element;

declare class AcCodeFlask extends React$1.Component {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    render(): React$1.JSX.Element;
}
declare const AcCodeFlaskFc: (props: any) => React$1.JSX.Element;

type AcColorPickerProps = {
    className?: string;
    value?: string;
    onChange?: StdCallback<string>;
} & Omit<ColorPickerProps, 'value' | 'onChange'>;
declare class AcColorPicker extends React$1.Component<AcColorPickerProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    state: {
        value: string | undefined;
    };
    shouldComponentUpdate(inProps: Readonly<AcColorPickerProps>): boolean;
    handleChange: (inColor: any) => void;
    handleClear: () => void;
    render(): React$1.JSX.Element;
}
declare const AcColorPickerFc: (props: AcColorPickerProps) => React$1.JSX.Element;

interface AcConfirmButtonProps extends Omit<PopconfirmProps, 'title'> {
    className?: string;
    lang?: AppLocale;
    title?: string;
    type?: ButtonProps['type'] | 'raw' | 'anchor';
    childProps?: ButtonProps;
    onClick?: React$1.MouseEventHandler<HTMLElement>;
    children?: React$1.ReactNode;
}
declare class AcConfirmButton extends Component<AcConfirmButtonProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        lang: string;
        type: string;
        childProps: {};
    };
    get computedChildren(): string | number | boolean | React$1.JSX.Element | Iterable<React$1.ReactNode> | null | undefined;
    handleCancel: () => void;
    t: (key: string) => any;
    render(): React$1.JSX.Element;
}

type AcDatePickerProps = Omit<DatePickerProps, 'value' | 'onChange' | 'ref'> & {
    className?: string;
    value?: any;
    onChange?: StdCallback<string>;
};
declare class AcDatePicker extends React$1.Component<AcDatePickerProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: AcDatePickerProps;
    get valueFormat(): any;
    get value(): any;
    handleChange: (value: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcDatePickerFc: (props: AcDatePickerProps) => React$1.JSX.Element;

type AcEditableTagGroupProps = {
    name: string;
    className?: string;
    value?: string[];
    onChange?: (e: {
        target: {
            value: string[];
        };
    }) => void;
    readOnly?: boolean;
    disabled?: boolean;
    min?: number;
    max?: number;
    triggers?: string[];
};
declare const AcEditableTagGroup: React$1.FC<AcEditableTagGroupProps>;

type AcInputProps = {
    className?: string;
    onChange?: StdCallback;
    autoComplete?: boolean;
} & InputProps;
declare class AcInput extends React$1.Component<AcInputProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        autoComplete: boolean;
    };
    state: {
        value: rc_input_lib_interface.ValueType;
    };
    shouldComponentUpdate(inProps: Readonly<AcInputProps>): boolean;
    handleChange: (inEvent: any) => void;
    get complete(): "off" | "on";
    render(): React$1.JSX.Element;
}
declare const AcInputFc: (props: AcInputProps) => React$1.JSX.Element;

type AcInputCopyableValueType = 'text' | 'link';
interface AcInputCopyableProps extends AcInputProps {
    valueType?: AcInputCopyableValueType;
}
interface AcInputCopyableState {
    value?: ValueType;
}
declare class AcInputCopyable extends React$1.Component<AcInputCopyableProps, AcInputCopyableState> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        valueType: string;
    };
    constructor(props: AcInputCopyableProps);
    get copyView(): React$1.JSX.Element;
    get linkView(): React$1.JSX.Element | null;
    shouldComponentUpdate(props: Readonly<AcInputProps>): boolean;
    handleInputChange: (e: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcInputCopyableFc: (props: AcInputCopyableProps) => React$1.JSX.Element;

declare class AcInputHidden extends React$1.Component {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    render(): React$1.JSX.Element;
}
declare const AcInputHiddenFc: (props: InputProps) => React$1.JSX.Element;

type AcInputNumberProps = {
    className?: string;
    value?: number;
    onChange?: StdCallback;
} & InputNumberProps;
declare class AcInputNumber extends React$1.Component<AcInputNumberProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    state: {
        value: number | undefined;
    };
    shouldComponentUpdate(inProps: Readonly<AcInputNumberProps>): boolean;
    handleChange: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcInputNumberFc: (props: AcInputNumberProps) => React$1.JSX.Element;

type AcInputTagsProps = {
    className?: string;
    items?: string[];
    disabled?: boolean;
    onChange?: StdCallback;
} & React$1.HTMLAttributes<HTMLDivElement>;
type State$1 = {
    items?: string[];
    inputValue: string;
    isComposite: boolean;
};
declare class AcInputTags extends React$1.Component<AcInputTagsProps, State$1> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        items: never[];
        disabled: boolean;
    };
    inputRef: React$1.RefObject<HTMLInputElement>;
    constructor(inProps: any);
    shouldComponentUpdate(nextProps: Readonly<AcInputTagsProps>): boolean;
    handleInputChange: (inEvent: any) => void;
    handleInputKeyAction: (inEvent: any) => false | void;
    handleTagRemove: (inIndex: any, inForce?: boolean) => void;
    handleMouseEnter: () => void;
    execChange: (inItems: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcInputTagsFc: (props: AcInputTagsProps) => React$1.JSX.Element;

type AcInputTokenProps = {
    className?: string;
    value?: string;
    onChange?: StdCallback;
    autoComplete?: boolean;
    labelCreate?: string;
    labelRemove?: string;
} & InputProps;
declare class AcInputToken extends React$1.Component<AcInputTokenProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        autoComplete: boolean;
        labelCreate: string;
        labelRemove: string;
    };
    private rootRef;
    state: {
        value: string | (string & readonly string[]) | undefined;
    };
    shouldComponentUpdate(nextProps: Readonly<AcInputTokenProps>): boolean;
    get complete(): "off" | "on";
    get tokenView(): React$1.JSX.Element;
    handleTokenCreate: () => void;
    handleTokenRemove: () => void;
    handleChange: (inEvent: any) => void;
    doChange: (inValue: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcInputTokenFc: (props: AcInputTokenProps) => React$1.JSX.Element;

type AcMarkdownEditorProps = {
    className?: string;
    value?: string;
    onChange?: StdCallback;
} & React$1.ComponentProps<typeof MarkdownEditor>;
declare class AcMarkdownEditor extends React$1.Component<AcMarkdownEditorProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    handleChange: (inValue: string) => void;
    render(): React$1.JSX.Element;
}
declare const AcMarkdownEditorFc: (props: AcMarkdownEditorProps) => React$1.JSX.Element;

interface Value {
    option: string;
    keyword: string;
}
type AcPreSelectProps = {
    /**
     * The extended className for component.
     */
    className?: string;
    /**
     * Default value.
     */
    value?: Value;
    /**
     * Select options.
     */
    items?: any[];
    /**
     * The change handler.
     */
    onChange?: Function;
    /**
     * The handler for search.
     */
    onSearch?: Function;
    /**
     * If use search input.
     */
    searchable?: boolean;
    /**
     * The prefix select options.
     */
    selectOptions?: any;
    /**
     * The suffix input options.
     */
    inputOptions?: any;
};
declare class AcPreSelect extends React$1.Component<AcPreSelectProps> {
    static displayName: string;
    static formSchema: string;
    static version: string;
    static defaultProps: {
        searchable: boolean;
    };
    state: {
        value: Value | undefined;
    };
    get addonView(): React$1.JSX.Element;
    handleFiledAction: (inField: any, inEvent: any, inCallback: any) => void;
    handleChange: (inField: any, inEvent: any) => void;
    handleSearch: (inField: any, inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcPreSelectFc: (props: AcPreSelectProps) => React$1.JSX.Element;

type AcRadioGroupProps = {
    className?: string;
    value?: any;
    defaultValue?: any;
    items?: any[];
    onChange?: StdCallback;
    onSearch?: StdCallback;
    template?: TemplateCallback;
    templateOptions?: any;
    buttonStyle?: 'solid' | 'outline';
} & RadioGroupProps & HTMLAttributes<any>;
declare class AcRadioGroup extends React$1.Component<AcRadioGroupProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        items: never[];
        template: (args: any, opts: any) => React$1.JSX.Element;
    };
    get templateCallback(): (item: any) => React$1.ReactNode;
    state: {
        value: any;
    };
    static getDerivedStateFromProps(inProps: Readonly<AcRadioGroupProps>, inState: any): {
        value: any;
    } | null;
    handleChange: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcRadioGroupFc: (props: AcRadioGroupProps) => React$1.JSX.Element;

type AcRangePickerProps = {
    className?: string;
    value?: any;
    defaultValue?: any;
    onChange?: StdCallback;
} & RangePickerProps;
declare class AcRangePicker extends React$1.Component<AcRangePickerProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        format: string;
    };
    handleChange: (inEvent: any) => void;
    parse: (inValue: any) => any;
    stringify: (inValue: any) => any;
    render(): React$1.JSX.Element;
}
declare const AcRangePickerFc: (props: AcRangePickerProps) => React$1.JSX.Element;

type AcRateProps = {
    className?: string;
    value?: number;
    onChange?: StdCallback;
} & RateProps;
declare class AcRate extends React$1.Component<AcRateProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    handleChange: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcRateFc: (props: AcRateProps) => React$1.JSX.Element;

type AcSearchProps = {
    value?: string;
    onChange?: StdCallback;
    onSearch?: StdCallback;
    autoComplete?: boolean;
} & SearchProps;
declare class AcSearch extends React$1.Component<AcSearchProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        autoComplete: boolean;
        placeholder: string;
    };
    get complete(): "off" | "on";
    handleSearch: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcSearchFc: (props: AcSearchProps) => React$1.JSX.Element;

type AcSelectProps = {
    className?: string;
    items?: any[];
    kv?: Record<string, string>;
    onChange?: StdCallback;
    onSearch?: StdCallback;
    template?: TemplateCallback;
} & Omit<SelectProps, 'options'>;
declare class AcSelect extends React$1.Component<AcSelectProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        placeholder: string;
        items: never[];
        kv: {
            label: string;
            value: string;
        };
        template: (args: any) => React$1.JSX.Element;
    };
    state: {
        value: any;
    };
    shouldComponentUpdate(nextProps: Readonly<AcSelectProps>): boolean;
    handleChange: (inValue: any) => void;
    template: (args: any) => string | number | boolean | React$1.JSX.Element | Iterable<React$1.ReactNode> | null | undefined;
    render(): React$1.JSX.Element;
}
declare const AcSelectFc: (props: AcSelectProps) => React$1.JSX.Element;

type AcSliderProps = {
    className?: string;
    onChange?: StdCallback;
} & SliderSingleProps;
declare class AcSlider extends React$1.Component<AcSliderProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    handleChange: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcSliderFc: (props: AcSliderProps) => React$1.JSX.Element;

type AcSliderRangeProps = {
    className?: string;
    range?: true;
    onChange?: StdCallback;
} & Omit<SliderRangeProps, 'range'>;
declare class AcSliderRange extends React$1.Component<AcSliderRangeProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    handleChange: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcSliderRangeFc: (props: AcSliderRangeProps) => React$1.JSX.Element;

type AcSwitchProps = {
    className?: string;
    value?: boolean;
    onChange?: StdCallback;
} & SwitchProps;
declare class AcSwitch extends React$1.Component<AcSwitchProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    state: {
        value: boolean;
    };
    shouldComponentUpdate(nextProps: Readonly<AcSwitchProps>): boolean;
    handleChange: (value: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcSwitchFc: React$1.ForwardRefExoticComponent<{
    className?: string;
    value?: boolean;
    onChange?: StdCallback;
} & SwitchProps & React$1.RefAttributes<AcSwitch>>;

type AcTableProps = TableProps & {
    /**
     * The identity name.
     * @default '@'
     */
    name: string;
    /**
     * The language.
     * @default 'zh-CN'
     */
    lang?: AppLocale;
    /**
     * The platform module name.
     * @default admin
     */
    module?: string;
    /**
     * The extra params when query data.
     */
    params?: Record<string, any>;
    /**
     * The extra params when redirect to add page.
     * `paramsAdd` will merge with `params` when redirect to add page.
     */
    paramsAdd?: Record<string, any>;
    /**
     * The extra params when redirect to edit page.
     * `paramsEdit` will merge with `paramsAdd` when redirect to edit page.
     */
    paramsEdit?: Record<string, any>;
    /**
     * The extra params when reset the page.
     */
    paramsReset?: Record<string, any>;
    /**
     * Use custom router path for add page.
     */
    pathAdd?: string;
    /**
     * Use custom router path for edit page.
     */
    pathEdit?: string;
    /**
     * Custom get standard data.
     * @param params { current: number; pageSize: number }
     * @returns Promise<{ data: any[]; total: number }>
     */
    fetcher?: (params: FetcherParams) => FetcherResponse;
    /**
     * @param page
     * @param size
     */
    onPageChange?: (page: number, size: number) => void;
    /**
     * When destroy complete.
     * @param model
     */
    onDestroyComplete?: (model: any) => void;
    /**
     * Default page.
     */
    defaultCurrent?: number;
    /**
     * Default page size.
     */
    defaultPageSize?: number;
    /**
     * Total data from backend.
     */
    total?: number;
    /**
     * The response data key.
     */
    dataPath?: string;
    /**
     * The response total key.
     */
    totalPath?: string;
    /**
     * Column fields for table.
     */
    columnsFields?: TableProps['columns'];
    /**
     * Column fields for table action.
     */
    columnsAction?: ColumnsType<any>;
    /**
     * The table action params.
     */
    columnsActionParams?: Record<string, any>;
    /**
     * The table columns.
     */
    columns?: TableProps['columns'];
};
type AcTableState = {
    currentRowId: any;
    dataSource: TableProps['dataSource'];
    isLoading: boolean;
    current: any;
    pageSize: any;
    total: any;
};
declare class AcTable extends React$1.Component<AcTableProps, AcTableState> {
    static displayName: string;
    static formSchema: string;
    private harmonyEvents;
    static event: EventMittNamespace.EventMitt;
    static events: string[];
    static defaultProps: {
        name: string;
        lang: string;
        module: string;
        rowKey: string;
        defaultCurrent: number;
        defaultPageSize: number;
        dataPath: string;
        totalPath: string;
        columnsFields: never[];
        params: {};
    };
    eventBus: EventMittNamespace.EventMitt;
    sync: UrlSyncFlat;
    private defaultFetcher;
    get routerKey(): string;
    get calculateColumnsAction(): ColumnsType<any> | {
        title: any;
        dataIndex: string;
        key: string;
        width: number;
        render: (_: any, record: any) => React$1.JSX.Element;
    }[];
    get calculateColumns(): ColumnsType<antd_es__util_type.AnyObject> | undefined;
    constructor(props: AcTableProps);
    private initFetcher;
    private toQueryString;
    componentDidMount(): Promise<void>;
    componentDidUpdate(prevProps: AcTableProps): Promise<void>;
    componentWillUnmount(): void;
    fetchData: (page: number, size: number, overrideParams?: Record<string, any> | null) => Promise<void>;
    /**
     * Load data from backend.
     */
    load: (payload: Record<string, any>) => Promise<void>;
    /**
     * Refresh data use current state.
     */
    refetch: () => Promise<void>;
    /**
     * Reset to default state, and fetch data.
     */
    reset: () => Promise<void>;
    /**
     * CURD(local): optimisticUpdate data before data fetch.
     */
    draft: (payload: Record<string, any>) => Promise<void>;
    /**
     * CURD(action): Delete data from backend.
     */
    destroy: (item: any) => void;
    /**
     * CURD(page): Redirect to add page.
     */
    add: () => void | Promise<void>;
    /**
     * CURD(page): Redirect to edit page.
     */
    edit: (item: any) => void | Promise<void>;
    handleOnRow: (record: any) => {
        onMouseEnter: () => void;
        onMouseLeave: () => void;
    };
    render(): React$1.JSX.Element;
}

type AcTextareaProps = {
    className?: string;
    value?: boolean;
    onChange?: StdCallback;
} & TextAreaProps;
declare class AcTextarea extends React$1.Component<AcTextareaProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {};
    render(): React$1.JSX.Element;
}
declare const AcTextareaFc: (props: AcTextareaProps) => React$1.JSX.Element;

type AcTimePickerProps = {
    className?: string;
    value?: string | dayjs.Dayjs;
    defaultValue?: string | dayjs.Dayjs;
    onChange?: StdCallback;
} & Omit<TimePickerProps, 'value' | 'defaultValue' | 'onChange' | 'ref'>;
declare class AcTimePicker extends React$1.Component<AcTimePickerProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        format: string;
    };
    handleChange: (inEvent: any) => void;
    parse: (inValue: any) => dayjs.Dayjs;
    stringify: (inValue: any) => any;
    normalize: (inValues: any) => any;
    render(): React$1.JSX.Element;
}
declare const AcTimePickerFc: (props: AcTimePickerProps) => React$1.JSX.Element;

type AcTransferProps = {
    className?: string;
    items?: any[];
    template: TemplateCallback;
    value?: any[];
    onChange?: StdCallback;
} & TransferProps<any>;
declare class AcTransfer extends React$1.Component<AcTransferProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        items: never[];
        template: ({ item }: {
            item: any;
        }, options?: any) => React$1.ReactNode;
    };
    get templateCallback(): any;
    state: {
        value: any[] | undefined;
    };
    shouldComponentUpdate(nextProps: Readonly<AcTransferProps>): boolean;
    handleChange: (inEvent: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcTransferFc: (props: AcTransferProps) => React$1.JSX.Element;

type AcTreeProps = {
    className?: string;
    items?: any[];
    kv?: Record<string, string>;
    template?: any;
    itemsKey?: string | ((index: number, item: any) => any);
    directory?: boolean;
} & TreeProps;
declare class AcTree extends React$1.Component<AcTreeProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        directory: boolean;
        items: never[];
        kv: {
            label: string;
            value: string;
        };
        template: ({ item }: {
            item: any;
        }, cb: any) => React$1.JSX.Element;
        itemsKey: string;
    };
    get childView(): any;
    template: (args: any) => any;
    render(): React$1.JSX.Element | null;
}

type AcTreeSelectProps = {
    className?: string;
    items?: any[];
    template?: any;
    itemsKey?: string | ((index: number, item: any) => any);
    onChange?: StdCallback;
} & TreeSelectProps;
declare class AcTreeSelect extends React$1.Component<AcTreeSelectProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        items: never[];
        template: ({ item }: {
            item: any;
        }, cb: any) => React$1.JSX.Element;
        itemsKey: string;
    };
    get childView(): any;
    handleChange: (inValue: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcTreeSelectFc: (props: AcTreeSelectProps) => React$1.JSX.Element;

type CustomRequest$1 = (inEvent: any) => Promise<any>;
type AcUploadProps = {
    className?: string;
    value?: number;
    onChange?: StdCallback;
    onRequest?: CustomRequest$1;
    btnProps?: ButtonProps;
} & UploadProps;
declare class AcUpload extends React$1.Component<AcUploadProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        onRequest: (inEvent: any) => Promise<any>;
    };
    handleChange: (inEvent: any) => void;
    handleCustomRequest: (inRequestOption: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcUploadFc: (props: AcUploadProps) => React$1.JSX.Element;

type CustomRequest = (inEvent: any) => Promise<any>;
type AcUploadDraggerProps = {
    className?: string;
    value?: any[];
    defaultValue?: any[];
    onChange?: StdCallback;
    onRequest?: CustomRequest;
} & DraggerProps;
declare class AcUploadDragger extends React$1.Component<AcUploadDraggerProps> {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        onRequest: (inEvent: any) => Promise<any>;
    };
    handleChange: (inEvent: any) => void;
    handleCustomRequest: (inRequestOption: any) => void;
    render(): React$1.JSX.Element;
}
declare const AcUploadDraggerFc: (props: AcUploadDraggerProps) => React$1.JSX.Element;

type AcAbstractUploadProps = {
    className?: string;
    value?: any[] | [];
    onChange?: StdCallback;
    transformResponse?: (inResponse: any) => any;
    transformURL?: (inPid: any) => string;
} & DraggerProps;
type State = {
    fileList: any[];
};
declare class AcAbstractUpload extends React$1.Component<AcAbstractUploadProps, State> {
    protected rootRef: React$1.RefObject<HTMLDivElement>;
    protected sortable: any;
    protected viewer: any;
    toFileList: (inUrls: any[] | any) => any[];
    constructor(inProps: AcAbstractUploadProps);
    componentDidMount(): Promise<void>;
    shouldComponentUpdate(nextProps: Readonly<AcAbstractUploadProps>): boolean;
    mountSortable(el: any): void;
    mountViewer(el: any): Promise<void>;
    componentWillUnmount(): void;
    handlePreview: (file: UploadFile<any>) => void;
    handleChange: (inEvent: UploadChangeParam<UploadFile<any>>) => void;
    handleSortEnd: (inEvent: any) => void;
    doChange: (inValue: any) => void;
    previewFile: (file: any) => Promise<string>;
    render(): ReactNode;
}

declare class AcUploadPicture extends AcAbstractUpload {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        value: never[];
        maxCount: number;
        transformURL: (pid: any) => any;
        transformResponse: (inFileList: any) => any;
    };
    render(): React$1.JSX.Element;
}
declare const AcUploadPictureFc: (props: any) => React$1.JSX.Element;

declare class AcUploadPictureCard extends AcAbstractUpload {
    static displayName: string;
    static formSchema: string;
    static defaultProps: {
        value: never[];
        transformURL: (pid: any) => any;
        transformResponse: (inFileList: any) => any;
    };
    render(): React$1.JSX.Element;
}
declare const AcUploadPictureCardFc: (props: any) => React$1.JSX.Element;

declare const breadcrumbDefault: ({ item, index, data }: {
    item: any;
    index: any;
    data: any;
}) => React$1.JSX.Element;

interface Options$1 {
    component: React$1.ComponentType<any>;
    value?: string;
    label?: string;
    [key: string]: any;
}
/**
 * KV component template, for key-value pair.
 * @param item
 * @param index
 * @param options
 */
declare const kv: ({ item, index }: {
    item: any;
    index: any;
}, options: Options$1) => React$1.JSX.Element;
declare const checkboxKv: (args: any) => React$1.JSX.Element;
declare const selectKv: (args: any) => React$1.JSX.Element;
declare const radioKv: (args: any, opts: any) => React$1.JSX.Element;
declare const treeKv: ({ item }: {
    item: any;
}, cb: any) => React$1.JSX.Element;
declare const treeSelectKv: ({ item }: {
    item: any;
}, cb: any) => React$1.JSX.Element;

interface Options {
    component: React$1.ComponentType<any>;
    [key: string]: any;
}
/**
 * Raw component template, for array of items.
 * @param item
 * @param index
 * @param options
 */
declare const raw: ({ item, index }: {
    item: any;
    index: any;
}, options: Options) => React$1.JSX.Element;
declare const checkboxRaw: (args: any) => React$1.JSX.Element;
declare const selectRaw: (args: any) => React$1.JSX.Element;
declare const radioRaw: (args: any, opts: any) => React$1.JSX.Element;

declare const transferLabel: ({ item }: {
    item: any;
}, options?: any) => React$1.ReactNode;

type AcCardExtrasProps = SpaceProps & {
    name: string;
    lang?: AppLocale;
    as?: React$1.ComponentType<any>;
    extraBefore?: React$1.ReactNode;
    extraAfter?: React$1.ReactNode;
    asProps?: any;
    actions?: string[];
};
declare const AcCardExtras: FC<AcCardExtrasProps>;

/**
 * @Author: aric.zheng 1290657123@qq.com
 * @Date: 2025-10-29 10:54:41
 * @LastEditors: aric 1290657123@qq.com
 * @LastEditTime: 2025-10-31 08:32:21
 */

type AcExtraSearchProps = SearchProps & {
    name: string;
    lang?: AppLocale;
    queryKey?: string;
    routerType?: 'hash' | 'browser';
};
declare const AcExtraSearch: FC<AcExtraSearchProps>;

/**
 * @Author: aric 1290657123@qq.com
 * @Date: 2025-10-25 18:48:19
 * @LastEditors: aric 1290657123@qq.com
 * @LastEditTime: 2025-10-25 21:53:43
 */

type FormActionsProps = SpaceProps & {
    lang?: AppLocale;
    actions?: string[];
    okText?: string;
    cancelText?: string;
    onOk?: (e: React$1.MouseEvent<HTMLElement>) => void;
    onCancel?: (e: React$1.MouseEvent<HTMLElement>) => void;
    okProps?: ButtonProps;
    cancelProps?: ButtonProps;
    buttonProps?: ButtonProps;
    as?: React$1.ComponentType<any>;
    asProps?: any;
};
declare const FormActions: React$1.ForwardRefExoticComponent<SpaceProps & {
    lang?: AppLocale;
    actions?: string[];
    okText?: string;
    cancelText?: string;
    onOk?: (e: React$1.MouseEvent<HTMLElement>) => void;
    onCancel?: (e: React$1.MouseEvent<HTMLElement>) => void;
    okProps?: ButtonProps;
    cancelProps?: ButtonProps;
    buttonProps?: ButtonProps;
    as?: React$1.ComponentType<any>;
    asProps?: any;
} & React$1.RefAttributes<HTMLDivElement>>;

declare const initWidgets: (names?: string[] | null, externalWidgets?: Record<string, ReactComponent>) => void;

type AcTableLinksProps = {
    name: string;
    model: any;
    lang?: AppLocale;
    extraBefore?: React$1.ReactNode;
    extraAfter?: React$1.ReactNode;
    as?: React$1.ComponentType<any>;
    asProps?: any;
    actions?: string[];
};
declare const AcTableLinks: FC<AcTableLinksProps>;

type AcTableStatusSwitcherProps = ReactAntStatusSwitchProps & {
    name: string;
    items: any[];
    model: any;
    params?: any;
    idKey?: string;
    updateKey?: string;
    updateApi?: string;
    onSuccess?: () => void;
};
declare const AcTableStatusSwitcher: FC<AcTableStatusSwitcherProps>;

/**
 * @Author: aric.zheng 1290657123@qq.com
 * @Date: 2025-10-29 14:09:01
 * @LastEditors: aric.zheng 1290657123@qq.com
 * @LastEditTime: 2025-10-29 15:49:36
 */

type AcTableToggleSwitcherProps = SwitchProps & {
    name: string;
    model: any;
    updateKey: string;
    params?: any;
    idKey?: string;
    updateApi?: string;
    onSuccess?: () => void;
};
declare const AcTableToggleSwitcher: FC<AcTableToggleSwitcherProps>;

type ExecuteFn = (command: string, data?: any) => void;
type ListenFn = (command: string, callback: any) => void;
type Payload = Record<string, any>;
declare const useCommand: (inName?: string) => {
    listen: ListenFn;
    execute: ExecuteFn;
    load: (payload: Payload) => void;
    refetch: () => void;
    reset: () => void;
    add: () => void;
    edit: (payload: Payload) => void;
    destroy: (payload: Payload) => void;
    draft: (payload: Payload) => void;
};

declare const BtnCreate: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnEdit: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnDelete: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnView: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnPreview: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnSave: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnExport: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnImport: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnRefresh: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnBack: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnSubmit: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnCancel: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnSync: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;
declare const BtnCopy: (props: ButtonProps & {
    lang?: AppLocale;
}) => React$1.JSX.Element;

export { AcBreadcrumb, type AcBreadcrumbProps, AcCardExtras, type AcCardExtrasProps, AcCheckableDropdown, type AcCheckableDropdownProps, AcCheckableTag, AcCheckableTagFc, AcCheckableTagList, AcCheckableTagListFc, type AcCheckableTagListProps, type AcCheckableTagProps, AcCheckbox, AcCheckboxFc, AcCheckboxGroup, AcCheckboxGroupFc, type AcCheckboxGroupProps, type AcCheckboxProps, AcCodeFlask, AcCodeFlaskFc, AcColorPicker, AcColorPickerFc, type AcColorPickerProps, AcConfirmButton, type AcConfirmButtonProps, AcDatePicker, AcDatePickerFc, type AcDatePickerProps, AcEditableTagGroup, type AcEditableTagGroupProps, AcExtraSearch, type AcExtraSearchProps, AcInput, AcInputCopyable, AcInputCopyableFc, AcInputFc, AcInputHidden, AcInputHiddenFc, AcInputNumber, AcInputNumberFc, type AcInputNumberProps, type AcInputProps, AcInputTags, AcInputTagsFc, type AcInputTagsProps, AcInputToken, AcInputTokenFc, type AcInputTokenProps, AcMarkdownEditor, AcMarkdownEditorFc, type AcMarkdownEditorProps, AcPreSelect, AcPreSelectFc, type AcPreSelectProps, AcRadioGroup, AcRadioGroupFc, type AcRadioGroupProps, AcRangePicker, AcRangePickerFc, type AcRangePickerProps, AcRate, AcRateFc, type AcRateProps, AcSearch, AcSearchFc, type AcSearchProps, AcSelect, AcSelectFc, type AcSelectProps, AcSlider, AcSliderFc, type AcSliderProps, AcSliderRange, AcSliderRangeFc, type AcSliderRangeProps, AcSwitch, AcSwitchFc, type AcSwitchProps, AcTable, AcTableLinks, type AcTableLinksProps, type AcTableProps, AcTableStatusSwitcher, type AcTableStatusSwitcherProps, AcTableToggleSwitcher, type AcTableToggleSwitcherProps, AcTextarea, AcTextareaFc, type AcTextareaProps, AcTimePicker, AcTimePickerFc, type AcTimePickerProps, AcTransfer, AcTransferFc, type AcTransferProps, AcTree, type AcTreeProps, AcTreeSelect, AcTreeSelectFc, type AcTreeSelectProps, AcUpload, AcUploadDragger, AcUploadDraggerFc, type AcUploadDraggerProps, AcUploadFc, AcUploadPicture, AcUploadPictureCard, AcUploadPictureCardFc, AcUploadPictureFc, type AcUploadProps, BtnBack, BtnCancel, BtnCopy, BtnCreate, BtnDelete, BtnEdit, BtnExport, BtnImport, BtnPreview, BtnRefresh, BtnSave, BtnSubmit, BtnSync, BtnView, FormActions, type FormActionsProps, breadcrumbDefault, checkboxKv, checkboxRaw, initWidgets, kv, radioKv, radioRaw, raw, selectKv, selectRaw, transferLabel, treeKv, treeSelectKv, useCommand as useTableCommand };