@vunk/form 2.3.3 → 2.5.0

package/components/information/src/index.vue.d.ts

@@ -0,0 +1,391 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    data: {
+        type: import("vue").PropType<import("@vunk/shared").NormalObject>;
+        default: () => {};
+    };
+    formItems: {
+        type: import("vue").PropType<any[]>;
+        default: () => any[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: import("vue").PropType<import("@vunk/shared").NormalObject>;
+        default: () => {};
+    };
+    formItems: {
+        type: import("vue").PropType<any[]>;
+        default: () => any[];
+    };
+}>> & Readonly<{}>, {
+    data: import("@vunk/shared").NormalObject;
+    formItems: any[];
+}, {}, {
+    ElForm: import("element-plus/es/utils").SFCWithInstall<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+            readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+            readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, {
+            validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
+            validateField: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>, callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
+            resetFields: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>) => void;
+            clearValidate: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>) => void;
+            scrollToField: (prop: import("element-plus").FormItemProp) => void;
+            fields: import("element-plus").FormItemContext[];
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
+        }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
+            readonly disabled: boolean;
+            readonly inline: boolean;
+            readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+            readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+            readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, {
+            validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
+            validateField: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>, callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
+            resetFields: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>) => void;
+            clearValidate: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>) => void;
+            scrollToField: (prop: import("element-plus").FormItemProp) => void;
+            fields: import("element-plus").FormItemContext[];
+        }, {}, {}, {}, {
+            readonly disabled: boolean;
+            readonly inline: boolean;
+            readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        readonly model: ObjectConstructor;
+        readonly rules: {
+            readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+        readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+        readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+        readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly inline: BooleanConstructor;
+        readonly inlineMessage: BooleanConstructor;
+        readonly statusIcon: BooleanConstructor;
+        readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly hideRequiredAsterisk: BooleanConstructor;
+        readonly scrollToError: BooleanConstructor;
+        readonly scrollIntoViewOptions: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+    }>> & {
+        onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    }, {
+        validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
+        validateField: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>, callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
+        resetFields: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>) => void;
+        clearValidate: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>) => void;
+        scrollToField: (prop: import("element-plus").FormItemProp) => void;
+        fields: import("element-plus").FormItemContext[];
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
+    }, string, {
+        readonly disabled: boolean;
+        readonly inline: boolean;
+        readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+        readonly inlineMessage: boolean;
+        readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly requireAsteriskPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+        readonly labelSuffix: string;
+        readonly validateOnRuleChange: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly statusIcon: boolean;
+        readonly hideRequiredAsterisk: boolean;
+        readonly scrollToError: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    })> & {
+        FormItem: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                readonly label: StringConstructor;
+                readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+                readonly prop: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+                readonly rules: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly error: StringConstructor;
+                readonly validateStatus: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly for: StringConstructor;
+                readonly inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+                readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>>, {
+                size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+                validateMessage: import("vue").Ref<string>;
+                validateState: import("vue").Ref<"" | "error" | "success" | "validating">;
+                validate: (trigger: string, callback?: import("element-plus/es/components/form/src/types").FormValidateCallback) => import("element-plus/es/components/form/src/types").FormValidationResult;
+                clearValidate: () => void;
+                resetField: () => void;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
+                readonly required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "top" | "left" | "right", unknown>;
+                readonly inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+                readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                readonly label: StringConstructor;
+                readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+                readonly prop: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+                readonly rules: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly error: StringConstructor;
+                readonly validateStatus: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly for: StringConstructor;
+                readonly inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+                readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>>, {
+                size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+                validateMessage: import("vue").Ref<string>;
+                validateState: import("vue").Ref<"" | "error" | "success" | "validating">;
+                validate: (trigger: string, callback?: import("element-plus/es/components/form/src/types").FormValidateCallback) => import("element-plus/es/components/form/src/types").FormValidationResult;
+                clearValidate: () => void;
+                resetField: () => void;
+            }, {}, {}, {}, {
+                readonly required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "top" | "left" | "right", unknown>;
+                readonly inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+                readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            readonly label: StringConstructor;
+            readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "top" | "left" | "right", unknown, "", boolean>;
+            readonly prop: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => string | string[]) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+            readonly rules: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly error: StringConstructor;
+            readonly validateStatus: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly for: StringConstructor;
+            readonly inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+            readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {
+            size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+            validateMessage: import("vue").Ref<string>;
+            validateState: import("vue").Ref<"" | "error" | "success" | "validating">;
+            validate: (trigger: string, callback?: import("element-plus/es/components/form/src/types").FormValidateCallback) => import("element-plus/es/components/form/src/types").FormValidationResult;
+            clearValidate: () => void;
+            resetField: () => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+            readonly required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "top" | "left" | "right", unknown>;
+            readonly inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+            readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                label?(_: {
+                    label: string;
+                }): any;
+                default?(_: {}): any;
+                error?(_: {
+                    error: string;
+                }): any;
+            };
+        });
+    };
+    VkfFormItemRenderer: {
+        new (...args: any[]): any;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<Record<string | symbol, any>>>, Record<string | symbol, any>, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        [x: string]: any;
+        [x: symbol]: any;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        install(app: import("vue").App): void;
+    };
+    VkfRendererData: {
+        new (...args: any[]): any;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<Record<string | symbol, any>>>, Record<string | symbol, any>, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        [x: string]: any;
+        [x: symbol]: any;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        install(app: import("vue").App): void;
+    };
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/information/src/types.d.ts

@@ -0,0 +1,3 @@
+import { __VkfInputCollection } from '@vunk/form/components/input-collection';
+import { __VkfTemplatesDefault } from '@vunk/form';
+export type FormItem<P extends string = string> = __VkfTemplatesDefault.Source<P> | __VkfInputCollection.Source<P>;

package/components/information-templates-default/index.cjs

@@ -0,0 +1,196 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var formItemRendererTemplate = require('@vunk/form/components/form-item-renderer-template');
+var formItem = require('@vunk/form/components/form-item');
+var select = require('@vunk/form/components/select');
+var tagInformation = require('@vunk/form/components/tag-information');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {};
+const emits = {};
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfInformationTemplatesDefault",
+  components: {
+    VkfFormItem: formItem.VkfFormItem,
+    VkfFormItemRendererTemplate: formItemRendererTemplate.VkfFormItemRendererTemplate,
+    VkfTagInformation: tagInformation.VkfTagInformation,
+    VkfSelect: select.VkfSelect
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const prefixCls = "vkf-information-templates-default";
+    const simpleStringTemplates = [
+      "VkfInput",
+      "VkfInputNumber",
+      "VkfSlider"
+    ];
+    const simpleSelectTemplates = [
+      "VkfSelect",
+      "VkfRadio"
+    ];
+    const simpleCollectionTemplates = [
+      "VkfInputCollection"
+    ];
+    return {
+      prefixCls,
+      simpleStringTemplates,
+      simpleSelectTemplates,
+      simpleCollectionTemplates
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkfFormItem = vue.resolveComponent("VkfFormItem");
+  const _component_VkfFormItemRendererTemplate = vue.resolveComponent("VkfFormItemRendererTemplate");
+  const _component_VkfSelect = vue.resolveComponent("VkfSelect");
+  const _component_VkfTagInformation = vue.resolveComponent("VkfTagInformation");
+  return vue.openBlock(), vue.createElementBlock(
+    vue.Fragment,
+    null,
+    [
+      (vue.openBlock(true), vue.createElementBlock(
+        vue.Fragment,
+        null,
+        vue.renderList(_ctx.simpleStringTemplates, (t) => {
+          return vue.openBlock(), vue.createBlock(_component_VkfFormItemRendererTemplate, {
+            key: t,
+            type: t
+          }, {
+            default: vue.withCtx(({ props, value }) => [
+              vue.createVNode(_component_VkfFormItem, {
+                class: vue.normalizeClass(`${_ctx.prefixCls}-main`),
+                label: props.label,
+                prop: props.prop,
+                information: true
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createElementVNode(
+                    "div",
+                    {
+                      class: vue.normalizeClass(`${_ctx.prefixCls}-value`)
+                    },
+                    vue.toDisplayString(value),
+                    3
+                    /* TEXT, CLASS */
+                  )
+                ]),
+                _: 2
+                /* DYNAMIC */
+              }, 1032, ["class", "label", "prop"])
+            ]),
+            _: 2
+            /* DYNAMIC */
+          }, 1032, ["type"]);
+        }),
+        128
+        /* KEYED_FRAGMENT */
+      )),
+      (vue.openBlock(true), vue.createElementBlock(
+        vue.Fragment,
+        null,
+        vue.renderList(_ctx.simpleSelectTemplates, (t) => {
+          return vue.openBlock(), vue.createBlock(_component_VkfFormItemRendererTemplate, {
+            key: t,
+            type: t
+          }, {
+            default: vue.withCtx(({ props, value }) => [
+              vue.createVNode(_component_VkfSelect, {
+                label: props.label,
+                information: true,
+                class: vue.normalizeClass(`${_ctx.prefixCls}-main`),
+                readonly: true,
+                "model-value": value,
+                options: props.options
+              }, null, 8, ["label", "class", "model-value", "options"])
+            ]),
+            _: 2
+            /* DYNAMIC */
+          }, 1032, ["type"]);
+        }),
+        128
+        /* KEYED_FRAGMENT */
+      )),
+      (vue.openBlock(true), vue.createElementBlock(
+        vue.Fragment,
+        null,
+        vue.renderList(_ctx.simpleCollectionTemplates, (t) => {
+          return vue.openBlock(), vue.createBlock(_component_VkfFormItemRendererTemplate, {
+            key: t,
+            type: t
+          }, {
+            default: vue.withCtx(({ props, value }) => [
+              vue.createVNode(_component_VkfFormItem, {
+                class: vue.normalizeClass(`${_ctx.prefixCls}-main`),
+                label: props.label,
+                prop: props.prop,
+                information: true
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createElementVNode(
+                    "div",
+                    {
+                      class: vue.normalizeClass(`${_ctx.prefixCls}-value`)
+                    },
+                    [
+                      (vue.openBlock(true), vue.createElementBlock(
+                        vue.Fragment,
+                        null,
+                        vue.renderList(value, (item, index) => {
+                          return vue.openBlock(), vue.createBlock(_component_VkfTagInformation, {
+                            key: index,
+                            "label-render": props.summaryLabel,
+                            data: item,
+                            "form-items": props.columns.map((v) => {
+                              return {
+                                ...v,
+                                ...v.templateProps,
+                                ...v.templateProps?.createTemplateProps?.({
+                                  row: item
+                                })
+                              };
+                            })
+                          }, null, 8, ["label-render", "data", "form-items"]);
+                        }),
+                        128
+                        /* KEYED_FRAGMENT */
+                      ))
+                    ],
+                    2
+                    /* CLASS */
+                  )
+                ]),
+                _: 2
+                /* DYNAMIC */
+              }, 1032, ["class", "label", "prop"])
+            ]),
+            _: 2
+            /* DYNAMIC */
+          }, 1032, ["type"]);
+        }),
+        128
+        /* KEYED_FRAGMENT */
+      ))
+    ],
+    64
+    /* STABLE_FRAGMENT */
+  );
+}
+var VkfInformationTemplatesDefault = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/information-templates-default/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfInformationTemplatesDefault.install = (app) => {
+  app.component(VkfInformationTemplatesDefault.name || "VkfInformationTemplatesDefault", VkfInformationTemplatesDefault);
+};
+
+exports.VkfInformationTemplatesDefault = VkfInformationTemplatesDefault;
+exports.__VkfInformationTemplatesDefault = types;
+exports.default = VkfInformationTemplatesDefault;

package/components/information-templates-default/index.css

@@ -0,0 +1,12 @@
+.vkf-information-templates-default-main .el-form-item__label {
+  color: var(--el-text-color-secondary);
+  font-weight: normal;
+}
+.vkf-information-templates-default-main .el-select__wrapper.el-select__wrapper {
+  padding: 0;
+  border: none;
+  box-shadow: none;
+}
+.vkf-information-templates-default-main .el-select__selected-item {
+  user-select: text;
+}

package/components/information-templates-default/index.d.ts

@@ -0,0 +1,4 @@
+import VkfInformationTemplatesDefault from './src/index.vue';
+export * as __VkfInformationTemplatesDefault from './src/types';
+export { VkfInformationTemplatesDefault, };
+export default VkfInformationTemplatesDefault;