@gx-design-vue/pro-table 0.2.0-alpha.7 → 0.2.0-alpha.9

package/dist/components/ScrollBar/Bar.d.ts

@@ -0,0 +1,81 @@
+import * as _$vue from "vue";
+import { CSSProperties } from "vue";
+import * as _$vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region src/components/ScrollBar/Bar.d.ts
+interface BarExpose {
+  handleScroll: (wrap: HTMLElement) => void;
+  update: () => void;
+}
+declare const barProps: {
+  readonly always: {
+    readonly type: BooleanConstructor;
+    readonly default: true;
+  };
+  readonly minSize: {
+    readonly type: NumberConstructor;
+    readonly default: 20;
+  };
+  readonly barStyle: {
+    readonly type: () => {
+      x: CSSProperties;
+      y: CSSProperties;
+    };
+    readonly default: () => {};
+  };
+  readonly hasScrollY: {
+    readonly type: BooleanConstructor;
+    readonly default: false;
+  };
+};
+declare const _default: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  readonly always: {
+    readonly type: BooleanConstructor;
+    readonly default: true;
+  };
+  readonly minSize: {
+    readonly type: NumberConstructor;
+    readonly default: 20;
+  };
+  readonly barStyle: {
+    readonly type: () => {
+      x: CSSProperties;
+      y: CSSProperties;
+    };
+    readonly default: () => {};
+  };
+  readonly hasScrollY: {
+    readonly type: BooleanConstructor;
+    readonly default: false;
+  };
+}>, () => _$vue_jsx_runtime0.JSX.Element, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  readonly always: {
+    readonly type: BooleanConstructor;
+    readonly default: true;
+  };
+  readonly minSize: {
+    readonly type: NumberConstructor;
+    readonly default: 20;
+  };
+  readonly barStyle: {
+    readonly type: () => {
+      x: CSSProperties;
+      y: CSSProperties;
+    };
+    readonly default: () => {};
+  };
+  readonly hasScrollY: {
+    readonly type: BooleanConstructor;
+    readonly default: false;
+  };
+}>> & Readonly<{}>, {
+  readonly always: boolean;
+  readonly minSize: number;
+  readonly barStyle: {
+    x: CSSProperties;
+    y: CSSProperties;
+  };
+  readonly hasScrollY: boolean;
+}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { BarExpose, barProps, _default as default };

package/dist/components/ScrollBar/Bar.js

@@ -0,0 +1,84 @@
+import { useInjectScrollBarContext } from "./context.js";
+import "./util.js";
+import Thumb_default from "./Thumb.js";
+import { Fragment, createVNode, defineComponent, nextTick, onMounted, ref } from "vue";
+//#region src/components/ScrollBar/Bar.tsx
+const barProps = {
+	always: {
+		type: Boolean,
+		default: true
+	},
+	minSize: {
+		type: Number,
+		default: 20
+	},
+	barStyle: {
+		type: Object,
+		default: () => ({})
+	},
+	hasScrollY: {
+		type: Boolean,
+		default: false
+	}
+};
+var Bar_default = /* @__PURE__ */ defineComponent({
+	name: "ScrollBarBar",
+	inheritAttrs: false,
+	props: barProps,
+	setup(props, { expose }) {
+		const scrollbar = useInjectScrollBarContext();
+		const moveX = ref(0);
+		const moveY = ref(0);
+		const sizeWidth = ref("");
+		const sizeHeight = ref("");
+		const ratioY = ref(1);
+		const ratioX = ref(1);
+		function handleScroll(wrap) {
+			if (!wrap) return;
+			const offsetHeight = wrap.offsetHeight - 4;
+			const offsetWidth = wrap.offsetWidth - 4;
+			moveY.value = wrap.scrollTop * 100 / offsetHeight * ratioY.value;
+			moveX.value = wrap.scrollLeft * 100 / offsetWidth * ratioX.value;
+		}
+		function update() {
+			const wrap = scrollbar?.wrapElement?.value;
+			if (!wrap) return;
+			const offsetHeight = wrap.offsetHeight - 4;
+			const offsetWidth = wrap.offsetWidth - 4;
+			const originalHeight = offsetHeight ** 2 / wrap.scrollHeight;
+			const originalWidth = offsetWidth ** 2 / wrap.scrollWidth;
+			const height = Math.max(originalHeight, props.minSize);
+			const width = Math.max(originalWidth, props.minSize);
+			ratioY.value = originalHeight / (offsetHeight - originalHeight) / (height / (offsetHeight - height));
+			ratioX.value = originalWidth / (offsetWidth - originalWidth) / (width / (offsetWidth - width));
+			sizeHeight.value = height + 4 < offsetHeight ? `${height}px` : "";
+			sizeWidth.value = width + 4 < offsetWidth ? `${width}px` : "";
+		}
+		onMounted(() => {
+			nextTick(() => update());
+		});
+		expose({
+			update,
+			handleScroll
+		});
+		return () => {
+			if (!scrollbar) return null;
+			return createVNode(Fragment, null, [createVNode(Thumb_default, {
+				"move": moveX.value,
+				"barStyle": props.barStyle.x,
+				"ratio": ratioX.value,
+				"size": sizeWidth.value,
+				"always": props.always
+			}, null), props.hasScrollY && createVNode(Thumb_default, {
+				"move": moveY.value,
+				"barStyle": props.barStyle.y,
+				"ratio": ratioY.value,
+				"size": sizeHeight.value,
+				"vertical": true,
+				"always": props.always
+			}, null)]);
+		};
+	}
+});
+//#endregion
+export { barProps, Bar_default as default };

package/dist/components/ScrollBar/Thumb.d.ts

@@ -0,0 +1,52 @@
+import * as _$vue from "vue";
+import { CSSProperties } from "vue";
+import * as _$vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region src/components/ScrollBar/Thumb.d.ts
+declare const thumbProps: {
+  readonly vertical: BooleanConstructor;
+  readonly size: StringConstructor;
+  readonly move: NumberConstructor;
+  readonly ratio: {
+    readonly type: NumberConstructor;
+    readonly required: true;
+  };
+  readonly always: BooleanConstructor;
+  readonly barStyle: {
+    readonly type: () => CSSProperties;
+    readonly default: () => {};
+  };
+};
+declare const _default: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  readonly vertical: BooleanConstructor;
+  readonly size: StringConstructor;
+  readonly move: NumberConstructor;
+  readonly ratio: {
+    readonly type: NumberConstructor;
+    readonly required: true;
+  };
+  readonly always: BooleanConstructor;
+  readonly barStyle: {
+    readonly type: () => CSSProperties;
+    readonly default: () => {};
+  };
+}>, () => _$vue_jsx_runtime0.JSX.Element, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  readonly vertical: BooleanConstructor;
+  readonly size: StringConstructor;
+  readonly move: NumberConstructor;
+  readonly ratio: {
+    readonly type: NumberConstructor;
+    readonly required: true;
+  };
+  readonly always: BooleanConstructor;
+  readonly barStyle: {
+    readonly type: () => CSSProperties;
+    readonly default: () => {};
+  };
+}>> & Readonly<{}>, {
+  readonly always: boolean;
+  readonly barStyle: CSSProperties;
+  readonly vertical: boolean;
+}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { _default as default, thumbProps };

package/dist/components/ScrollBar/{Thumb/index.js → Thumb.js}

@@ -1,14 +1,29 @@
-import { useScrollBarContext } from "../context.js";
-import { BAR_MAP, renderThumbStyle } from "../util.js";
-import { thumbProps } from "./props.js";
+import { useInjectScrollBarContext } from "./context.js";
+import { BAR_MAP, renderThumbStyle } from "./util.js";
 import { computed, createVNode, defineComponent, onBeforeUnmount, ref } from "vue";
+import { useEventListener } from "@vueuse/core";
 import { unit } from "@gx-design-vue/pro-provider";
-import { isClient, useEventListener } from "@vueuse/core";
-//#region src/components/ScrollBar/Thumb/index.tsx
-const Thumb = /* @__PURE__ */ defineComponent({
+//#region src/components/ScrollBar/Thumb.tsx
+const thumbProps = {
+	vertical: Boolean,
+	size: String,
+	move: Number,
+	ratio: {
+		type: Number,
+		required: true
+	},
+	always: Boolean,
+	barStyle: {
+		type: Object,
+		default: () => ({})
+	}
+};
+var Thumb_default = /* @__PURE__ */ defineComponent({
+	name: "ScrollBarThumb",
+	inheritAttrs: false,
 	props: thumbProps,
 	setup(props) {
-		const { tableHeaderHeight, hashId, wrapElement, scrollbarElement, className } = useScrollBarContext();
+		const scrollbar = useInjectScrollBarContext();
 		const instance = ref();
 		const thumb = ref();
 		const thumbState = ref({});
@@ -17,57 +32,61 @@ const Thumb = /* @__PURE__ */ defineComponent({
 		let cursorLeave = false;
 		let baseScrollHeight = 0;
 		let baseScrollWidth = 0;
-		let originalOnSelectStart = isClient ? document.onselectstart : null;
 		const bar = computed(() => BAR_MAP[props.vertical ? "vertical" : "horizontal"]);
 		const thumbStyle = computed(() => renderThumbStyle({
 			size: props.size,
 			move: props.move,
 			bar: bar.value
 		}));
-		const offsetRatio = computed(() => instance.value[bar.value.offset] ** 2 / wrapElement.value[bar.value.scrollSize] / props.ratio / thumb.value[bar.value.offset]);
-		const clickThumbHandler = (e) => {
-			e.stopPropagation();
-			if (e.ctrlKey || [1, 2].includes(e.button)) return;
-			window.getSelection()?.removeAllRanges();
-			startDrag(e);
-			const el = e.currentTarget;
-			if (!el) return;
-			thumbState.value[bar.value.axis] = el[bar.value.offset] - (e[bar.value.client] - el.getBoundingClientRect()[bar.value.direction]);
-		};
-		const clickTrackHandler = (e) => {
-			if (!thumb.value || !instance.value || !wrapElement.value) return;
-			const thumbPositionPercentage = (Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) - thumb.value[bar.value.offset] / 2) * 100 * offsetRatio.value / instance.value[bar.value.offset];
-			wrapElement.value[bar.value.scroll] = thumbPositionPercentage * wrapElement.value[bar.value.scrollSize] / 100;
-		};
-		function startDrag(e) {
-			if (!wrapElement.value) return;
-			e.stopImmediatePropagation();
-			cursorDown = true;
-			baseScrollHeight = wrapElement.value.scrollHeight;
-			baseScrollWidth = wrapElement.value.scrollWidth;
-			document.addEventListener("mousemove", mouseMoveDocumentHandler);
-			document.addEventListener("mouseup", mouseUpDocumentHandler);
-			originalOnSelectStart = document.onselectstart;
-			document.onselectstart = () => false;
+		const offsetRatio = computed(() => {
+			if (!instance.value || !thumb.value || !scrollbar?.wrapElement?.value) return 1;
+			return instance.value[bar.value.offset] ** 2 / scrollbar.wrapElement.value[bar.value.scrollSize] / props.ratio / thumb.value[bar.value.offset];
+		});
+		function restoreOnSelectStart(originalOnSelectStart) {
+			if (document.onselectstart !== originalOnSelectStart) document.onselectstart = originalOnSelectStart;
 		}
 		function mouseMoveDocumentHandler(e) {
-			if (!wrapElement.value) return;
-			if (!instance.value || !thumb.value) return;
-			if (cursorDown === false) return;
+			if (!scrollbar?.wrapElement?.value || !instance.value || !thumb.value || !cursorDown) return;
 			const prevPage = thumbState.value[bar.value.axis];
 			if (!prevPage) return;
 			const thumbPositionPercentage = ((instance.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1 - (thumb.value[bar.value.offset] - prevPage)) * 100 * offsetRatio.value / instance.value[bar.value.offset];
-			if (bar.value.scroll === "scrollLeft") wrapElement.value[bar.value.scroll] = thumbPositionPercentage * baseScrollWidth / 100;
-			else wrapElement.value[bar.value.scroll] = thumbPositionPercentage * baseScrollHeight / 100;
+			if (bar.value.scroll === "scrollLeft") scrollbar.wrapElement.value[bar.value.scroll] = thumbPositionPercentage * baseScrollWidth / 100;
+			else scrollbar.wrapElement.value[bar.value.scroll] = thumbPositionPercentage * baseScrollHeight / 100;
 		}
+		let originalOnSelectStart = document.onselectstart;
 		function mouseUpDocumentHandler() {
 			cursorDown = false;
 			thumbState.value[bar.value.axis] = 0;
 			document.removeEventListener("mousemove", mouseMoveDocumentHandler);
 			document.removeEventListener("mouseup", mouseUpDocumentHandler);
-			restoreOnselectstart();
+			restoreOnSelectStart(originalOnSelectStart);
 			if (cursorLeave) visible.value = false;
 		}
+		function startDrag(e) {
+			if (!scrollbar?.wrapElement?.value) return;
+			e.stopImmediatePropagation();
+			cursorDown = true;
+			baseScrollHeight = scrollbar.wrapElement.value.scrollHeight;
+			baseScrollWidth = scrollbar.wrapElement.value.scrollWidth;
+			document.addEventListener("mousemove", mouseMoveDocumentHandler);
+			document.addEventListener("mouseup", mouseUpDocumentHandler);
+			originalOnSelectStart = document.onselectstart;
+			document.onselectstart = () => false;
+		}
+		function clickThumbHandler(e) {
+			e.stopPropagation();
+			if (e.ctrlKey || [1, 2].includes(e.button)) return;
+			window.getSelection()?.removeAllRanges();
+			startDrag(e);
+			const el = e.currentTarget;
+			if (!el) return;
+			thumbState.value[bar.value.axis] = el[bar.value.offset] - (e[bar.value.client] - el.getBoundingClientRect()[bar.value.direction]);
+		}
+		function clickTrackHandler(e) {
+			if (!thumb.value || !instance.value || !scrollbar?.wrapElement?.value) return;
+			const thumbPositionPercentage = (Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) - thumb.value[bar.value.offset] / 2) * 100 * offsetRatio.value / instance.value[bar.value.offset];
+			scrollbar.wrapElement.value[bar.value.scroll] = thumbPositionPercentage * scrollbar.wrapElement.value[bar.value.scrollSize] / 100;
+		}
 		const mouseMoveScrollbarHandler = () => {
 			cursorLeave = false;
 			visible.value = !!props.size;
@@ -76,19 +95,17 @@ const Thumb = /* @__PURE__ */ defineComponent({
 			cursorLeave = true;
 			visible.value = cursorDown;
 		};
+		useEventListener(scrollbar?.scrollbarElement, "mousemove", mouseMoveScrollbarHandler);
+		useEventListener(scrollbar?.scrollbarElement, "mouseleave", mouseLeaveScrollbarHandler);
 		onBeforeUnmount(() => {
-			restoreOnselectstart();
+			restoreOnSelectStart(originalOnSelectStart);
 			document.removeEventListener("mouseup", mouseUpDocumentHandler);
 		});
-		function restoreOnselectstart() {
-			if (document.onselectstart !== originalOnSelectStart) document.onselectstart = originalOnSelectStart;
-		}
-		useEventListener(scrollbarElement, "mousemove", mouseMoveScrollbarHandler);
-		useEventListener(scrollbarElement, "mouseleave", mouseLeaveScrollbarHandler);
 		return () => {
+			if (!scrollbar) return null;
 			const verticalStyle = bar.value.key === "vertical" ? {
-				height: `calc(100% - ${unit(tableHeaderHeight.value + 1)})`,
-				top: unit(tableHeaderHeight.value + 1)
+				height: `calc(100% - ${unit(scrollbar.tableHeaderHeight.value + 1)})`,
+				top: unit(scrollbar.tableHeaderHeight.value + 1)
 			} : {};
 			return createVNode("div", {
 				"ref": instance,
@@ -96,21 +113,16 @@ const Thumb = /* @__PURE__ */ defineComponent({
 					...props.barStyle,
 					...verticalStyle
 				},
-				"class": [
-					`${className}-bar`,
-					`is-${bar.value.key}`,
-					hashId.value
-				],
+				"class": `${scrollbar.className}-bar is-${bar.value.key}`,
 				"onMousedown": clickTrackHandler
 			}, [createVNode("div", {
 				"ref": thumb,
-				"class": `${className}-thumb ${hashId.value}`,
+				"class": `${scrollbar.className}-thumb`,
 				"style": thumbStyle.value,
 				"onMousedown": clickThumbHandler
 			}, null)]);
 		};
 	}
 });
-Thumb.inheritAttrs = false;
 //#endregion
-export { Thumb as default };
+export { Thumb_default as default, thumbProps };

package/dist/components/ScrollBar/context.d.ts

@@ -1,14 +1,13 @@
 import { Ref } from "vue";
 
 //#region src/components/ScrollBar/context.d.ts
-interface ScrollbarContext {
+interface ScrollBarContext {
   className: string;
-  hashId: Ref<string>;
   tableHeaderHeight: Ref<number>;
   tableScrollYHeight: Ref<number>;
   scrollbarElement: Ref<HTMLElement | undefined>;
   wrapElement: Ref<HTMLElement | undefined>;
 }
-declare const useScrollBarContext: (injectDefaultValue?: ScrollbarContext) => ScrollbarContext, provideScrollBarContext: (value: ScrollbarContext) => void;
+declare const useProvideScrollBarContext: (args_0: ScrollBarContext) => ScrollBarContext, useInjectScrollBarContext: () => ScrollBarContext;
 //#endregion
-export { ScrollbarContext, provideScrollBarContext, useScrollBarContext };
+export { ScrollBarContext, useInjectScrollBarContext, useProvideScrollBarContext };

package/dist/components/ScrollBar/context.js

@@ -1,5 +1,5 @@
-import { useContext } from "@gx-design-vue/context";
+import { createInjectionState } from "@vueuse/core";
 //#region src/components/ScrollBar/context.ts
-const { useInjectContext: useScrollBarContext, provideContext: provideScrollBarContext } = useContext("scrollbar");
+const [useProvideScrollBarContext, useInjectScrollBarContext] = createInjectionState((context) => context);
 //#endregion
-export { provideScrollBarContext, useScrollBarContext };
+export { useInjectScrollBarContext, useProvideScrollBarContext };

package/dist/components/ScrollBar/util.d.ts

@@ -24,14 +24,15 @@ declare const BAR_MAP: {
     readonly direction: "left";
   };
 };
+type BarDirection = keyof typeof BAR_MAP;
 declare function renderThumbStyle({
   move,
   size,
   bar
-}: Pick<any, 'move' | 'size'> & {
-  bar: typeof BAR_MAP[keyof typeof BAR_MAP];
+}: {
+  move: number;
+  size: string;
+  bar: typeof BAR_MAP[BarDirection];
 }): CSSProperties;
-declare function isStringNumber(val: string): boolean;
-declare function addUnit(value?: string | number, defaultUnit?: string): string;
 //#endregion
-export { BAR_MAP, GAP, addUnit, isStringNumber, renderThumbStyle };
+export { BAR_MAP, BarDirection, GAP, renderThumbStyle };

package/dist/components/ScrollBar/util.js

@@ -1,4 +1,3 @@
-import { isNumber, isString } from "@gx-design-vue/pro-utils";
 //#region src/components/ScrollBar/util.ts
 const GAP = 4;
 const BAR_MAP = {
@@ -29,15 +28,5 @@ function renderThumbStyle({ move, size, bar }) {
 		transform: `translate${bar.axis}(${move}%)`
 	};
 }
-function isStringNumber(val) {
-	if (!isString(val)) return false;
-	return !Number.isNaN(Number(val));
-}
-function addUnit(value, defaultUnit = "px") {
-	if (!value) return "";
-	if (isNumber(value) || isStringNumber(value)) return `${value}${defaultUnit}`;
-	else if (isString(value)) return value;
-	console.warn("utils/dom/style", "value 必须为数字");
-}
 //#endregion
-export { BAR_MAP, GAP, addUnit, isStringNumber, renderThumbStyle };
+export { BAR_MAP, GAP, renderThumbStyle };

package/dist/components/SearchForm/CollapseToggle.d.ts

@@ -0,0 +1,55 @@
+import * as _$vue from "vue";
+import { PropType } from "vue";
+import { CustomRender, WithFalse } from "@gx-design-vue/pro-utils";
+import * as _$vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region src/components/SearchForm/CollapseToggle.d.ts
+declare const CollapseToggle: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  collapsed: {
+    type: BooleanConstructor;
+    default: any;
+  };
+  collapseRender: {
+    type: PropType<WithFalse<(collapsed?: boolean) => CustomRender> | undefined>;
+    default: any;
+  };
+  prefixCls: {
+    type: StringConstructor;
+    required: true;
+  };
+  hashId: {
+    type: StringConstructor;
+    default: string;
+  };
+  onToggle: {
+    type: PropType<(collapsed: boolean) => void>;
+    required: true;
+  };
+}>, () => _$vue_jsx_runtime0.JSX.Element, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  collapsed: {
+    type: BooleanConstructor;
+    default: any;
+  };
+  collapseRender: {
+    type: PropType<WithFalse<(collapsed?: boolean) => CustomRender> | undefined>;
+    default: any;
+  };
+  prefixCls: {
+    type: StringConstructor;
+    required: true;
+  };
+  hashId: {
+    type: StringConstructor;
+    default: string;
+  };
+  onToggle: {
+    type: PropType<(collapsed: boolean) => void>;
+    required: true;
+  };
+}>> & Readonly<{}>, {
+  collapsed: boolean;
+  collapseRender: WithFalse<(collapsed?: boolean) => CustomRender>;
+  hashId: string;
+}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { CollapseToggle };

package/dist/components/SearchForm/CollapseToggle.js

@@ -0,0 +1,47 @@
+import { createVNode, defineComponent } from "vue";
+import { DownOutlined, UpOutlined } from "@antdv-next/icons";
+//#region src/components/SearchForm/CollapseToggle.tsx
+const CollapseToggle = /* @__PURE__ */ defineComponent({
+	name: "ProTableCollapseToggle",
+	props: {
+		collapsed: {
+			type: Boolean,
+			default: void 0
+		},
+		collapseRender: {
+			type: [
+				Function,
+				Object,
+				Boolean
+			],
+			default: void 0
+		},
+		prefixCls: {
+			type: String,
+			required: true
+		},
+		hashId: {
+			type: String,
+			default: ""
+		},
+		onToggle: {
+			type: Function,
+			required: true
+		}
+	},
+	setup(props) {
+		return () => {
+			if (props.collapseRender === false) return null;
+			if (typeof props.collapseRender === "function") return createVNode("span", {
+				"class": [`${props.prefixCls}-search-control-text`, props.hashId],
+				"onClick": () => props.onToggle(!props.collapsed)
+			}, [props.collapseRender(props.collapsed)]);
+			return createVNode("span", {
+				"class": `${props.prefixCls}-search-control-text`,
+				"onClick": () => props.onToggle(!props.collapsed)
+			}, [props.collapsed ? "展开" : "收起", props.collapsed ? createVNode(DownOutlined, null, null) : createVNode(UpOutlined, null, null)]);
+		};
+	}
+});
+//#endregion
+export { CollapseToggle };

package/dist/components/SearchForm/FormItemContainer.d.ts

@@ -0,0 +1,75 @@
+import { ProSearchMap } from "../../interface.js";
+import * as _$vue from "vue";
+import { PropType } from "vue";
+import * as _$vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region src/components/SearchForm/FormItemContainer.d.ts
+declare const FormItemContainer: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  prefixCls: {
+    type: StringConstructor;
+    required: true;
+  };
+  record: {
+    type: PropType<ProSearchMap>;
+    required: true;
+  };
+  formState: {
+    type: PropType<Record<string, any>>;
+    required: true;
+  };
+  autoRequest: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  loading: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  onChange: {
+    type: PropType<(value: any, record: ProSearchMap, options?: {
+      key?: number;
+    }) => void>;
+    required: true;
+  };
+  onSubmit: {
+    type: PropType<() => void>;
+    default: any;
+  };
+}>, () => _$vue_jsx_runtime0.JSX.Element, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  prefixCls: {
+    type: StringConstructor;
+    required: true;
+  };
+  record: {
+    type: PropType<ProSearchMap>;
+    required: true;
+  };
+  formState: {
+    type: PropType<Record<string, any>>;
+    required: true;
+  };
+  autoRequest: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  loading: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  onChange: {
+    type: PropType<(value: any, record: ProSearchMap, options?: {
+      key?: number;
+    }) => void>;
+    required: true;
+  };
+  onSubmit: {
+    type: PropType<() => void>;
+    default: any;
+  };
+}>> & Readonly<{}>, {
+  autoRequest: boolean;
+  loading: boolean;
+  onSubmit: () => void;
+}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { FormItemContainer };