import { DateFormatType, LabelValueItem, TAny, TNoopDefine, TPlainObject } from '@flatbiz/utils';
import { IAllProps } from '@tinymce/tinymce-react';
import { AlertProps, ButtonProps, CardProps, CascaderProps, CheckboxProps, CollapseProps, ColorPickerProps, DatePicker, DrawerProps, DropdownProps, FormInstance, FormItemProps, FormListFieldData, FormListOperation, FormProps, GetProps, InputNumber, InputNumberProps, InputProps, MentionProps, ModalProps, PaginationProps, PopconfirmProps, PopoverProps, RadioGroupProps, RowProps, SelectProps, SpaceProps, SwitchProps, TableProps, Tabs, TabsProps, TagProps, TimePickerProps, TimeRangePickerProps, TooltipProps, TreeProps, TreeSelectProps, UploadProps } from 'antd';
import { ConfigProviderProps } from 'antd/es/config-provider';
import { PickerProps } from 'antd/es/date-picker/generatePicker';
import { FormListProps } from 'antd/es/form';
import { FormListProps } from 'antd/es/form/FormList.js';
import { ColumnsType } from 'antd/es/table';
import { RcFile } from 'antd/es/upload';
import { CheckboxGroupProps } from 'antd/lib/checkbox';
import { SearchProps, TextAreaProps } from 'antd/lib/input';
import { UploadChangeParam } from 'antd/lib/upload';
import { UploadFile } from 'antd/lib/upload/interface.js';
import { CSSProperties, DependencyList, DetailedHTMLProps, FC, ForwardRefExoticComponent, ReactElement, ReactNode, RefAttributes } from 'react';
import { IAceEditorProps } from 'react-ace';
import { SplitProps } from 'react-split';
import { Editor as TinyMCEEditor } from 'tinymce';

export type AceEditorGroovyProps = Omit<IAceEditorProps, "mode" | "value" | "onChange" | "theme"> & {
	/** 编辑器高度，默认值：100%，可输入值例如 300px、100% */
	height?: string;
	value?: string | TPlainObject | TPlainObject[];
	onChange?: (value?: string | TPlainObject | TPlainObject[]) => void;
	/** 配置输入自动提示关键字 */
	autoCompleterList?: {
		name: string;
		desc?: string;
	}[];
	/**
	 * 编辑器主题配置，例如：github、terminal、xcode
	 * ```
	 * 1. 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
	 * 2. 配置 theme = xxxx
	 * ```
	 */
	theme?: string;
};
/**
 * groovy编辑器
 * ```
 * 1. 受控组件，需要使用value、onChange配合显示数据
 * 2. heigth 默认为100%，如果外层无高度，需要自定义设置height属性
 * 3. 通过 autoCompleterList 配置自动提示关键字
 * 4. 通过 hiddenVerifyBtn、hiddenFormatterBtn可隐藏底部操作按钮
 * 5. 通过 theme 配置编辑器主题，例如：
 *    5.1 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
 *    5.2 配置 theme = xxxx
 * ```
 */
export declare const AceEditorGroovy: (props: AceEditorGroovyProps) => import("react").JSX.Element;
export type AceEditorJavaProps = Omit<IAceEditorProps, "mode" | "value" | "onChange" | "theme"> & {
	/** 编辑器高度，默认值：100%，可输入值例如 300px、100% */
	height?: string;
	value?: string | TPlainObject | TPlainObject[];
	onChange?: (value?: string | TPlainObject | TPlainObject[]) => void;
	/** 配置输入自动提示关键字 */
	autoCompleterList?: {
		name: string;
		desc?: string;
	}[];
	/**
	 * 编辑器主题配置，例如：github、terminal、xcode
	 * ```
	 * 1. 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
	 * 2. 配置 theme = xxxx
	 * ```
	 */
	theme?: string;
};
/**
 * java编辑器
 * ```
 * 1. 受控组件，需要使用value、onChange配合显示数据
 * 2. heigth 默认为100%，如果外层无高度，需要自定义设置height属性
 * 3. 通过 autoCompleterList 配置自动提示关键字
 * 4. 通过 hiddenVerifyBtn、hiddenFormatterBtn可隐藏底部操作按钮
 * 5. 通过 theme 配置编辑器主题，例如：
 *    5.1 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
 *    5.2 配置 theme = xxxx
 * ```
 */
export declare const AceEditorJava: (props: AceEditorJavaProps) => import("react").JSX.Element;
export type AceEditorJsonProps = Omit<IAceEditorProps, "mode" | "value" | "onChange" | "theme"> & {
	/** 编辑器高度，默认值：100%，可输入值例如 300px、100% */
	height?: string;
	value?: string | TPlainObject | TPlainObject[];
	onChange?: (value?: string | TPlainObject | TPlainObject[]) => void;
	/** 配置输入自动提示关键字 */
	autoCompleterList?: {
		name: string;
		desc?: string;
	}[];
	/** 是否隐藏【验证数据】按钮 */
	hiddenVerifyBtn?: boolean;
	/** 是否隐藏内部验证异常文案 */
	hiddenErrorMsg?: boolean;
	/**
	 * 编辑器主题配置，例如：github、terminal、xcode
	 * ```
	 * 1. 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
	 * 2. 配置 theme = xxxx
	 * ```
	 */
	theme?: string;
	/** 底部额外布局 */
	footerExtraRender?: (children: ReactElement) => ReactElement;
	footerStyle?: CSSProperties;
};
/**
 * Json编辑器
 * ```
 * 1. 受控组件，需要使用value、onChange配合显示数据
 * 2. heigth 默认为100%，如果外层无高度，需要自定义设置height属性
 * 3. 通过 autoCompleterList 配置自动提示关键字
 * 4. 通过 hiddenVerifyBtn 配置隐藏底部操作按钮
 * 5. 通过 theme 配置编辑器主题，例如：
 *    5.1 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
 *    5.2 配置 theme = xxxx
 * ```
 */
export declare const AceEditorJson: (props: AceEditorJsonProps) => import("react").JSX.Element;
export type AceEditorMysqlProps = Omit<IAceEditorProps, "theme" | "mode" | "value" | "onChange"> & {
	/** 编辑器高度，默认值：100%，可输入值例如 300px、100% */
	height?: string;
	value?: string;
	onChange?: (value?: string) => void;
	/** 配置输入自动提示关键字 */
	autoCompleterList?: {
		name: string;
		desc?: string;
	}[];
	/** 隐藏【美化】按钮 */
	hiddenFormatterBtn?: boolean;
	/**
	 * 编辑器主题配置，例如：github、terminal、xcode
	 * ```
	 * 1. 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
	 * 2. 配置 theme = xxxx
	 * ```
	 */
	theme?: string;
	/** 底部额外布局 */
	footerExtraRender?: (children: ReactElement) => ReactElement;
	footerStyle?: CSSProperties;
};
export declare const AceEditorMysql: (props: AceEditorMysqlProps) => import("react").JSX.Element;
export type AceEditorXmlProps = Omit<IAceEditorProps, "mode" | "value" | "onChange" | "theme"> & {
	/** 编辑器高度，默认值：100%，可输入值例如 300px、100% */
	height?: string;
	value?: string | TPlainObject | TPlainObject[];
	onChange?: (value?: string | TPlainObject | TPlainObject[]) => void;
	/** 配置输入自动提示关键字 */
	autoCompleterList?: {
		name: string;
		desc?: string;
	}[];
	/** 隐藏【验证数据】按钮 */
	hiddenVerifyBtn?: boolean;
	/** 是否隐藏内部验证异常文案 */
	hiddenErrorMsg?: boolean;
	/** 隐藏【美化】按钮 */
	hiddenFormatterBtn?: boolean;
	/**
	 * 编辑器主题配置，例如：github、terminal、xcode
	 * ```
	 * 1. 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
	 * 2. 配置 theme = xxxx
	 * ```
	 */
	theme?: string;
	/** 底部额外布局 */
	footerExtraRender?: (children: ReactElement) => ReactElement;
	footerStyle?: CSSProperties;
};
/**
 * xml编辑器
 * ```
 * 1. 受控组件，需要使用value、onChange配合显示数据
 * 2. heigth 默认为100%，如果外层无高度，需要自定义设置height属性
 * 3. 通过 autoCompleterList 配置自动提示关键字
 * 4. 通过 hiddenVerifyBtn、hiddenFormatterBtn可隐藏底部操作按钮
 * 5. 通过 theme 配置编辑器主题，例如：
 *    5.1 顶部引入 import 'ace-builds/src-noconflict/theme-xxxx';
 *    5.2 配置 theme = xxxx
 * ```
 */
export declare const AceEditorXml: (props: AceEditorXmlProps) => import("react").JSX.Element;
export type AlertWrapperProps = AlertProps & {
	size?: "small" | "default" | "large";
};
/**
 * antd Alert 无法控制内边距，此组件扩展size属性
 */
export declare const AlertWrapper: (props: AlertWrapperProps) => import("react").JSX.Element;
export type AmountFenInputProps = Omit<InputNumberProps, "defaultValue"> & {
	value?: number;
	onChange?: (value?: number) => void;
};
export declare const AmountFenInput: (props: AmountFenInputProps) => import("react").JSX.Element;
export type AmountFenInputFormItemProps = FormItemProps & {
	inputNumberProps?: Omit<InputNumberProps, "value" | "onChange" | "defaultValue">;
};
/**
 * 分金额输入组件（集成了FormItem），入参为分，返回为分，显示为元
 * ```
 * 例如：
 *      <AmountFenInputFormItem
 *        inputNumberProps={{ placeholder: '请输入', style: { width: 'auto' } }}
 *        name="amount"
 *        label="金额"
 *      />
 * ```
 */
export declare const AmountFenInputFormItem: (props: AmountFenInputFormItemProps) => import("react").JSX.Element;
export type AnchorStepsProps = {
	steps: {
		id: string;
		title: string;
		content: ReactElement;
	}[];
	className?: string;
};
/**
 * 锚点步骤组件
 * @param props
 * @returns
 */
export declare const AnchorSteps: (props: AnchorStepsProps) => import("react").JSX.Element;
export type BlockLayoutProps = DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
/**
 * 块布局（控制light/dark模式下，块背景色和字体颜色）
 * ```
 * 1. light 模式
 *   网页背景色为 #1b1a1a（黑灰），此时块布局背景色为 #000（黑色），字体颜色rgba(255, 255, 255, 0.85)
 * 2. dark 模式
 *   网页背景色为 #f9f9f9（白灰），此时块布局背景色为 #FFF（白色），字体颜色rgba(0, 0, 0, 0.88)
 * ```
 * @param props
 * @returns
 */
export declare const BlockLayout: (props: BlockLayoutProps) => import("react").JSX.Element;
export type FormItemNamePath = string | number | Array<string | number>;
export type TLocale = "en" | "zh-cn";
export type TFbaLocale = {
	TreeWrapper?: {
		/** 数据加载异常默认文案 */
		requestError?: string;
	};
	FbaDialogModal?: {
		cancelText?: string;
	};
};
export declare const types: () => void;
export type ConfigProviderWrapperProps = Omit<ConfigProviderProps, "locale"> & {
	locale?: TLocale;
	/** 自定义国际化数据 */
	customLocaleMessage?: Partial<TFbaLocale>;
	/** 同 fbaHooks.useCopyRemoveSpace[ignoreClass]  */
	copyOperateIgnoreClass?: string[];
};
/**
 *  antd ConfigProvider 扩展类
 * ```
 * 1. 新增监听辅助行为，移除复制文本中前后空格能力
 * ```
 */
export declare const ConfigProviderWrapper: (props: ConfigProviderWrapperProps) => import("react").JSX.Element;
export type BootstrapProps = {
	/** 是否紧凑模式 */
	compact?: boolean;
	/** 是否drak模式 */
	dark?: boolean;
	children: ReactNode;
	configProviderProps?: ConfigProviderWrapperProps;
	/** @default zhCN */
	locale?: "en" | "zh-cn";
	/**
	 * 背景颜色配置
	 * ```
	 * 默认值：
	 * dark: { bgColor: '#1b1a1a', blockBgColor: '#000'  }
	 * light: { bgColor: '#f9f9f9', blockBgColor: '#FFF'  }
	 * ```
	 */
	bgColorConfig?: {
		dark?: {
			bgColor?: string;
			blockBgColor?: string;
		};
		light?: {
			bgColor?: string;
			blockBgColor?: string;
		};
	};
};
/**
 * 如果当前项目入口不使用@flatbiz/pro-layout，必须使用 Bootstrap 组件包装
 * ```
 * Bootstrap 内部
 * 1. 封装 antd App组件
 * 2. 封装 @flatbiz/antd FbaApp组件
 * 3. 适配 light/dark模式
 * 4. 封装 antd ConfigProvider 可配置主题
 * ```
 */
export declare const Bootstrap: (props: BootstrapProps) => import("react").JSX.Element;
export type TBoxBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
export interface ICommonReact {
	children?: ReactNode;
	className?: string;
	style?: CSSProperties;
}
export type Gutter = number | undefined | Partial<Record<TBoxBreakpoint, number>>;
export type GutterParams = Gutter | [
	Gutter,
	Gutter
];
/**
 * 监听盒子大小变化，返回当前的断点
 * @param dom
 * @returns
 */
export declare const useBoxBreakpoint: (dom: any) => {
	boxBreakpoint: TBoxBreakpoint;
	/**
	 * @deprecated
	 * 使用 haveWidth 替代
	 */
	isInit: boolean;
	/** width为0，或者不存在 */
	haveWidth: boolean;
};
declare const PresetDefaultGrid: {
	xs: number;
	sm: number;
	md: number;
	lg: number;
	xl: number;
	xxl: number;
};
export interface BoxRowProps {
	/**
	 * 在不同响应尺寸下的元素占位格数
	 * 应用到所有Col子元素上
	 */
	defaultGrid?: Partial<typeof PresetDefaultGrid>;
	/** 间距 */
	gutter?: GutterParams;
	/** flex 布局的垂直对齐方式 */
	align?: "top" | "middle" | "bottom" | "stretch";
	/** flex 布局的水平排列方式 */
	justify?: "start" | "end" | "center" | "space-around" | "space-between" | "space-evenly";
	/** 尺寸变化回调 */
	onBoxBreakpointChange?: (breakpoint: TBoxBreakpoint) => void;
}
export type BoxColProps = {
	/**
	 * 栅格占位格数
	 * span 优先级最高：配置了span后，其他的响应式配置将失效；
	 * 范围 0 ～ 24
	 * 为  0  相当于隐藏
	 * 为  24  相当于独占一行
	 */
	span?: number;
	/** 屏幕 < 576px  */
	xs?: number;
	/** 屏幕 ≥ 576px */
	sm?: number;
	/** 屏幕 ≥ 768px */
	md?: number;
	/** 屏幕 ≥ 992px */
	lg?: number;
	/** 屏幕 ≥ 1200px */
	xl?: number;
	/** 屏幕 ≥ 1600px */
	xxl?: number;
	/**
	 * 是否移除 外部包装div
	 * ```
	 * 1. 如果children 为数组，则此配置不生效
	 * 2. 如果移除，会在children中添加style和className（所以children组件必须要有style、className属性）
	 * ```
	 */
	removeWrapper?: boolean;
};
export declare const BoxGrid: {
	/**
	 *  网格响应式布局
	 *```
	 * 1. 应用场景：根据盒子大小决定内部元素的布局
	 * 2. 子元素只能是 BoxGrid.Col
	 */
	Row: import("react").FC<BoxRowProps & ICommonReact>;
	/**
	 * 网格响应式布局，
	 * 默认值：
	 * { xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 6 }
	 * xs={24} sm={12} md={12} lg={8} xl={8} xxl={6}
	 *```
	 * 1. 设置 span 栅格占位格数，0 ～ 24
	 * 2. grid 自定义响应式网格布局
	 * xs: 容器尺寸 < 576px
	 * sm: 容器尺寸 ≥ 576px
	 * md: 容器尺寸 ≥ 768px
	 * lg: 容器尺寸 ≥ 992px
	 * xl: 容器尺寸 ≥ 1200px
	 * xxl: 容器尺寸 ≥ 1600px
	 * ```
	 */
	Col: import("react").FC<BoxColProps & ICommonReact>;
	/**
	 * 获取栅格响应式布局的配置
	 * @param minSize 元素的最小可接受宽度
	 * @returns { xs: num, sm: num, md: num, lg: num, xl: num, xxl: num }
	 */
	getGridMapByRange: (minSize: number) => Record<TBoxBreakpoint, number>;
};
export type ButtonWrapperProps = Omit<ButtonProps, "onClick" | "color"> & {
	/** 当返回 Promise 时，按钮自动loading */
	onClick?: (e: React.MouseEvent<HTMLElement>) => Promise<TAny> | void;
	/** 重复点击间隙，单位毫秒 默认值：500 */
	debounceDuration?: number;
	/** 基于GLOBAL中elemAclLimits按钮权限列表，控制按钮显示、隐藏 */
	permission?: string;
	/** 是否隐藏按钮 */
	hidden?: boolean;
	/** loading 显示位置，默认值：left */
	loadingPosition?: "left" | "center";
	/** 移除按钮内边距，一般用于 type=link 类型下 */
	removeGap?: boolean;
	color?: string;
};
/**
 * antd Button包装组件
 * 1. 添加按钮 onClick 返回 Promise自动loading效果
 * 2. 内置 防抖 效果（在第一触发函数后，在指定时间内再次触发无效，即两次触发的时间间隙大于指定时间）
 * @param props
 * @returns
 */
export declare const ButtonWrapper: (props: ButtonWrapperProps) => import("react").JSX.Element | null;
export type DialogModalProps = Omit<ModalProps, "onOk" | "onCancel" | "getContainer" | "open" | "open" | "okButtonProps" | "cancelButtonProps" | "footer"> & {
	/**
	 * 内置尺寸，根据比例固定高度、宽度，默认：无
	 * ```
	 * 1. 如果自定义了width、bodyHeight属性，size中的height、width将对应失效
	 * 2. 不传、传null值可取消内置尺寸
	 * ```
	 */
	size?: "small" | "middle" | "large" | null;
	onOk?: (form: FormInstance, e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	onCancel?: (form: FormInstance, e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	content: string | ReactElement | ((form: FormInstance, operate: {
		onClose: TNoopDefine;
	}) => ReactElement);
	configProviderProps?: ConfigProviderWrapperProps;
	okHidden?: boolean;
	cancelHidden?: boolean;
	okButtonProps?: Omit<ButtonWrapperProps, "hidden" | "children" | "onClick">;
	cancelButtonProps?: Omit<ButtonWrapperProps, "hidden" | "children" | "onClick">;
	/**
	 * 设置modal body height 为当前窗口height的百分比，例如：30
	 * @deprecated 已失效，可通过size属性设置
	 * ```
	 * 1. 最大值：80
	 * 1. 设置bodyStyle.height 后，bodyHeightPercent失效
	 * ```
	 */
	bodyHeightPercent?: number;
	titleExtra?: ReactElement;
	/**
	 * null则隐藏footer
	 * ```
	 * extraData 为外部通过 useDialogModal.rerenderFooter 重新渲染footer携带的数据
	 * ```
	 */
	footer?: null | ReactElement | ReactElement[] | ((form: FormInstance, extraData?: TPlainObject) => ReactElement);
	/** 内容高度，为styles.body.height快捷配置，优先级低于styles.body.height */
	bodyHeight?: number;
};
/**
 * 居中弹框
 * ```
 * 1. 可嵌套使用
 * 2. 为什么不推荐使用
 *    dialogModal.open 打开的内容无法适配兼容自定义主题、无法适配兼容旧版浏览器、无法兼容国际化
 *    适配兼容旧版浏览器（https://ant-design.antgroup.com/docs/react/compatible-style-cn）
 * 3. 需要修改默认主题风格的场景，请使用
 *    const { appDialogModal } = FbaApp.useDialogModal();
 *    appDialogModal.open({})
 * 4. size属性可使用预设的弹窗尺寸（默认值middle），如果不使用内置尺寸可设置 size = null
 * ```
 */
export declare const dialogModal: {
	open: (props: DialogModalProps) => {
		close: () => void;
	};
	/**
	 * ```
	 * 1. 关闭最新弹框，如果有多个弹框只能关闭最后一个
	 * 2. 多个弹框主动关闭，只能使用 dialogModal.open()返回值中的close
	 * ```
	 */
	close: () => void;
	/**
	 * ```
	 * 1. rerenderFooter 携带指定数据重新渲染 footer，可用于切换footer中的按钮状态
	 * ```
	 */
	useDialogModal: () => {
		/** 重新渲染 footer， data为携带的数据，是footer的第二个参数  */
		rerenderFooter: (data?: TPlainObject) => void;
	};
};
export interface DropdownMenuItem extends Omit<ButtonProps, "color"> {
	text?: string | ReactElement;
	color?: string;
	onClick?: (event: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	permission?: string;
	needConfirm?: boolean;
	confirmMessage?: ReactNode;
	hidden?: boolean;
	confirmModalProps?: DialogModalProps;
	stopPropagation?: boolean;
}
export interface DropdownMenuWrapperProps extends Omit<DropdownProps, "menu"> {
	menuList: Array<DropdownMenuItem | null>;
	/** dropdown 设置弹框根节点在body下 */
	isFixed?: boolean;
}
/**
 * DropdownMenuWrapper
 * 升级 antd 5.5.1 后，Dropdown 中 Popconfirm弹框使用存在问题，所以在 @flatbiz/antd@4.2.49版本修改为使用dialogConfirm组件实现二次弹框确认功能
 * @param props
 * @returns
 * ```
 * 1. Dropdown默认弹框根节点在组件内部，通过isFixed=true可设置弹框根节点在body下
 * ```
 */
export declare const DropdownMenuWrapper: (props: DropdownMenuWrapperProps) => import("react").JSX.Element;
export interface ButtonOperateItem extends ButtonWrapperProps {
	/** hover 提示文字，isFold=true无效 */
	hoverTips?: string | ReactElement;
	/** hover 提示类型 默认：'tooltip' */
	tipsType?: "popover" | "tooltip";
	/** 按钮文案 */
	text?: string | ReactElement;
	/** 自定义按钮颜色 */
	color?: string;
	/** 是否需要二次弹框确认 */
	needConfirm?: boolean;
	/** 二次弹框确认文案  */
	confirmMessage?: ReactNode;
	popconfirmProps?: Pick<PopconfirmProps, "placement" | "okText" | "cancelText" | "trigger">;
	/** 是否折叠合拢 */
	isFold?: boolean;
	confirmModalProps?: DialogModalProps;
}
export interface ButtonOperateProps {
	className?: string;
	style?: CSSProperties;
	/**
	 * 如果数组中元素为ReactElement类型
	 * 1. 一般为antd Button组件，如果组件存在属性hidden=true、v-hidden=true，则会隐藏
	 * 2. 可配置 v-permission 权限值，例如 v-permission="add"
	 * 3. 任何confirm、disabled等状态在外部控制
	 * 3. 不支持fold效果
	 */
	operateList: Array<ButtonOperateItem | null | ReactElement>;
	/** 是否换行，默认true */
	wrap?: boolean;
	/** 隐藏图标Icon */
	foldIcon?: ReactElement;
	/** 按钮之间是否添加分隔符 */
	split?: boolean;
	/** 多个按钮的包装组件Space属性 */
	spaceProps?: SpaceProps;
	/** 间距，默认：10；split=true配置下无效（可通过spaceProps设置间距） */
	gap?: number;
	/** 折叠合拢属性 */
	dropdownMenuProps?: Omit<DropdownMenuWrapperProps, "menuList">;
}
export declare const ButtonOperateItemContent: (props: Pick<ButtonOperateItem, "hoverTips" | "tipsType"> & {
	content: ReactNode;
}) => import("react").JSX.Element;
/**
 * 按钮组合处理组件
 * ```
 * 1. operateList中存在ReactElement类型的元素，可通过配置 v-permission 属性来设置权限，例如 v-permission="add"
 * 2. operateList中存在ReactElement类型的元素，如果有hidden、v-hidden属性，值为true会隐藏
 *
 *
 * flatbiz/antd@4.2.49
 * 1. 替换 Fold 中 needConfirm交互，有 Popconfirm 改为 dialogConfirm组件实现二次弹框确认功能
 * 2. 修改原因：升级 antd 5.5.1 后，Dropdown 中 Popconfirm弹框组合使用存在问题
 * ```
 */
export declare const ButtonOperate: FC<ButtonOperateProps>;
export type CardLayoutProps = {
	/** 描述 */
	desc?: string | string[] | ReactElement | ReactElement[];
	/** 标题 */
	title?: string | ReactElement;
	/** 子标题，在标题右侧 */
	subTitle?: string | ReactElement;
	/**
	 * layoutType 布局类型
	 * ```
	 * 1. layer：分层布局
	 * 2. tight：紧凑布局（没有外边距）
	 * ```
	 */
	layoutType?: "layer" | "tight";
	/** 隐藏标题左侧符号 */
	titleLeftLine?: boolean;
	titleStyle?: CSSProperties;
	titleContentStyle?: CSSProperties;
	subTitleStyle?: CSSProperties;
	titleExtraStyle?: CSSProperties;
	contentStyle?: CSSProperties;
	/** 优先级大于 style padding */
	padding?: CSSProperties["padding"];
	/** 优先级大于 style width */
	width?: CSSProperties["width"];
	/** 优先级大于 style height */
	height?: CSSProperties["height"];
	/** 标题右侧布局 */
	titleExtra?: string | ReactElement;
	/** 当存在滚动条时，标题固定，滚动区域为内部部分 */
	titleFixed?: boolean;
	/**
	 * 间距尺寸
	 * 1. default = 15
	 * 2. small = 8
	 */
	size?: "default" | "small";
	onClick?: (event: any) => void;
	hidden?: boolean;
	children?: ReactNode;
	className?: string;
	style?: CSSProperties;
};
/**
 * 卡片结构布局，替代 SimpleLayout 组件
 * @param props
 * @returns
 * ```
 * 1. layoutType 布局类型
 *    layer：分层布局
 *    tight：紧凑布局（没有外边距）
 * ```
 */
export declare const CardLayout: {
	(props: CardLayoutProps): import("react").JSX.Element;
	defaultProps: {
		titleLeftLine: boolean;
		layoutType: string;
	};
};
/**
 * ```
 * 主要为了解决，标题固定，内容滚动
 * ```
 * @param props
 * @returns
 */
export declare const CardWrapper: (props: CardProps) => import("react").JSX.Element;
export type TRequestStatus = "request-init" | "request-progress" | "request-success" | "request-error" | "no-dependencies-params";
export type TRequestStatusProps = {
	status?: TRequestStatus;
	errorButton?: ReactElement;
	messageConfig?: Partial<Record<TRequestStatus, string>>;
	loading?: boolean;
};
export declare const RequestStatus: (props: TRequestStatusProps) => import("react").JSX.Element;
export type CascaderWrapperServiceConfig = {
	params?: TPlainObject;
	onRequest?: (params?: TAny) => TAny;
	/** 响应数据适配器 */
	onRequestResultAdapter?: (respData: TAny) => TPlainObject[];
	/** 必填字段设置 */
	requiredParamsKeys?: string[];
};
export type CascaderWrapperProps = Omit<CascaderProps<TAny>, "loading" | "notFoundContent" | "options" | "value" | "multiple" | "onChange" | "fieldNames"> & {
	/**
	 * 参数Key映射
	 * ```
	 * 1. 默认值：value=value、label=label、children=children
	 * 2. list 为 onRequest 返回数据中列表key值，可多级取值，例如： 'a.b.c'
	 * 3. 配置 serviceConfig.onRequestResultAdapter后，fieldNames.list配置失效
	 * 4. 如果没有配置list，可说明接口返回为数组
	 * ```
	 */
	fieldNames?: {
		list?: string;
		label?: string;
		value?: string;
		children?: string;
	};
	/**
	 * 请求服务需求的数据，当设置`selectorList`后无效果
	 */
	serviceConfig?: CascaderWrapperServiceConfig;
	onLabelRenderAdapter?: (dataItem: TPlainObject) => string | ReactElement;
	onSelectorListChange?: (dataList: TPlainObject[]) => void;
	/**
	 * 是否动态加载选项
	 */
	isDynamicLoad?: boolean;
	value?: string | number | Array<string | number> | LabelValueItem | LabelValueItem[];
	onChange?: (value?: string | number | Array<string | number>, selectedList?: TPlainObject[]) => void;
	/** 配置数据查询状态描述，比如有依赖字段描述 */
	requestMessageConfig?: TRequestStatusProps["messageConfig"];
	/**
	 * 选择数据响应类型（当用户选中后响应数据）,默认值：last
	 * ```
	 * 1. last 响应选中的最后一级数据
	 * 2. all 响应选中的多级数据
	 * ```
	 */
	responseType?: "last" | "all";
	/** 响应数据是否包含label、value */
	labelInValue?: boolean;
};
export type CascaderWrapperRefApi = {
	getCascaderList: () => TPlainObject[];
};
/**
 * 级联选择器包装组件
 * ```
 * 1. 数据源中 value 不能重复
 * 2. 不支持多选
 * 3. modelKey的配置是为了缓存数据，只缓存初始化数据，如果isDynamicLoad=true，动态获取的数据不再缓存
 * 4. onChange操作第一个参数返回叶子节点value（可配置返回多级），第二个参数返回选中的多级数据
 * 5. isDynamicLoad=true 会在请求中添加当前选中option的fieldNames.value为key的数据
 * 6. @flatbiz/antd@5.0.25 删除 modelKey 字段
 * 7. serviceConfig.params 参数发生变化时，会重新请求数据
 * ```
 */
export declare const CascaderWrapper: import("react").ForwardRefExoticComponent<Omit<CascaderProps<any, string | number | symbol, boolean>, "multiple" | "onChange" | "value" | "loading" | "notFoundContent" | "options" | "fieldNames"> & {
	/**
	 * 参数Key映射
	 * ```
	 * 1. 默认值：value=value、label=label、children=children
	 * 2. list 为 onRequest 返回数据中列表key值，可多级取值，例如： 'a.b.c'
	 * 3. 配置 serviceConfig.onRequestResultAdapter后，fieldNames.list配置失效
	 * 4. 如果没有配置list，可说明接口返回为数组
	 * ```
	 */
	fieldNames?: {
		list?: string;
		label?: string;
		value?: string;
		children?: string;
	};
	/**
	 * 请求服务需求的数据，当设置`selectorList`后无效果
	 */
	serviceConfig?: CascaderWrapperServiceConfig;
	onLabelRenderAdapter?: (dataItem: TPlainObject) => string | ReactElement;
	onSelectorListChange?: (dataList: TPlainObject[]) => void;
	/**
	 * 是否动态加载选项
	 */
	isDynamicLoad?: boolean;
	value?: string | number | Array<string | number> | LabelValueItem | LabelValueItem[];
	onChange?: (value?: string | number | Array<string | number>, selectedList?: TPlainObject[]) => void;
	/** 配置数据查询状态描述，比如有依赖字段描述 */
	requestMessageConfig?: TRequestStatusProps["messageConfig"];
	/**
	 * 选择数据响应类型（当用户选中后响应数据）,默认值：last
	 * ```
	 * 1. last 响应选中的最后一级数据
	 * 2. all 响应选中的多级数据
	 * ```
	 */
	responseType?: "last" | "all";
	/** 响应数据是否包含label、value */
	labelInValue?: boolean;
} & import("react").RefAttributes<CascaderWrapperRefApi>>;
export interface CommonPropsWithChildren<S extends TPlainObject = TPlainObject> {
	className?: string;
	style?: CSSProperties & Partial<S>;
	children?: ReactNode | undefined;
}
export type CheckListItemValue = string | number;
export type CheckListSelectedValue<T extends "multi" | "radio"> = T extends "multi" ? CheckListItemValue[] : CheckListItemValue;
export type CheckListProps<T extends "multi" | "radio"> = {
	multiple?: boolean;
	onChange?: (value: CheckListSelectedValue<T>, operateValue: CheckListItemValue) => void;
	onPreChange?: (value: CheckListItemValue) => Promise<void>;
	value?: CheckListSelectedValue<T>;
	defaultValue?: CheckListSelectedValue<T>;
	beforeExtra?: ReactNode;
	afterExtra?: ReactNode;
	stopPropagation?: boolean;
	required?: boolean;
} & CommonPropsWithChildren;
export type CheckListItemContentProps = {
	checked?: boolean;
	disabled?: boolean;
	onClick?: (event: any) => void;
	className?: string;
	readonly?: boolean;
	style?: CSSProperties;
};
export type CheckListItemProps = {
	value: CheckListItemValue;
	disabled?: boolean;
	readonly?: boolean;
	children: (data: CheckListItemContentProps) => ReactElement;
	className?: string;
	style?: CSSProperties;
};
export declare const CheckList: (<T extends "multi" | "radio">(props: CheckListProps<T>) => import("react").JSX.Element) & {
	Item: (props: CheckListItemProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null;
};
export type CheckboxWrapperProps = Omit<CheckboxProps, "checked" | "defaultChecked" | "onChange"> & {
	value?: string | number | boolean;
	checkedValue: string | number | boolean;
	unCheckedValue: string | number | boolean;
	onChange?: (value: string | number | boolean) => void;
};
/**
 * 解决 Checkbox 只能接收boolean的限制，与Form.Item结合使用最佳
 * ```
 * 1. value 为状态值，不局限于boolean，可以为 [string | number | boolean]
 * 2. checkedValue 选中值
 * 3. unCheckedValue 未选中值
 * 4. 与 Form.Item 结合使用，不再需要配置 valuePropName
 *     <Form.Item name="fieldName">
 *       <CheckboxWrapper checkedValue={2} unCheckedValue={1} />
 *     </Form.Item>
 * ```
 */
export declare const CheckboxWrapper: (props: CheckboxWrapperProps) => import("react").JSX.Element;
export type ColorPickerWrapperProps = Omit<ColorPickerProps, "value" | "onChange"> & {
	/** 格式：#1677ff */
	value?: string;
	/** 转换成 hex 格式颜色字符串，返回格式如：#1677ff  */
	onChange?: (hex?: string) => void;
	viewMinWidth?: number;
};
export declare const ColorPickerWrapper: (props: ColorPickerWrapperProps) => import("react").JSX.Element;
export type CssHoverProps = {
	children: ReactElement | ReactElement[];
} & Pick<CommonPropsWithChildren<{
	"--v-css-hover-bgcolor": CSSProperties["backgroundColor"];
	"--v-css-hover-opacity": CSSProperties["opacity"];
	"--v-css-hover-border-radius": CSSProperties["borderRadius"];
}>, "style" | "children">;
/**
 * css hover 效果
 * ```
 * 1. 当children为数组时，会为children添加父级（会产生新节点）
 * 2. 当children为单个元素时，会在children元素上添加className、style（不会产生新节点）
 * ```
 * @param props
 * @returns
 */
export declare const CssNodeHover: (props: CssHoverProps) => import("react").JSX.Element;
export type DataRenderProps = {
	isEmpty: boolean | (() => boolean);
	empty?: ReactElement;
	emptyText?: string | ReactElement;
	emptyStyle?: CSSProperties;
	emptyClassName?: string;
	children: ReactNode;
};
/**
 * 数据渲染，内置处理数据为空渲染
 * ```
 * 1. 配置 empty 后，emptyText、emptyStyle、emptyClassName将失效
 * 2. 使用方式，例如
 *    <DataRender isEmpty={list.length === 0}>
 *      <Fragment>
 *        {list.map((item) => {
 *          return (
 *            <div key={item}>....</div>
 *          );
 *        })}
 *      </Fragment>
 *    </DataRender>
 * ```
 */
export declare const DataRender: (props: DataRenderProps) => import("react").JSX.Element;
export type TDayjsDateType = "YYYY-MM-DD HH:mm:ss" | "YYYY-MM-DD HH:mm" | "YYYY-MM-DD HH" | "YYYY-MM-DD" | (string & {});
export type TDayjsTimeType = "HH:mm:ss" | "HH:mm" | "HH" | "mm:ss" | "mm" | "ss" | (string & {});
export type DatePickerWrapperProps = Omit<PickerProps<TAny>, "value" | "onChange" | "format"> & {
	/** 默认格式为 'YYYY-MM-DD' */
	value?: string;
	onChange?: (value?: string) => void;
	disabledDateConfig?: {
		minDate?: TDayjsDateType;
		maxDate?: TDayjsDateType;
		/** 禁用 小时 刻度列表，与日期无关  */
		disabledHourList?: number[];
		/** 禁用 分钟 刻度列表，与日期无关 */
		disabledMinuteList?: number[];
		/** 禁用 秒钟 刻度列表，与日期无关 */
		disabledSecondList?: number[];
	};
	/** 可自定义格式 */
	format?: TDayjsDateType;
	/** value 输出适配 */
	outputNormalize?: (value?: TAny) => TAny;
	/** value 输入适配 */
	inputNormalize?: (value?: TAny) => string | undefined;
};
/**
 * DatePicker包装组件
 * ```
 * 1. value 默认格式为 'YYYY-MM-DD'，可以通过 inputNormalize 来进行自定义转换
 * 2. onChange返回类型 string，可以通过 outputNormalize 来进行自定义转换
 * 3. 默认格式化类型 YYYY-MM-DD； 当showTime===true时，默认格式化类型 DayjsDateTypeEnum.YMDHms；其他格式化类型自定义format
 * 4. 设置 disabledDate 后，disabledDateConfig配置将失效
 * 5. 设置 disabledTime 后，内置的disabledTime逻辑将失效
 * ```
 */
export declare const DatePickerWrapper: (props: DatePickerWrapperProps) => import("react").JSX.Element;
export type RangePickerDateProps = GetProps<typeof DatePicker.RangePicker>;
export type DateRangePickerWrapperProps = Omit<RangePickerDateProps, "value" | "onChange" | "onCalendarChange" | "format"> & {
	value?: [
		string,
		string
	];
	onChange?: (value?: [
		string,
		string
	]) => void;
	/**
	 * 1. minDate、maxDate 与 format格式相同；默认：YYYY-MM-DD
	 * 2. maxDays 最大可选的天数
	 */
	disabledDateConfig?: {
		minDate?: TDayjsDateType;
		maxDate?: TDayjsDateType;
		maxDays?: number;
		/** 禁用 小时 刻度列表，与日期无关  */
		disabledHourList?: number[];
		/** 禁用 分钟 刻度列表，与日期无关 */
		disabledMinuteList?: number[];
		/** 禁用 秒钟 刻度列表，与日期无关 */
		disabledSecondList?: number[];
	};
	format?: TDayjsDateType;
	/** value 输出适配 */
	outputNormalize?: (value: [
		string,
		string
	]) => TAny;
	/** value 输入适配 */
	inputNormalize?: (value?: TAny) => [
		string,
		string
	] | undefined;
};
/**
 * DatePicker.RangePicker包装组件
 * ```
 * 1. value类型为 [string, string],可以通过 inputNormalize来进行自定义转换
 * 2. onChange返回类型 [string, string]，可以通过 outputNormalize来进行自定义转换
 * 3. 默认格式化类型 YYYY-MM-DD； 当showTime===true时，默认格式化类型YYYY-MM-DD HH:mm:ss；其他格式化类型自定义format
 * 4. 可设置disabledDateConfig，来控制日期项的disbaled状态
 * 5. 设置 disabledDate 后，disabledDateConfig配置将失效
 * 6. 设置 disabledTime 后，内置的disabledTime逻辑将失效
 *
 * TODO: 存在场景缺陷，当设置maxDays、showTime后，在选择单个日期不通过确认按钮直接切换输入框，无法获取回调，无法约束disabledDate
 * ```
 */
export declare const DateRangePickerWrapper: (props: DateRangePickerWrapperProps) => import("react").JSX.Element;
export type TFormLayoutPreClassNameProps = {
	/**
	 * label宽度，Form内部所有FormItem label都生效
	 * ```
	 * 1. 可设置数值
	 * 2. 可设置`auto`自适应
	 * ```
	 */
	labelWidth?: "auto" | "70" | "80" | "90" | "100" | "110" | "120" | "130" | "140" | "150" | "160" | "170" | "180" | "190" | "200";
	/** labelItem 竖直布局 */
	labelItemVertical?: boolean;
	/** label 对齐方式 */
	labelAlign?: "left" | "right";
	/** formItem之间竖直间距，默认值：24 */
	formItemGap?: "24" | "15" | "8" | "5" | "0";
	/**
	 * className 中可能会包含 preDefinedClassName.form.xx，优先级大于 labelWidth、labelItemVertical、labelAlign、formItemGap
	 */
	className?: string;
};
export type TFormItemLayoutPreClassNameProps = {
	/**
	 * label宽度，Form内部所有FormItem label都生效
	 * ```
	 * 1. 可设置数值
	 * 2. 可设置`auto`自适应
	 * ```
	 */
	labelWidth?: "auto" | "70" | "80" | "90" | "100" | "110" | "120" | "130" | "140" | "150" | "160" | "170" | "180" | "190" | "200";
	/** labelItem 竖直布局 */
	labelItemVertical?: boolean;
	/** label 对齐方式 */
	labelAlign?: "left" | "right";
	/**
	 * className 中可能会包含 preDefinedClassName.formItem.xx，优先级大于 labelWidth、labelItemVertical、labelAlign
	 */
	className?: string;
};
export type FormItemWrapperProps = Omit<FormItemProps, "hidden" | "children" | "noStyle"> & TFormItemLayoutPreClassNameProps & {
	wrapper?: (children: ReactNode) => ReactElement;
	/** 设置wrapper后，before、after失效 */
	before?: ReactNode;
	/** 设置wrapper后，before、after失效 */
	after?: ReactNode;
	/** 设置 before、after 属性的包装结构style */
	beforeAfterStyle?: CSSProperties;
	/** value 序列化处理 */
	inputNormalize?: (value?: TAny) => TAny;
	/**
	 * onChange 参数序列化处理
	 * 如果设置 normalize 属性，outputNormalize将失效
	 */
	outputNormalize?: (value?: TAny) => TAny;
	/**
	 * 隐藏 Form.Item，同时清除 Form.Item 值
	 * ```
	 * 1.与 dependencies 属性配合使用，可实现当前FormItemWrapper的显示隐藏
	 * 2.提交不校验rules
	 * ```
	 */
	isClear?: boolean | ((formValues: TPlainObject) => boolean);
	/**
	 * 隐藏 Form.Item，不会清除 Form.Item 值
	 * ```
	 * 1.与 dependencies 属性配合使用，可实现当前FormItemWrapper的显示隐藏
	 * 2.提交会校验rules
	 * ```
	 */
	hidden?: boolean | ((formValues: TPlainObject) => boolean);
	/**
	 * 栅格占位格数，最大值：24
	 * ```
	 * 1. 当前FormItemWrapper处在 EasyForm 直接子节点中有效，即FormItemWrapper在EasyForm栅格中的占位格数；
	 * 2. 父节点使用属性值，当前节点不使用属性值
	 * ```
	 */
	span?: number;
	/** 不支持函数式写法，如果需要使用dependencies获取表单值，可使用FormItemWrapperDependencies 组件  */
	children?: ReactNode;
	/**
	 * ```
	 * 1. 设置noStyle后，可能会导致 FromItemWrapper 在 EasyFrom 内部渲染网格布局时出现异常
	 * 2. 在FormItemWrapper中使用 dependencies 逻辑不需要设置 noStyle
	 * ```
	 */
	noStyle?: boolean;
};
/**
 * 对 Form.Item 包装处理
 * ```
 * 1. 为 children 增加 before、after
 * 2. 对输入、输出数据进行序列化处理
 * 3. 内置布局样式使用 preDefinedClassName.formItem
 * 4. 设置隐藏域（不清除字段值） 使用hidden，存在依赖逻辑，可与dependencies属性配合使用
 * 5. 设置隐藏域（清除字段值）使用isClear，存在依赖逻辑，可与dependencies属性配合使用
 * 6. 不支持noStyle属性、children不支持函数写法、如果需要获取依赖字段值，可使用 FormItemWrapperDependencies 组件
 * 7. 设置noStyle后，可能会导致 FromItemWrapper 在 EasyFrom 内部渲染网格布局时出现异常
 *
 *
 * ** 依赖其他字段 自身切换显示隐藏 **
 * <FormItemWrapper
 *  label="label"
 *  name="xx1"
 *  dependencies={['type']}
 *  isClear={(values)  => {
 *    return values.type == 1
 *  }}>
 *  <Input placeholder="请输入" />
 * </FormItemWrapper>
 *
 * 如果只是想获取依赖字段值，可使用 FormItemWrapperDependencies 组件
 * ```
 */
export declare const FormItemWrapper: {
	(props: FormItemWrapperProps): import("react").JSX.Element;
	domTypeName: string;
};
export type DateRangePickerWrapperFormItemProps = Omit<FormItemWrapperProps, "name"> & {
	/**
	 * 开始的时间name
	 */
	startName: FormItemNamePath;
	/**
	 * 结束的时间name
	 */
	endName: FormItemNamePath;
	/**
	 * 如果 DateRangePickerWrapperFormItem 在Form.List场景下 必传
	 * @deprecated 使用 formListCompleteName 配置
	 */
	formListName?: Array<string | number>;
	/**
	 * 前端 formItem 前缀FormName，当 TimeRangePickerWrapperFormItem 处在Form.List场景下，必传
	 * ```
	 * 例如 处在formList内部时，则 formListCompleteName = ['xxxxList']
	 * 例如 处在formList套formList内部时，则 formListCompleteName = ['xxxxList', 索引值, 'xxxxList2']
	 * ```
	 */
	formListCompleteName?: Array<string | number> | string;
	dateRangePickerWrapperProps?: DateRangePickerWrapperProps;
};
/**
 * 包含了Form.Item组件的时间区间选择组件，时间区间组件可以定义成两个字段操作，不用再通过数组处理
 * ```
 * 1. 会在form中产生一个 `__#invalid_date_xxxx_xxxx` 的无效字段，可以直接忽略
 * 2. 设置日期格式 dateRangePickerWrapperProps={{ format: 'YYYY-MM-DD HH:mm' }}
 * 使用场景：
 * 1. 基础使用场景
 *    <DateRangePickerWrapperFormItem startName={'date1'} endName={'date2'} />
 * 2. Form.List 内部使用
 *    <FormListWrapper name="dataList" prevCompleteName={[]}>
 *      {(data) => {
 *        return <DateRangePickerWrapperFormItem formListCompleteName={data.prevCompleteName} startName={data.getInsideFormItemName('date1')} endName={data.getInsideFormItemName('date2')} />
 *      }}
 *    </FormListWrapper>
 * 3. Form.List 套 Form.List 内部使用
 *    <FormListWrapper name="dataList" prevCompleteName={[]}>
 *      {(data) => {
 *        return <FormListWrapper name={data.getInsideFormItemName('childrenList')} prevCompleteName={data.prevCompleteName}>
 *          {(data2) => {
 *            return <DateRangePickerWrapperFormItem formListCompleteName={data2.prevCompleteName} startName={data2.getInsideFormItemName('date1')} endName={data2.getInsideFormItemName('date2')} />
 *          }}
 *        </FormListWrapper>
 *      }}
 *    </FormListWrapper>
 * ```
 */
export declare const DateRangePickerWrapperFormItem: (props: DateRangePickerWrapperFormItemProps) => import("react").JSX.Element;
/** 删除节点，点击后会显示二次确认点击 */
export declare const DeleteNode: (props: {
	onDelete: () => void;
	/** 默认图标 */
	icon?: ReactElement;
	/** 确认图标 */
	confirmIcon?: ReactElement;
	/** 是否隐藏 */
	hidden?: boolean;
	style?: CSSProperties;
	className?: string;
}) => import("react").JSX.Element;
export type DialogAlertProps = Omit<DialogModalProps, "onOk" | "cancelHidden" | "cancelButtonProps" | "onCancel" | "onClick"> & {
	onClick?: (e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
};
/**
 * 确认弹框
 * ```
 * 1. 可嵌套使用
 * 2. 为什么不推荐使用
 *    dialogAlert.open 打开的内容无法适配兼容自定义主题、无法适配兼容旧版浏览器、无法兼容国际化
 *    适配兼容旧版浏览器（https://ant-design.antgroup.com/docs/react/compatible-style-cn）
 * 3. 需要修改默认主题风格的场景，请使用
 *    const { appDialogAlert } = FbaApp.useDialogAlert();
 *    appDialogAlert.open({})
 * ```
 */
export declare const dialogAlert: {
	open: (props: DialogAlertProps) => {
		close: () => void;
	};
};
/**
 * 确认弹框
 * ```
 * 1. 可嵌套使用
 * 2. 为什么不推荐使用
 *    dialogConfirm.open 打开的内容无法适配兼容自定义主题、无法适配兼容旧版浏览器、无法兼容国际化
 *    适配兼容旧版浏览器（https://ant-design.antgroup.com/docs/react/compatible-style-cn）
 * 3. 需要修改默认主题风格的场景，请使用
 *    const { appDialogConfirm } = FbaApp.useDialogConfirm();
 *    appDialogConfirm.open({})
 * ```
 */
export declare const dialogConfirm: {
	open: (props: DialogModalProps) => {
		close: () => void;
	};
};
export type DialogDrawerProps = Omit<DrawerProps, "onOk" | "onCancel" | "getContainer" | "open" | "open" | "footer" | "extra"> & {
	okText?: string | ReactElement;
	cancelText?: string | ReactElement;
	onOk?: (form: FormInstance, e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	onCancel?: (form: FormInstance, e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	content: string | ReactElement | ((form: FormInstance, operate: {
		onClose: TNoopDefine;
	}) => ReactElement);
	configProviderProps?: ConfigProviderWrapperProps;
	okButtonExtraProps?: Omit<ButtonWrapperProps, "onClick" | "children" | "loading">;
	cancelButtonExtraProps?: Omit<ButtonWrapperProps, "onClick" | "children">;
	okHidden?: boolean;
	cancelHidden?: boolean;
	/** 设置操作区域位置 */
	operatePosition?: "header" | "footer";
	/** 右上角自定义内容，如果operatePosition=header，此设置无效 */
	extra?: ReactNode | ((form: FormInstance) => ReactElement);
	/**
	 * ```
	 * 1. 自定义弹框操作区域，通过 operatePosition 配置可以自定义位置
	 * 2. extraData 为外部通过 useDialogModal.rerenderFooter 重新渲染footer携带的数据
	 * ```
	 */
	operateRender?: (form: FormInstance, extraData?: TPlainObject) => ReactElement;
};
/**
 * 抽屉弹框
 * ```
 * 1. 可嵌套使用
 * 2. 为什么不推荐使用
 *    dialogDrawer.open 打开的内容无法适配兼容自定义主题、无法适配兼容旧版浏览器、无法兼容国际化
 *    适配兼容旧版浏览器（https://ant-design.antgroup.com/docs/react/compatible-style-cn）
 * 3. 需要修改默认主题风格的场景，请使用
 *    const { appDialogDrawer } = FbaApp.useDialogDrawer();
 *    appDialogDrawer.open({})
 * ```
 */
export declare const dialogDrawer: {
	open: (props: DialogDrawerProps) => {
		close: () => void;
	};
	/**
	 * ```
	 * 1. 关闭最新弹框，如果有多个弹框只能关闭最后一个
	 * 2. 多个弹框主动关闭，只能使用 dialogDrawer.open()返回值中的close
	 * ```
	 */
	close: () => void;
	/**
	 * ```
	 * 1. rerenderFooter 携带指定数据重新渲染 footer，可用于切换footer中的按钮状态
	 * ```
	 */
	useDialogDrawer: () => {
		/** 重新渲染 footer， data为携带的数据，是footer的第二个参数  */
		rerenderFooter: (data?: TPlainObject) => void;
	};
};
export type DialogDrawerContentProps = {
	footer?: (data: {
		onClose: () => void;
	}) => ReactElement;
	footerStyle?: CSSProperties;
	children?: ReactNode;
	okHidden?: boolean;
	cancelHidden?: boolean;
	okButtonExtraProps?: Omit<ButtonWrapperProps, "onClick" | "children" | "loading">;
	cancelButtonExtraProps?: Omit<ButtonWrapperProps, "onClick" | "children" | "loading">;
	okText?: string | ReactElement;
	cancelText?: string | ReactElement;
	onOk?: (e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	onCancel?: (e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
};
/**
 * 当dialogDrawer底部操作按钮在业务content内部时，使用
 * ```
 * 1. 只能与 dialogDrawer 配合使用；与 FbaApp.useDialogDrawer 配合使用无效
 * 2. 设置 footer 后，okHidden、cancelHidden、okButtonExtraProps、cancelButtonExtraProps、okText、cancelText、onOk、onCancel全部失效
 * ```
 */
export declare const DialogDrawerContent: (props: DialogDrawerContentProps) => import("react").JSX.Element;
export type DialogLoadingProps = {
	className?: string;
	message?: string;
	mask?: boolean;
};
/**
 * Loading弹框
 * ```
 * 1. 可嵌套使用
 * 2. 为什么不推荐使用
 *    dialogLoading.open 打开的内容无法适配兼容自定义主题、无法适配兼容旧版浏览器、无法兼容国际化
 *    适配兼容旧版浏览器（https://ant-design.antgroup.com/docs/react/compatible-style-cn）
 * 3. 需要修改默认主题风格的场景，请使用
 *    const { appDialogLoading } = FbaApp.useDialogLoading();
 *    appDialogLoading.open({})
 * ```
 */
export declare const dialogLoading: {
	open: (props?: DialogLoadingProps) => {
		close: () => void;
	};
	/**
	 * ```
	 * 1. 关闭最新弹框，如果有多个弹框只能关闭最后一个
	 * 2. 多个弹框主动关闭，只能使用 dialogModal.open()返回值中的close
	 * ```
	 */
	close: () => void;
};
export type DialogPreviewImageProps = {
	imageUrl: string;
};
/** 图片预览 */
export declare const dialogPreviewImage: {
	show: (props: DialogPreviewImageProps) => {
		close: () => void;
	};
	hiden: () => void;
};
export type DragCollapseItemKey = number | string;
export type DragCollapseItem = {
	key: DragCollapseItemKey;
	header: ReactNode;
	content: ReactElement;
};
export type DragCollapseProps = {
	className?: string;
	style?: CSSProperties;
	/** 面板数据 */
	items: DragCollapseItem[];
	/** 拖拽面板回调 */
	onDropChange: (items: DragCollapseItem[]) => void;
	/** 手风琴模式，只允许单个内容区域展开 */
	accordion?: boolean;
	/** 当前激活 tab 面板的key  */
	activeKey?: DragCollapseItemKey | DragCollapseItemKey[];
	/** 所有子面板是否可折叠或指定可折叠触发区域，可选: header | icon | disabled */
	collapsible?: CollapseProps["collapsible"];
	/** 初始化选中面板的 key */
	defaultActiveKey?: DragCollapseItemKey[];
	/** 自定义切换图标	 */
	expandIcon?: CollapseProps["expandIcon"];
	/** 设置图标位置，可选：start | end */
	expandIconPosition?: CollapseProps["expandIconPosition"];
	/** 设置折叠面板大小	 */
	size?: CollapseProps["size"];
	/** 隐藏拖拽图标，默认不隐藏 */
	hideDragIcon?: boolean;
	/** 设置拖拽图标 */
	dragIcon?: ReactElement;
	/** 切换面板的回调	 */
	onChange?: (activeKey?: DragCollapseItemKey | DragCollapseItemKey[]) => void;
};
/**
 * 可拖拽 折叠面板
 * @param props
 * @returns
 */
export declare const DragCollapse: (props: DragCollapseProps) => import("react").JSX.Element;
export type DragCollapseFormListContentProps = {
	/** Form.List item fieldData */
	formListFieldData: FormListFieldData;
	/** 当前阶段 完整 formItem name */
	formStageCompleteName: Array<string | number>;
	/** Form.List 操作项 */
	operation: FormListOperation;
	uid: string | number;
	/** 获取当前FormList 内部 Form.Item name */
	getInsideFormItemName: (key: string | string[]) => Array<string | number>;
	/** 获取当前 FormList Item 数据 */
	getInsideFormItemData: () => TPlainObject;
	/** 索引 */
	index: number;
};
export type DragCollapseFormListHeaderProps = DragCollapseFormListContentProps;
export type DragCollapseFormListProps = {
	/** formList item 数据中的唯一值，默认值：uid */
	uidFieldName?: string;
	className?: string;
	style?: CSSProperties;
	/** formList name */
	formListName: string | number | (string | number)[];
	/** 拖拽面板回调 */
	onDropChange?: (items: TPlainObject[]) => void;
	/** 手风琴模式，只允许单个内容区域展开 */
	accordion?: boolean;
	/** 当前激活 tab 面板的key  */
	activeKey?: number | number[];
	/** 所有子面板是否可折叠或指定可折叠触发区域，可选: header | icon | disabled */
	collapsible?: CollapseProps["collapsible"];
	/** 初始化选中面板的 key */
	defaultActiveKey?: number[];
	/** 自定义切换图标	 */
	expandIcon?: CollapseProps["expandIcon"];
	/** 设置图标位置，可选：start | end */
	expandIconPosition?: CollapseProps["expandIconPosition"];
	/** 设置折叠面板大小	 */
	size?: CollapseProps["size"];
	/** 设置拖拽图标 */
	dragIcon?: ReactElement;
	/** 切换面板的回调	 */
	onChange?: (activeKey?: number | string | (number | string)[]) => void;
	/** 禁用拖拽，拖拽图标隐藏 */
	dragDisabled?: boolean;
	/** 折叠面板 header 渲染 */
	header: (data: DragCollapseFormListHeaderProps) => ReactElement;
	/** 折叠面板 content 渲染 */
	content: (data: DragCollapseFormListContentProps) => ReactElement;
	/** 设置面板禁止拖拽   */
	getItemDragDisabled?: (uid: string | number, index: number) => boolean;
	rules?: FormListProps["rules"];
};
/**
 * 可拖拽 折叠面板+FormList
 * ```
 * 1. FormList数组中必须要有唯一值字段，默认值字段名称uid，可通过uidFieldName自定义设置名称
 * ```
 */
export declare const DragCollapseFormList: (props: DragCollapseFormListProps) => import("react").JSX.Element;
export type FormWrapperProps<Values = any> = TFormLayoutPreClassNameProps & FormProps<Values> & {
	children: ReactNode;
};
/**
 * Form 包装组件，添加对formItem的布局控制
 * ```
 * 1. 内置布局样式使用 preDefinedClassName.form
 * ```
 */
export declare const FormWrapper: (props: FormWrapperProps) => import("react").JSX.Element;
export type EasyFormProps = Omit<FormWrapperProps, "children"> & {
	/**
	 * 定义一行显示几列（当外层宽度尺寸大于 992px（lg） 时，一行显示几列）, 默认值：3
	 * ```
	 * 1. 当外层宽度尺寸小于992px（lg），为xs、sm、md情况下不受column值影响（column=1除外）
	 * 2. 宽度尺寸定义
	 *    xs: 宽度 < 576px
	 *    sm: 宽度 ≥ 576px
	 *    md: 宽度 ≥ 768px
	 *    lg: 宽度 ≥ 992px
	 *    xl: 宽度 ≥ 1200px
	 *    xxl: 宽度 ≥ 1600px
	 * 3. 列数尺寸定义
	 *  {
	 *    1: { xs: 24, sm: 24, md: 24, lg: 24, xl: 24, xxl: 24 },
	 *    2: { xs: 24, sm: 12, md: 12, lg: 12, xl: 12, xxl: 12 },
	 *    3: { xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 8 },
	 *    4: { xs: 24, sm: 12, md: 12, lg: 6, xl: 6, xxl: 6 },
	 *  };
	 * ```
	 */
	column?: 1 | 2 | 3 | 4;
	/**
	 * 强制定义一行显示几列，不考虑响应式
	 * ```
	 * 1. 优先级大于column
	 * 2. 建议优先使用column配置
	 * ```
	 */
	forceColumn?: 1 | 2 | 3 | 4;
	/**
	 * Form显示宽度，可数值、可百分比；在小屏幕尺寸（xs、sm）上无效
	 */
	width?: number | string;
	/** 网格间距 */
	gridGutter?: BoxRowProps["gutter"];
	children: ReactNode;
	/**
	 * 是否为纯净模式，对EasyForm的子节点不做任何包装处理
	 */
	isPure?: boolean;
	/**
	 * true: 当前EasyForm组件不使用Antd Form包裹，可在Form、EasyForm、FormWrapper内部使用
	 */
	nonuseFormWrapper?: boolean;
	/**
	 * 栅格占位格数，最大值：24
	 * ```
	 * 1. 当前EasyForm处在 EasyForm 直接子节点中有效，即当前EasyForm在EasyForm栅格中的占位格数；
	 * 2. 父节点使用属性值，当前节点不使用属性值
	 * ```
	 */
	span?: number;
};
/**
 * 简单Form布局，可自定义网格布局
 * ```
 * 1. demo：https://fex.qa.tcshuke.com/docs/admin/main/form/grid
 * 2. EasyForm的children列表会进行网格化布局
 * 3. 自定义栅格占位格数的4中方式
 *    3.1 设置FormItemWrapper、FormItemText组件span属性；
 *    3.2 使用 EasyFormItemSpan 包裹children item，设置span属性
 *    3.3 使用 <BoxGrid.Col span={24} ></BoxGrid.Col> 包裹，设置响应式属性
 *    3.4 设置 EasyForm isPure = true设置纯净模式，对EasyForm的子节点不做任何包装处理
 * 4. EasyForm可嵌套使用，嵌套内部的<EasyForm />节点Form相关属性失效，例如属性form、initialValues等都失效
 *  <EasyForm form={form}>
 *    ....
 *    <EasyForm>...</EasyForm>
 *    ....
 *    <EasyForm>...</EasyForm>
 *    ....
 *  </EasyForm>
 * 5. 布局网格以当前组件的宽度来计算的，不是屏幕宽度
 * 6. EasyForm 子节点包含 hidden = true 会被忽略
 * 7. 通过 column 可定义一行显示几列FormItem
 * 8. 通过 labelItemVertical 可定义 formitem 竖直布局
 * 9. 通过 formItemGap 可定义 formItem竖直方向间隙
 * 10. 通过 forceColumn 可强制定义一行显示几列，不考虑响应式
 * 11. 通过 labelWidth 可控制Form内部所有label的宽度（可实现整齐效果）
 * 12. 自定义栅格占位格数，见下方`例如`

 * 例如
 * <EasyForm column={3}>
 *	 <FormItemWrapper name="field1" label="条件1">
 *	   <Input placeholder="请输入" allowClear={true} />
 *	 </FormItemWrapper>
 *	 <!-- ！！自定义栅格占位格数第一种方式：可通过使用 BoxGrid.Col 包裹元素来自定义网格占比 -->
 *	 <BoxGrid.Col span={24}>
 *	   <FormItemWrapper name="field5" label="条件5">
 *	 	<Input placeholder="请输入" allowClear={true} />
 *	   </FormItemWrapper>
 *	 </BoxGrid.Col>
 *	 <!-- ！！自定义栅格占位格数第二种方式：如果为FormItemWrapper组件，可设置span属性 -->
 *	 <FormItemWrapper name="field6" label="条件6" span={24}>
 *	   <Input placeholder="请输入" allowClear={true} />
 *	 </FormItemWrapper>
 *	 <FormItemWrapper noStyle span={24}>
 *	   <Button>按钮</Buttone>
 *	 </FormItemWrapper>
 * </EasyForm>
 * ```
 */
export declare const EasyForm: {
	(props: EasyFormProps): import("react").JSX.Element;
	domTypeName: string;
};
export type EditableCardDataIndex = string | string[];
export interface EditableCardOperation {
	index: number;
	add: (defaultValue: TPlainObject, insertIndex?: number) => void;
	remove: (index: number) => void;
	/** 同一级内移动 */
	move: (fromIndex: number, toIndex: number) => void;
	/** 是否可编辑 */
	editable: boolean;
	/**
	 * 设置当前卡片指定字段值
	 */
	setCurrentRowField: (dataIndexConfigs: {
		name: EditableCardDataIndex;
		value?: TAny;
	}[]) => void;
	/** 获取当前卡片表单数据 */
	getCurrentRowData: () => TPlainObject;
	/**
	 * 当前卡片表单 name
	 * ```
	 * 值为 field.name
	 * ```
	 */
	rowFormItemName: string | number;
	/**
	 * 当前卡片表单完整 name
	 * ```
	 * 例如：['dataList', 0]
	 * ```
	 */
	rowFormItemCompleteName: Array<string | number>;
	/** 当前卡片表单验证，需要自行指定nameList（dataIndex数组） */
	validateRowFields: (nameList: EditableCardDataIndex[]) => Promise<void>;
	forceUpdate: () => void;
}
/** 卡片内字段配置 */
export type EditableCardColumnItem = {
	/**
	 * 字段key值
	 * ```
	 * 例如：
	 * dataIndex： 'abc'
	 * dataIndex： ['abc', 'xyz']
	 * ```
	 */
	dataIndex: EditableCardDataIndex;
	/** 是否可编辑 */
	editable: boolean | ((operation: Pick<EditableCardOperation, "index" | "getCurrentRowData">, index: number) => boolean);
	/**
	 * 布局占用网格数目（最大数值24）
	 * ```
	 * 1. 一行总共等分24份
	 * ```
	 */
	gridNumber?: number;
	/** 标题 */
	title?: ReactElement | string;
	/**
	 * Form.Item props
	 */
	formItemProps?: Omit<FormItemWrapperProps, "children" | "name"> | ((operation: EditableCardOperation) => Omit<FormItemWrapperProps, "children" | "name">);
	/**
	 * 通过 operation.editable 来判断渲染结构，其中render返回的根节点会作为 Form.Item 的children
	 * ```
	 *  例如
	 *  render: (operation) => {
	 *    if (operation.editable) {
	 *      return <Input placeholder="请输入" />;
	 *    }
	 *    return <Tag>{value}</Tag>;
	 *  }
	 *
	 *  如果需要额外布局，可通过 formItemProps.wrapper 实现
	 *  formItemProps: (operation) => {
	 *    return {
	 *      wrapper: (children) => {
	 *        return (
	 *          <FlexLayout fullIndex={[0]} direction="horizontal" gap={10}>
	 *            <div>{children}</div>
	 *            <div>额外布局</div>
	 *          </FlexLayout>
	 *        );
	 *      },
	 *    };
	 *  },
	 *  render: (operation) => {
	 *    if (operation.editable) {
	 *      return <Input placeholder="请输入" />;
	 *    }
	 *    return <Tag>{value}</Tag>;
	 *  }
	 * ```
	 */
	render?: (operation: EditableCardOperation) => ReactElement;
	/**
	 * 会在 title 之后展示一个 icon
	 */
	tips?: string;
	/** 为表格header中的字段添加必填标识，如果未配置 formItemProps.rules，内部会新增一条required rule  */
	required?: boolean;
	/**
	 * 隐藏域设置
	 * ```
	 * 如果是动态隐藏，并且在逻辑切换后无效果，可尝试执行 operation.forceUpdate()
	 * ```
	 */
	hidden?: (operation: EditableCardOperation, index: number) => boolean;
	/** 移除设置，优先级高于 hidden */
	remove?: (operation: EditableCardOperation, index: number) => boolean;
	formItemContainer?: (formItem: ReactElement) => ReactElement | null;
};
export type EditableCardProps = {
	className?: string;
	style?: CSSProperties;
	/** 卡片内字段配置 */
	columns: EditableCardColumnItem[];
	/**
	 * 当前Edittable处在formList内部时（必填），完整formItem的name
	 * ```
	 * 例如 处在formList内部
	 * 1. formListName=[0,dataList]
	 * 2. formListCompleteName=[xxxList, 0, dataList]
	 * ```
	 */
	formListCompleteName?: Array<string | number>;
	/** Form.List name */
	formListName: Array<string | number> | string;
	/** 初始化值 */
	initialValue?: TPlainObject[];
	/**
	 * Form.List rules
	 * ```
	 rules={[
		{
		  validator: async (_, names) => {
			if (!names || names.length < 2) {
			  return Promise.reject(new Error('At least 2 passengers'));
			}
		  },
		},
	  ]}
	 * ```
	 */
	rules?: FormListProps["rules"];
	/**`默认新增按钮`新增行默认值，hiddenFooterBtn != true 有效 */
	addRowDefaultValues?: () => TPlainObject;
	/** 自定义新增按钮名称 */
	addRowBtnName?: ReactNode;
	/** 隐藏底部`新增`按钮 */
	hiddenFooterBtn?: boolean;
	/** 隐藏默认删除按钮 */
	hiddenDeleteBtn?: boolean;
	/** 顶部区域渲染 */
	contentBeforeRender?: (formListOperation: FormListOperation, nextRowIndex: number) => ReactElement | null;
	/** 底部区域渲染 */
	contentAfterRender?: (formListOperation: FormListOperation, nextRowIndex: number) => ReactElement | null;
	/** 设置默认卡片名称，设置 onCustomWrapper 后失效 */
	onCustomGroupName?: (index: number) => string | ReactElement;
	/** 自定义卡片包裹，同时可自定义删除按钮、新增按钮 */
	onCustomWrapper?: (children: ReactElement, extraData: {
		operation: FormListOperation;
		fields: FormListFieldData[];
		fieldItem: FormListFieldData;
		index: number;
		required?: boolean;
		key: string;
	}) => ReactElement;
	/** 设置必填，但只有一条数据时，隐藏默认删除按钮 */
	required?: boolean;
	/** 默认卡片样式 */
	cardClassName?: string;
	/** 默认卡片样式 */
	cardStyle?: CSSProperties;
	/**
	 * 每个卡片内容都使用了 EasyForm 包裹，此处可设置 EasyFormProps
	 * ```
	 * 可使用 EasyForm 中 FormItem布局
	 * ```
	 */
	cardEasyFormProps?: Omit<EasyFormProps, "nonuseFormWrapper" | "isPure" | "children">;
	/**
	 * 默认卡片右侧布局，设置 onCustomWrapper 后失效
	 * ```
	 * 1. 通过before 、after自定义删除按钮左右布局
	 * cardExtraRender={(extraData)=>{
	 *   return {
	 *      before: [<div>1</div>, <div>2</div>],
	 *      after: [<div>3</div>, <div>4</div>],
	 *    }
	 *  }}
	 * 2. 返回ReactElement，可自定义右侧布局
	 * cardExtraRender={(extraData)=>{
	 *   return <div>111</div>
	 *  }}
	 * ```
	 */
	cardExtraRender?: (extraData: {
		operation: FormListOperation;
		fields: FormListFieldData[];
		fieldItem: FormListFieldData;
		index: number;
		required?: boolean;
		key: string;
	}) => {
		before?: ReactElement[];
		after?: ReactElement[];
	} | ReactElement;
};
export type DragEditableCardProps = Omit<EditableCardProps, "onCustomWrapper"> & {
	/**
	 * 拖拽图标自定义，默认使用 DragOutlined 图标
	 */
	dragIcon?: ReactElement;
	/** 禁用拖拽 */
	disabledDrag?: boolean;
	/**
	 * 表格数据唯一值字段Key
	 * ```
	 * ```
	 */
	uidFieldKey: string;
	/**
	 * 拖拽结束事件
	 * ```
	 * dataSource: 拖拽完成后的数据源
	 * dragData
	 * 1. activeId 拖拽ID
	 * 2. activeIndex 拖拽起始表格数组索引值
	 * 3. overIndex 拖拽结束表格数组索引值
	 * ```
	 */
	onDragChange?: (dataSource: TPlainObject[], dragData: {
		activeId: string | number;
		overId?: string | number;
		activeIndex: number;
		overIndex: number;
	}) => void;
	/**
	 * 拖拽触发位置，默认在左侧
	 */
	dragTriggerPosition?: "left" | "right";
};
/**
 * 可拖拽编辑卡片
 * ```
 * 1. 卡片数组必须有唯一值字段，通过参数 uidFieldKey 告诉组件
 * ```
 */
export declare const DragEditableCard: (props: DragEditableCardProps) => import("react").JSX.Element;
export type TipsWrapperProps = {
	gap?: number;
	className?: string;
	style?: CSSProperties;
	children?: ReactNode;
	icon?: ReactElement;
	/** Icon添加点击事件，设置hoverTips后失效 */
	onClick?: (event: any) => void;
	/**
	 * 提示效果类型
	 * ```
	 * 1. popover 气泡卡片，内容通过popoverProps设置
	 * 2. tooltip 文字提示，内容通过tooltipProps设置
	 * ```
	 */
	tipType?: "popover" | "tooltip";
	popoverProps?: PopoverProps;
	tooltipProps?: TooltipProps;
	trigger?: "icon" | "all";
};
/**
 * 为目标元素右侧添加Icon
 * ```
 * Icon有两种交互行为
 * 1. 鼠标悬浮显示提示效果;
 * 2. 为Icon添加点击事件
 *
 * 例如：
 * 1.
 * <TipsWrapper tipType="tooltip" tooltipProps={{ title:'说明文案' }}>ABC</TipsWrapper>
 * 2.
 * <TipsWrapper tipType="popover" popoverProps={{ title:'说明标题', content:'说明内容' }}>ABC</TipsWrapper>
 * 3.
 * <TipsWrapper onClick={noop}>ABC</TipsWrapper>
 * ```
 */
export declare const TipsWrapper: (props: TipsWrapperProps) => import("react").JSX.Element;
export type SelectorWrapperValue = string | number | Array<string | number> | TPlainObject<string | number> | Array<TPlainObject<string | number>>;
export type SelectorServiceConfig = {
	params?: TPlainObject;
	/** 与 params 配合使用 */
	requiredParamsKeys?: string[];
	onRequest?: (params?: TAny) => Promise<TAny>;
	/**
	 * 响应数据适配器
	 */
	onRequestResultAdapter?: (respData: TAny) => TPlainObject[];
};
export type SelectorWrapperProps = Omit<SelectProps, "onSearch" | "notFoundContent" | "options" | "fieldNames" | "onChange" | "value" | "loading" | "mode"> & {
	/** 不支持 tags 模式，tags模式请使用 SelectorWrapperSimple 组件 */
	mode?: "multiple";
	/** key值，相同的key 同页面可共用缓存数据 */
	modelKey: string;
	/**
	 * 参数Key映射
	 * ```
	 * 1. 默认值：value=value、label=label、disabled=disabled
	 * 2. list 为 onRequest 返回数据中列表key值，可多级取值，例如： 'a.b.c'
	 * 3. 配置 serviceConfig.onRequestResultAdapter后，fieldNames.list配置失效
	 * 4. 如果没有配置list，可说明接口返回为数组
	 * ```
	 */
	fieldNames?: {
		list?: string;
		label?: string;
		value?: string;
		disabled?: string;
	};
	/**
	 * 请求服务需求的数据
	 */
	serviceConfig?: SelectorServiceConfig;
	/**
	 * 同步设置选择器选项列表
	 * ```
	 * 1. 如果配置fieldNames，会转换后使用
	 * 2. 值为undefined、null不会更新，需要清空可传递空数组
	 * ```
	 */
	selectorList?: TPlainObject[];
	/**
	 * select 数据源发生变更时触发，第一次不调用
	 */
	onSelectorListChange?: (dataList: TPlainObject[]) => void;
	/** select 数据源发生变更时触发，每次都会调用 */
	onSelectorListAllChange?: (dataList: TPlainObject[]) => void;
	/**
	 * 通过服务获取数据异常回调
	 */
	onSelectorRequestError?: (error: Error) => void;
	/**
	 * 添加全部选项
	 * ```
	 * 1. 默认值label="全部"，value=""
	 * 2. 可配置label、value
	 * ```
	 */
	showAllOption?: true | {
		label: string;
		value: string | number;
	};
	onLabelRenderAdapter?: (dataItem: TPlainObject) => string | ReactElement;
	onChange?: (value?: SelectorWrapperValue, selectedList?: TPlainObject[] | TPlainObject) => void;
	showIcon?: boolean;
	/** select option添加图标；与showIcon组合使用 */
	icon?: (data: TPlainObject, index: number) => ReactElement;
	requestMessageConfig?: TRequestStatusProps["messageConfig"];
	/**
	 * value格式
	 *```
	 * 1. string 、number
	 * 2. Array<string | number>
	 * 3. lableInValue = true，根据fieldNames配置格式
	 * 4. lableInValue = true，Array<fieldNames配置>
	 * ```
	 */
	value?: SelectorWrapperValue;
	/**
	 * 使用缓存，默认值：true
	 * ```
	 * 1. true: 在 modelKey下使用请求参数缓存数据，如果相同modelKey、相同请求参数直接使用缓存数据
	 * 2. false: 每次都调用接口，不参与缓存数据、不使用缓存数据
	 * 3. useCache=false 在 serviceConfig.requiredParamsKeys.length > 0 有效
	 * ```
	 */
	useCache?: boolean;
};
export type SwitchWrapperValue = string | number | boolean;
export type SwitchWrapperProps = Omit<SwitchProps, "checked" | "defaultChecked" | "onChange" | "value"> & {
	value?: SwitchWrapperValue;
	checkedValue: SwitchWrapperValue;
	unCheckedValue: SwitchWrapperValue;
	onChange?: (value: SwitchWrapperValue) => void;
	tooltipProps?: Omit<TooltipProps, "title">;
	tooltipTitle?: string | ((value?: SwitchWrapperValue) => string | undefined);
	serviceConfig?: {
		onRequest: (value: SwitchWrapperValue) => TAny;
		message?: {
			success?: string;
			defaultError?: string;
		};
	};
};
/**
 * 解决Switch只能接收boolean的限制，与Form.Item结合使用最佳
 * ```
 * 1. value 为状态值，不局限于boolean，可以为 [string | number | boolean]
 * 2. checkedValue 选中值
 * 3. unCheckedValue 未选中值
 * 4. 与 Form.Item 结合使用，不再需要配置 valuePropName
 *     <Form.Item name="fieldName">
 *       <SwitchWrapper checkedValue={2} unCheckedValue={1} />
 *     </Form.Item>
 * 5. 可设置tooltip效果数据显示
 * 6. 可设置 serviceConfig 配置服务调用交互
 * ```
 */
export declare const SwitchWrapper: (props: SwitchWrapperProps) => import("react").JSX.Element;
export type UploadWrapperFileItem = {
	uid: string;
	name: string;
	url?: string;
};
export type UploadWrapperProps<T extends TPlainObject = TPlainObject> = {
	value?: T[] | T;
	onChange?: (value?: T[]) => void;
	onUploadError?: (message?: string) => void;
	onUploadChange?: (info: UploadChangeParam<UploadFile>) => void;
	/**
	 * 属性取值映射
	 */
	fieldNames?: {
		uid: string;
		name?: string;
		url?: string;
		/** 文件大小 */
		size?: string | number;
	};
	/**
	 * 接口响应数据适配器，如果配置了fieldNames，适配器返回值会再进过fieldNames转换
	 */
	onRequestResultAdapter?: (respData: TAny) => TPlainObject;
	/** 操作触发显示文本 */
	triggerText?: string;
	/** 超过maxCount 隐藏上传入口  */
	limitHidden?: boolean;
	/**
	 * 自动提交，默认：true
	 * ```
	 * 1. 自定义beforeUpload配置后 autoSubmit 失效
	 * ```
	 */
	autoSubmit?: boolean;
	/** 图片预览开关, 重写 onPreview 方法后失效 */
	imagePreviewSwitch?: boolean;
	/** 图片预览文件类型，默认：['png', 'jpg', 'jpeg', 'gif'] */
	imagePreviewAccept?: string[];
	/**
	 * 配置文件额外操作
	 * ```
	 * 额外操作超过两项后，listType为 picture-card、picture-circle 时会出现显示异常，需要自行修改覆盖样式
	 * ```
	 */
	extraOperate?: {
		icon: ReactElement;
		onClick: (file: UploadFile, fileList: UploadFile[], e: any) => void;
	}[];
} & Omit<UploadProps, "onChange" | "fileList">;
/**
 * 文件上传
 * ```
 * demo: https://fex.qa.tcshuke.com/docs/admin/main/file/upload
 * 1. 可通过配置children替换默认上传触发布局
 * 2. 接口返回结构：
 *    formData上传接口返回值
 *    {
 *     code: '0000',
 *     data: {
 *       uid: '唯一值，可使用fileKey值'
 *       name: '文件名称'
 *       url: '预览地址'
 *     }
 *    }
 * 3. 如果接口返回的不是上面的字段名称，可通过fieldNames配置接口返回字段名称映射
 *
 * 4. 最佳使用方式，与Form结合使用
 * <Form.Item name="attachmentList" label="附件">
 *   <UploadWrapper action={uploadUrl} />
 * </Form.Item>
 *
 * 5. 回填数据结构
 * [{
 *    uid: '唯一值',
 *    name（非必填）: 'image.png',
 *    url: 'https://zos.alipayobjects.com/rmsportal/jkjgkEfvpUPVyRjUImniVslZfWPnJuuZ.png',
 *  }]
 * 1. 其中 uid、name、url 可为其他命名，通过 fieldNames 进行映射即可,
 * 2. 其他需要的字段可在对象中添加 responseData 对象
 * 例如：
 * [{
 *    uid: '唯一值',
 *    name（非必填）: 'image.png',
 *    url: 'https://zos.alipayobjects.com/rmsportal/jkjgkEfvpUPVyRjUImniVslZfWPnJuuZ.png',
 *    responseData: { 'xx':'xxx' }
 *  }]
 * ```
 *
 */
export declare const UploadWrapper: (props: UploadWrapperProps) => import("react").JSX.Element;
export type EditableTableName = string | number | Array<string | number>;
export type EditableTableRecordType = FormListFieldData & {
	operation: FormListOperation;
};
export type EditableInputConfig = {
	type: "input";
	editableComptProps?: InputProps;
};
export type EditableInputNumberConfig = {
	type: "inputNumber";
	editableComptProps?: InputNumberProps;
};
export type EditableSelectWrapperConfig = {
	type: "selectorWrapper";
	editableComptProps: SelectorWrapperProps;
};
export type EditableDatePickerWrapperConfig = {
	type: "datePickerWrapper";
	editableComptProps?: DatePickerWrapperProps;
};
export type EditableDateRangePickerWrapperConfig = {
	type: "dateRangePickerWrapper";
	editableComptProps?: DateRangePickerWrapperProps;
};
export type EditableCheckboxGroupConfig = {
	type: "checkboxGroup";
	editableComptProps: CheckboxGroupProps;
};
export type EditableRadioGroupConfig = {
	type: "radioGroup";
	editableComptProps: RadioGroupProps;
};
export type EditableTextareaConfig = {
	type: "textArea";
	editableComptProps: TextAreaProps;
};
export type EditableFileUploadConfig = {
	type: "uploadWrapper";
	editableComptProps: UploadWrapperProps;
};
export type EditableSwitchWrapperConfig = {
	type: "switchWrapper";
	editableComptProps: SwitchWrapperProps;
};
/**
 * 自定义编辑组件
 * ```
 * 1.需要处理Form.Item
 * 2. 例如
 *  editableConfig: {
	  type: 'custom',
	  editableComptProps: (props) => {
		return (
		  <Form.Item name={props.name}>
			<Input />
		  </Form.Item>
		);
	  },
	},
	```
 */
export type EditableCustomConfig = {
	type: "custom";
	editableComptProps: (props: {
		name: Array<number | string>;
		editable?: boolean;
		completeName: Array<number | string>;
		tableRowIndex: number;
	}) => ReactElement;
};
export type EditableTypeConfig = EditableCustomConfig | EditableInputConfig | EditableSelectWrapperConfig | EditableDatePickerWrapperConfig | EditableDateRangePickerWrapperConfig | EditableCheckboxGroupConfig | EditableTextareaConfig | EditableInputNumberConfig | EditableRadioGroupConfig | EditableFileUploadConfig | EditableSwitchWrapperConfig;
export type FieldSingleConfig = {
	editable?: boolean | ((data: {
		tableRowIndex: number;
	}) => boolean);
	editableConfig?: EditableTypeConfig;
	/**
	 * 当editableConfig type=custom时，此配置无效
	 */
	formItemProps?: Omit<FormItemProps, "name">;
	/**
	 * 自定义非编辑渲染
	 * 1. 当editableConfig type=custom时，此配置无效
	 * 2. 只在editable=false的情况下有效
	 * 3. 同级配置 editableConfigList后，同级render配置失效
	 * 4. checkboxGroup、radioGroup、selectorWrapper第二次参数为options数组
	 */
	render?: (params?: TAny, other?: TAny) => ReactNode;
};
export type FormListItemMethodOperateProps = {
	tableRowIndex: number;
	add: FormListOperation["add"];
	remove: () => void;
	formListItemIndex: number;
	value: TAny;
};
export type FormListMethodOperateProps = {
	tableRowIndex: number;
	add: FormListOperation["add"];
	value: TAny;
};
export type FormListConfig = {
	editableConfigList: Array<FieldSingleConfig & {
		fieldName: string;
	}>;
	onFormListBeforeRender?: (data: FormListMethodOperateProps) => ReactElement | null;
	onFormListAfterRender?: (data: FormListMethodOperateProps) => ReactElement | null;
	onFormListItemBeforeRender?: (data: FormListItemMethodOperateProps) => ReactElement | null;
	onFormListItemAfterRender?: (data: FormListItemMethodOperateProps) => ReactElement | null;
	deleteOperateRender?: (data: {
		remove: () => void;
		formListItemIndex: number;
	}) => ReactElement;
};
export type fieldConfigFunctionParams = {
	tableRowIndex: number;
	name: EditableTableName;
	tableRowName: EditableTableName;
	getTableRowData: () => TPlainObject;
};
/**
 * antd 默认render功能此处不能使用
 */
export type EditableTableColumn = Omit<ColumnsType["0"], "render"> & {
	/**
	 * @description 请使用 tipsWrapperProps 属性配置
	 * ```
	 * 会在 title 之后展示一个 icon，hover 之后提示一些信息
	 * 1. title为string类型、ReactElement有效
	 * 2. hoverArea 默认值：icon
	 * ```
	 */
	/**
	 * 会在 title 之后展示一个 icon
	 * ```
	 * 1. title为string类型有效
	 * 2. 可为icon添加提示效果
	 * 3. 可为icon添加点击事件
	 * ```
	 */
	tipsWrapperProps?: string | TipsWrapperProps;
	dataIndex?: string;
	fieldConfig?: FieldSingleConfig | FormListConfig | ((data: fieldConfigFunctionParams) => FieldSingleConfig | FormListConfig);
	/** 隐藏域字段 */
	hiddenField?: {
		dataIndex: string;
	} | {
		dataIndex: string;
	}[];
	/**
	 * 渲染中间件，如果renderMiddleware返回值为ReactElement格式，则会终止后续逻辑，fieldConfig配置将失效
	 * ```
	 * 1. tableRowIndex: 当前row的索引值
	 * 2. name: 当前table单元格的form.item的name值
	 * 3. operation Form.List的操作函数
	 * 4. 对 table children column渲染无效
	 * ```
	 */
	renderMiddleware?: (item: {
		tableRowIndex: number;
		name: EditableTableName;
		tableRowName: EditableTableName;
		operation: FormListOperation;
		index: number;
		getTableRowData: () => TPlainObject;
	}) => ReactElement | null;
	/** table datasource children column 自定义渲染  */
	tableChildrenColumnRender?: (value: TAny, record: TPlainObject, index: number) => ReactElement | null;
	/** 为表格header中的字段添加必填标识，无验证拦截功能 */
	required?: boolean;
};
export type EditableTableProps = {
	/** FormList name属性 */
	name: EditableTableName;
	/**
	 * 当前Edittable处在formList内部时（必填），完整formItem的name
	 * ```
	 * 例如 处在formList内部
	 * 1. name=[0,dataList]
	 * 2. completeName=[xxxList, 0, dataList]
	 * ```
	 */
	completeName?: Array<string | number>;
	/**
	 * 表格行数据，唯一值字段Key
	 * ```
	 * 1. 如果数据中没有可前端添加key
	 * 2. 有问题可咨询 xg15472
	 * ```
	 */
	uidFieldKey: string;
	/**
	 * ```
	 * antd table属性
	 * 1. 新增cellVerticalAlign，单元格竖直方向对齐方式，设置table column onCell属性后失效
	 * ```
	 */
	tableProps?: Omit<TableProps<EditableTableRecordType>, "dataSource" | "columns" | "rowKey"> & {
		cellVerticalAlign?: "baseline" | "middle" | "top" | "bottom";
	};
	columns: EditableTableColumn[];
	onTableBeforeRender?: (formListOperation: FormListOperation, nextRowIndex: number) => ReactElement | null;
	/**
	 * 设置后，将覆盖底部`新增`按钮
	 */
	onTableAfterRender?: (formListOperation: FormListOperation, nextRowIndex: number) => ReactElement | null;
	/** 新增行默认值，自定义onTableAfterRender后失效 */
	getAddRowDefaultValues?: () => TPlainObject;
	/** 隐藏底部`新增`按钮，设置 onTableAfterRender后 失效 */
	hiddenFooterBtn?: boolean;
	/**
	 * Form.List rules
	 * ```
	 rules={[
		{
		  validator: async (_, names) => {
			if (!names || names.length < 2) {
			  return Promise.reject(new Error('At least 2 passengers'));
			}
		  },
		},
	  ]}
	 * ```
	 */
	rules?: FormListProps["rules"];
	/** 空效果显示尺寸，默认值：small */
	emptyShowSize?: "small" | "large";
	className?: string;
	style?: CSSProperties;
};
/**
 * 可编辑表格（通过FormList实现）
 * @deprecated 已过期，请使用 EditableTablePro 组件
 * demo：https://fex.qa.tcshuke.com/docs/admin/main/table/row-editable1
 * ```
 * 1. 表格数据必须要有唯一值字段，通过属性uidFieldKey设置
 * 2. 通过 tableProps 设置Table属性，table size默认：small
 * 3. Table children column 不可编辑
 * 4. 当存在折叠children数据时，组件会在children中内置_isChildrenItem字段
 * 5. 可通过tableChildrenColumnRender自定义渲染 table children column 显示
 * 6. 4.5.0版本移除 ref.getTableItemDataByFormListItemKey 功能，可选择表格参考（https://fex.qa.tcshuke.com/docs/admin/main/table/row-editable2）
 * ```
 */
export declare const EditableTable: (props: EditableTableProps) => import("react").JSX.Element;
export type DragEditableTableProps = EditableTableProps & {
	/**
	 * 拖拽图标自定义，默认使用 DragOutlined 图标
	 */
	dragIcon?: ReactElement;
	/** 禁用拖拽 */
	disabledDrag?: boolean;
	/**
	 * 表格数据唯一值字段Key
	 * ```
	 * ```
	 */
	uidFieldKey: string;
	/**
	 * 拖拽结束事件
	 * ```
	 * dataSource: 拖拽完成后的数据源
	 * dragData
	 * 1. activeId 拖拽ID
	 * 2. activeIndex 拖拽起始表格数组索引值
	 * 3. overIndex 拖拽结束表格数组索引值
	 * ```
	 */
	onDragChange?: (dataSource: TPlainObject[], dragData: {
		activeId: string | number;
		overId?: string | number;
		activeIndex: number;
		overIndex: number;
	}) => void;
};
/**
 * 可拖拽编辑表格
 * @deprecated 已过期，请使用 DragEditableTablePro组件
 * ```
 * 1. 表格数据必须要有唯一值字段，通过参数 uidFieldKey 告诉组件
 * 2. Table 参数 components.body.row 被组件内部使用
 * ```
 */
export declare const DragEditableTable: (props: DragEditableTableProps) => import("react").JSX.Element;
export type EditableTableProDataIndex = string | readonly (string | number)[];
export interface EditableTableProOperation {
	add: (defaultValue: TPlainObject, insertIndex?: number) => void;
	remove: (index: number) => void;
	/** 同一级内移动 */
	move: (fromIndex: number, toIndex: number) => void;
	/** 是否可编辑 */
	editable: boolean;
	/** 当前行数据层级 */
	level: number;
	/** 设置当前行指定字段值 */
	setCurrentRowTargetField: (dataIndexConfigs: {
		name: EditableTableProDataIndex;
		value?: TAny;
	}[]) => void;
	/** 设置当前行 children 数据 */
	setCurrentRowChildrenValue: (value?: TPlainObject[]) => void;
	/** 当前行父级数据 */
	parentItem: TPlainObject | null;
	/** 当前行表单 name */
	tableRowFormItemName: Array<string | number>;
	/** 当前行表单完整 name */
	tableRowFormItemCompleteName: Array<string | number>;
	/** 当前行表单验证，需要自行指定nameList（dataIndex数组） */
	validateRowFields: (nameList: EditableTableProDataIndex[]) => Promise<void>;
}
export type EditableTableProColumnItem = Omit<ColumnsType[0], "render" | "title" | "dataIndex"> & {
	title?: ReactElement | string;
	dataIndex?: EditableTableProDataIndex;
	/** Form.Item props */
	formItemProps?: Omit<FormItemWrapperProps, "children" | "name"> | ((value: TAny, record: TPlainObject, index: number, operation: EditableTableProOperation) => Omit<FormItemWrapperProps, "children" | "name">);
	/**
	 * 通过 operation.editable 来判断渲染结构，其中render返回的根节点会作为 Form.Item 的children
	 * ```
	 *  例如
	 *  render: (_value, _record, _index, operation) => {
	 *    if (operation.editable) {
	 *      return <Input placeholder="请输入" />;
	 *    }
	 *    return <Tag>{value}</Tag>;
	 *  }
	 *
	 *  如果需要额外布局，可通过 formItemProps.wrapper 实现
	 *  formItemProps: (_value, _record, _index, operation) => {
	 *    return {
	 *      wrapper: (children) => {
	 *        return (
	 *          <FlexLayout fullIndex={[0]} direction="horizontal" gap={10}>
	 *            <div>{children}</div>
	 *            <div>额外布局</div>
	 *          </FlexLayout>
	 *        );
	 *      },
	 *    };
	 *  },
	 *  render: (_value, _record, _index, operation) => {
	 *    if (operation.editable) {
	 *      return <Input placeholder="请输入" />;
	 *    }
	 *    return <Tag>{value}</Tag>;
	 *  }
	 * ```
	 */
	render?: (value: TAny, record: TPlainObject, index: number, operation: EditableTableProOperation) => ReactElement;
	/** 是否可编辑 */
	editable: boolean | ((record: TPlainObject, index: number) => boolean);
	/**
	 * 会在 title 之后展示一个 icon
	 * ```
	 * 1. title为string类型有效
	 * 2. 可为icon添加提示效果
	 * 3. 可为icon添加点击事件
	 * ```
	 */
	tipsWrapperProps?: string | TipsWrapperProps;
	/** 为表格header中的字段添加必填标识，如果未配置 formItemProps.rules，内部会新增一条required rule  */
	required?: boolean;
};
export type EditableTableProProps = {
	columns: EditableTableProColumnItem[];
	/**
	 * 当前Edittable处在formList内部时（必填），完整formItem的name
	 * ```
	 * 例如 处在formList内部
	 * 1. formListName=[0,dataList]
	 * 2. formListCompleteName=[xxxList, 0, dataList]
	 * ```
	 */
	formListCompleteName?: Array<string | number>;
	/** Form.List name */
	formListName: Array<string | number> | string;
	/** 唯一值字段Key */
	uidFieldKey: string;
	/** 初始化值 */
	initialValue?: TPlainObject[];
	/** 指定树形结构的列名，默认值：children */
	childrenColumnName?: string;
	/** 表格组件配置 */
	tableProps?: Omit<TableProps<TPlainObject>, "dataSource" | "columns" | "rowKey"> & {
		cellVerticalAlign?: "baseline" | "middle" | "top" | "bottom";
	};
	/**
	 * Form.List rules
	 * ```
	 rules={[
		{
		  validator: async (_, names) => {
			if (!names || names.length < 2) {
			  return Promise.reject(new Error('At least 2 passengers'));
			}
		  },
		},
	  ]}
	 * ```
	 */
	rules?: FormListProps["rules"];
	className?: string;
	style?: CSSProperties;
	/**`默认新增按钮`新增行默认值，hiddenFooterBtn != true 有效 */
	addRowDefaultValues?: () => TPlainObject;
	/** 隐藏底部`新增`按钮 */
	hiddenFooterBtn?: boolean;
	/** 表格顶部区域渲染 */
	tableBeforeAreaRender?: (formListOperation: FormListOperation, nextRowIndex: number) => ReactElement | null;
	/** 表格底部区域渲染 */
	tableAfterAreaRender?: (formListOperation: FormListOperation, nextRowIndex: number) => ReactElement | null;
	/** 展开的行key，一般用于初始化，重新tableProps.expandable.expandedRowKeys后失效 */
	expandedRowKeys?: string[];
	/**
	 * 展开图标布局，默认：layout1
	 * ```
	 * 1. 可编辑表格第一项为可编辑状态时，选 layout1
	 * 2. 可编辑表格第一项为非可编辑状态时，选 layout2
	 * ```
	 */
	expandedIconLayout?: "layout1" | "layout2";
};
/**
 * 使用FormList实现可编辑表格
 * ```
 * 1. 必须在外部包裹Form组件
 * 2. 表格数据源数组中必须存在唯一值字段，通过uidFieldKey配置
 * 3. 可嵌套编辑，数据嵌套的节点名称可通过 childrenColumnName设置，默认：children
 * 4. 行内需要联动逻辑可使用 column.render.operation.setCurrentRowTargetField 方法
 * 5. 在多级编辑中，可通过 column.render.operation.level 判断当前行数据层级
 * 6. 不存在多级的情况下，可使用DragEditableTablePro组件实现拖拽排序
 * 7. 存在多级的情况下，可通过 column.render.operation.move 方法实现同一级内移动
 *
 * demo
 * https://fex.qa.tcshuke.com/docs/admin/main/table/row-editable1
 * https://fex.qa.tcshuke.com/docs/admin/main/table/row-editable2
 * https://fex.qa.tcshuke.com/docs/admin/main/table/row-editable4
 * ```
 */
export declare const EditableTablePro: (props: EditableTableProProps) => import("react").JSX.Element;
export type DragEditableTableProProps = EditableTableProProps & {
	/**
	 * 拖拽图标自定义，默认使用 DragOutlined 图标
	 */
	dragIcon?: ReactElement;
	/** 禁用拖拽 */
	disabledDrag?: boolean;
	/**
	 * 表格数据唯一值字段Key
	 * ```
	 * ```
	 */
	uidFieldKey: string;
	/**
	 * 拖拽结束事件
	 * ```
	 * dataSource: 拖拽完成后的数据源
	 * dragData
	 * 1. activeId 拖拽ID
	 * 2. activeIndex 拖拽起始表格数组索引值
	 * 3. overIndex 拖拽结束表格数组索引值
	 * ```
	 */
	onDragChange?: (dataSource: TPlainObject[], dragData: {
		activeId: string | number;
		overId?: string | number;
		activeIndex: number;
		overIndex: number;
	}) => void;
};
/**
 * 可拖拽编辑表格
 * ```
 * 1. 表格数据必须有唯一值字段，通过参数 uidFieldKey 告诉组件
 * 2. Table 参数 components.body.row 被组件内部使用
 * 3. 不存在多级的情况下，可使用DragEditableTablePro组件实现拖拽排序
 * 4. 存在多级的情况下，通过上移、下移操作按钮，调用 column.render.operation.move 方法实现同一级内移动
 * ```
 */
export declare const DragEditableTablePro: (props: DragEditableTableProProps) => import("react").JSX.Element;
export type FormItemHorizontalUnionProps = {
	className?: string;
	style?: CSSProperties;
	label?: string | ReactElement;
	/** 水平布局元素 */
	groupConfigList: {
		hidden?: boolean;
		before?: ReactElement | string;
		/**
		 * 设置宽度
		 * ```
		 * 1. 自适应可设置：auto
		 * 2. 可设置具体数值
		 * 3. 不设置会在铺满flex剩余空间
		 * 4. 多个未设置会等分铺满剩余空间
		 * ```
		 */
		width?: number | string;
		mainItem: ReactElement;
		after?: ReactElement | string;
	}[];
	/** 水平布局原始之间的间距 */
	gap?: number;
	flexLayoutStyle?: CSSProperties;
	flexLayoutClassName?: string;
	hidden?: boolean;
	required?: boolean;
	colon?: boolean;
};
export type DragFormListContentProps = {
	/** Form.List item fieldData */
	formListFieldData: FormListFieldData;
	/**
	 * 当前阶段 完整 formItem name
	 * ```
	 * 1. 获取当前输入项Item数据
	 *    form.getFieldValue(props.formStageCompleteName);
	 * 2. 获取当前输入项Item指定字段数据
	 *    form.getFieldValue([...props.formStageCompleteName, 'key']);
	 * ```
	 */
	formStageCompleteName: (string | number)[];
	/**
	 * formList上一级 formItem完整name
	 */
	prevCompleteName: (string | number)[];
	/** Form.List 操作项 */
	operation: FormListOperation;
	/** 索引 */
	index: number;
	/** 获取当前FormList 内部 Form.Item name */
	getInsideFormItemName: (key: string | string[]) => Array<string | number>;
	/** 获取当前 FormList Item 数据 */
	getInsideFormItemData: () => TPlainObject;
	/** 唯一值字段Key */
	uidKey: string;
};
export type DragFormListProps = {
	className?: string;
	style?: CSSProperties;
	itemStyle?: CSSProperties;
	/** formList item 数据中的唯一值，默认值：uid */
	uidFieldName?: string;
	/** formList name */
	name: string | number | (string | number)[];
	/**
	 * formList上一级 formItem完整name
	 * ```
	 * 1. 如果没有传 []
	 * 2. FormList内部通过 Form.useWatch 取值需要完整 name
	 * ```
	 */
	prevCompleteName: (string | number)[];
	/** 拖拽回调 */
	onDropChange?: (items: TPlainObject[]) => void;
	/** 设置拖拽图标 */
	dragIcon?: ReactElement;
	/** 禁用拖拽，拖拽图标隐藏 */
	dragDisabled?: boolean;
	/** 设置item禁止拖拽   */
	getItemDragDisabled?: (uid: string | number, index: number) => boolean;
	/** 新增行默认值，自定义onTableAfterRender后失效 */
	getAddRowDefaultValues?: () => TPlainObject;
	/** 隐藏新增行按钮 */
	hiddenAddRowButton?: boolean;
	/** 自定义新增行按钮，getAddRowDefaultValues配置失效 */
	onCustomAddRowButton?: (operation: FormListOperation) => ReactElement;
	/** formListItem 内容 */
	children: (data: DragFormListContentProps) => ReactElement;
	/** 隐藏数据为空渲染 */
	hiddenEmptyRender?: boolean;
	/** formList内部渲染包装，多用于FormListWrapper嵌套布局 */
	formListChildrenWrapper?: (props: {
		children: ReactElement;
	}) => ReactElement;
	/**
	 * Form.List rules
	 * ```
	 rules={[
		{
		  validator: async (_, names) => {
			if (!names || names.length < 2) {
			  return Promise.reject(new Error('At least 2 passengers'));
			}
		  },
		},
	  ]}
	 * ```
	 */
	rules?: FormListProps["rules"];
	/**
	 * 设置FormList字段标题&必填标志
	 * ```
	 * demo: http://dev.flatjs.com:6007/pages/flat/oss-demo/main/form/list?env=me
	 * 1. 会根据数组顺序进行渲染
	 * 2. 未设置width的元素，参与等分剩余宽度
	 * 3. 设置width 要与FormList children中的item宽度相同，不然内容与标题无法对齐
	 * ```
	 */
	formListItemTitleList?: {
		title: string;
		required?: boolean;
		width?: number;
	}[];
	/** formListItemTitle HorizontalUnionProps 配置 */
	formListItemTitleHorizontalUnionProps?: Omit<FormItemHorizontalUnionProps, "groupConfigList">;
	/** FormList Item 之间间隙，默认值：16 */
	itemGap?: number;
};
/**
 * 可拖拽FormList
 * ```
 * Demo: https://fex.qa.tcshuke.com/docs/admin/main/form/list
 * 1. FormList数组中必须要有唯一值字段，默认值字段名称uid，可通过uidFieldName自定义设置
 * 2. 通过 itemGap 设置FormList Item 之间间隙
 * ```
 */
export declare const DragFormList: (props: DragFormListProps) => import("react").JSX.Element;
export type DragTableProps = Omit<TableProps<TPlainObject>, "dataSource"> & {
	/**
	 * ```
	 * 1. 可自定义拖拽图标
	 * 2. dragIcon = false，可设置表格行拖拽
	 * ```
	 */
	dragIcon?: false | ReactElement;
	/** 表格数据唯一值字段Key，未填或者无法唯一，都不能拖拽能力 */
	uidFieldKey: string;
	dataSource?: TPlainObject[];
	/** 禁用拖拽 */
	disabledDrag?: boolean;
	/**
	 * 拖拽结束事件
	 * ```
	 * dataSource: 拖拽完成后的数据源
	 * dragData
	 * 1. activeId 拖拽ID
	 * 2. activeIndex 拖拽起始表格数组索引值
	 * 3. overIndex 拖拽结束表格数组索引值
	 * ```
	 */
	onDragChange?: (dataSource: TPlainObject[], dragData: {
		activeId: string | number;
		activeIndex: number;
		overIndex: number;
	}) => void;
};
/**
 * 可拖拽表格
 * ```
 * 1. 必须设置唯一值字段 uidFieldKey
 * 2. 如果拖拽显示异常，请检查 uidFieldKey 是否正确
 * 3. Table 参数 components.body.row 被组件内部使用
 * ```
 */
export declare const DragTable: (props: DragTableProps) => import("react").JSX.Element;
export type TDynamicNodeProps = {
	className?: string;
	getContainer?: HTMLElement | (() => HTMLElement) | string;
	content?: ReactElement;
	fixed?: boolean;
	style?: CSSProperties;
};
/**
 * 动态添加 element 元素
 * ```
 * 1. 默认添加到 body 下
 * 2. 可通过 getContainer 参数设置添加位置
 * ```
 */
export declare const dynamicNode: {
	append: (props?: TDynamicNodeProps) => {
		elementId: string;
	};
	remove: (elementId?: string) => void;
};
export type TEasyTableTableColumn<T> = ColumnsType<T>[0] & {
	/**
	 * @description 请使用 tipsWrapperProps 属性配置
	 * ```
	 * 会在 title 之后展示一个 icon，hover 之后提示一些信息
	 * 1. title为string类型有效
	 * 2. hoverArea 默认值：icon
	 * ```
	 */
	tooltip?: string | {
		content: string;
		icon?: ReactElement;
		hoverArea?: "icon" | "all";
	};
	dataIndex?: keyof T | (string & {});
	/**
	 * 会在 title 之后展示一个 icon
	 * ```
	 * 1. title为string类型有效
	 * 2. 可为icon添加提示效果
	 * 3. 可为icon添加点击事件
	 * ```
	 */
	tipsWrapperProps?: string | TipsWrapperProps;
	/** 是否隐藏 */
	hidden?: boolean;
	/** 是否折叠在更多中 */
	isFold?: boolean;
	/**
	 * 异步数据渲染，与asyncColumnRequest配合使用
	 * ```
	 * 1. 使用asyncRender后，render配置失效
	 * 2. 使用场景为，表格列数据是通过接口查询后渲染的（通常表格数据为code，但是页面渲染要使用name）
	 * 3. respData为异步返回数据
	 * ```
	 */
	asyncRender?: (value: TAny, record: T, index: number, respData?: TAny) => ReactNode;
	/** 设置默认值，当数据为【undefined、null、''】时显示；自定义render后失效 */
	defaultValue?: string;
};
export type EasyTableServiceConfig = {
	/** 接口配置 */
	onRequest: (params?: TPlainObject) => Promise<TPlainObject | TPlainObject[]>;
	/** 请求参数处理 */
	requestParamsAdapter?: (params: TPlainObject) => TPlainObject;
	/**
	 * 接口相应数据处理
	 * ```
	 * 返回数据为对象，包含两个字段
	 * 1. 表格列表数据 - Array
	 * 2. 表格条数总数 - Number
	 * 其中 字段key 命名会通过 fieldNames 进行转义
	 * 例如：
	 * fieldNames={{
	 *    list: 'aList',
	 *    total: 'aTotal',
	 *  }}
	 *  serviceConfig={{
	 *    url: '/v1/board/list',
	 *    requestResultAdapter: (respData) => {
	 *      return {
	 *        aList: respData.data.rows,
	 *        aTotal: respData.page.total,
	 *      };
	 *    },
	 *  }}
	 * ```
	 */
	requestResultAdapter?: (params: TAny) => TPlainObject;
	/**
	 * 动态列自定义渲染
	 * ```
	 * 1. respData: 接口返回数据
	 * 2. columns: Table columns配置项
	 * ```
	 *
	 */
	dynamicColumsAdapter?: (respData?: TAny, columns?: TEasyTableTableColumn<TPlainObject>[]) => TEasyTableTableColumn<TPlainObject>[] | undefined;
};
export type EasyTableProps = {
	className?: string;
	style?: CSSProperties;
	children: ReactElement | ReactElement[] | ((dataSource?: TAny) => ReactElement);
	/**
	 * EasyTable唯一值，可用于缓存查询条件
	 * @deprecated 已过时，如果需要缓存数据请设置 cacheKey 参数
	 */
	modelKey?: string;
	/**
	 * 缓存查询条件开关，默认false
	 * @deprecated 已过时 请使用 cacheKey 参数
	 * ```
	 * 1. 是否缓存表格查询条件，在路由跳转回来时，不会丢失
	 * 2. 如果一个页面有多个EasyTable，并需要缓存查询条件，可设置cacheSwitch为唯一字符串
	 * ```
	 */
	cacheSwitch?: boolean | string;
	/**
	 * 缓存key
	 * ```
	 * 1. 缓存查询条件key（刷新页面保留查询条件）
	 * 2. 表格列折叠缓存key
	 * ```
	 */
	cacheKey?: string;
	/** 接口数据配置 */
	serviceConfig: EasyTableServiceConfig;
	/**
	 * 1. 查询条件Form initialValues
	 * 2. 接口其他参数，例如常量类型
	 */
	initialValues?: TPlainObject;
	/**
	 * 分页初始化参数，默认值： pageSize = 10
	 * @deprecated 已过时 4.3.0版本移除，使用 pageSize 赋值
	 */
	initialPaginationParams?: {
		pageSize?: number;
	};
	/** 分页单页条数，默认值：10 */
	pageSize?: number;
	/**
	 * 字段映射，默认值：{ list:'list', total:'total', pageNo:'pageNo', pageSize:'pageSize'  }
	 * ```
	 * 1. list、total用于解析接口响应数据，可以配置多级，例如：{ list: 'data.rows', total: 'page.total' }
	 * 2. pageNo、pageSize用于接口分页入参Key定义，只能一级，例如：pageNo: 'page'
	 * ```
	 */
	fieldNames?: {
		list?: string;
		total?: string;
		pageNo?: string;
		pageSize?: string;
	};
	/** 初始化是否请求，默认值：true */
	initRequest?: boolean;
	/** 表格数据变更回调 */
	onDataSourceChange?: (dataSource: TAny) => void;
	/** 如果自定义查询按钮，可设置 Form onFinish */
	onFormFinish?: (values?: TPlainObject) => void;
	/** 在父节点高度下，上下铺满；默认值：true */
	isFull?: boolean;
	/** 查询条件固定，不随滚动条滚动, 屏幕尺寸为xs时失效  */
	filterFixed?: boolean;
	/** 分页区域固定，不随滚动条滚动 */
	paginationFixed?: boolean;
	/**
	 * 1. 配合paginationFixed=true一起使用有效果
	 * 2. 当使用Table内的pagination时，在EasyTable.Table中配置分页属性
	 */
	pagination?: PaginationProps;
	/**
	 * 查询条件展开、收起，被收起key数组；数组内容为EasyTable.Filter 子节点key值
	 */
	foldKeys?: string[];
	/** 自定义处理服务异常 */
	onRequestErrorHandle?: (error: any) => void;
	/**
	 * 是否inline模式
	 * ```
	 * 1. 缩短 EasyTable.Filter 与 EasyTable.Table 之间的距离
	 * 2. 取消内边距
	 * ```
	 */
	isInline?: boolean;
	/** Form 实例 */
	form?: FormInstance;
	/**
	 * 字段折叠配置
	 * ```
	 * 1. 设置EasyTable.Table columns中isFold=true
	 * 2. 通过initSelectedKeys、onChange可将选择字段数据外部存储
	 * 3. 设置cacheKey后，缓存数据优先级高于initSelectedKeys
	 * 4. 必须要设置 EasyTable.Table columns中dataIndex字段（保证在columns中唯一）
	 * ```
	 */
	columnFoldConfig?: {
		/** 初始化选中数据，缓存数据优先级更高 */
		initSelectedKeys?: string[];
		/** 隐藏默认触发节点 */
		hidden?: boolean;
		/** 自定义图标 */
		icon?: ReactElement;
		/** 文本 */
		text?: string;
		/** 鼠标悬浮文案 */
		hoverTipText?: string;
		/** 折叠字段选择事件 */
		onChange?: (keys: string[]) => void;
		/** 触发交互弹出类型 */
		triggerType?: "drawer" | "dropdown";
	};
	/**
	 * 配置表格列中需要异步请求数据
	 * ```
	 * 1. 与table column asyncRender配合使用
	 * ```
	 */
	asyncColumnRequest?: {
		dataIndex: string;
		onRequest: () => Promise<TAny>;
	}[];
	/**
	 * 调用接口前自定义判断，返回Promise.resolve才能发起查询操作
	 * ```
	 * 例如：
	 *  breforeRequest={async (form) => {
	 *    await sleep(100);
	 *    return form.validateFields();
	 *  }}
	 * ```
	 */
	breforeRequest?: (form: FormInstance) => Promise<void>;
};
export type EasyTableRefApi = {
	/** 外部发起请求服务 */
	onRequest: (params?: TPlainObject) => void;
	/** 获取请求参数 */
	getRequestParams: () => TPlainObject;
	/**
	 * 清除Form查询条件
	 * ```
	 * 1. 会执行form.resetFields();
	 * 2. values 为清除后指定赋值form的数据
	 * ```
	 */
	clearQueryCondition: (values?: TPlainObject) => void;
	/** 更新Form查询条件，不会执行form.resetFields(); */
	updateQueryCondition: (values: TPlainObject) => void;
	/** 搜素表单实例 */
	form: FormInstance;
	/** 重置请求 */
	onResetRequest: (params?: TPlainObject) => void;
	/**
	 * 表格数据源，用在 useEffect、useMemo 中，可保持引用不变
	 */
	dataSource: TAny;
	/**
	 * 接口数据源
	 * ```
	 * 1. 每次获取到的都是新的实例
	 * 2. 可使用 easyTableRefApi.dataSource，获取不变实例
	 * ```
	 */
	getDataSource: () => TAny;
	/** 过滤表格数据源，不会触发 onDataSourceChange 函数 */
	onFilterDataSource: (dataSource: TPlainObject[]) => void;
	/** 清空表格数据 */
	onClearDataSource: () => void;
	/** 修改表格数据源，会触发onDataSourceChange函数  */
	onUpdateDataSource: (dataList: TPlainObject[]) => void;
	/** 自定义字段折叠触发位置，默认位置在最后一个字段标题右侧 */
	columnFoldTriggerRender: (children: ReactElement, columns: TEasyTableTableColumn<TPlainObject>[]) => ReactElement;
	/** 查询loading状态 */
	loading?: boolean;
	/**
	 * 更新 table columns 数据
	 * ```
	 * 1. 初始化阶段可使用 EasyTable.serviceConfig.dynamicColumsAdapter 实现动态表格列
	 * demo: https://fex.qa.tcshuke.com/docs/admin/main/table/easy-table?tabKey=key7
	 * ```
	 */
	onChangeTableColumns: (columns: TEasyTableTableColumn<TPlainObject>[]) => void;
	getTableColumns: () => TEasyTableTableColumn<TPlainObject>[];
	/** 设置启用初始化请求 */
	setEnabledInitRequest: () => void;
};
export type FormOperateColProps = {
	className?: string;
	leftList?: Array<ReactElement | null>;
	rightList?: Array<ReactElement | null>;
	justify?: RowProps["justify"];
	/** 强制单独一行 */
	forceAloneRow?: boolean;
	hidden?: boolean;
	leftSpaceProps?: SpaceProps;
	rightSpaceProps?: SpaceProps;
};
export type FormRowProps = RowProps & {
	children?: ReactNode | ReactNode[];
	/**
	 * default = { xs: 24, sm: 12, md: 8, lg: 8, xl: 8, xxl: 6 };
	 * small = { xs: 24, sm: 12, md: 8, lg: 6, xl: 6, xxl: 6 };
	 */
	gridSize?: "default" | "small";
};
export type EasyTableFilterProps = {
	children: ReactElement | ReactElement[] | ((form: FormInstance) => ReactElement);
	/** isPure = true时无效 */
	filterOperate?: (form: FormInstance) => FormOperateColProps;
	/** 是否为纯净模式（查询条件布局是否自定义）， */
	isPure?: boolean;
	/** 查询按钮配置 */
	queryButtonProps?: Omit<ButtonWrapperProps, "onClick"> & {
		text?: string;
	};
	/** 重置按钮配置 */
	resetButtonProps?: Omit<ButtonWrapperProps, "onClick"> & {
		text?: string;
	};
	/**
	 * 网格布局设置
	 * default = { xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 6 };
	 * small = { xs: 24, sm: 8, md: 8, lg: 6, xl: 6, xxl: 6 };
	 */
	formGridSize?: FormRowProps["gridSize"];
	/**
	 * @deprecated已过期，使用 easyFormProps.className 配置
	 */
	formClassName?: string;
	/**
	 * @deprecated已过期，使用 easyFormProps.style 配置
	 */
	formStyle?: CSSProperties;
	/** filter Form 外层 BlockLayout style */
	filterWrapperStyle?: CSSProperties;
	/** filter Form 外层 BlockLayout className  */
	filterWrapperClassName?: string;
	/**
	 * 自定义 filterOperate.rightList 后 默认【查询、重置】按钮处理逻辑
	 * 1. cover：覆盖内部查询重置按钮（默认值）
	 * 2. beforeAppend：添加到【查询重置】按钮前面
	 * 3. afterAppend：添加到【查询重置】按钮后面
	 *
	 * 如果想隐藏【查询、重置】按钮中的某一个，可设置 queryButtonProps.hidden、resetButtonProps.hidden
	 */
	rightOperateAreaAppendType?: "cover" | "beforeAppend" | "afterAppend";
	/** 默认重启按钮触发请求，默认值：true */
	defaultResetButtonTriggerRequest?: boolean;
	easyFormProps?: Omit<EasyFormProps, "isPure" | "column" | "forceColumn" | "width" | "gridGutter" | "children">;
};
export type EasyTableTableProps<T> = Omit<TableProps<TAny>, "dataSource" | "loading" | "rowKey" | "columns"> & {
	children?: ReactElement | ReactElement[];
	/**
	 * 表格行 key 的取值，
	 * ```
	 * 如果 rowKey 为string类型
	 * 1. 组件会判断表格列表数据第一条是否存在当前rowKey对象的数据，如果没有组件内部会动态添加唯一值
	 * 2. 基于上一条的逻辑，如果表格数据没有唯一值，可指定 rowKey 值为table数据中不存在的字段名，例如：rowKey="_uid"
	 * 3. 如果触发上述逻辑，表格数据中会多出rowKey对应的键值对数据
	 * ```
	 */
	rowKey: TableProps<TAny>["rowKey"];
	/** table Form 外层 SimpleLayout className  */
	tableWrapperStyle?: CSSProperties;
	/** table Form 外层 SimpleLayout className  */
	tableWrapperClassName?: string;
	/**
	 * ```
	 * 1. 当配置了 EasyTable.serviceConfig.dynamicColumsAdapter 后，columns配置只在初始化有效，再次修改无效
	 * 2. 可通过 EasyTableRef.onChangeTableColumns 实现 columns 的指定修改
	 * ```
	 */
	columns: TEasyTableTableColumn<T>[];
	/**
	 * 数据加载与表格初始化渲染 是否同步
	 * @version 4.4.6
	 * ```
	 * 1. true：获取数据后再初始化渲染表格（可用于实现表格中defaultXxxx相关功能的使用）
	 * ```
	 */
	isSync?: boolean;
	/**
	 * 空效果显示尺寸，默认值：small
	 * @version 4.4.6
	 */
	emptyShowSize?: "small" | "large";
};
/**
 * 对 查询条件+表格数据 进行深度封装，内置数据交互处理
 * ```
 * Demo https://fex.qa.tcshuke.com/docs/admin/main/crud/easy-table
 *
 * 1. 废弃modelKey参数
 * 2. 如果需要在路由跳转回退中缓存查询条件，设置cacheSwitch=true；如果存在多个EasyTable缓存情况可设置cacheSwitch为自定义字符串
 * 3. 需要获取查询条件、主动发起请求等可通过ref、useEasyTable操作
 * 4. 可通过属性 initRequest 设置初始化是否请求数据
 * 5. 可通过属性 fieldNames 来设置自定义变量，默认值为：list、total、pageNo、pageSize
 * 6. isFull=true，设置【在父节点高度下，上下铺满】（默认值：true）
 * 7. filterFixed=true，设置查询条件固定，不随滚动条滚动
 * 8. paginationFixed=true，可设置分页条件在底部固定，不随滚动条滚动
 * 9. foldKeys=string[]，查询条件展开、收起，被收起数组内容为EasyTable.Filter 子节点key值
 * 10. windows环境下，会在EasyTable.Table外部包装一下 TableScrollbar，提高windows下table左右滚动体验
 * 11. 可实现部分字段折叠，手动选择显示，将EasyTable.Table columns中isFold属性设为true，可通过EasyTable columnFoldConfig配置属性，demo（https://fex.qa.tcshuke.com/docs/admin/main/crud/demo1）
 * 12. 通过asyncColumnRequest、asyncRender配合使用可实现表格列数据接口渲染（demo：https://fex.qa.tcshuke.com/docs/admin/main/crud/easy-table）
 * ```
 */
export declare const EasyTable: import("react").ForwardRefExoticComponent<EasyTableProps & import("react").RefAttributes<EasyTableRefApi>> & {
	/**
	 * 过滤条件
	 *```
	 * 1. 用法1
	 *  -- 默认网格布局 规则：{ xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 6 }
	 *  <EasyTable.Filter>
	 *   <FormItemWrapper name="field1" label="条件1">xxx</FormItemWrapper>
	 *  </EasyTable.Filter>
	 *
	 *  -- 自定义网格布局 使用 FormGrid.Col 组件包装 FormItemWrapper
	 *  <EasyTable.Filter>
	 *    <FormGrid.Col span={12}><FormItemWrapper name="field1" label="条件1">xxx</FormItemWrapper></FormGrid.Col>
	 *  </EasyTable.Filter>
	 *
	 *  -- children 可为 function
	 *  <EasyTable.Filter>
	 *   {(form) => {
	 *     return <FormItemWrapper name="field1" label="条件1">xxx</FormItemWrapper>
	 *   }}
	 * </EasyTable.Filter>
	 * 2. 用户2（自定义布局）
	 *    EasyTable.Filter设置 isPure = true，FormItem无布局规则
	 * 3. EasyTable.Filter中内置了 Form 标签，当children为函数时，可获取form实例
	 * 4. 默认布局下，可通过设置 filterOperate 设置操作按钮
	 * 5. Filter 子节点包含 hidden = true 会被忽略
	 * 6. 如果想隐藏【查询、重置】按钮中的某一个，可设置 queryButtonProps.hidden、resetButtonProps.hidden
	 * 7. EasyTableFilter 子节点可使用 FormItemWrapper，FormItemWrapper中可配置label宽度等
	 * 8. 通过easyFormProps属性可整体控制子节点FormItem布局
	 *```
	 */
	Filter: (props: EasyTableFilterProps) => import("react").JSX.Element;
	/**
	 * 表格渲染
	 * @param props
	 * ```
	 * 1. 继承了 TableProps 可设置antd table功能
	 * 2. 分页功能已内置处理，不调用 onChange
	 * ```
	 */
	Table: <T extends import("@flatbiz/utils").TPlainObject>(props: EasyTableTableProps<T>) => import("react").JSX.Element;
	/**
	 * @deprecated 已过时 4.3.0版本移除，请使用 useEasyTable
	 */
	useEasyTablRef: () => {
		current: EasyTableRefApi;
	};
	/**  在 EasyTable子组件内才可使用 */
	useEasyTable: () => EasyTableRefApi;
	/** 设置启用初始化请求 */
	setEnabledInitRequest: (cacheKey: string) => void;
};
/**
 * 使用FormList实现可编辑卡片
 * ```
 * 1. 必须在外部包裹Form组件或者EasyForm组件
 * 2. 行内需要联动逻辑可使用 column.render.operation.setCurrentRowField 方法
 * 3. 可使用DragEditableCard组件实现拖拽排序
 *
 * demo
 * https://fex.qa.tcshuke.com/docs/admin/main/form/grid
 * ```
 */
export declare const EditableCard: (props: EditableCardProps) => import("react").JSX.Element;
export interface EditableFieldProps {
	className?: string;
	style?: CSSProperties;
	editRender: ReactElement | ((data: {
		value?: TAny;
		onChange?: (data?: TAny) => void;
	}) => ReactElement);
	viewRender?: (value?: TAny) => ReactNode;
	value?: TAny;
	onChange?: (data?: TAny) => void;
	placeholderValue?: string;
	/** edit 区域是否铺满，showEditableIcon=false 无效  */
	isEditFull?: boolean;
	/** 只读状态 */
	readonly?: boolean;
	/** 显示为编辑状态 */
	showEditable?: boolean;
	/** 是否显示编辑、确认、取消操作icon，默认值：true */
	showEditableIcon?: boolean;
	/** 点击编辑按钮，操作前，返回reject不会开启编辑效果 */
	onClickEditIconPre?: (value?: TAny) => Promise<void>;
	onEditCallback?: (value?: TAny) => void;
	/** 点击确定按钮，操作前，返回reject不会执行确定功能 */
	onClickConfirmIconPre?: (value?: TAny, preValue?: TAny) => Promise<void>;
	onConfirmCallback?: (value?: TAny, preValue?: TAny) => void;
	/** 组件操作Icon配置 */
	iconConfig?: {
		editIcon?: (options: {
			onClick: () => void;
		}) => ReactElement;
		confirmIcon?: (options: {
			onClick: () => void;
		}) => ReactElement;
		cancelIcon?: (options: {
			onClick: () => void;
		}) => ReactElement;
	};
}
/**
 * 可编辑字段组件
 * @param props
 * @returns
 * ```
 * 字段渲染有两种状态
 * 1. 只读：如果value类型为复杂格式，必须要通过【viewRender】来进行处理操作，转成简单数据类型
 * 2. 编辑：参数value的格式要求必须满足编辑组件入参value要求
 * 3. 可自定义编辑Icon、确定Icon、取消Icon
 * 4. 可拦截编辑操作、确定操作
 * ```
 */
export declare const EditableField: (props: EditableFieldProps) => any;
export interface EditableFieldProviderProps {
	children: ReactElement;
	/** 是否只读 */
	readonly?: boolean;
	/** 是否编辑状态 */
	showEditable?: boolean;
	/** 是否显示编辑操作按钮 */
	showEditableIcon?: boolean;
}
/**
 * EditableFieldProvider 控制内部使有的 EditableField 状态
 * @param props
 * @returns
 */
export declare const EditableFieldProvider: (props: EditableFieldProviderProps) => import("react").JSX.Element;
export interface ErrorBoundaryProps {
	message?: ReactNode;
	description?: ReactNode;
	children?: ReactNode;
	onRenderReset?: TNoopDefine;
	/** 栈消息最大高度，默认值200 */
	stackMaxHeight?: number | "auto";
}
export interface ErrorBoundaryStates {
	error?: Error | null;
	info?: {
		componentStack?: string;
	};
}
declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryStates> {
	state: {
		error: undefined;
		info: {
			componentStack: string;
		};
	};
	componentDidCatch(error: Error | null, info: object): void;
	render(): string | number | boolean | Iterable<ReactNode> | React.JSX.Element | null | undefined;
}
/**
 * react 异常拦截
 */
export declare const ErrorBoundaryWrapper: typeof ErrorBoundary;
export type FbaAppDrawerProps = Omit<DrawerProps, "onOk" | "onCancel" | "getContainer" | "footer" | "extra"> & {
	okText?: string | ReactElement;
	cancelText?: string | ReactElement;
	onOk?: (form: FormInstance, e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	onCancel?: (form: FormInstance, e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	content: string | ReactElement | ((form: FormInstance, operate: {
		onClose: DrawerProps["onClose"];
	}) => ReactElement);
	okButtonExtraProps?: Omit<ButtonWrapperProps, "onClick" | "children" | "loading">;
	cancelButtonExtraProps?: Omit<ButtonWrapperProps, "onClick" | "children">;
	okHidden?: boolean;
	cancelHidden?: boolean;
	/** 设置操作区域位置 */
	operatePosition?: "header" | "footer";
	/** 右上角自定义内容，如果operatePosition=header，此设置无效 */
	extra?: ReactNode | ((form: FormInstance) => ReactElement);
	/**
	 * ```
	 * 1. 自定义弹框操作区域，通过 operatePosition 配置可以自定义位置
	 * 2. extraData 为外部通过 useDialogModal.rerenderFooter 重新渲染footer携带的数据
	 * ```
	 */
	operateRender?: (form: FormInstance, extraData?: TPlainObject) => ReactElement;
};
export type FbaAppModalProps = Omit<ModalProps, "onOk" | "onCancel" | "getContainer" | "okButtonProps" | "cancelButtonProps" | "footer"> & {
	/**
	 * 内置尺寸，根据比例固定高度、宽度
	 * ```
	 * 1. 如果自定义了width、bodyHeight属性，size中的height、width将对应失效
	 * 2. 不传、传null值可取消内置尺寸
	 * ```
	 */
	size?: "small" | "middle" | "large" | null;
	onOk?: (form: FormInstance, e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	onCancel?: (form: FormInstance, e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
	onClose?: () => void;
	content: string | ReactElement | ((form: FormInstance, operate: {
		onClose: TNoopDefine;
	}) => ReactElement);
	okHidden?: boolean;
	cancelHidden?: boolean;
	okButtonProps?: Omit<ButtonWrapperProps, "hidden" | "children" | "onClick">;
	cancelButtonProps?: Omit<ButtonWrapperProps, "hidden" | "children" | "onClick">;
	/**
	 * 设置modal body height 为当前窗口height的百分比，例如：30
	 * @deprecated 已失效，可通过size属性设置
	 * ```
	 * 1. 最大值：80
	 * 1. 设置bodyStyle.height 后，bodyHeightPercent失效
	 * ```
	 */
	bodyHeightPercent?: number;
	titleExtra?: ReactElement;
	/**
	 * null则隐藏footer
	 * ```
	 * extraData 为外部通过 useDialogModal.rerenderFooter 重新渲染footer携带的数据
	 * ```
	 */
	footer?: null | ReactElement | ReactElement[] | ((form: FormInstance, extraData?: TPlainObject) => ReactElement);
	/** 内容高度，为styles.body.height快捷配置，优先级低于styles.body.height */
	bodyHeight?: number;
};
export type FbaAppConfirmProps = FbaAppModalProps;
export type FbaAppAlertProps = Omit<FbaAppModalProps, "onOk" | "cancelHidden" | "cancelButtonProps" | "onCancel" | "onClick"> & {
	onClick?: (e: React.MouseEvent<HTMLElement>) => void | Promise<void>;
};
export type FbaAppLoadingProps = {
	className?: string;
	message?: string;
	mask?: boolean;
};
export declare const FbaApp: ((props: {
	children: import("react").ReactNode;
}) => import("react").JSX.Element) & {
	/** 不支持多次弹框，第二个弹框可使用useDialogDrawer2 */
	useDialogDrawer: () => {
		appDialogDrawer: {
			open: (data: FbaAppDrawerProps) => {
				onClose: () => void;
			};
			close: () => void;
			useAppDialogDrawer: () => {
				rerenderFooter: (data?: import("@flatbiz/utils").TPlainObject) => void;
			};
		};
	};
	useDialogDrawer2: () => {
		appDialogDrawer2: {
			open: (data: FbaAppDrawerProps) => {
				onClose: () => void;
			};
			close: () => void;
			useAppDialogDrawer: () => {
				rerenderFooter: (data?: import("@flatbiz/utils").TPlainObject) => void;
			};
		};
	};
	/** 不支持多次弹框，第二个弹框可使用useDialogModal2 */
	useDialogModal: () => {
		appDialogModal: {
			open: (data: FbaAppModalProps) => {
				onClose: () => void;
			};
			close: () => void;
			useAppDialogModal: () => {
				rerenderFooter: (data?: import("@flatbiz/utils").TPlainObject) => void;
			};
		};
	};
	useDialogModal2: () => {
		appDialogModal2: {
			open: (data: FbaAppModalProps) => {
				onClose: () => void;
			};
			close: () => void;
			useAppDialogModal: () => {
				rerenderFooter: (data?: import("@flatbiz/utils").TPlainObject) => void;
			};
		};
	};
	/** 不支持多次弹框 */
	useDialogConfirm: () => {
		appDialogConfirm: {
			open: (data: FbaAppConfirmProps) => {
				onClose: () => void;
			};
			close: () => void;
		};
	};
	/** 不支持多次弹框 */
	useDialogAlert: () => {
		appDialogAlert: {
			open: (data: FbaAppAlertProps) => {
				onClose: () => void;
			};
			close: () => void;
		};
	};
	/** 不支持多次弹框 */
	useDialogLoading: () => {
		appDialogLoading: {
			open: (data?: FbaAppLoadingProps) => {
				onClose: () => void;
			};
			close: () => void;
		};
	};
};
export type ShouldUpdateFunc<T> = (prev: T | undefined, next: T) => boolean;
declare function usePrevious<T>(state: T, shouldUpdate?: ShouldUpdateFunc<T>): T | undefined;
export type CopyRemoveSpaceProps = {
	/** 设置监听复制范围，如果不设置则监听全局 */
	target?: () => Element;
	/**
	 * 忽略的class配置（不参与copy逻辑处理的class），例如：['ace_editor']
	 * ```
	 * 1. 某些控件（例如：ace编辑器、富文本等）内部自定义处理copy逻辑，此处不能进行拦截，通过配置class属性来忽略
	 * 2. ignoreClass可配置操作目标class、以及层层父节点class，通过目标节点以及层层父节点的class与ignoreClass匹配成功后，取消后续copy文案处理逻辑
	 * ```
	 */
	ignoreClass?: string[];
};
export declare const fbaHooks: {
	useEffectCustom: (fn: import("react").EffectCallback, deps: import("react").DependencyList) => void;
	useEffectCustomAsync: (fn: () => Promise<void>, deps: import("react").DependencyList) => void;
	useThemeToken: () => import("antd").GlobalToken;
	useArrayChange: <T>(defautDataList: Array<T>, forceUpdate?: boolean) => readonly [
		T[],
		{
			add: (dataItem: T | Array<T>, isUnshift?: boolean) => void;
			update: (index: number, dataItem: T) => void;
			delete: (index: number) => T[];
			resetList: (dataList: Array<T>) => void;
			getList: () => T[];
		}
	];
	usePrevious: typeof usePrevious;
	useResponsivePoint: () => string | undefined;
	useSafeState: <S extends undefined | unknown>(initialState?: S | (() => S)) => [
		S,
		import("react").Dispatch<import("react").SetStateAction<S>>
	];
	useMemoCustom: <T>(fn: () => T, deps: import("react").DependencyList) => T;
	useCopyRemoveSpace: (props?: CopyRemoveSpaceProps) => void;
};
declare function attachPropertiesToComponent<C, P extends Record<string, unknown>>(component: C, properties: P): C & P;
export declare const fbaUtils: {
	hasPermission: (name?: string) => boolean;
	getPermissionList: () => string[];
	attachPropertiesToComponent: typeof attachPropertiesToComponent;
	getModelKey: () => string;
	/**
	 * 手动触发Antd Form 的 onValuesChange
	 * ```
	 * 1. 正常在通过 form.setFieldsValue 不会触发onValuesChange
	 * 2. 需要触发可调用此方法
	 * ```
	 */
	triggerFormValuesChange: (form: FormInstance, changeList: {
		name: string | number | Array<string | number>;
		value: TAny;
	}[]) => void;
	/**
	 * 操作Antd Form
	 * ```
	 * 1. 通过 form.setFields 修改属性值
	 * 2. 触发 Form 的 onValuesChange
	 * ```
	 */
	setFormFieldsAndTriggerValuesChange: (form: FormInstance, changeList: {
		name: string | number | Array<string | number>;
		value: TAny;
	}[]) => void;
	/**
	 * 移除Form Values中无效字段
	 * ```
	 * 1. 在使用 DateRangePickerWrapperFormItem、TimeRangePickerWrapperFormItem 会产生 `__#invalid_xxxx` 无效字段
	 * ```
	 */
	removeFormValuesInvalidField: (params?: TPlainObject) => TPlainObject | undefined;
};
export type FileExportProps = {
	/** 触发节点 */
	action: (ReactElement & {
		onClick?: (e: any) => void;
	}) | ((data: {
		onClick: (e: any) => void;
	}) => ReactElement);
	/**
	 * 获取文件流数据
	 * ```
	 * 1. fileName 文件名称
	 * 2. data 文件流
	 * ```
	 */
	onRequest: () => Promise<{
		fileName: string;
		data: Blob;
	}>;
	/** 导出操作前 */
	onExportPre?: () => void;
	/** 导出操作后 */
	onExportNext?: () => void;
	/** 导出操作失败，隐藏默认失败效果 */
	onExportError?: (error?: any) => void;
};
/**
 * 文件导出
 * ```
 * demo：https://fex.qa.tcshuke.com/docs/admin/main/widget?key=file-export
 * 例如：
   <FileExport
	 action={<Button>下载</Button>}
	 onRequest={() => {
	   return serviceHandle.fileExport('/export/file', {});
	 }}
	 onExportNext={() => {
	   message.success('导出成功...');
	 }}
   />
 * ```
 */
export declare const FileExport: (props: FileExportProps) => import("react").JSX.Element;
export type FileImportProps = {
	/** 上传文件接口返回处理 */
	onImportFinish: (data?: TAny) => void;
	buttonName?: string | ReactElement;
	children?: ReactNode | ((data: {
		loading: boolean;
	}) => ReactNode);
} & Omit<UploadProps, "fileList" | "showUploadList" | "itemRender" | "listType" | "multiple" | "previewFile" | "progress" | "onChange" | "onDownload" | "onRemove" | "onPreview" | "directory" | "customRequest" | "defaultFileList" | "iconRender">;
/**
 * 文件导入
 * ```
 * demo：https://fex.qa.tcshuke.com/docs/admin/main/widget?key=file-export
 * 1. accept默认值 '.xlsx,.xls',
 * 2. formData 上传key默认值 file
 *
 * 例如：
   <FileImport
	 action={'https://xxx/xxx/xx'}
	 onImportFinish={(data) => {
	   console.log('上传接口响应数据', data);
	 }}
   >
	 <Button>文件上传</Button>
   </FileImport>
 * ```
 */
export declare const FileImport: {
	(props: FileImportProps): import("react").JSX.Element;
	defaultProps: {
		name: string;
		accept: string;
	};
};
export type FileSelectProps = {
	buttonName?: string | ReactElement;
	children?: ReactNode;
	/** 上传按钮与文件排版 默认：horizontal */
	direction?: "horizontal" | "hertical";
	/** 可选择文件格式，默认：.xlsx,.xls */
	accept?: string;
	onChange?: (file?: RcFile) => void;
	className?: string;
};
/**
 * 文件选择，内部不调用服务上传
 * ```
 * 默认选择文件格式：.xlsx,.xls
 * ```
 */
export declare const FileSelect: (props: FileSelectProps) => import("react").JSX.Element;
export type FlexLayoutProps = {
	className?: string;
	/** 子组件铺满的索引值，从0开始 */
	fullIndex: number | number[];
	/**方向，默认值vertical */
	direction?: "vertical" | "horizontal";
	onClick?: () => void;
	style?: CSSProperties;
	/** 间隙尺寸 */
	gap?: number;
	children?: ReactNode | null | Array<ReactNode | null>;
};
/**
 * flex布局，主要用于Flex结构性布局
 * ```
 * 4.2.87版本中将fullIndex改为了必填属性，如果在升级中遇到问题，不确定怎么写，可设置 fullIndex=[] 保持原样
 * ```
 */
export declare const FlexLayout: (props: FlexLayoutProps) => import("react").JSX.Element;
export type FormColProps = {
	/** 栅格占位格数，替换lg、xl、xxl默认数据 */
	span?: number;
	/** 屏幕 < 576px  */
	xs?: number;
	/** 屏幕 ≥ 576px */
	sm?: number;
	/** 屏幕 ≥ 768px */
	md?: number;
	/** 屏幕 ≥ 992px */
	lg?: number;
	/** 屏幕 ≥ 1200px */
	xl?: number;
	/** 屏幕 ≥ 1600px */
	xxl?: number;
	/** 强制单独一行 */
	forceAloneRow?: boolean;
	children?: ReactNode | ReactNode[];
	hidden?: boolean;
};
export declare const FormGrid: {
	/**
	 * FormItem网格响应式布局
	 *```
	 * 1. 应用场景：Form条件布局
	 * 2. 子元素只能是 FormGrid.Col、FormGrid.OperateCol，其他会被忽略
	 * 3. 所有子元素中只能存在一个 FormGrid.OperateCol
	 */
	Row: (props: FormRowProps) => import("react").JSX.Element;
	/**
	 * 网格响应式布局，默认值：{ xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 6 }
	 *```
	 * 1. 设置 span 栅格占位格数，替换lg、xl、xxl默认数据，不替换xs、sm布局数据
	 * 2. grid 自定义响应式网格布局
	 * xs: 屏幕 < 576px
	 * sm: 屏幕 ≥ 576px
	 * md: 屏幕 ≥ 768px
	 * lg: 屏幕 ≥ 992px
	 * xl: 屏幕 ≥ 1200px
	 * xxl: 屏幕 ≥ 1600px
	 * ```
	 */
	Col: {
		(props: FormColProps): import("react").JSX.Element | null;
		domTypeName: string;
	};
	/**
	 * FormOperateCol 布局说明
	 * ```
	 * 1. 网格数以及位置为动态计算，不支持 xs、sm、md等
	 * 2. 如果FormRow只有一行col，则OperateCol会在当前行剩余网格内居左对齐
	 * 3. 如果同时设置 leftList、rightList，则此cell会强制独占一行，并左右布局
	 * 4. 如果只设置 leftList、rightList其中一个，则会在最后一行剩余网格内居右对齐
	 * ```
	 */
	OperateCol: {
		(props: FormOperateColProps): import("react").JSX.Element | null;
		domTypeName: string;
	};
};
export type FormItemCardProps = {
	title?: string | ReactElement;
	children: ReactElement | ReactElement[];
	className?: string;
	style?: CSSProperties;
	titleSign?: boolean;
};
export declare const FormItemGroup: {
	HorizontalUnion: (props: FormItemHorizontalUnionProps) => import("react").JSX.Element;
	Card: import("react").FC<FormItemCardProps>;
};
export type FormItemHiddenProps = {
	name: FormItemProps["name"];
	className?: string;
	style?: CSSProperties;
};
export declare const FormItemHidden: {
	(props: FormItemHiddenProps): import("react").JSX.Element;
	domTypeName: string;
};
export type FormItemSpanProps = {
	span?: number;
	children?: ReactNode;
	className?: string;
	style?: CSSProperties;
	/** 是否移除 */
	hidden?: boolean;
};
/**
 * 包裹EasyForm children item元素, 设置自定义栅格占位格数（使用在EasyForm一级子节点下生效）
 * ```
 * EasyForm中自定义栅格占位格数方式
 * 1. 设置 FormItemWrapper、FormItemText 的 span 属性（支持移动端小屏幕span强制转为24逻辑）
 * 2. 使用 <BoxGrid.Col span={24} ></BoxGrid.Col> 包裹，设置 span 属性（不支持移动端小屏幕span强制转为24逻辑）
 * 3. 使用 <FormItemSpan span={24} ></FormItemSpan> 包裹，设置 span 属性（支持移动端小屏幕span强制转为24逻辑）
 *   <EasyForm>
 *    <FormItemSpan span={24}>
 *      <CardLayout title={'基本信息'}>
 *        <EasyForm nonuseFormWrapper>
 *          <FormItemWrapper></FormItemWrapper>
 *        </EasyForm>
 *      </CardLayout>
 *    </FormItemSpan>
 *    <FormItemSpan span={24}>
 *      <CardLayout title={'紧急联系人信息'}>
 *        <EasyForm nonuseFormWrapper>
 *          <FormItemWrapper></FormItemWrapper>
 *        </EasyForm>
 *      </CardLayout>
 *    </FormItemSpan>
 *  </EasyForm>
 * 4. 处在EasyFrom直接子节点时hidden、span属性生效
 * ```
 */
export declare const FormItemSpan: {
	(props: FormItemSpanProps): import("react").JSX.Element;
	domTypeName: string;
};
export type FormItemTextServiceConfig = {
	onRequest: (params?: TAny) => Promise<TAny>;
	/** 接口参数，当params发生变化后，会主动发送查询请求 */
	params?: TPlainObject;
	/** 标记serviceConfig.params中无效参数，被设置的params key 不传入服务接口入参  */
	invalidParamKey?: string[];
	/** 如果没有配置 render，返回结果会直接进行dom渲染，如果非string类型会进行JSON.stringify处理 */
	onResponseAdapter?: (respData?: TAny, value?: TAny) => TAny;
	/** 必须参数key列表，与params配合使用 */
	requiredParamsKeys?: string[];
};
export type FormItemTextProps = Omit<FormItemWrapperProps, "onChange"> & {
	/** 是否换行，默认不换行，超出省略（鼠标悬浮可显示） */
	wrap?: boolean;
	/** 自定义数据显示 */
	render?: (value?: TAny) => ReactNode;
	/** 占位值，当 value 为 ''、undefined、null时显示 */
	placeholderValue?: string;
	/**
	 * 发起服务调用显示数据，例如：数据为key，通过key查询text显示
	 * ```
	 * 1. 当serviceConfig.params发生变化后，会主动发送查询请求
	 * ```
	 */
	serviceConfig?: FormItemTextServiceConfig;
};
/**
 * FormItem 文本显示，默认不换行，超出省略（鼠标悬浮可显示）
 * ```
 * 可通过配置 serviceConfig 通过接口获取数据，一般用于 Select 数据显示
 *
 * 例如：
 * 1. 基本数据渲染
 * <FormItemText name="xxx" label="xxx" />
 * 2. 对象数据渲染
 * <FormItemText
 *   name="xxx"
 *   label="xxx"
 *   render={(value) => {
 *     const target = [].find(
 *       (item) => item.value === value,
 *     );
 *     return target ? (
 *       <Tag color={target['color']}>{target.label}</Tag>
 *     ) : null;
 *   }}
 * />
 * 3. 接口数据渲染
 * <FormItemText
 *   name="xxx"
 *   label="xxx"
 *   serviceConfig={{
 *     onRequest: () => {
 *       return serviceHandle.request('/random/api9468', {}, 'post');
 *     },
 *     onResponseAdapter: (dataList: TPlainObject[], value) => {
 *       return dataList?.find((item) => item.value === value);
 *     },
 *   }}
 *   render={(dataItem) => {
 *     return dataItem ? (
 *       <Tag style={{ margin: 0 }} color={dataItem['color']}>
 *         {dataItem.label}
 *       </Tag>
 *     ) : null;
 *   }}
 * />
 * ```
 */
export declare const FormItemText: {
	(props: FormItemTextProps): import("react").JSX.Element;
	domTypeName: string;
};
export type FormItemWrapperDependenciesProps = {
	children?: (form: FormInstance, otherProps: {
		style?: CSSProperties;
		className?: string;
	}) => ReactElement;
	dependencies: any[];
	className?: string;
	style?: CSSProperties;
};
/**
 * FormItem依赖写法包装，当处在EasyForm内部时，不支持  <Form.Item dependencies={['xxx']} noStyle /> 此写法，使用 <FormItemWrapperDependencies dependencies={['xxx']} /> 代替
 *
 * ```
 * 例如：（其中 otherProps 中 style、className透传是必要的）
 *  <FormItemWrapperDependencies dependencies={['xx2']}>
 *    {(_form, otherProps) => {
 *      return (
 *        <FormItemWrapper
 *          name="xxxxx"
 *          label="xx1"
 *          style={otherProps.style}
 *          className={otherProps.className}
 *        >
 *          <Input />
 *        </FormItemWrapper>
 *      );
 *    }}
 *  </FormItemWrapperDependencies>
 *
 *
 * 说明：
 * 透传style、className 是因为在EasyForm内部的BoxGrid组件下发的style、className在配置了noStyle后Form.Item不接收导致的
 *
 * ```
 */
export declare const FormItemWrapperDependencies: {
	(props: FormItemWrapperDependenciesProps): import("react").JSX.Element;
	domTypeName: string;
};
export type FormListWrapperContentProps = {
	/** Form.List item fieldData */
	formListFieldData: FormListFieldData;
	/**
	 * 当前阶段 完整 formItem name
	 * ```
	 * 1. 获取当前输入项Item数据
	 *    form.getFieldValue(props.formStageCompleteName);
	 * 2. 获取当前输入项Item指定字段数据
	 *    form.getFieldValue([...props.formStageCompleteName, 'key']);
	 * ```
	 */
	formStageCompleteName: (string | number)[];
	/**
	 * formList上一级 formItem完整name
	 */
	prevCompleteName: (string | number)[];
	/** Form.List 操作项 */
	operation: FormListOperation;
	/** 索引 */
	index: number;
	/** 获取当前FormList 内部 Form.Item name */
	getInsideFormItemName: (key: string | string[]) => Array<string | number>;
	/** 获取当前 FormList Item 数据 */
	getInsideFormItemData: () => TPlainObject;
	/** 唯一值字段Key */
	uidKey: string;
};
export type FormListWrapperProps = {
	className?: string;
	style?: CSSProperties;
	/** formList item 数据中的唯一值，默认值：uid */
	uidFieldName?: string;
	/** formList name */
	name: string | number | (string | number)[];
	/**
	 * formList上一级 formItem完整name
	 * ```
	 * 1. 如果没有传 []
	 * 2. FormList内部通过 Form.useWatch 取值需要完整 name
	 * ```
	 */
	prevCompleteName: (string | number)[];
	/** formListItem 内容 */
	/** 新增行默认值，自定义onTableAfterRender后失效 */
	getAddRowDefaultValues?: () => TPlainObject;
	/** 隐藏新增行按钮 */
	hiddenAddRowButton?: boolean;
	/** 自定义新增行按钮，getAddRowDefaultValues配置失效 */
	onCustomAddRowButton?: (operation: FormListOperation) => ReactElement;
	/** formListItem 内容 */
	children: (data: FormListWrapperContentProps) => ReactElement;
	/** 隐藏数据为空渲染 */
	hiddenEmptyRender?: boolean;
	/** formList内部渲染包装，多用于FormListWrapper嵌套布局 */
	formListChildrenWrapper?: (props: {
		children: ReactElement;
	}) => ReactElement;
	/**
	 * Form.List rules
	 * ```
	 rules={[
		{
		  validator: async (_, names) => {
			if (!names || names.length < 2) {
			  return Promise.reject(new Error('At least 2 passengers'));
			}
		  },
		},
	  ]}
	 * ```
	 */
	rules?: FormListProps["rules"];
	/**
	 * 设置FormList字段标题&必填标志
	 * ```
	 * demo: http://dev.flatjs.com:6007/pages/flat/oss-demo/main/form/list?env=me
	 * 1. 会根据数组顺序进行渲染
	 * ```
	 */
	formListItemTitleList?: {
		title: string;
		required?: boolean;
		width?: number;
	}[];
	/** formListItemTitle HorizontalUnionProps 配置 */
	formListItemTitleHorizontalUnionProps?: Omit<FormItemHorizontalUnionProps, "groupConfigList">;
	/** FormList Item 之间间隙，默认值：16 */
	itemGap?: number;
};
/**
 * Form.List 包装组件，使用更简单
 * ```
 * Demo: https://fex.qa.tcshuke.com/docs/admin/main/form/list
 * 1. FormList数组中必须要有唯一值字段，默认值字段名称uid，可通过uidFieldName自定义设置
 * 2. 通过 itemGap 设置FormList Item 之间间隙
 * ```
 */
export declare const FormListWrapper: (props: FormListWrapperProps) => import("react").JSX.Element;
export type GapProps = {
	height?: number;
	width?: number;
	className?: string;
	style?: CSSProperties;
	inline?: boolean;
};
/**
 * 间隙组件
 * @param props
 * @returns
 */
export declare const Gap: (props: GapProps) => import("react").JSX.Element;
export type IconWrapperProps = {
	hoverTips?: string | ReactElement;
	/**
	 * 提示类型
	 * @default 'tooltip'
	 */
	tipsType?: "popover" | "tooltip";
	icon?: ReactNode;
	style?: CSSProperties;
	text?: string | ReactElement;
	className?: string;
	size?: "small" | "middle" | "large";
	onClick?: (event: any) => void;
	hideHoverBgColor?: boolean;
	hidden?: boolean;
	/** 图标对比文字的位置，默认：brefore */
	position?: "before" | "after";
	/** 图标与文字之间的间距 */
	gap?: number;
};
export declare const IconWrapper: (props: IconWrapperProps) => import("react").JSX.Element;
export type InputSearchWrapperProps = Omit<SearchProps, "defaultValue">;
/**
 * ```
 * 1. 在输入框内输入拼音的时候，在拼音尚未输入完成时，字母会触发Input的onChange事件；导致以上效果的原因是input事件没办法知道我们在使用中文输入法
 * 2. 此处封装可以解决此问题，在输入拼音未完成时不会触达onChange，选择拼音结果触发onChange
 *
 * 3. 设置value时，内部可将受控操作转为非受控操作（具体实现逻辑，自行查看源码）
 * 4. 适用场景：需要通过onChange事件处理业务逻辑，例如：在onChange中调用接口数据
 * 5. defaultValue不可使用
 *
 * ```
 */
export declare const InputSearchWrapper: (props: InputSearchWrapperProps) => import("react").JSX.Element;
export type InputTextAreaWrapperProps = Omit<TextAreaProps, "defaultValue"> & {
	debounceDuration?: number;
};
/**
 * ```
 * 1. 在输入框内输入拼音的时候，在拼音尚未输入完成时，字母会触发Input的onChange事件；导致以上效果的原因是input事件没办法知道我们在使用中文输入法
 * 2. 此处封装可以解决此问题，在输入拼音未完成时不会触达onChange，选择拼音结果触发onChange
 *
 * 3. 设置value时，内部可将受控操作转为非受控操作（具体实现逻辑，自行查看源码）
 * 4. 适用场景：需要通过onChange事件处理业务逻辑，例如：在onChange中调用接口数据
 * 5. defaultValue不可使用
 *
 * ```
 */
export declare const InputTextAreaWrapper: (props: InputTextAreaWrapperProps) => import("react").JSX.Element;
export type InputWrapperProps = Omit<InputProps, "defaultValue"> & {
	debounceDuration?: number;
};
/**
 * ```
 * 1. 在输入框内输入拼音的时候，在拼音尚未输入完成时，字母会触发Input的onChange事件；导致以上效果的原因是input事件没办法知道我们在使用中文输入法
 * 2. 此处封装可以解决此问题，在输入拼音未完成时不会触达onChange，选择拼音结果触发onChange
 *
 * 3. 设置value时，内部可将受控操作转为非受控操作（具体实现逻辑，自行查看源码）
 * 4. 适用场景：需要通过onChange事件处理业务逻辑，例如：在onChange中调用接口数据
 * 5. defaultValue不可使用
 * 6. 可设置防抖执行时间
 * ```
 */
export declare const InputWrapper: (props: InputWrapperProps) => import("react").JSX.Element;
export type LabelValueLayoutProps = {
	options: {
		label: string | ReactElement;
		value?: string | number | ReactElement | null;
		span?: number;
		hidden?: boolean;
	}[];
	labelWidth?: number | "auto";
	column?: number;
	/** 添加边框 */
	bordered?: boolean;
	className?: string;
	style?: CSSProperties;
	/** 边框 row 内边距 */
	borderedRowPadding?: CSSProperties["padding"];
};
/**
 * @deprecated 已过期，请使用 LabelValueRender 组件
 * options[].span 是 Description.Item 的数量。 span={2} 会占用两个 DescriptionItem 的宽度
 * options[].hidden 是否隐藏 Description.Item
 */
export declare const LabelValueLayout: (props: LabelValueLayoutProps) => import("react").JSX.Element;
export type TLabelValueItem = {
	label: string | ReactElement;
	value?: string | number | ReactElement;
	/** 根据LabelValueRender.column配置，当前item占几列  */
	span?: 1 | 2 | 3 | 4 | 6;
	/** 是否隐藏 */
	hidden?: boolean;
	/** 超出宽度是否隐藏 */
	ellipsis?: boolean;
	/** 是否添加必填标识 */
	required?: boolean;
	/** 添加说明标签 */
	tips?: string;
	/** value 点击事件 */
	onClick?: (e: any) => void;
	/** 关闭tooltip功能 */
	hideTip?: boolean;
	/** value 渲染不使用 TextOverflow 包裹 */
	valueNoWrapper?: boolean;
	labelStyle?: CSSProperties;
	valueStyle?: CSSProperties;
};
export type LabelValueRenderProps = {
	className?: string;
	style?: CSSProperties;
	/**
	 * 定义一行显示几列, 默认值：4
	 * ```
	 * 1. label+value 一组为一列
	 * 2. 当外层宽度尺寸大于 992px（lg） 时，一行显示几列
	 * 3. 当外层宽度尺寸小于992px（lg），为xs、sm、md情况下不受column值影响，响应式布局
	 * 4. 宽度尺寸定义
	 *    xs: 宽度 < 576px
	 *    sm: 宽度 ≥ 576px
	 *    md: 宽度 ≥ 768px
	 *    lg: 宽度 ≥ 992px
	 *    xl: 宽度 ≥ 1200px
	 *    xxl: 宽度 ≥ 1600px
	 * 5. 列数尺寸定义
	 *  {
	 *    1: { xs: 24, sm: 24, md: 24, lg: 24, xl: 24, xxl: 24 },
	 *    2: { xs: 24, sm: 12, md: 12, lg: 12, xl: 12, xxl: 12 },
	 *    3: { xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 8 },
	 *    4: { xs: 24, sm: 12, md: 12, lg: 6, xl: 6, xxl: 6 },
	 *    6: { xs: 24, sm: 12, md: 8, lg: 6, xl: 4, xxl: 4 },
	 *  };
	 * ```
	 */
	column?: 1 | 2 | 3 | 4 | 6;
	/**
	 * 强制定义一行显示几列，不考虑响应式
	 * ```
	 * 1. 优先级大于column
	 * 2. 建议优先使用column配置
	 * ```
	 */
	forceColumn?: 1 | 2 | 3 | 4 | 6;
	/** 数据源配置 */
	options: TLabelValueItem[];
	/**
	 * 超过宽度将自动省略，默认值：true
	 * ```
	 * 1. 当 direction = vertical时，强制为true
	 * ```
	 */
	ellipsis?: boolean;
	/**
	 * 是否添加边框
	 * @deprecated 已过期，请使用 bordered
	 */
	border?: boolean;
	/** 是否添加边框 */
	bordered?: boolean;
	/** label对齐方式 */
	labelAlign?: "left" | "right" | "center";
	/** label 宽度，默认值：100 */
	labelWidth?: number | "auto";
	width?: number;
	/** label 样式 */
	labelStyle?: CSSProperties;
	/** value 样式 */
	valueStyle?: CSSProperties;
	size?: "default" | "small";
	/**
	 * label&value 方向布局
	 * ```
	 * 1. auto表示当响应式为xs（小屏幕）时为vertical，其他情况为horizontal
	 * ```
	 */
	direction?: "vertical" | "horizontal" | "auto";
	/**
	 * 网格布局间距，默认值：[10, 0]
	 * ```
	 * 1. border = true 无效
	 * ```
	 */
	gutter?: [
		number,
		number
	];
	/** 隐藏 value hover效果 */
	hiddenValueHover?: boolean;
};
/**
 * label+value 列表布局
 * ```
 * 1. 可设置超出隐藏、必填标识、设置隐藏、添加说明标签等功能
 * 2. 可自定义设置占用网格列数
 * 3. 内置响应式布局
 * ```
 */
export declare const LabelValueRender: (props: LabelValueRenderProps) => import("react").JSX.Element;
export type LocalLoadingServiceConfig = {
	onRequest: (params?: TAny) => Promise<TAny>;
	params?: TPlainObject;
	/** 标记serviceConfig.params中无效参数，被设置的params key 不传入服务接口入参  */
	invalidParamKey?: string[];
	/** 必填字段设置 */
	requiredParamsKeys?: string[];
};
export interface LocalLoadingProps {
	className?: string;
	style?: CSSProperties;
	contentStyle?: CSSProperties;
	/** 接口数据配置 */
	serviceConfig: LocalLoadingServiceConfig;
	/** children 为函数，参数【respData】为接口返回数据 */
	children: (respData?: TAny) => ReactElement;
	/**
	 * 是否异步，默认：false
	 * ```
	 * true（异步）：onRequest、react dom渲染同步执行
	 * false（同步）：onRequest有结果了才渲染 react dom
	 * ```
	 */
	isAsync?: boolean;
	/** loading高度，默认值：100；isAsync = true 无效 */
	loadingHeight?: number | string;
	/** loading spin 属性设置 */
	loadingSpinProps?: {
		/** loading tip，默认值：Loading */
		tip?: string;
		/** loading 内容 */
		content?: ReactElement;
		/** 背景色，默认值：rgba(0,0,0,0.01) */
		bgColor?: string;
	};
	textConfigs?: {
		/** 必填异常文本 */
		requiredErrorText?: string;
	};
	/** 是否显示必填异常 */
	showRequiredError?: boolean;
	/** 自定义异常渲染处理 */
	errorRender?: (error?: TAny) => ReactElement;
	/** 设置内部滚动，需要设置 style.height 才能生效，@5.0.16 */
	contentScroll?: boolean;
	/** 设置高度 */
	height?: number | string;
}
export type LocalLoadingRefApi = {
	onRefresh: (params?: TPlainObject) => void;
};
/**
 * 局部加载，包含接口数据处理逻辑
 * ```
 * 包括
 * 1. loading显示效果、error显示效果、获取服务数据
 * 2. 当 serviceConfig.params 值与上一次值不相等时，会主动发起服务调用
 * 3. 通过 serviceConfig.requiredParamsKeys 设置服务调用必填字段
 * 4. 通过 ref.onRequest 可主动发起服务调用
 * 5. 子组件通过下面方式主动发起服务调用
 *    const localLoadingApi = LocalLoading.useLocalLoading();
 *    localLoadingApi.onRequest();
 * 6. 如果内部需要滚动条，可设置 contentScroll = true （外部有高度或者设置style.height 才能生效）
 * ```
 */
export declare const LocalLoading: import("react").ForwardRefExoticComponent<LocalLoadingProps & import("react").RefAttributes<LocalLoadingRefApi>> & {
	useLocalLoading: () => {
		onRequest: (params?: TPlainObject) => void;
	};
};
export type MentionsWrapperRef = {
	getInputInstance: () => any;
};
export type MentionsWrapperProps = Omit<MentionProps, "value" | "onChange" | "onClick" | "onCursorChange" | "options" | "id" | "split" | "validateSearch" | "ref" | "prefix"> & {
	value?: string;
	onChange?: (value?: string) => void;
	/** 设置列表提示关键字，例如：@、$等 */
	prefix?: string | string[];
	onClick?: (value?: string) => void;
	/** 光标移动回调 */
	onCursorChange?: (position: number) => void;
	/**
	 * 输入框内整体关键词列表
	 * ```
	 * 整体关键词交互
	 * 1. 光标可整体移动
	 * 2. 光标不会存在关键词内部
	 * 3. 删除时，整体删除
	 * ```
	 */
	options?: string[];
};
/**
 * 基于Antd Mentions进行二次封装，可实现输入内关键字整体控制，包括光标移动、关键词删除等
 * ```
 * 可实现
 * 1. 控制光标输入
 * 2. 可设置关键词，光标不会出现在关键词内部
 * 3. 可整体删除关键词
 *
 * 应用场景例如：
 * 1. 公式输入
 * (【xx金额1】+【xx金额2】)*2
 * <MentionsWrapper prefix="$" options={['【xx金额1】', '【xx金额2】']}/>
 *
 * 2. 短信模板设置
 * 您的订单号为${订单号}，订单交易时间为${订单时间}
 * <MentionsWrapper prefix="$" options={['${订单号}', '${订单时间}']}/>
 *
 * demo：https://fex.qa.tcshuke.com/docs/admin/main/other/widget
 * ```
 *
 */
export declare const MentionsWrapper: import("react").ForwardRefExoticComponent<Omit<MentionProps, "ref" | "split" | "onClick" | "id" | "prefix" | "onChange" | "value" | "onCursorChange" | "options" | "validateSearch"> & {
	value?: string;
	onChange?: (value?: string) => void;
	/** 设置列表提示关键字，例如：@、$等 */
	prefix?: string | string[];
	onClick?: (value?: string) => void;
	/** 光标移动回调 */
	onCursorChange?: (position: number) => void;
	/**
	 * 输入框内整体关键词列表
	 * ```
	 * 整体关键词交互
	 * 1. 光标可整体移动
	 * 2. 光标不会存在关键词内部
	 * 3. 删除时，整体删除
	 * ```
	 */
	options?: string[];
} & import("react").RefAttributes<MentionsWrapperRef>>;
export type ParamItem = {
	/** 模版参数code */
	code: string;
	/** 模版参数类型 文本/数字/链接 */
	type: "text" | "number" | "link";
	/** 模版参数 value */
	value: TAny;
} & Record<string, TAny>;
export type OperationPresetProps = {
	/** icon */
	icon: ReactElement;
	/** 模版参数文案 */
	label?: string;
	/** 模版参数类型 */
	type: string;
	/** 自增code前缀 */
	codePrefix: string;
	/** 自定义生成模版参数code */
	codeAdapter?: () => string | undefined;
};
export type MentionEditorProps = Omit<MentionsWrapperProps, "prefix"> & {
	/**
	 * onChange
	 * @item 点击的预设模版参数
	 */
	onSelectParam?: (item: ParamItem, prefix?: string) => void;
	/** 模版参数前缀 & ｜ $ */
	prefix?: string;
	/** editor 支持添加的模版参数类型 */
	operations?: OperationPresetProps[];
	/** 模版参数列表 */
	params?: ParamItem[] | undefined;
};
/**
 * 基于MentionWrapper封装的模版字符串配置组件
 * 1. 提供变量，数字，链接等可选的模版参数
 * 2. 不同类型模版参数可配置多个
 * 3. mention 会根据 传入的params自动推断出关键字
 * 4. 模版参数建议都以${_xxx}为格式
 * 5. Demo: https://fex.qa.tcshuke.com/docs/admin/main/widget?key=mention-editor
 */
export declare const MentionEditor: (props: MentionEditorProps) => import("react").JSX.Element;
export interface ModalActionProps {
	children: ReactElement | ((data: {
		onClose: () => void;
		open: boolean;
	}) => ReactElement);
	action?: (ReactElement & {
		onClick?: (e: any) => void;
	}) | ((data: {
		onClick: (e: any) => void;
		onClose: () => void;
		open: boolean;
	}) => ReactElement);
}
/**
 * 弹框 触发器
 * ```
 * <ModalAction action={<Button type="primary">打开</Button>}>
 *   {({ onClose }) => (
 *     <Modal onOk={onClose}>xxx</Modal>
 *   )}
 * </ModalAction>
 * ```
 */
export declare const ModalAction: (props: ModalActionProps) => import("react").JSX.Element;
type InputNumberProps$1 = GetProps<typeof InputNumber>;
export type NumberRangeFormItemProps = Omit<FormItemWrapperProps, "name" | "rules"> & {
	minFormItemName: FormItemNamePath;
	maxFormItemName: FormItemNamePath;
	/** 是否必填 */
	required?: boolean;
	/** 必填验证异常文案 */
	requiredRuleMessage?: string | [
		string,
		string
	];
	/** 范围验证异常文案 */
	rangeRuleMessage?: string | [
		string,
		string
	];
	minInputNumberProps?: Omit<InputNumberProps$1, "value">;
	maxInputNumberProps?: Omit<InputNumberProps$1, "value">;
	/** 最小值与最大值输入是否可以相同 */
	isInputEqual?: boolean;
};
/**
 * 数字输入范围组件
 */
export declare const NumberRangeFormItem: (props: NumberRangeFormItemProps) => import("react").JSX.Element;
export type PageFixedFooterProps = {
	className?: string;
	style?: CSSProperties;
	children?: ReactNode | ReactNode[];
	hidden?: boolean;
};
export declare const PageFixedFooter: (props: PageFixedFooterProps) => import("react").JSX.Element | null;
export type Page404Props = {
	message?: string;
};
export declare const Page404: (props: Page404Props) => import("react").JSX.Element;
/**
 * 由于 antd 5.3.x 分页Pagination组件，存在点击分页选择框时，一直朝下
 * issues：https://github.com/ant-design/ant-design/issues/36866
 * 为了兼容，在 Pagination 中添加了 selectComponentClass 属性，后期antd 官方优化了bug，可取消 配置selectComponentClass
 * @param props
 * @returns
 */
export declare const PaginationWrapper: (props: PaginationProps) => import("react").JSX.Element;
/**
 * pdf预览
 * ```
 * 使用方式：在cdn.ts中引入 '//file.40017.cn/tcsk/react/pdf@3.2.146/pdf.min.js'
 * Git: https://github.com/mozilla/pdfjs-dist/tree/master
 * Demo: https://fex.qa.tcshuke.com/docs/admin/main/file/pdf
 * Demo: https://fex.qa.tcshuke.com/docs/admin/main/file/pdf-seal
 * ```
 */
export declare const Pdf: {
	Document: (props: {
		pdfUrl: string;
		onLoadError?: (error: any) => void;
		onLoadSuccess?: (pdfInstance: any) => void;
		children: import("react").ReactNode;
		error?: import("react").ReactElement | ((error: any) => import("react").ReactElement);
		className?: string;
	}) => import("react").JSX.Element;
	Page: (props: {
		onRenderSuccess?: (pageInstance: any, pdfInstance: any) => void;
		onRenderError?: (error: any, pdfInstance: any) => void;
		width?: number;
		scale?: number;
		gap?: number;
		pageNumber: number;
		children?: import("react").ReactNode;
		onClick?: (e: any) => void;
		className?: string;
		style?: import("react").CSSProperties;
	}) => import("react").JSX.Element;
};
export type PdfPreviewProps = {
	pdfUrl: string;
	/** 缩放比例，默认值：1 */
	scale?: number;
	className?: string;
	/** 导航pdf，缩放比例，默认值：0.2 */
	navigationScale?: number;
	/** 隐藏导航栏 */
	hiddenNavigation?: boolean;
	/** 导航栏宽度，默认值：200 */
	navigationWidth?: number;
};
/**
 * pdf预览方式1
 * ```
 * 使用方式：在cdn.ts中引入 '//file.40017.cn/tcsk/react/pdf@3.2.146/pdf.min.js'
 * Git: https://github.com/mozilla/pdfjs-dist/tree/master
 * Demo: https://fex.qa.tcshuke.com/docs/admin/main/file/pdf
 * Demo: https://fex.qa.tcshuke.com/docs/admin/main/file/pdf-seal
 * ```
 */
export declare const PdfPreview: (props: PdfPreviewProps) => import("react").JSX.Element;
export type PdfPreview2Props = {
	pdfUrl: string;
	/** 网络环境，inner/内网，outer/外网，默认inner */
	networkEnv?: "inner" | "outer";
};
/**
 * PDF预览方式2
 * ```
 * 1. 使用 https://web.tcshuke.com/webapps/pdf-preview/index.html 作为载体预览PDF
 * 2. 预览PDF载体git项目：https://gitlab.itcjf.com/statics/pdf-preview
 * 3. networkEnv 设置内网、外网，默认内网
 * ```
 */
export declare const PdfPreview2: (props: PdfPreview2Props) => import("react").JSX.Element;
export interface PermissionProps {
	name?: string;
	children?: ReactNode | ReactNode[];
}
export declare const Permission: (props: PermissionProps) => import("react").JSX.Element | null;
/**
 * 预定义className
 * ```
 * form: 使用在Form组件上，设置form-item label宽度
 * formItem: 使用在Form.Item组件上，设置form-item label宽度
 * ```
 */
export declare const preDefinedClassName: {
	/**
	 * @deprecated，已过期，使用preDefinedClassName.getFormLayoutClassName(...)
	 */
	form: {
		label_width_70: string;
		label_width_80: string;
		label_width_90: string;
		label_width_100: string;
		label_width_110: string;
		label_width_120: string;
		label_width_130: string;
		label_width_140: string;
		label_width_150: string;
		label_width_160: string;
		label_width_170: string;
		label_width_180: string;
		label_width_190: string;
		label_width_200: string;
		label_width_auto: string;
		label_align_left: string;
		label_align_right: string;
		label_value_vertical: string;
		formItemGap15: string;
		formItemGap8: string;
		formItemGap5: string;
		formItemGap0: string;
	};
	/**
	 * @deprecated 已过期，使用preDefinedClassName.getFormItemLayoutClassName(...)
	 */
	formItem: {
		label_width_70: string;
		label_width_80: string;
		label_width_90: string;
		label_width_100: string;
		label_width_110: string;
		label_width_120: string;
		label_width_130: string;
		label_width_140: string;
		label_width_150: string;
		label_width_160: string;
		label_width_170: string;
		label_width_180: string;
		label_width_190: string;
		label_width_200: string;
		label_width_auto: string;
		label_align_left: string;
		label_align_right: string;
		label_value_vertical: string;
	};
	/**
	 * 获取针对Form下全部label布局的预设className，包括
	 * ```
	 * 1. formLabel宽度
	 * 2. formLabel对齐方式
	 * 3. form label value的竖直布局
	 * 4. formItem之间的间距
	 * ```
	 */
	getFormLayoutClassName: (props: TFormLayoutPreClassNameProps) => string;
	/**
	 * 获取针对单个FormItem label布局的预设className，包括
	 * ```
	 * 1. formLabel宽度
	 * 2. formLabel对齐方式
	 * 3. form label value的竖直布局
	 * ```
	 */
	getFormItemLayoutClassName: (props: TFormItemLayoutPreClassNameProps) => string;
};
export type RadioGroupWrapperValue = string | number | boolean;
export type RadioGroupWrapperOptionItem = {
	label: string | ReactElement;
	value: RadioGroupWrapperValue;
	disabled?: boolean;
};
export type CustomRadioGroupProps = {
	value?: RadioGroupWrapperValue;
	onChange?: (value?: RadioGroupWrapperValue) => void;
	onPreChange?: (value?: RadioGroupWrapperValue) => Promise<void>;
	options: RadioGroupWrapperOptionItem[];
	/** 是否可取消选中，默认：false */
	isCancel?: boolean;
	disabled?: boolean;
	/**方向，默认值 horizontal */
	direction?: "horizontal" | "vertical";
};
/**
 * RadioGroupWrapper 为了解决 RadioGroup 组件不能取消选中问题
 * @param props
 * @returns
 */
export declare const RadioGroupWrapper: (props: CustomRadioGroupProps) => import("react").JSX.Element;
export type RelationProps = {
	/** 左侧Tag+线占用宽度 */
	tagLineWidth?: number;
	/** 缩进宽度，配合【RelationGroup】使用 */
	indentWidth?: number;
	/** 连接线上Tag文案 */
	tagName?: string;
	/** 连接线上Tag颜色 */
	tagColor?: string;
	/** 连接线上Tag宽度 */
	tagWidth?: number;
	/** 连接线上Tag点击事件 */
	onTagClick?: (tagName?: string) => void;
	/**连接线颜色 */
	lineColor?: string;
	solt1: () => ReactElement;
	solt2?: () => ReactElement | null;
	className?: string;
	onlyOne?: boolean;
	onlyNoMainOne?: boolean;
	label?: string;
};
export type RelationTreeProps = {
	className?: string;
	dataSource?: TRelationTreeData;
	children: (data: TRelationTreeCustomData, operate: TRelationTreeOperate, extraData?: TPlainObject) => ReactElement;
	onChange?: (dataSource?: TRelationTreeData) => void;
	relationProps?: Pick<RelationProps, "tagLineWidth" | "indentWidth" | "tagColor" | "tagWidth" | "lineColor">;
	onTagClick?: (uid: string, extraData?: TPlainObject) => void;
};
export type TRelationTreeCustomData = TPlainObject & {
	uid: string;
};
export type TRelationTreeRelationItem = {
	uid: string;
	customData?: TRelationTreeCustomData;
	children?: TRelationTreeData[];
	extraData?: TPlainObject;
};
export type TRelationTreeData = {
	uid: string;
	tagName: string;
	label?: string;
	relationList: TRelationTreeRelationItem[];
	extraData?: TPlainObject;
};
export type TRelationTreeOperate = {
	add: (soruceData: TRelationTreeCustomData, initialData: TRelationTreeRelationItem) => void;
	addChildren: (soruceData: TRelationTreeCustomData, initialData: TRelationTreeData) => void;
	remove: (uid: string) => void;
	onChange: (name: string, value: TAny) => void;
};
export declare const RelationTree: (props: RelationTreeProps) => import("react").JSX.Element;
export interface RichTextEditorProps extends Omit<IAllProps, "onChange" | "init"> {
	/** 设置高度，默认：500 */
	height?: number;
	onChange?: (data?: string) => void;
	/** 上传图片服务 */
	onUploadImage?: (file: File) => Promise<string>;
	/** 图片点击预览 */
	imgPreview?: boolean;
	init?: IAllProps["init"] & {
		/**
		 * 通过粘贴图片创建的img标签，显示压缩比例，此处min、max是和指图片宽度
		 * ```
		 * 1. 默认值：[{ min: 0, max: 1000, ratio: 0.5 }, { min: 1000, ratio: 0.3 }]
		 * ```
		 */
		img_ratio?: {
			min: number;
			max?: number;
			ratio: number;
		}[];
		/**
		 *  粘贴文本大小限制
		 * ```
		 * 1. limit 限制大小，单位KB，例如限制2M，值为2*1024
		 * 2. 限制提示文案
		 * ```
		 */
		paste_text_limit?: {
			limit: number;
			message: string;
		};
		/** 插件添加；自定义plugins后失效 */
		plugins_append?: string;
		/** 工具栏添加；自定义toolbar后失效  */
		toolbar_append?: string;
	};
	/** 点击全屏按钮回调 */
	onFullScreenChange?: (state?: boolean) => void;
	className?: string;
}
/**
 * 富文本编辑器，配置参考tinymce https://www.tiny.cloud/docs/tinymce/6
 * @param props
 * @returns
 * ```
 * 1. 如果需要粘贴上传图片服务，需要提供 onUploadImage 上传图片接口
 * 2. 获取富文本实例，通过onInit(_, editor)函数获取
 * 3. 预览富文本数据，使用 RichTextViewer 组件
 * 4. 添加其他插件使用方式，配置 init.plugins_append、init.toolbar_append
 *    <RichTextEditor init={{ plugins_append: 'codesample', toolbar_append: 'codesample' }} />
 * 5. 可通过设置 init.plugins、init.toolbar 完全自定义插件、工具栏
 * 6. 其他插件
 *    emoticons 表情插件
 * 7. 可通过设置 init.img_ratio 设置通过粘贴上传的图片压缩显示比例
 *    默认比例：[{ min: 0, max: 1000, ratio: 0.5 }, { min: 1000, ratio: 0.3 }]
 * ```
 */
export declare const RichTextEditor: (props: RichTextEditorProps) => import("react").JSX.Element;
export type RichTextViewerProps = {
	value: string;
	className?: string;
	style?: CSSProperties;
	fullscreen?: boolean;
	onInit?: (editor: TinyMCEEditor) => void;
	children?: ReactElement;
	fullscreenIconTips?: string;
};
/**
 * 预览 RichTextEditor 生成的富文本数据
 * ```
 * 1. 通过 onInit 属性可获取实例：editor
 * 2. 如果高度发生变更，可执行 editor.execCommand('mceAutoResize');
 *
 * ```
 * @param props
 * @returns
 */
export declare const RichTextViewer: (props: RichTextViewerProps) => import("react").JSX.Element;
export type RollLocationCenterProps = {
	renderList: {
		activeKey: string;
		render: ReactElement;
	}[];
	activeKey?: string;
	behavior?: ScrollBehavior;
	direction?: "horizontal" | "vertical";
	style?: CSSProperties;
	className?: string;
};
export declare const RollLocationCenter: (props: RollLocationCenterProps) => import("react").JSX.Element;
export type RollLocationInViewProps = {
	renderList: {
		activeKey: string;
		render: ReactElement;
	}[];
	activeKey?: string;
	behavior?: ScrollBehavior;
	activeOffset?: number;
	direction?: "horizontal" | "vertical";
	style?: CSSProperties;
	className?: string;
};
export declare const RollLocationInView: (props: RollLocationInViewProps) => import("react").JSX.Element;
export type RuleDataItem = {
	title?: string | ReactElement;
	desc?: string | ReactElement;
};
export type RuleDescribeProps = {
	title?: string;
	showTitleIndex?: boolean;
	ruleDataList: RuleDataItem[];
	titleSign?: boolean;
	className?: string;
	ruleItemTitleStyle?: CSSProperties;
	ruleItemDescStyle?: CSSProperties;
	ruleItemStyle?: CSSProperties;
};
export declare const RuleDescribe: (props: RuleDescribeProps) => import("react").JSX.Element;
export type SearchFormProps = {
	children: ReactElement | ReactElement[] | ((form: FormInstance) => ReactElement);
	/** isPure = true时无效 */
	searchOperate?: (form: FormInstance) => FormOperateColProps;
	/** 是否为纯净模式（查询条件布局是否自定义）， */
	isPure?: boolean;
	/** 查询按钮配置 */
	queryButtonProps?: Omit<ButtonWrapperProps, "onClick"> & {
		text?: string;
	};
	/** 重置按钮配置 */
	resetButtonProps?: Omit<ButtonWrapperProps, "onClick"> & {
		text?: string;
	};
	/**
	 * 网格布局设置
	 * default = { xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 6 };
	 * small = { xs: 24, sm: 8, md: 8, lg: 6, xl: 6, xxl: 6 };
	 */
	formGridSize?: FormRowProps["gridSize"];
	formClassName?: string;
	formStyle?: CSSProperties;
	/** form 初始值 */
	formInitialValues?: TPlainObject;
	/** label宽度，Form内部所有FormItem label都生效 */
	formLabelWidth?: FormWrapperProps["labelWidth"];
	/** labelItem 竖直布局 */
	formLabelItemVertical?: FormWrapperProps["labelItemVertical"];
	/** label 对齐方式 */
	formLabelAlign?: FormWrapperProps["labelAlign"];
	/** formItem之间竖直间距，默认值：24 */
	formFormItemGap?: FormWrapperProps["formItemGap"];
	/**
	 * 自定义 searchOperate.rightList 后 默认【查询、重置】按钮处理逻辑
	 * 1. cover：覆盖内部查询重置按钮（默认值）
	 * 2. beforeAppend：添加到【查询重置】按钮前面
	 * 3. afterAppend：添加到【查询重置】按钮后面
	 *
	 * 如果想隐藏【查询、重置】按钮中的某一个，可设置 queryButtonProps.hidden、resetButtonProps.hidden
	 */
	rightOperateAreaAppendType?: "cover" | "beforeAppend" | "afterAppend";
	/** 默认重启按钮触发请求，默认值：true */
	defaultResetButtonTriggerRequest?: boolean;
	/**
	 * 展开、收起key值列表（内容当前组件子组件key值）
	 */
	foldKeys?: string[];
	/**
	 * 按钮提交事件
	 * 如果需要自定义回车提交事件，需要自定义提交按钮
	 */
	onFormFinish?: (values?: TPlainObject) => void;
	/** 重置按钮 */
	onReset?: () => void;
	/** 查询按钮 */
	onQuery?: (values: TPlainObject) => void;
	/**
	 * 是否缓存查询数据，默认值：true
	 * ```
	 * 1. 一般首页可缓存，二级、三级等页面不能缓存
	 * ```
	 */
	cacheSwitch?: boolean;
	/** 初始化是否请求，默认值：true */
	initRequest?: boolean;
	form?: FormInstance;
};
export type SearchFormRefApi = {
	onQuery: (values?: TPlainObject) => void;
	form: FormInstance;
};
/**
 * 搜索表单
 *
 *```
 * 1. 用法1
 *  -- 默认网格布局 规则：{ xs: 24, sm: 12, md: 12, lg: 8, xl: 8, xxl: 6 }
 *  <SearchForm>
 *   <Form.Item name="field1" label="条件1">xxx</Form.Item>
 *  </SearchForm>
 *
 *  -- 自定义网格布局 使用 FormCol组件包装 Form.Item
 *  <SearchForm>
 *    <FormCol span={12}><Form.Item name="field1" label="条件1">xxx</Form.Item></FormCol>
 *  </SearchForm>
 *
 *  -- children 可为 function
 *  <SearchForm>
 *   {(form) => {
 *     return <Form.Item name="field1" label="条件1">xxx</Form.Item>
 *   }}
 * </SearchForm>
 *
 * 2. 用户2（自定义布局）
 *    SearchForm设置 isPure = true，FormItem无布局规则
 * 3. SearchForm中内置了 Form 标签，当children为函数时，可获取form实例
 * 4. 默认布局下，可通过设置 searchOperate 设置操作按钮
 * 5. SearchForm 子节点包含 hidden = true 会被忽略
 * 6. 如果想隐藏【查询、重置】按钮中的某一个，可设置 queryButtonProps.hidden、resetButtonProps.hidden
 * 7. 通过设置 defaultResetButtonTriggerRequest，可在右侧按钮区域新增自定义按钮
 * 8. 可设置 cacheSwitch 来控制是否缓存查询数据（一般一级页面可缓存，二级、三级等不能缓存），
 *    缓存数据存储在内存中，react路由跳转可正常读取缓存，浏览器刷新后缓存丢失
 *```
 */
export declare const SearchForm: import("react").ForwardRefExoticComponent<SearchFormProps & import("react").RefAttributes<SearchFormRefApi>>;
export interface ISearchMenuProps {
	size?: "small" | "default";
	/**
	 * 如果传了value，就变成受控组件
	 * 目前只支持单选
	 */
	value?: string;
	onChange?: (key: string, targetItem?: TPlainObject) => void;
	/** 树型源数据 */
	dataSource: TPlainObject[];
	/** 惰性搜索 */
	lazySearch?: boolean;
	/** 搜索目标字段 */
	searchKeyList?: string[];
	/** 格式化参数 */
	fieldNames?: {
		label?: string;
		key?: string;
	};
	/** 自定义渲染条目 */
	renderItem?: (nodeData: TPlainObject) => ReactElement;
	/** 搜索框参数 */
	inputProps?: InputSearchWrapperProps;
	/** 搜索位置额外元素 */
	searchExtraElement?: ReactElement;
	placeholder?: string;
	className?: string;
	wrapStyle?: CSSProperties;
	style?: CSSProperties;
	searchStyle?: CSSProperties;
	/** 是否显示搜索区域 */
	showSearch?: boolean;
}
export interface IListViewItem {
	label: ReactNode;
	key: string;
}
export interface IListViewProps {
	dataList: IListViewItem[];
	value?: string;
	onChange?: (key: string, item: IListViewItem) => void;
	style?: CSSProperties;
	/** 自定义空数据提示 */
	emptyView?: ReactElement;
}
/**
 * 列表搜索
 * @param props
 * @returns
 */
export declare function SearchMenu(props: ISearchMenuProps & Pick<IListViewProps, "emptyView">): import("react").JSX.Element;
/**
 * 选择器包装组件
 * ```
 * 1. 不支持搜索调用服务模式，可使用组件 SelectorWrapperSearch
 * ```
 */
export declare const SelectorWrapper: (props: SelectorWrapperProps) => import("react").JSX.Element;
export type SelectorWrapperSearchServiceConfig = {
	params?: TPlainObject;
	onRequest: (params?: TAny) => TAny;
	onRequestResultAdapter?: (respData: TAny) => TPlainObject[];
};
export type SelectorWrapperSearchProps = Omit<SelectProps, "onSearch" | "notFoundContent" | "options" | "fieldNames" | "loading"> & {
	/**
	 * 参数Key映射
	 * ```
	 * 1. list 为 onRequest 返回数据中列表key值，可多级取值，例如：'a.b.c'
	 * 2. 配置 serviceConfig.onRequestResultAdapter后，fieldNames.list配置失效
	 * ```
	 */
	fieldNames?: {
		label: string;
		value: string;
		disabled?: string;
		searchKeyword?: string;
		list?: string;
	};
	/**
	 * 请求服务需求的数据
	 */
	serviceConfig: SelectorWrapperSearchServiceConfig;
	/**
	 * 添加全部选项
	 * ```
	 * 1. 默认值label="全部"，value=""
	 * 2. 可配置label、value
	 * ```
	 */
	showAllOption?: true | TPlainObject<string | number>;
	/** selectorList发生变更时触发，每次都会调用 */
	onSelectorListChange?: (dataList: TPlainObject[]) => void;
	/** 通过服务获取数据异常回调 */
	onSelectorRequestError?: (error: Error) => void;
	/** 交互文案配置 */
	requestMessageConfig?: TRequestStatusProps["messageConfig"];
	onLabelRenderAdapter?: (dataItem: TPlainObject) => string | ReactElement;
	customKeyword?: string;
};
/**
 * 选择器简单包装组件
 * @param props
 * @returns
 * ```
 * 1. 只支持 search + 服务 功能
 * 2. 不会缓存接口数据
 * 3. 不会对value、onChange做任何处理
 * ```
 */
export declare const SelectorWrapperSearch: (props: SelectorWrapperSearchProps) => import("react").JSX.Element;
export type SelectorWrapperSimpleServiceConfig = {
	params?: TPlainObject;
	onRequest: (params?: TAny) => TAny;
	onRequestResultAdapter?: (respData: TAny) => TPlainObject[];
};
export type SelectorWrapperSimpleProps = Omit<SelectProps, "onSearch" | "notFoundContent" | "options" | "fieldNames" | "loading"> & {
	/**
	 * 参数Key映射
	 * ```
	 * 1. list 为 onRequest 返回数据中列表key值，可多级取值，例如： 'a.b.c'
	 * 2. 配置 serviceConfig.onRequestResultAdapter后，fieldNames.list配置失效
	 * ```
	 */
	fieldNames?: {
		label: string;
		value: string;
		disabled?: string;
		list?: string;
	};
	/**
	 * 请求服务需求的数据
	 */
	serviceConfig: SelectorWrapperSimpleServiceConfig;
	/**
	 * 添加全部选项
	 * ```
	 * 1. 默认值label="全部"，value=""
	 * 2. 可配置label、value
	 * ```
	 */
	showAllOption?: true | TPlainObject<string | number>;
	/** selectorList发生变更时触发，每次都会调用 */
	onSelectorListChange?: (dataList: TPlainObject[]) => void;
	/**
	 * 通过服务获取数据异常回调
	 */
	onSelectorRequestError?: (error: Error) => void;
	requestMessageConfig?: TRequestStatusProps["messageConfig"];
};
/**
 * 选择器简单包装组件
 * @param props
 * @returns
 * ```
 * 1. 不支持search效果
 * 2. 不会缓存接口数据
 * 3. 不会对value、onChange做任何处理
 * ```
 */
export declare const SelectorWrapperSimple: (props: SelectorWrapperSimpleProps) => import("react").JSX.Element;
export type SimpleLayoutProps = {
	className?: string;
	style?: CSSProperties;
	title?: string | ReactElement;
	desc?: string | ReactElement | string[] | ReactElement[];
	/**
	 * @deprecated 已过期，请使用form className 属性 preDefinedClassName.form.xxx
	 */
	formLabelAlign?: "left" | "right";
	/**
	 * layoutType 布局类型
	 * ```
	 * 1. layer：分层布局
	 * 2. tight：紧凑布局（没有外边距）
	 * ```
	 */
	layoutType?: "layer" | "tight";
	titleLeftLine?: boolean;
	titleStyle?: CSSProperties;
	contentStyle?: CSSProperties;
	/** 优先级大于 style padding */
	padding?: CSSProperties["padding"];
	/** 优先级大于 style width */
	width?: CSSProperties["width"];
	children?: ReactNode | ReactNode[];
	titleExtra?: string | ReactElement;
	hidden?: boolean;
	titleFixed?: boolean;
	/**
	 * 间距尺寸
	 * 1. default = 15
	 * 2. small = 8
	 */
	size?: "default" | "small";
	onClick?: (event: any) => void;
};
/**
 * 简单布局
 * @deprecated 已过期，使用 CardLayout 组件替代
 * ```
 * 1. layoutType 布局类型
 *    layer：分层布局
 *    tight：紧凑布局（没有外边距）
 * ```
 */
export declare const SimpleLayout: {
	(props: SimpleLayoutProps): import("react").JSX.Element;
	defaultProps: {
		titleLeftLine: boolean;
		layoutType: string;
	};
};
export interface SmsCountDownProps {
	onSendRequest: () => Promise<void>;
	totalTicks?: number;
	duration?: number;
	autoStart?: boolean;
	format?: string;
	sendTxt?: string;
	sentTxt?: string;
	processingTxt?: string;
	onTick?: (time: number) => void;
	className?: string;
}
export declare const SmsCountDown: FC<SmsCountDownProps>;
export type SplitWrapperProps = SplitProps & {
	panelStyle?: CSSProperties;
};
/**
 * 分屏可拖动组件
 * ```
 *  <SplitWrapper
	  sizes={[25, 75]}
	  minSize={[300, 300]}
	  direction={'vertical'}
	>{...}</SplitWrapper>
	1. 通过 sizes 来初始化设置面板分屏尺寸
	2. 通过 minSize 来设置面板最小尺寸
	3. 通过 direction 设置方向
 * ```
 */
export declare const SplitWrapper: (props: SplitWrapperProps) => import("react").JSX.Element;
export declare const styles: () => void;
export type SvgHttpViewProps = {
	/**
	 * svg地址
	 * ```
	 * 1. 可传http绝对路径
	 * 2. 可传ionic组图标，例如：ionic/alarm-outline
	 * 3. 可传lucide组图标，例如：lucide/crosshair
	 *
	 * 查询ionic、lucide图标 https://fex.qa.tcshuke.com/docs/admin/resources/icons
	 * ```
	 */
	svgPath: string;
	/** 默认：20px */
	width?: number;
	/** 默认：20px */
	height?: number;
	/** svg 颜色， 默认：#555 */
	color?: string;
	onClick?: (e: any) => void;
	className?: string;
	style?: CSSProperties;
};
/**
 * http svg地址解析，可自定义颜色
 * ```
 * 1. 内置ionic、lucide组图标基础路径
 * 2. 可传自定义http绝对路径svg数据
 * 3.
 * ```
 */
export declare const SvgHttpView: (props: SvgHttpViewProps) => import("react").JSX.Element;
export type SwitchConfirmWrapperValue = string | number | boolean;
export type SwitchConfirmWrapperProps = Omit<SwitchProps, "defaultChecked" | "onChange"> & {
	value?: SwitchConfirmWrapperValue;
	checkedValue: SwitchConfirmWrapperValue;
	unCheckedValue: SwitchConfirmWrapperValue;
	needConfirm?: "close" | "open" | "all" | "none";
	noMessage?: boolean;
	onChange?: (value: SwitchConfirmWrapperValue) => void;
	popConfirmProps?: Pick<PopconfirmProps, "disabled" | "title" | "description"> | ((checked?: boolean) => Pick<PopconfirmProps, "disabled" | "title" | "description">);
	serviceConfig?: {
		onRequest: (value: SwitchConfirmWrapperValue) => TAny;
		message?: {
			success?: string;
			defaultError?: string;
		};
	};
};
/**
 *
 * @description switch 切换时做二次pop提醒， 非可控组件【内部控制】
 * @param props
 * @param value
 * @param checkedValue：选中状态值
 * @param unCheckedValue：非选中状态值
 * @param needConfirm：二次pop拦截时机 可不传
 *        close：switch 由开启转换成关闭时pop弹出
 *        open：switch 由开启转换成开启时pop弹出
 *        all：switch 一直pop
 *        none：switch 不弹出
 * @param noMessage：不采用内置message提示
 * @param onChange：switch 有效切换回掉
 * @param popConfirmProps：popConfirm中参数 disabled title description
 * @param serviceConfig onRequest
 * @field onRequest 请求函数
 * @field message message配置 success defaultError
 * ```
 * 1. 单独使用
 *    <SwitchConfirmWrapper
 *        value={value}
 *        checkedValue={'1'}
 *        unCheckedValue={'2'}
 *        serviceConfig={{
 *          onRequest: async () => {
 *            await sleep(2000);
 *          },
 *        }}
 *        needConfirm={'all'}
 *        popConfirmProps={{
 *          title: '确定要开启吗？',
 *        }}
 *        onChange={(value) => {
 *          setValue(value as string);
 *        }}
 *      />
 *
 * 2. 与Form.Item结合使用
 *    <Form.Item name="open">
 *        <SwitchConfirmWrapper
 *          checkedValue={'1'}
 *          unCheckedValue={'2'}
 *          serviceConfig={{
 *            onRequest: async () => {
 *              await sleep(2000);
 *            },
 *          }}
 *          needConfirm={'all'}
 *          popConfirmProps={{
 *            title: '确定要开启吗？',
 *          }}
 *        />
 *      </Form.Item>
 * ```
 */
export declare const SwitchConfirmWrapper: (props: SwitchConfirmWrapperProps) => import("react").JSX.Element;
export type TagListSelectValue = string | number | boolean;
export type TagListSelectDataItem = {
	label: string;
	value: TagListSelectValue;
	color?: string;
};
export type TagListSelectProps = {
	dataList: TagListSelectDataItem[];
	/** 颜色配置数据，例如：{ 1:'red', 2: 'blue'} key值与 dataList中value相同 */
	colorMap?: Record<string | number, string>;
	value?: TagListSelectValue | TagListSelectValue[];
	/** 是否强制匹配，默认值false */
	forceMatch?: boolean;
};
/**
 * 在列表数据中通过value匹配数据，以Tag形式展示
 * @deprecated 已过期，请使用 TagListRender 组件
 * @param props
 * @returns
 * ```
 *  1. forceMatch: 是否强制匹配（默认值false）
 *     - false: 匹配不到显示value值，
 *     - true：匹配不到不显示
 *  2. value 与 dataList中label、value任一相等，都可匹配
 *
 *  用法1：
 *  <TagListSelect
 *    dataList=[{ label: '启用', value: 1 }]
 *    colorMap={{ 1:'red', 2: 'blue'}}
 *    value={1} />
 *  =>
 *  <Tag color={'red'}>启用</Tag>
 *
 *  用法2
 *  <TagListSelect
 *    dataList=[{ label: '启用', value: 1. color: 'red' }]
 *    value="启用" />
 *  =>
 *  <Tag color={'red'}>启用</Tag>
 * ```
 */
export declare const TagListSelect: FC<TagListSelectProps>;
export type TableColumnIconRenderProps = {
	/** 额外内容，一般为Icon  */
	extra: ReactElement;
	extraPosition?: "before" | "after";
	onClick?: (e: any) => void;
	/** 是否显示原单元格数据，默认值：true */
	showData?: boolean;
	/** 溢出显示【...】, 最大长度（默认：20个字节） */
	showMaxNumber?: number;
	/** 未溢出显示【extra】配置，默认值：true  */
	notOverflowShowExtra?: boolean;
};
export declare const tableCellRender: {
	/**
	 * 表格单元格 拼接额外内容渲染
	 * ```
	 * 1. extra 额外内容
	 * 2. showData 是否显示原单元格数据，默认值：true
	 * 3. showMaxNumber 显示最大长度，作用于原单元格字符串数据
	 *
	 *
	 * 结合table column render 使用
	 * # 在单元格渲染文字右侧添加图标
	 * render: tableCellRender.extraContentRender(() => {
	 *   return {
	 *     extra: <FullscreenOutlined />,
	 *     onClick: () => { ... },
	 *   };
	 * }),
	 * ```
	 */
	extraContentRender: (handle: (item: TPlainObject) => TableColumnIconRenderProps) => (value: TAny, item: TPlainObject) => any;
	/**
	 * table 索引展示，如果存在pageSize、pageNo参数可分页展示索引，否则每页都从1开始
	 * @deprecated 已过时 4.3.0版本移除，请使用 serialNumberCell
	 */
	indexCell: (pageNo?: number, pageSize?: number) => (_value: any, _record: any, index: number) => number;
	/**
	 * table 序号展示，如果存在pageSize、pageNo参数可分页展示累加序号，否则每页都从1开始
	 * ```
	 *  render: tableCellRender.serialNumberCell(() => {
	 *    return { pageNo,pageSize };
	 *  }),
	 * ```
	 */
	serialNumberCell: (method?: () => {
		pageNo?: number;
		pageSize?: number;
	}) => (_value: any, _record: any, index: number) => number;
	/**
	 * 表格日期格式数据渲染，默认格式：YYYY-MM-DD
	 * ```
	 * 独立使用
	 * tableCellRender.dateCell('YYYY-MM-DD hh:mm:ss')(value)
	 *
	 * 结合table column render 使用
	 * render: tableCellRender.dateCell('YYYY-MM-DD hh:mm:ss')
	 * render: (value) => {
	 *   return tableCellRender.dateCell('YYYY-MM-DD')(value);
	 * }
	 * ```
	 */
	dateCell: (dateFormatType?: DateFormatType, defaultValue?: string) => (value: string | number) => string | number | undefined;
	/**
	 * table操作栏目渲染
	 * ```
	 * 使用方式
	 * tableCellRender.operateCell((item) => ({
	 *   operateList: [
	 *     {
	 *       text: '编辑',
	 *       onClick: onItemOperate.bind(null, 'update', item),
	 *     },
	 *     {
	 *       text: '删除',
	 *       needConfirm: true,
	 *       confirmMessage: '确定要删除吗？',
	 *       onClick: onItemOperate.bind(null, 'delete', item),
	 *     },
	 *   ],
	 * }))
	 * ```
	 */
	operateCell: (options: (item: TAny, index: number) => ButtonOperateProps) => (_value: string | number, record: any, index: number) => import("react").JSX.Element;
	/**
	 * 实现字段超出隐藏，默认长度10个字符
	 * @deprecated 已过期，请使用 TextOverflow 组件实现
	 * ```
	 * 1. showMaxNumber: 显示最大长度
	 * 2. 会讲字符转出字节进行计算显示
	 * ```
	 */
	tooltipCell: (showMaxNumber?: number, defaultValue?: string) => (value: string | number) => string | number | import("react").JSX.Element | undefined;
	/**
	 * Tag格式数据渲染，可结合枚举定义数据
	 * ```
	 * 独立使用
	 * tableCellRender.selectorCell([{ label: '已开启', value: 1 }])(value)
	 * tableCellRender.selectorCell([{ label: '已开启', value: 1, color: '#108ee9' }])(value)
	 * tableCellRender.selectorCell([{ label: '已开启', value: 1 }], { 1: '#108ee9' })(value)
	 * tableCellRender.selectorCell(taskTypeEnumList)(value);
	 *
	 *
	 * 结合table column render 使用
	 * render: tableCellRender.selectorCell(taskTypeEnumList);
	 * render: tableCellRender.selectorCell([{ label: '已开启', value: 1 ]);
	 * render: (value) => {
	 *   return tableCellRender.selectorCell([{ label: '已开启', value: 1 ])(value);
	 * }
	 *
	 * 其中value值可以是单个值或者数组；例如：'1' 或者 ['1', '2']
	 * ```
	 */
	selectorCell: (selectorList: TagListSelectProps["dataList"], colorMap?: TagListSelectProps["colorMap"], options?: {
		/** 最大显示Tag数量，超出折叠隐藏 */
		maxShowCount?: number;
		/** 触发maxShowCount后，被折叠的内容是否显示完整tag，默认值：false */
		foldShowAllTag?: boolean;
	}) => (value?: TAny) => import("react").JSX.Element | null;
	/**
	 * 单元格对象数据处理，支持多级处理
	 * ```
	 * tableCellRender.objectCell('a.b.c')
	 * ```
	 */
	objectCell: (key: string, defaultValue?: string) => (value?: TPlainObject) => any;
	/**
	 * 分金额展示，入参分，显示元（默认添加千分位）
	 * ```
	 * 可配置
	 * 1. separator：是否显示千分位分隔符，默认值：false
	 * 2. defaultValue：当值为空默认展示
	 * 3. hideBgColor：隐藏背景颜色
	 *
	 * 例如：
	 * fen2yuanCell()(100090) => 1000.90
	 * fen2yuanCell({separator: true})(100090) => 1,000.90
	 * fen2yuanCell()('abc') => abc
	 * fen2yuanCell({defaultValue: '--'})('') =>  --
	 * fen2yuanCell()('') => undefined
	 * fen2yuanCell({ defaultValue: 0 })('') => 0.00
	 * ```
	 */
	fen2yuanCell: (options?: {
		/** 是否显示分隔符，默认值：false */
		separator?: boolean;
		defaultValue?: string | number;
		/** 隐藏背景颜色, 默认值：true */
		hideBgColor?: boolean;
	}) => (value?: string | number) => string | number | import("react").JSX.Element | undefined;
	/**
	 * 分金额展示，入参分，显示万元（默认添加千分位）
	 * ```
	 * 可配置
	 * 1. separator：是否显示千分位分隔符，默认值：false
	 * 2. defaultValue：当值为空默认展示
	 * 3. showBgColor：隐藏背景颜色
	 * 4. removeTailZero：移除小数点后末尾零
	 *
	 * 例如：
	 * fen2yuanCell()(1000900000) => 1000.90
	 * fen2yuanCell({separator: true})(1000900000) => 1,000.90
	 * fen2yuanCell()('abc') => abc
	 * fen2yuanCell({defaultValue: '--'})('') =>  --
	 * fen2yuanCell()('') => undefined
	 * fen2yuanCell({ defaultValue: 0 })('') => 0.00
	 * ```
	 */
	fen2wanCell: (options?: {
		/** 是否显示分隔符，默认值：false */
		separator?: boolean;
		defaultValue?: string | number;
		/** 隐藏背景颜色，默认：false */
		showBgColor?: boolean;
		/** 移除小数点后末尾零 */
		removeTailZero?: boolean;
	}) => (value?: string | number) => string | number | import("react").JSX.Element | undefined;
	/**
	 * 单元格徽标展示数据
	 * ```
	 * 1. badge 默认颜色：灰色rgba(0, 0, 0, 0.25)
	 *
	 * 独立使用
	 * tableCellRender.badgeCell([{ label: '已开启', value: 1 ])(value)
	 * tableCellRender.badgeCell([{ label: '已开启', value: 1, color: '#108ee9' }])(value)
	 * tableCellRender.badgeCell([{ label: '已开启', value: 1 }], { 1: '#108ee9' })(value)
	 *
	 * 结合table column render 使用
	 * render: tableCellRender.badgeCell([{ label: '已开启', value: 1 ])
	 * render: (value) => {
	 *   return tableCellRender.badgeCell([{ label: '已开启', value: 1 ])(value)
	 * }
	 * ```
	 */
	badgeCell: (selectorList: {
		label: string;
		value: TagListSelectValue;
		color?: string;
	}[], colorMap?: Record<string | string, string>) => (value?: TAny) => any;
	/**
	 * 单元格点击事件
	 * ```
	 * 独立使用
	 * tableCellRender.clickCell(onClick)(value, record)
	 *
	 * 结合table column render 使用
	 * render: tableCellRender.clickCell(onClick)
	 * render: (value, record) => {
	 *   return tableCellRender.clickCell(onClick)(value, record)
	 * }
	 * ```
	 */
	clickCell: (onClick: (record: TPlainObject, e: any) => void, defaultValue?: string) => (value: TAny, record: TPlainObject) => string | import("react").JSX.Element | undefined;
};
export type TableScrollProps = {
	children: ReactNode;
	/**
	 * y轴的滚动条
	 */
	target?: HTMLElement;
};
/**
 * 表格x轴浮动滚动条
 * ```
 * 使用方法
 * <TableScrollbar>
 *    <Table/>
 * </TableScrollbar>
 * ```
 */
export declare const TableScrollbar: ({ children, target, ...props }: TableScrollProps) => import("react").FunctionComponentElement<{
	summary: (...args: any[]) => import("react").JSX.Element;
}>;
export type TableTitleTooltipProps = {
	title: string | ReactElement;
	tooltip: string | {
		icon?: ReactElement;
		content: string;
		hoverArea?: "icon" | "all";
	};
	gap?: number;
	className?: string;
	style?: CSSProperties;
};
/**
 * title + tooltip
 * @deprecated 已过期，请使用 TipsWrapper 组件
 */
export declare const TableTitleTooltip: (props: TableTitleTooltipProps) => import("react").JSX.Element;
export type TabsType = GetProps<typeof Tabs>;
export type TabsStickyProps = {
	tabsProps: Omit<TabsType, "tabPosition">;
	/** tabs头部布局 */
	headerRender?: ReactElement;
	/** 点击tabItem后，tab跳到顶部吸顶效果；默认值true */
	clickTabToTop?: boolean;
	/** 设置tabItem 内容包裹元素的样式 */
	tabItemContentWrapperStyle?: (key: string) => CSSProperties;
};
/**
 * Tabs吸顶组件
 * ```
 * 1. 组件根节点设置了 height: 100%、overflow: auto；所以外部包裹元素必须要有高度
 * ```
 */
export declare const TabsSticky: (props: TabsStickyProps) => import("react").JSX.Element;
export type TabsWrapperProps = TabsProps & {
	/**
	 * Tabs Header 提供 Sticky 效果，默认值：true
	 * @deprecated 已废弃 4.3.0版本移除，请使用 isFixed 属性
	 */
	isSticky?: boolean;
	/**
	 *  Tabs Header 提供 Fixed 效果，默认值：true
	 */
	isFixed?: boolean;
	/** 是否取消 active 缓存 */
	cancelActiveCache?: boolean;
	activeCacheKey?: string;
	/** 隐藏头部 */
	hiddenTabHeader?: boolean;
};
/**
 * Tabs 包装组件
 * ```
 * 1. Tabs Header 提供 Sticky 效果，默认值：true
 * 2. 使用时，父级必须要有高度，可置于Flex布局中
 * 3. 默认缓存激活的tab item（activeKey受控操作下缓存无效）
 *    当未设置activeKey，非受控操作时，组件内部会会话缓存activeKey，在刷新时，会显示上次的激活的tab item
 *    缓存Key：如果未设置 activeCacheKey，则使用默认的 cache key（tabs-wrapper-activeKey）
 *    缓存模式：会话缓存，在浏览器关闭后，会清除
 * ```
 */
export declare const TabsWrapper: (props: TabsWrapperProps) => import("react").JSX.Element;
export type TagGroupDataItem = {
	label: string;
	value: string | number;
	color?: string;
};
export type TagGroupProps = {
	dataList: TagGroupDataItem[];
	/**
	 * 颜色配置数据，例如：{ 1:'red', 2: 'blue'} key值与 dataList中value相同
	 */
	colorMap?: Record<string, string>;
	spaceProps?: SpaceProps;
};
/**
 * Tag 列表显示
 */
export declare const TagGroup: FC<TagGroupProps>;
export type TagListRenderValue = string | number | boolean;
export type TagListRenderDataItem = {
	label: string;
	value: TagListRenderValue;
	color?: string;
};
export type TagListRenderProps = {
	dataList: TagListRenderDataItem[];
	/** 颜色配置数据，例如：{ 1:'red', 2: 'blue'} key值与 dataList中value相同 */
	colorMap?: Record<string | number, string>;
	value?: TagListRenderValue | TagListRenderValue[];
	/** 是否强制匹配，默认值false */
	forceMatch?: boolean;
	/** 最大显示Tag数量，超出折叠隐藏 */
	maxShowCount?: number;
	/** 触发maxShowCount后，被折叠的内容是否显示完整tag，默认值：false */
	foldShowAllTag?: boolean;
	/** 所有tag背景匹配此颜色，在colorMap为空、dataList中未配置color的情况下有效果 */
	tagColor?: string;
};
/**
 * 在列表数据dataList中通过value匹配数据，以Tag形式展示
 * ```
 *  1. forceMatch: 是否强制匹配（默认值false）
 *     - false: 匹配不到显示value值，
 *     - true：匹配不到不显示
 *  2. value 与 dataList中label、value任一相等，都可匹配
 *
 *  用法1：
 *  <TagListRender
 *    dataList=[{ label: '启用', value: 1 }]
 *    colorMap={{ 1:'red', 2: 'blue'}}
 *    value={1} />
 *  =>
 *  <Tag color={'red'}>启用</Tag>
 *
 *  用法2
 *  <TagListRender
 *    dataList=[{ label: '启用', value: 1. color: 'red' }]
 *    value="启用" />
 *  =>
 *  <Tag color={'red'}>启用</Tag>
 * ```
 */
export declare const TagListRender: FC<TagListRenderProps>;
export type TagWrapperProps = Omit<TagProps, "onClick"> & {
	onClick?: (e: React.MouseEvent<HTMLElement>) => Promise<TAny> | void;
	loading?: boolean;
	debounceDuration?: number;
};
/**
 * 为 Tag 添加 loading 效果
 */
export declare const TagWrapper: (props: TagWrapperProps) => import("react").JSX.Element;
export type TextOverflowProps = {
	/** text 为ReactElement类型时，maxLength配置无效 */
	text: string | ReactElement;
	/** 最大显示宽度 */
	maxWidth?: number;
	/** 最大显示字数 */
	maxLength?: number;
	/**
	 * 关闭tooltip功能
	 * 文字超出后，鼠标移入，不展示全部文字
	 */
	hideTip?: boolean;
	onClick?: (e: any) => void;
};
/**
 * 内容溢出截取，并在尾部添加...，被截取的添加Tooltip显示完整数据
 * ```
 * 控制文本显示三种方式
 * 1. 通过 maxLength 控制超长
 * 2. 通过 maxWidth 控制超长
 * 3. 与父节点宽度比较，控制超长
 * 4. 优先级  maxLength > maxWidth
 *
 * 注意：
 * 1. 当前节点父节点需要添加 overflow-x: hidden;
 * 2. 如果父节点设置flex-shrink会有影响，可复写flex-shrink: initial;
 * 3. 与 Table columns render结合使用，需要配置ellipsis=true
 *    例如：<Table columns={[{
			 ...
			 render: (value) => {
			   return <TextOverflow text={value} />;
			 },
			 ellipsis: true,
		   }]} />
	4. 与 Table columns render结合使用，如果Table配置了 scroll={{ x: 'max-content' }}后，不能与TextOverflow maxWidth结合使用
 * ```
 */
export declare const TextOverflow: import("react").MemoExoticComponent<(props: TextOverflowProps) => import("react").JSX.Element>;
export type TextSymbolWrapperProps = {
	className?: string;
	style?: CSSProperties;
	/** 内置图标类型 */
	symbolType?: "required";
	/** 自定义标记符号，优先级大于 symbolType */
	symbol?: ReactNode;
	/** 标记位置，默认：brefore */
	position?: "before" | "after";
	/** 显示文本 */
	text?: string | ReactElement;
	symbolStyle?: CSSProperties;
	onSymbolClick?: (event: any) => void;
	/** 只隐藏符号，不隐藏文案 */
	hiddenSymbol?: boolean;
	/** 图标与文字之间的间距 */
	gap?: number;
};
/**
 * 为文字添加符号，例如：必填符号
 * ```
 * 例如： <TextSymbolWrapper text={'用户名'} symbolType="required" />
 * ```
 */
export declare const TextSymbolWrapper: (props: TextSymbolWrapperProps) => import("react").JSX.Element;
export type TimePickerWrapperProps = Omit<TimePickerProps, "value" | "onChange" | "format"> & {
	value?: string;
	onChange?: (value?: string) => void;
	/**
	 * 1. minTime、maxTime设置为 DayjsTimeTypeEnum，默认格式：HH:mm:ss
	 * 2. minTime、maxTime格式必须与 format 相同
	 */
	disabledTimeConfig?: {
		minTime?: TDayjsTimeType;
		maxTime?: TDayjsTimeType;
		/** 禁用 小时 刻度列表，与日期无关  */
		disabledHourList?: number[];
		/** 禁用 分钟 刻度列表，与日期无关 */
		disabledMinuteList?: number[];
		/** 禁用 秒钟 刻度列表，与日期无关 */
		disabledSecondList?: number[];
	};
	format?: TDayjsTimeType;
};
/**
 * TimePicker组件包装
 * ```
 * 1. value类型为 string
 * 2. onChange返回类型 string
 * 3. 默认格式化类型 HH:mm:ss
 * 4. 其他格式化类型自定义format
 * 5. 设置disabledTime后，disabledTimeConfig配置将失效
 * ```
 */
export declare const TimePickerWrapper: (props: TimePickerWrapperProps) => import("react").JSX.Element;
export type TimeRangePickerWrapperProps = Omit<TimeRangePickerProps, "value" | "onChange" | "format"> & {
	value?: [
		string,
		string
	];
	onChange?: (value?: [
		string,
		string
	]) => void;
	/**
	 * 1. minTime、maxTime设置格式，默认格式：HH:mm:ss
	 * 2. minTime、maxTime格式必须与 format 相同
	 */
	disabledTimeConfig?: {
		minTime?: TDayjsTimeType;
		maxTime?: TDayjsTimeType;
		/** 禁用 小时 刻度列表，与日期无关 */
		disabledHourList?: number[];
		/** 禁用 分钟 刻度列表，与日期无关 */
		disabledMinuteList?: number[];
		/** 禁用 秒钟 刻度列表，与日期无关 */
		disabledSecondList?: number[];
	};
	format?: TDayjsTimeType;
};
/**
 * TimePicker组件包装
 * ```
 * 1. value类型为 [string, string]
 * 2. onChange返回类型 [string, string]
 * 3. 默认格式化类型 HH:mm:ss，其他格式化类型自定义format
 * 4. 设置disabledTime后，disabledTimeConfig配置将失效
 * ```
 */
export declare const TimeRangePickerWrapper: (props: TimeRangePickerWrapperProps) => import("react").JSX.Element;
export type TimeRangePickerWrapperFormItemProps = Omit<FormItemWrapperProps, "name"> & {
	/**
	 * 开始的时间name
	 */
	startName: FormItemNamePath;
	/**
	 * 结束的时间name
	 */
	endName: FormItemNamePath;
	/**
	 * 如果 TimeRangePickerWrapperFormItem 在Form.List场景下 必传
	 * @deprecated 使用 formListCompleteName 配置
	 */
	formListName?: Array<string | number>;
	/**
	 * 前端 formItem 前缀FormName，当 TimeRangePickerWrapperFormItem 处在Form.List场景下，必传
	 * ```
	 * 例如 处在formList内部时，则 formListCompleteName = ['xxxxList']
	 * 例如 处在formList套formList内部时，则 formListCompleteName = ['xxxxList', 索引值, 'xxxxList2']
	 * ```
	 */
	formListCompleteName?: Array<string | number> | string;
	timeRangePickerWrapperProps?: TimeRangePickerWrapperProps;
};
/**
 * 包含了Form.Item组件的时间区间选择组件，时间区间组件可以定义成两个字段操作，不用再通过数组处理
 * ```
 * 1. 会在form中产生一个 `__#invalid_time_xxxx_xxxx` 的无效字段，可以直接忽略
 * 2. 设置日期格式 timeRangePickerWrapperProps={{ format: 'HH:mm:ss' }}
 * 使用场景：
 * 1. 基础使用场景
 *    <TimeRangePickerWrapperFormItem startName={'date1'} endName={'date2'} />
 * 2. Form.List 内部使用
 *    <FormListWrapper name="dataList" prevCompleteName={[]}>
 *      {(data) => {
 *        return <TimeRangePickerWrapperFormItem formListCompleteName={data.prevCompleteName} startName={data.getInsideFormItemName('date1')} endName={data.getInsideFormItemName('date2')} />
 *      }}
 *    </FormListWrapper>
 * 3. Form.List 套 Form.List 内部使用
 *    <FormListWrapper name="dataList" prevCompleteName={[]}>
 *      {(data) => {
 *        return <FormListWrapper name={data.getInsideFormItemName('childrenList')} prevCompleteName={data.prevCompleteName}>
 *          {(data2) => {
 *            return <TimeRangePickerWrapperFormItem formListCompleteName={data2.prevCompleteName} startName={data2.getInsideFormItemName('date1')} endName={data2.getInsideFormItemName('date2')} />
 *          }}
 *        </FormListWrapper>
 *      }}
 *    </FormListWrapper>
 * ```
 */
export declare const TimeRangePickerWrapperFormItem: (props: TimeRangePickerWrapperFormItemProps) => import("react").JSX.Element;
export type TipsTitleProps = {
	className?: string;
	style?: CSSProperties;
	title: string | ReactElement;
	titleStyle?: CSSProperties;
	children: ReactNode;
	size?: "default" | "small";
	/** 自定义 help icon */
	helpIcon?: ReactElement;
	/** 配置 helpIcon 后，此参数失效 */
	onHelp?: () => void;
	hidden?: boolean;
	borderColor?: string;
};
export declare const TipsTitle: (props: TipsTitleProps) => import("react").JSX.Element | null;
export type TreeWrapperValue = string | number | Array<string | number> | TPlainObject<string | number> | Array<TPlainObject<string | number>>;
export type TreeServiceConfig = {
	params?: TPlainObject;
	requiredParamsKeys?: string[];
	onRequest?: (params?: TAny) => TAny;
	/**
	 * 响应数据适配器
	 */
	onRequestResultAdapter?: (respData: TAny) => TPlainObject[];
};
export type TreeLoadDataServiceConfig = {
	getParams?: (dataItem: TPlainObject) => TPlainObject;
	onRequest: (params: TPlainObject) => TAny;
	/**
	 * 响应数据适配器
	 */
	onRequestResultAdapter?: (respData: TAny) => TPlainObject[];
};
export type TreeWrapperProps = Omit<TreeProps, "treeData" | "onExpand" | "selectedKeys" | "checkedKeys" | "onCheck" | "onSelect" | "fieldNames" | "multiple" | "loadData" | "icon" | "defaultCheckedKeys" | "defaultExpandParent" | "defaultSelectedKeys"> & {
	/** 唯一值，用于缓存数据 */
	modelKey: string;
	/**
	 * 字段映射
	 * ```
	 * 默认值：
	 * label = 'label'
	 * value = 'value'
	 * children = 'children'
	 *
	 * 如果未设置list，则说明接口返回数据为数组
	 * 如果返回数据存在多级，可通过设置 list='a.b.list'
	 * ```
	 */
	fieldNames?: {
		label?: string;
		value?: string;
		children?: string;
		list?: string;
	};
	/**
	 * useEffect依赖项数组，用于重新发起获取接口数据
	 */
	effectDependencyList?: DependencyList;
	/**
	 * 请求服务需求的数据，当设置`selectorTreeList`后无效果
	 */
	serviceConfig?: TreeServiceConfig;
	/**
	 * 是否开启异步加载
	 */
	loadDataFlag?: boolean;
	/**
	 * 异步加载数据配置
	 * ```
	 * 1. 会通过fieldNames配置label、value、children进行转义
	 * 2. fieldNames.list 配置在此处无效
	 * ```
	 */
	loadDataServiceConfig?: TreeLoadDataServiceConfig;
	/**
	 * 当设置selectorTreeList后，serviceConfig将失效
	 * ```
	 * 1. 不支持异步数据，异步使用serviceConfig方式
	 * ```
	 */
	selectorTreeList?: TPlainObject[];
	/**
	 * 通过服务获取数据后回调，当设置`selectorList`后无效果
	 * ```
	 * 相同modelKey，同时发起多个渲染时，只有第一个会执行 onSelectorTreeListChange 回调
	 * ```
	 */
	onSelectorTreeListChange?: (dataList: TPlainObject[]) => void;
	/** 接口响应数据变更 */
	onRequestResponseChange?: (data: TAny) => void;
	onChange?: (selectedKey?: TreeWrapperValue, operateNodeData?: TPlainObject[] | TPlainObject, operateAllNodeDataList?: TPlainObject[], extraData?: TPlainObject) => void;
	/**
	 * 搜索关键字，打开tree折叠过滤关键字
	 */
	searchValue?: string;
	/**
	 * checkable模式下，onChange是否返回父节点，默认值true
	 * @description 已过期，请使用 checkableType 配置
	 * ```
	 * 注意：checkStrictly = true，checkableResponseParentNode配置失效
	 * ```
	 */
	checkableResponseParentNode?: boolean;
	/**
	 * 节点选择类型（默认值：'2'）, 多选时有效
	 * ```
	 * '1' 表示返回所有选中的节点（包含父节点和叶子节点）
	 * '2' 表示只返回叶子节点
	 * '3' 表示当叶子节点全选时，返回父节点，不返回下面的叶子节点
	 *
	 *  注意：checkStrictly = true，checkableType配置失效
	 * ```
	 */
	checkableType?: "1" | "2" | "3";
	/**
	 * 菜单结构类型 tile/平铺 fold/折叠；默认：fold
	 * @deprecated 已过期 4.3.0版本移除，请使用 menus
	 * ```
	 * 自定义设置 titleRender 后失效
	 * ```
	 */
	menuLayoutType?: "tile" | "fold";
	/**
	 * 获取菜单类别
	 * @param dataItem
	 * @deprecated 已过期 4.3.0版本移除，请使用 menus
	 * @returns
	 * ```
	 * 1. menuLayoutType = tile 无效
	 * 2. 自定义设置 titleRender 后失效
	 * ```
	 */
	getMenuOptions?: (dataItem: TPlainObject) => DropdownMenuItem[] | ButtonOperateItem[];
	/**
	 * 根据 menuLayoutType 类型赋值
	 * @deprecated 已过期 4.3.0版本移除，请使用 menuOptions
	 */
	menuOptions?: {
		tile?: (dataItem: TPlainObject) => ButtonOperateProps;
		fold?: (dataItem: TPlainObject) => DropdownMenuItem[];
	};
	/**
	 * 菜单触发类型，默认：click
	 * ```
	 * 自定义设置 titleRender 后失效
	 * ```
	 */
	menuTriggerType?: "click" | "hover";
	menus?: (dataItem: any) => ButtonOperateProps;
	showSearch?: boolean;
	onSearchValueChange?: (searchValue?: string) => void;
	searchPlaceholder?: string;
	searchStyle?: CSSProperties;
	icon?: (data: {
		isParent: boolean;
		isLeaf: boolean;
		[key: string]: TAny;
	}) => ReactElement;
	/**
	 * 状态文案配置
	 */
	requestMessageConfig?: TRequestStatusProps["messageConfig"];
	/**
	 * value格式
	 *```
	 * 1. string 、number
	 * 2. Array<string | number>
	 * 3. lableInValue = true，根据labelInValueFieldNames配置格式
	 * 4. lableInValue = true，Array<labelInValueFieldNames配置>
	 * ```
	 */
	value?: TreeWrapperValue;
	/**
	 * 选择的节点数据，是否包含label信息
	 * ```
	 * 默认选择的节点只有value数据
	 * ```
	 */
	labelInValue?: boolean;
	/**
	 * ```
	 * @deprecated 废弃
	 * lableInValue = true，onChange输出数据字段名称，默认：{ label: string; value: string|number }
	 * ```
	 */
	labelInValueFieldNames?: {
		label: string;
		value: string;
	};
	/**
	 * 禁用状态是否可选，默认值true
	 * 当dateItem中包含 disabled 则数据为禁用状态
	 */
	disabledCanUse?: boolean;
	/** treeItem数据适配器 */
	treeItemDataAdapter?: (dataItem: TPlainObject) => TPlainObject;
	/** 搜索位置额外元素 */
	searchExtraElement?: ReactElement;
	/** 有唯一跟节点时，初始化是否展开，默认值：false */
	initRootExpand?: boolean;
	/** 搜素过滤方式，高亮 | 过滤；默认：filter */
	searchResultType?: "highlight" | "filter";
	/**
	 * 拖拽节点处理，自定义onDrop事件后，失效
	 * ```
	 * 参数
	 * 1. parentId 拖拽结束位置父节点ID
	 * 2. id 当前拖拽节点ID
	 * 3. index 拖拽结束位置所在数组下标
	 * ```
	 */
	onDropNodeHandle?: (result: {
		parentId?: string | number;
		id: string | number;
		index: number;
	}) => void;
	/**
	 * 拖拽排序前判断，如果返回 true，可排序，其他不可排序
	 * ```
	 * 可用于需要权限控制判断
	 * ```
	 */
	onDropPrev?: (info: any) => boolean;
	/**
	 * 标签渲染
	 * ```
	 * 1. 自定义设置 titleRender 后失效
	 * 2. 与titleRender的区别
	 *    a. 设置 labelRender 后，menuLayout有效
	 *    b. 设置 titleRender 后，menuLayout失效
	 * ```
	 */
	labelRender?: (nodeData: TPlainObject) => ReactElement;
	/**
	 * 自定义搜索规则
	 */
	customSearchRule?: (nodeData: TPlainObject, searchValue?: string) => boolean;
	/**
	 * 点击父节点 是否切换折叠
	 * ```
	 * 1. 设置 titleRender 后，此配置失效
	 * ```
	 */
	clickParentNodeToggleExpand?: boolean;
	/**
	 * 禁用节点选中
	 * ```
	 * 1. checkable = true，此配置失效
	 * 2. 在未设置节点 disabled 属性情况下，满足此配置不会触发onChange事件
	 * ```
	 */
	disableNodeSelect?: (item: TPlainObject) => boolean;
	/**
	 * 是否必选，最后一个不能取消
	 * ```
	 * 1. 设置 checkable = true 时无效
	 * ```
	 */
	required?: boolean;
	/**
	 * 在第一次渲染value时，主动执行一次onChange
	 * ```
	 * 1. 设置labelInValue = true 时有效
	 * 2. 不考虑子父节点的关系
	 * ```
	 */
	executeOnChangeInRenderFirstValue?: boolean;
};
export type TreeWrapperRefApi = {
	onClearSelectorList: () => void;
	getTreeDataList: () => TreeProps["treeData"];
	onChangeExpandedKeys: (expandedKeys: Array<string | number>) => void;
	getTreeTiledArray: () => TPlainObject[];
	getTreeTiledArrayMap: () => TPlainObject;
	/** 选择所有 */
	onSelectAll: () => void;
	/** 取消选择所有 */
	onCancelSelectAll: () => void;
	/** 展开所有 */
	onExpandedAll: () => void;
	/** 取消展开所有 */
	onCancelExpandedAll: () => void;
};
/**
 * Tree包装组件，默认返回父节点，可配置不返回
 * @param props
 * @returns
 * ```
 * 1. treeNode内置字段说明（如需要相关功能，可在接口中添加固定字段）
 *    a. disabled 禁掉响应
 *    b. isLeaf  设置为叶子节点 (设置了 loadData 时有效)。为 false 时会强制将其作为父节点
 *    c. disableCheckbox  checkable模式下，treeNode复选框是否可选
 * 2. 当设置selectorTreeList属性后，serviceConfig将失效
 * 3. checkable=true，为多选模式
 * 4. 设置value后，组件显示受控
 * 5. 设置loadDataFlag=true，会动态获取children，当treeNode中包含isLeaf=true字段，表示为叶子节点，没有children了
 * 6. 内置 onDrop 事件已处理数组排序，通过 onDropNodeHandle 事件可获取操作节点排序数据；自定义onDrop后，内置onDrop失效
 * ```
 */
export declare const TreeWrapper: ForwardRefExoticComponent<TreeWrapperProps & RefAttributes<TreeWrapperRefApi>> & {
	getTreeDataList: (modelKey: string) => TPlainObject[];
};
export type TreeModelSelectItem = {
	label: string;
	value: string | number;
};
export type TreeModelSelectValue = TreeModelSelectItem[] | Array<TreeModelSelectItem["value"]> | TreeModelSelectItem["value"];
export type TreeModalContentProps = {
	/** 是否多选，默认值：true */
	isMultiple?: boolean;
	forceRender?: boolean;
	/**
	 * 内置尺寸，根据比例固定高度、宽度，默认：large
	 */
	size?: "small" | "middle" | "large";
	/** 字段映射 */
	fieldNames?: {
		label?: string;
		value?: string;
		children?: string;
	};
	/**
	 * 接口调用
	 * @deprecated 已过期，使用 serviceConfig
	 */
	onRequest?: () => Promise<TPlainObject[]>;
	serviceConfig?: {
		params?: TPlainObject;
		requiredParamsKeys?: string[];
		onRequest?: (params?: TAny) => TAny;
	};
	value?: TreeModelSelectValue;
	onChange?: (values?: TreeModelSelectItem[]) => void;
	textConfig: {
		title: string;
		/** 选择为空提示，例如：请选择 */
		placeholder?: string;
		/** 选择数量提示，例如：已选择{total}位用户 */
		selectQuantityPrompt?: string;
	};
	onDataSourceChange?: (treeDataList: TPlainObject[], mapData: TPlainObject) => void;
	treeProps?: Pick<TreeWrapperProps, "showSearch" | "searchResultType" | "searchPlaceholder" | "searchValue" | "loadDataFlag" | "loadDataServiceConfig" | "icon" | "disabledCanUse" | "treeItemDataAdapter" | "searchExtraElement" | "initRootExpand" | "searchResultType" | "labelRender" | "customSearchRule" | "checkableType" | "checkStrictly" | "defaultExpandAll" | "clickParentNodeToggleExpand" | "disableNodeSelect">;
};
export type TreeModalProps = TreeModalContentProps & {
	children: ReactElement & {
		onClick?: (e: any) => void | Promise<void>;
	};
	modalClassName?: string;
	modalWidth?: number;
	modalBodyHeight?: number;
	disabled?: boolean;
};
export declare const TreeModal: ((props: TreeModalProps) => import("react").JSX.Element) & {
	Content: (props: TreeModalContentProps) => import("react").JSX.Element;
};
export type TreeModalSelectorProps = Omit<TreeModalProps, "children" | "forceRender" | "onChange"> & {
	placeholder?: string;
	/**
	 * 1. 可指定数量
	 * 2. 可设置 responsive，一行自适应显示
	 */
	maxTagCount?: number | "responsive";
	/** 是否返回label+value模式 */
	labelInValue?: boolean;
	onChange?: (values?: TreeModelSelectItem[] | TreeModelSelectItem) => void;
	/** 最大选择数量 */
	maxCount?: number;
	/** 超过最大选择数量提示文本 */
	overMaxCountMsg?: string;
	disabled?: boolean;
};
/**
 * 树弹框选择器
 * ```
 * 1. 可通过 treeProps.checkableType 配置多选节点模式（包括返回所有节点、只返回叶子节点、叶子节点&父节点全选只返回父节点），默认只返回叶子节点
 * 2. demo: https://fex.qa.tcshuke.com/docs/admin/main/selector/tree
 * ```
 */
export declare const TreeModalSelector: (props: TreeModalSelectorProps) => import("react").JSX.Element;
export type TreeSelectorWrapperValue = string | number | Array<string | number> | TPlainObject<string | number> | Array<TPlainObject<string | number>>;
export type TreeSelectorServiceConfig = {
	params?: TPlainObject;
	requiredParamsKeys?: string[];
	onRequest?: (params?: TAny) => TAny;
	/**
	 * 响应数据适配器
	 */
	onRequestResultAdapter?: (respData: TAny) => TPlainObject[];
};
export type TreeSelectorWrapperProps = Omit<TreeSelectProps, "treeExpandedKeys" | "treeData" | "loading" | "onTreeExpand" | "onChange" | "value" | "fieldNames" | "defaultValue" | "treeDataSimpleMode" | "onSearch"> & {
	modelKey: string;
	fieldNames?: {
		/**
		 * 1. list 为 onRequest 返回数据中列表key值，可多级取值，例如： 'a.b.c'
		 * 2. 配置 serviceConfig.onRequestResultAdapter 后此配置失效
		 */
		list?: string;
		label?: string;
		value?: string;
		children?: string;
		disabled?: string;
	};
	/**
	 * useEffect依赖项数组，用于重新发起获取接口数据
	 */
	effectDependencyList?: DependencyList;
	/**
	 * 请求服务需求的数据，当设置`treeSelectorList`后无效果
	 */
	serviceConfig?: TreeSelectorServiceConfig;
	/**
	 * 当设置treeSelectorList后，serviceConfig 将失效
	 */
	treeSelectorList?: TreeSelectProps["treeData"];
	/**
	 * treeSelectorList发生变更时触发
	 */
	onTreeSelectorListChange?: (treeSelectorList?: TreeSelectProps["treeData"]) => void;
	/**
	 * 通过服务获取数据异常回调，当设置`treeSelectorList`后无效果
	 */
	onTreeSelectorRequestError?: (error: Error) => void;
	/**
	 * 添加全部选项
	 * ```
	 * 1. showAllOption = true，添加默认全部选项（value值为空字符串）
	 * 2. 可自定义全部选项，例如：{ label: '全部', value: 'all' }
	 * 3. 自定义字段会通过fieldNames转换后使用
	 * 4. 多选操作时，最好不要设置全部选项
	 * ```
	 */
	showAllOption?: true | TPlainObject<string | number>;
	/**
	 * 1. 当 treeCheckable = true && treeCheckStrictly = true，如果选择的数据中含有父节点，selectedValue、selectedList返回数据包含父节点
	 * 2. 当 treeCheckable = true && treeCheckStrictly = false，selectedValue、selectedList返回的数据不包含父节点
	 * 3. 当 treeCheckable = false，节点选择没有级联关系，selectedValue、selectedList返回的数据就是实际选择
	 * 4. selectAllDataList 返回的数据都包含父节点
	 * 5. 使用 onTreeItemAdapter 拼接label数据后，选中回填数据也是拼接后的
	 * 6. triggerInfo 当前操作节点数据
	 */
	onChange?: (selectedValue?: TreeSelectorWrapperValue, selectedData?: TPlainObject[] | TPlainObject, triggerInfo?: TPlainObject) => void;
	/**
	 * tree item 数据适配器，返回的数据会通过fieldNames配置取数据
	 * ```
	 * 1. 可用于设置disabled状态
	 * onTreeItemDataAdapter: (dataItem) => {
	 *   if(dataItem.xx === xx){
	 *     dataItem['disabled] = true;
	 *   }
	 *   return dataItem;
	 * }
	 * 2. 可设置label数据显示
	 * ```
	 */
	onTreeItemDataAdapter?: (dataItem: TPlainObject) => TPlainObject;
	/** 自定义异常提示文案 */
	requestMessageConfig?: TRequestStatusProps["messageConfig"];
	/**
	 * value格式
	 *```
	 * 1. string 、number
	 * 2. Array<string | number>
	 * 3. lableInValue = true，根据labelInValueFieldNames配置格式
	 * 4. lableInValue = true，Array<labelInValueFieldNames配置>
	 * ```
	 */
	value?: TreeSelectorWrapperValue;
	/**
	 * treeCheckStrictly 	checkable 状态下节点选择完全受控（父子节点选中状态不再关联），
	 * 会使得 labelInValue 强制为 true
	 */
	labelInValue?: boolean;
	/**
	 * @deprecated 已弃用
	 * ```
	 * lableInValue = true，onChange输出数据字段名称，默认：{ label: string; value: string|number }
	 * ```
	 */
	labelInValueFieldNames?: {
		label: string;
		value: string;
	};
	/**
	 * treeCheckStrictly = true模式下有效，点击父节点是否选中所有子节点，默认值：true
	 */
	selectedParentCheckedAllChildrenList?: boolean;
	/** 有唯一跟节点时，初始化是否展开，默认值：false */
	initRootExpand?: boolean;
	/**
	 * 在第一次渲染value时，主动执行一次onChange
	 * ```
	 * 1. 设置labelInValue = true 时有效
	 * 2. 不考虑子父节点的关系
	 * ```
	 */
	executeOnChangeInRenderFirstValue?: boolean;
};
/**
 * 树选择器包装组件，由于过度封装，部分antd TreeSelect原始功能不支持，不满足情况的请使用antd TreeSelect实现
 * ```
 * 1. 当设置treeSelectorList属性后，serviceConfig、onTreeSelectorListChange将失效
 * 2. 父节点默认不返回，需要返回请设置showCheckedStrategy
 * ```
 */
export declare const TreeSelectorWrapper: (props: TreeSelectorWrapperProps) => import("react").JSX.Element;
export type TXMindTreeItem = {
	data: {
		/** 节点文本 */
		text: string;
		/** 全局唯一id */
		uid: string;
		/** 额外的数据，用于使用时自定义渲染 */
		extraData?: TPlainObject;
	};
	/** 子节点 */
	children: TXMindTreeItem[];
};
export interface IXMindPreviewProps {
	data?: TXMindTreeItem;
	className?: string;
	style?: CSSProperties;
	/**
	 * 自定义节点渲染内容：
	 * 默认情况 xmind 会自动计算节点的宽高，
	 * 自定义渲染react组件，因为初始拿不到宽高，所以要返回一个节点宽高
	 * - 默认宽高 200 22
	 * - 返回值为空则使用默认渲染
	 * @param node
	 * @returns
	 */
	renderNode?: (node: TXMindTreeItem) => {
		width?: number;
		height?: number;
		reactNode: ReactNode;
	} | void;
}
export declare const XMindPreview: FC<IXMindPreviewProps>;

export {};