vee-validate 4.12.1 → 4.12.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/README.md +4 -4
  2. package/dist/vee-validate.d.ts +357 -506
  3. package/dist/vee-validate.esm.js +26 -20
  4. package/dist/vee-validate.js +26 -10
  5. package/dist/vee-validate.min.js +2 -2
  6. package/package.json +4 -4
package/dist/vee-validate.d.ts CHANGED
@@ -556,231 +556,168 @@ interface FieldSlotProps<TValue = unknown> extends Pick<FieldContext, 'validate'
556
556
  handleInput: FieldContext['handleChange'];
557
557
  }
558
558
  declare const Field: {
559
- new (...args: any[]): {
560
- $: vue.ComponentInternalInstance;
561
- $data: {};
562
- $props: Partial<{
563
- label: string;
564
- as: string | Record<string, any>;
565
- bails: boolean;
566
- uncheckedValue: any;
567
- modelValue: any;
568
- validateOnInput: boolean;
569
- validateOnChange: boolean;
570
- validateOnBlur: boolean;
571
- validateOnModelUpdate: boolean;
572
- rules: RuleExpression<unknown>;
573
- validateOnMount: boolean;
574
- modelModifiers: any;
575
- 'onUpdate:modelValue': (e: any) => unknown;
576
- standalone: boolean;
577
- keepValue: boolean;
578
- }> & Omit<{
579
- readonly name: string;
580
- readonly bails: boolean;
581
- readonly modelValue: any;
582
- readonly validateOnMount: boolean;
583
- readonly modelModifiers: any;
584
- readonly standalone: boolean;
585
- readonly label?: string;
586
- readonly as?: string | Record<string, any>;
587
- readonly uncheckedValue?: any;
588
- readonly validateOnInput?: boolean;
589
- readonly validateOnChange?: boolean;
590
- readonly validateOnBlur?: boolean;
591
- readonly validateOnModelUpdate?: boolean;
592
- readonly rules?: RuleExpression<unknown>;
593
- readonly 'onUpdate:modelValue'?: (e: any) => unknown;
594
- readonly keepValue?: boolean;
595
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
596
- as: {
597
- type: (ObjectConstructor | StringConstructor)[];
598
- default: any;
599
- };
600
- name: {
601
- type: StringConstructor;
602
- required: true;
603
- };
604
- rules: {
605
- type: PropType<RuleExpression<unknown>>;
606
- default: any;
607
- };
608
- validateOnMount: {
609
- type: BooleanConstructor;
610
- default: boolean;
611
- };
612
- validateOnBlur: {
613
- type: BooleanConstructor;
614
- default: any;
615
- };
616
- validateOnChange: {
617
- type: BooleanConstructor;
618
- default: any;
619
- };
620
- validateOnInput: {
621
- type: BooleanConstructor;
622
- default: any;
623
- };
624
- validateOnModelUpdate: {
625
- type: BooleanConstructor;
626
- default: any;
627
- };
628
- bails: {
629
- type: BooleanConstructor;
630
- default: () => boolean;
631
- };
632
- label: {
633
- type: StringConstructor;
634
- default: any;
635
- };
636
- uncheckedValue: {
637
- type: any;
638
- default: any;
639
- };
640
- modelValue: {
641
- type: any;
642
- default: symbol;
643
- };
644
- modelModifiers: {
645
- type: any;
646
- default: () => {};
647
- };
648
- 'onUpdate:modelValue': {
649
- type: PropType<(e: any) => unknown>;
650
- default: any;
651
- };
652
- standalone: {
653
- type: BooleanConstructor;
654
- default: boolean;
655
- };
656
- keepValue: {
657
- type: BooleanConstructor;
658
- default: any;
659
- };
660
- }>>, "label" | "as" | "bails" | "uncheckedValue" | "modelValue" | "validateOnInput" | "validateOnChange" | "validateOnBlur" | "validateOnModelUpdate" | "rules" | "validateOnMount" | "modelModifiers" | "onUpdate:modelValue" | "standalone" | "keepValue">;
661
- $attrs: {
662
- [x: string]: unknown;
663
- };
664
- $refs: {
665
- [x: string]: unknown;
666
- };
667
- $slots: Readonly<{
668
- [name: string]: vue.Slot<any>;
669
- }>;
670
- $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
671
- $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
672
- $emit: (event: string, ...args: any[]) => void;
673
- $el: any;
674
- $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
675
- as: {
676
- type: (ObjectConstructor | StringConstructor)[];
677
- default: any;
678
- };
679
- name: {
680
- type: StringConstructor;
681
- required: true;
682
- };
683
- rules: {
684
- type: PropType<RuleExpression<unknown>>;
685
- default: any;
686
- };
687
- validateOnMount: {
688
- type: BooleanConstructor;
689
- default: boolean;
690
- };
691
- validateOnBlur: {
692
- type: BooleanConstructor;
693
- default: any;
694
- };
695
- validateOnChange: {
696
- type: BooleanConstructor;
697
- default: any;
698
- };
699
- validateOnInput: {
700
- type: BooleanConstructor;
701
- default: any;
702
- };
703
- validateOnModelUpdate: {
704
- type: BooleanConstructor;
705
- default: any;
706
- };
707
- bails: {
708
- type: BooleanConstructor;
709
- default: () => boolean;
710
- };
711
- label: {
712
- type: StringConstructor;
713
- default: any;
714
- };
715
- uncheckedValue: {
716
- type: any;
717
- default: any;
718
- };
719
- modelValue: {
720
- type: any;
721
- default: symbol;
722
- };
723
- modelModifiers: {
724
- type: any;
725
- default: () => {};
726
- };
727
- 'onUpdate:modelValue': {
728
- type: PropType<(e: any) => unknown>;
729
- default: any;
730
- };
731
- standalone: {
732
- type: BooleanConstructor;
733
- default: boolean;
734
- };
735
- keepValue: {
736
- type: BooleanConstructor;
737
- default: any;
738
- };
739
- }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
740
- [key: string]: any;
741
- }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
559
+ new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
560
+ as: {
561
+ type: (ObjectConstructor | StringConstructor)[];
562
+ default: any;
563
+ };
564
+ name: {
565
+ type: StringConstructor;
566
+ required: true;
567
+ };
568
+ rules: {
569
+ type: PropType<RuleExpression<unknown>>;
570
+ default: any;
571
+ };
572
+ validateOnMount: {
573
+ type: BooleanConstructor;
574
+ default: boolean;
575
+ };
576
+ validateOnBlur: {
577
+ type: BooleanConstructor;
578
+ default: any;
579
+ };
580
+ validateOnChange: {
581
+ type: BooleanConstructor;
582
+ default: any;
583
+ };
584
+ validateOnInput: {
585
+ type: BooleanConstructor;
586
+ default: any;
587
+ };
588
+ validateOnModelUpdate: {
589
+ type: BooleanConstructor;
590
+ default: any;
591
+ };
592
+ bails: {
593
+ type: BooleanConstructor;
594
+ default: () => boolean;
595
+ };
596
+ label: {
597
+ type: StringConstructor;
598
+ default: any;
599
+ };
600
+ uncheckedValue: {
601
+ type: any;
602
+ default: any;
603
+ };
604
+ modelValue: {
605
+ type: any;
606
+ default: symbol;
607
+ };
608
+ modelModifiers: {
609
+ type: any;
610
+ default: () => {};
611
+ };
612
+ 'onUpdate:modelValue': {
613
+ type: PropType<(e: any) => unknown>;
614
+ default: any;
615
+ };
616
+ standalone: {
617
+ type: BooleanConstructor;
618
+ default: boolean;
619
+ };
620
+ keepValue: {
621
+ type: BooleanConstructor;
622
+ default: any;
623
+ };
624
+ }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
625
+ [key: string]: any;
626
+ }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
627
+ [key: string]: any;
628
+ }>[] | {
629
+ default: () => VNode<vue.RendererNode, vue.RendererElement, {
742
630
  [key: string]: any;
743
- }>[] | {
744
- default: () => VNode<vue.RendererNode, vue.RendererElement, {
745
- [key: string]: any;
746
- }>[];
747
- }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
748
- label: string;
749
- as: string | Record<string, any>;
750
- bails: boolean;
751
- uncheckedValue: any;
752
- modelValue: any;
753
- validateOnInput: boolean;
754
- validateOnChange: boolean;
755
- validateOnBlur: boolean;
756
- validateOnModelUpdate: boolean;
757
- rules: RuleExpression<unknown>;
758
- validateOnMount: boolean;
759
- modelModifiers: any;
760
- 'onUpdate:modelValue': (e: any) => unknown;
761
- standalone: boolean;
762
- keepValue: boolean;
763
- }, {}, string, {}> & {
764
- beforeCreate?: (() => void) | (() => void)[];
765
- created?: (() => void) | (() => void)[];
766
- beforeMount?: (() => void) | (() => void)[];
767
- mounted?: (() => void) | (() => void)[];
768
- beforeUpdate?: (() => void) | (() => void)[];
769
- updated?: (() => void) | (() => void)[];
770
- activated?: (() => void) | (() => void)[];
771
- deactivated?: (() => void) | (() => void)[];
772
- beforeDestroy?: (() => void) | (() => void)[];
773
- beforeUnmount?: (() => void) | (() => void)[];
774
- destroyed?: (() => void) | (() => void)[];
775
- unmounted?: (() => void) | (() => void)[];
776
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
777
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
778
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
779
- };
780
- $forceUpdate: () => void;
781
- $nextTick: typeof vue.nextTick;
782
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean>): vue.WatchStopHandle;
783
- } & Readonly<vue.ExtractPropTypes<{
631
+ }>[];
632
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
633
+ as: {
634
+ type: (ObjectConstructor | StringConstructor)[];
635
+ default: any;
636
+ };
637
+ name: {
638
+ type: StringConstructor;
639
+ required: true;
640
+ };
641
+ rules: {
642
+ type: PropType<RuleExpression<unknown>>;
643
+ default: any;
644
+ };
645
+ validateOnMount: {
646
+ type: BooleanConstructor;
647
+ default: boolean;
648
+ };
649
+ validateOnBlur: {
650
+ type: BooleanConstructor;
651
+ default: any;
652
+ };
653
+ validateOnChange: {
654
+ type: BooleanConstructor;
655
+ default: any;
656
+ };
657
+ validateOnInput: {
658
+ type: BooleanConstructor;
659
+ default: any;
660
+ };
661
+ validateOnModelUpdate: {
662
+ type: BooleanConstructor;
663
+ default: any;
664
+ };
665
+ bails: {
666
+ type: BooleanConstructor;
667
+ default: () => boolean;
668
+ };
669
+ label: {
670
+ type: StringConstructor;
671
+ default: any;
672
+ };
673
+ uncheckedValue: {
674
+ type: any;
675
+ default: any;
676
+ };
677
+ modelValue: {
678
+ type: any;
679
+ default: symbol;
680
+ };
681
+ modelModifiers: {
682
+ type: any;
683
+ default: () => {};
684
+ };
685
+ 'onUpdate:modelValue': {
686
+ type: PropType<(e: any) => unknown>;
687
+ default: any;
688
+ };
689
+ standalone: {
690
+ type: BooleanConstructor;
691
+ default: boolean;
692
+ };
693
+ keepValue: {
694
+ type: BooleanConstructor;
695
+ default: any;
696
+ };
697
+ }>>, {
698
+ label: string;
699
+ as: string | Record<string, any>;
700
+ bails: boolean;
701
+ uncheckedValue: any;
702
+ modelValue: any;
703
+ validateOnInput: boolean;
704
+ validateOnChange: boolean;
705
+ validateOnBlur: boolean;
706
+ validateOnModelUpdate: boolean;
707
+ rules: RuleExpression<unknown>;
708
+ validateOnMount: boolean;
709
+ modelModifiers: any;
710
+ 'onUpdate:modelValue': (e: any) => unknown;
711
+ standalone: boolean;
712
+ keepValue: boolean;
713
+ }, true, {}, {}, {
714
+ P: {};
715
+ B: {};
716
+ D: {};
717
+ C: {};
718
+ M: {};
719
+ Defaults: {};
720
+ }, Readonly<vue.ExtractPropTypes<{
784
721
  as: {
785
722
  type: (ObjectConstructor | StringConstructor)[];
786
723
  default: any;
@@ -845,7 +782,7 @@ declare const Field: {
845
782
  type: BooleanConstructor;
846
783
  default: any;
847
784
  };
848
- }>> & vue.ShallowUnwrapRef<() => VNode<vue.RendererNode, vue.RendererElement, {
785
+ }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
849
786
  [key: string]: any;
850
787
  }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
851
788
  [key: string]: any;
@@ -853,7 +790,23 @@ declare const Field: {
853
790
  default: () => VNode<vue.RendererNode, vue.RendererElement, {
854
791
  [key: string]: any;
855
792
  }>[];
856
- }> & {} & vue.ComponentCustomProperties & {};
793
+ }, {}, {}, {}, {
794
+ label: string;
795
+ as: string | Record<string, any>;
796
+ bails: boolean;
797
+ uncheckedValue: any;
798
+ modelValue: any;
799
+ validateOnInput: boolean;
800
+ validateOnChange: boolean;
801
+ validateOnBlur: boolean;
802
+ validateOnModelUpdate: boolean;
803
+ rules: RuleExpression<unknown>;
804
+ validateOnMount: boolean;
805
+ modelModifiers: any;
806
+ 'onUpdate:modelValue': (e: any) => unknown;
807
+ standalone: boolean;
808
+ keepValue: boolean;
809
+ }>;
857
810
  __isFragment?: never;
858
811
  __isTeleport?: never;
859
812
  __isSuspense?: never;
@@ -969,156 +922,52 @@ type FormSlotProps = UnwrapRef<Pick<FormContext, 'meta' | 'errors' | 'errorBag'
969
922
  getErrors<TValues extends GenericObject = GenericObject>(): FormErrors<TValues>;
970
923
  };
971
924
  declare const Form: {
972
- new (...args: any[]): {
973
- $: vue.ComponentInternalInstance;
974
- $data: {};
975
- $props: Partial<{
976
- onSubmit: SubmissionHandler;
977
- as: string;
978
- initialValues: Record<string, any>;
979
- validateOnMount: boolean;
980
- validationSchema: Record<string, any>;
981
- initialErrors: Record<string, any>;
982
- initialTouched: Record<string, any>;
983
- onInvalidSubmit: InvalidSubmissionHandler;
984
- keepValues: boolean;
985
- }> & Omit<{
986
- readonly as: string;
987
- readonly validateOnMount: boolean;
988
- readonly keepValues: boolean;
989
- readonly onSubmit?: SubmissionHandler;
990
- readonly initialValues?: Record<string, any>;
991
- readonly validationSchema?: Record<string, any>;
992
- readonly initialErrors?: Record<string, any>;
993
- readonly initialTouched?: Record<string, any>;
994
- readonly onInvalidSubmit?: InvalidSubmissionHandler;
995
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
996
- as: {
997
- type: PropType<string>;
998
- default: string;
999
- };
1000
- validationSchema: {
1001
- type: ObjectConstructor;
1002
- default: any;
1003
- };
1004
- initialValues: {
1005
- type: ObjectConstructor;
1006
- default: any;
1007
- };
1008
- initialErrors: {
1009
- type: ObjectConstructor;
1010
- default: any;
1011
- };
1012
- initialTouched: {
1013
- type: ObjectConstructor;
1014
- default: any;
1015
- };
1016
- validateOnMount: {
1017
- type: BooleanConstructor;
1018
- default: boolean;
1019
- };
1020
- onSubmit: {
1021
- type: PropType<SubmissionHandler>;
1022
- default: any;
1023
- };
1024
- onInvalidSubmit: {
1025
- type: PropType<InvalidSubmissionHandler>;
1026
- default: any;
1027
- };
1028
- keepValues: {
1029
- type: BooleanConstructor;
1030
- default: boolean;
1031
- };
1032
- }>>, "onSubmit" | "as" | "initialValues" | "validateOnMount" | "validationSchema" | "initialErrors" | "initialTouched" | "onInvalidSubmit" | "keepValues">;
1033
- $attrs: {
1034
- [x: string]: unknown;
1035
- };
1036
- $refs: {
1037
- [x: string]: unknown;
1038
- };
1039
- $slots: Readonly<{
1040
- [name: string]: vue.Slot<any>;
1041
- }>;
1042
- $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
1043
- $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
1044
- $emit: (event: string, ...args: any[]) => void;
1045
- $el: any;
1046
- $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
1047
- as: {
1048
- type: PropType<string>;
1049
- default: string;
1050
- };
1051
- validationSchema: {
1052
- type: ObjectConstructor;
1053
- default: any;
1054
- };
1055
- initialValues: {
1056
- type: ObjectConstructor;
1057
- default: any;
1058
- };
1059
- initialErrors: {
1060
- type: ObjectConstructor;
1061
- default: any;
1062
- };
1063
- initialTouched: {
1064
- type: ObjectConstructor;
1065
- default: any;
1066
- };
1067
- validateOnMount: {
1068
- type: BooleanConstructor;
1069
- default: boolean;
1070
- };
1071
- onSubmit: {
1072
- type: PropType<SubmissionHandler>;
1073
- default: any;
1074
- };
1075
- onInvalidSubmit: {
1076
- type: PropType<InvalidSubmissionHandler>;
1077
- default: any;
1078
- };
1079
- keepValues: {
1080
- type: BooleanConstructor;
1081
- default: boolean;
1082
- };
1083
- }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
1084
- [key: string]: any;
1085
- }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
925
+ new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
926
+ as: {
927
+ type: PropType<string>;
928
+ default: string;
929
+ };
930
+ validationSchema: {
931
+ type: ObjectConstructor;
932
+ default: any;
933
+ };
934
+ initialValues: {
935
+ type: ObjectConstructor;
936
+ default: any;
937
+ };
938
+ initialErrors: {
939
+ type: ObjectConstructor;
940
+ default: any;
941
+ };
942
+ initialTouched: {
943
+ type: ObjectConstructor;
944
+ default: any;
945
+ };
946
+ validateOnMount: {
947
+ type: BooleanConstructor;
948
+ default: boolean;
949
+ };
950
+ onSubmit: {
951
+ type: PropType<SubmissionHandler>;
952
+ default: any;
953
+ };
954
+ onInvalidSubmit: {
955
+ type: PropType<InvalidSubmissionHandler>;
956
+ default: any;
957
+ };
958
+ keepValues: {
959
+ type: BooleanConstructor;
960
+ default: boolean;
961
+ };
962
+ }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
963
+ [key: string]: any;
964
+ }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
965
+ [key: string]: any;
966
+ }>[] | {
967
+ default: () => VNode<vue.RendererNode, vue.RendererElement, {
1086
968
  [key: string]: any;
1087
- }>[] | {
1088
- default: () => VNode<vue.RendererNode, vue.RendererElement, {
1089
- [key: string]: any;
1090
- }>[];
1091
- }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
1092
- onSubmit: SubmissionHandler;
1093
- as: string;
1094
- initialValues: Record<string, any>;
1095
- validateOnMount: boolean;
1096
- validationSchema: Record<string, any>;
1097
- initialErrors: Record<string, any>;
1098
- initialTouched: Record<string, any>;
1099
- onInvalidSubmit: InvalidSubmissionHandler;
1100
- keepValues: boolean;
1101
- }, {}, string, {}> & {
1102
- beforeCreate?: (() => void) | (() => void)[];
1103
- created?: (() => void) | (() => void)[];
1104
- beforeMount?: (() => void) | (() => void)[];
1105
- mounted?: (() => void) | (() => void)[];
1106
- beforeUpdate?: (() => void) | (() => void)[];
1107
- updated?: (() => void) | (() => void)[];
1108
- activated?: (() => void) | (() => void)[];
1109
- deactivated?: (() => void) | (() => void)[];
1110
- beforeDestroy?: (() => void) | (() => void)[];
1111
- beforeUnmount?: (() => void) | (() => void)[];
1112
- destroyed?: (() => void) | (() => void)[];
1113
- unmounted?: (() => void) | (() => void)[];
1114
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1115
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1116
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
1117
- };
1118
- $forceUpdate: () => void;
1119
- $nextTick: typeof vue.nextTick;
1120
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean>): vue.WatchStopHandle;
1121
- } & Readonly<vue.ExtractPropTypes<{
969
+ }>[];
970
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
1122
971
  as: {
1123
972
  type: PropType<string>;
1124
973
  default: string;
@@ -1155,7 +1004,61 @@ declare const Form: {
1155
1004
  type: BooleanConstructor;
1156
1005
  default: boolean;
1157
1006
  };
1158
- }>> & vue.ShallowUnwrapRef<() => VNode<vue.RendererNode, vue.RendererElement, {
1007
+ }>>, {
1008
+ onSubmit: SubmissionHandler;
1009
+ as: string;
1010
+ initialValues: Record<string, any>;
1011
+ validateOnMount: boolean;
1012
+ validationSchema: Record<string, any>;
1013
+ initialErrors: Record<string, any>;
1014
+ initialTouched: Record<string, any>;
1015
+ onInvalidSubmit: InvalidSubmissionHandler;
1016
+ keepValues: boolean;
1017
+ }, true, {}, {}, {
1018
+ P: {};
1019
+ B: {};
1020
+ D: {};
1021
+ C: {};
1022
+ M: {};
1023
+ Defaults: {};
1024
+ }, Readonly<vue.ExtractPropTypes<{
1025
+ as: {
1026
+ type: PropType<string>;
1027
+ default: string;
1028
+ };
1029
+ validationSchema: {
1030
+ type: ObjectConstructor;
1031
+ default: any;
1032
+ };
1033
+ initialValues: {
1034
+ type: ObjectConstructor;
1035
+ default: any;
1036
+ };
1037
+ initialErrors: {
1038
+ type: ObjectConstructor;
1039
+ default: any;
1040
+ };
1041
+ initialTouched: {
1042
+ type: ObjectConstructor;
1043
+ default: any;
1044
+ };
1045
+ validateOnMount: {
1046
+ type: BooleanConstructor;
1047
+ default: boolean;
1048
+ };
1049
+ onSubmit: {
1050
+ type: PropType<SubmissionHandler>;
1051
+ default: any;
1052
+ };
1053
+ onInvalidSubmit: {
1054
+ type: PropType<InvalidSubmissionHandler>;
1055
+ default: any;
1056
+ };
1057
+ keepValues: {
1058
+ type: BooleanConstructor;
1059
+ default: boolean;
1060
+ };
1061
+ }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
1159
1062
  [key: string]: any;
1160
1063
  }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
1161
1064
  [key: string]: any;
@@ -1163,7 +1066,17 @@ declare const Form: {
1163
1066
  default: () => VNode<vue.RendererNode, vue.RendererElement, {
1164
1067
  [key: string]: any;
1165
1068
  }>[];
1166
- }> & {} & vue.ComponentCustomProperties & {};
1069
+ }, {}, {}, {}, {
1070
+ onSubmit: SubmissionHandler;
1071
+ as: string;
1072
+ initialValues: Record<string, any>;
1073
+ validateOnMount: boolean;
1074
+ validationSchema: Record<string, any>;
1075
+ initialErrors: Record<string, any>;
1076
+ initialTouched: Record<string, any>;
1077
+ onInvalidSubmit: InvalidSubmissionHandler;
1078
+ keepValues: boolean;
1079
+ }>;
1167
1080
  __isFragment?: never;
1168
1081
  __isTeleport?: never;
1169
1082
  __isSuspense?: never;
@@ -1236,79 +1149,50 @@ declare const Form: {
1236
1149
  getValues: FormSlotProps['getValues'];
1237
1150
  getMeta: FormSlotProps['getMeta'];
1238
1151
  getErrors: FormSlotProps['getErrors'];
1152
+ meta: FormSlotProps['meta'];
1153
+ values: FormSlotProps['values'];
1154
+ errors: FormSlotProps['errors'];
1239
1155
  $slots: {
1240
1156
  default: (arg: FormSlotProps) => VNode[];
1241
1157
  };
1242
1158
  });
1243
1159
 
1244
1160
  declare const FieldArray: {
1245
- new (...args: any[]): {
1246
- $: vue.ComponentInternalInstance;
1247
- $data: {};
1248
- $props: Partial<{}> & Omit<{
1249
- readonly name: string;
1250
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
1251
- name: {
1252
- type: StringConstructor;
1253
- required: true;
1254
- };
1255
- }>>, never>;
1256
- $attrs: {
1257
- [x: string]: unknown;
1258
- };
1259
- $refs: {
1260
- [x: string]: unknown;
1261
- };
1262
- $slots: Readonly<{
1263
- [name: string]: vue.Slot<any>;
1264
- }>;
1265
- $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
1266
- $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
1267
- $emit: (event: string, ...args: any[]) => void;
1268
- $el: any;
1269
- $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
1270
- name: {
1271
- type: StringConstructor;
1272
- required: true;
1273
- };
1274
- }>>, () => vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
1161
+ new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
1162
+ name: {
1163
+ type: StringConstructor;
1164
+ required: true;
1165
+ };
1166
+ }>>, () => vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
1167
+ [key: string]: any;
1168
+ }>[] | {
1169
+ default: () => VNode<vue.RendererNode, vue.RendererElement, {
1275
1170
  [key: string]: any;
1276
- }>[] | {
1277
- default: () => VNode<vue.RendererNode, vue.RendererElement, {
1278
- [key: string]: any;
1279
- }>[];
1280
- }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
1281
- beforeCreate?: (() => void) | (() => void)[];
1282
- created?: (() => void) | (() => void)[];
1283
- beforeMount?: (() => void) | (() => void)[];
1284
- mounted?: (() => void) | (() => void)[];
1285
- beforeUpdate?: (() => void) | (() => void)[];
1286
- updated?: (() => void) | (() => void)[];
1287
- activated?: (() => void) | (() => void)[];
1288
- deactivated?: (() => void) | (() => void)[];
1289
- beforeDestroy?: (() => void) | (() => void)[];
1290
- beforeUnmount?: (() => void) | (() => void)[];
1291
- destroyed?: (() => void) | (() => void)[];
1292
- unmounted?: (() => void) | (() => void)[];
1293
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1294
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1295
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
1296
- };
1297
- $forceUpdate: () => void;
1298
- $nextTick: typeof vue.nextTick;
1299
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean>): vue.WatchStopHandle;
1300
- } & Readonly<vue.ExtractPropTypes<{
1171
+ }>[];
1172
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
1173
+ name: {
1174
+ type: StringConstructor;
1175
+ required: true;
1176
+ };
1177
+ }>>, {}, true, {}, {}, {
1178
+ P: {};
1179
+ B: {};
1180
+ D: {};
1181
+ C: {};
1182
+ M: {};
1183
+ Defaults: {};
1184
+ }, Readonly<vue.ExtractPropTypes<{
1301
1185
  name: {
1302
1186
  type: StringConstructor;
1303
1187
  required: true;
1304
1188
  };
1305
- }>> & vue.ShallowUnwrapRef<() => vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
1189
+ }>>, () => vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
1306
1190
  [key: string]: any;
1307
1191
  }>[] | {
1308
1192
  default: () => VNode<vue.RendererNode, vue.RendererElement, {
1309
1193
  [key: string]: any;
1310
1194
  }>[];
1311
- }> & {} & vue.ComponentCustomProperties & {};
1195
+ }, {}, {}, {}, {}>;
1312
1196
  __isFragment?: never;
1313
1197
  __isTeleport?: never;
1314
1198
  __isSuspense?: never;
@@ -1341,77 +1225,24 @@ interface ErrorMessageSlotProps {
1341
1225
  message: string | undefined;
1342
1226
  }
1343
1227
  declare const ErrorMessage: {
1344
- new (...args: any[]): {
1345
- $: vue.ComponentInternalInstance;
1346
- $data: {};
1347
- $props: Partial<{
1348
- as: string;
1349
- }> & Omit<{
1350
- readonly name: string;
1351
- readonly as?: string;
1352
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
1353
- as: {
1354
- type: StringConstructor;
1355
- default: any;
1356
- };
1357
- name: {
1358
- type: StringConstructor;
1359
- required: true;
1360
- };
1361
- }>>, "as">;
1362
- $attrs: {
1363
- [x: string]: unknown;
1364
- };
1365
- $refs: {
1366
- [x: string]: unknown;
1367
- };
1368
- $slots: Readonly<{
1369
- [name: string]: vue.Slot<any>;
1370
- }>;
1371
- $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
1372
- $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
1373
- $emit: (event: string, ...args: any[]) => void;
1374
- $el: any;
1375
- $options: vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
1376
- as: {
1377
- type: StringConstructor;
1378
- default: any;
1379
- };
1380
- name: {
1381
- type: StringConstructor;
1382
- required: true;
1383
- };
1384
- }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
1385
- [key: string]: any;
1386
- }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
1228
+ new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
1229
+ as: {
1230
+ type: StringConstructor;
1231
+ default: any;
1232
+ };
1233
+ name: {
1234
+ type: StringConstructor;
1235
+ required: true;
1236
+ };
1237
+ }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
1238
+ [key: string]: any;
1239
+ }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
1240
+ [key: string]: any;
1241
+ }>[] | {
1242
+ default: () => VNode<vue.RendererNode, vue.RendererElement, {
1387
1243
  [key: string]: any;
1388
- }>[] | {
1389
- default: () => VNode<vue.RendererNode, vue.RendererElement, {
1390
- [key: string]: any;
1391
- }>[];
1392
- }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
1393
- as: string;
1394
- }, {}, string, {}> & {
1395
- beforeCreate?: (() => void) | (() => void)[];
1396
- created?: (() => void) | (() => void)[];
1397
- beforeMount?: (() => void) | (() => void)[];
1398
- mounted?: (() => void) | (() => void)[];
1399
- beforeUpdate?: (() => void) | (() => void)[];
1400
- updated?: (() => void) | (() => void)[];
1401
- activated?: (() => void) | (() => void)[];
1402
- deactivated?: (() => void) | (() => void)[];
1403
- beforeDestroy?: (() => void) | (() => void)[];
1404
- beforeUnmount?: (() => void) | (() => void)[];
1405
- destroyed?: (() => void) | (() => void)[];
1406
- unmounted?: (() => void) | (() => void)[];
1407
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1408
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1409
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
1410
- };
1411
- $forceUpdate: () => void;
1412
- $nextTick: typeof vue.nextTick;
1413
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean>): vue.WatchStopHandle;
1414
- } & Readonly<vue.ExtractPropTypes<{
1244
+ }>[];
1245
+ }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
1415
1246
  as: {
1416
1247
  type: StringConstructor;
1417
1248
  default: any;
@@ -1420,7 +1251,25 @@ declare const ErrorMessage: {
1420
1251
  type: StringConstructor;
1421
1252
  required: true;
1422
1253
  };
1423
- }>> & vue.ShallowUnwrapRef<() => VNode<vue.RendererNode, vue.RendererElement, {
1254
+ }>>, {
1255
+ as: string;
1256
+ }, true, {}, {}, {
1257
+ P: {};
1258
+ B: {};
1259
+ D: {};
1260
+ C: {};
1261
+ M: {};
1262
+ Defaults: {};
1263
+ }, Readonly<vue.ExtractPropTypes<{
1264
+ as: {
1265
+ type: StringConstructor;
1266
+ default: any;
1267
+ };
1268
+ name: {
1269
+ type: StringConstructor;
1270
+ required: true;
1271
+ };
1272
+ }>>, () => VNode<vue.RendererNode, vue.RendererElement, {
1424
1273
  [key: string]: any;
1425
1274
  }> | vue.Slot<any> | VNode<vue.RendererNode, vue.RendererElement, {
1426
1275
  [key: string]: any;
@@ -1428,7 +1277,9 @@ declare const ErrorMessage: {
1428
1277
  default: () => VNode<vue.RendererNode, vue.RendererElement, {
1429
1278
  [key: string]: any;
1430
1279
  }>[];
1431
- }> & {} & vue.ComponentCustomProperties & {};
1280
+ }, {}, {}, {}, {
1281
+ as: string;
1282
+ }>;
1432
1283
  __isFragment?: never;
1433
1284
  __isTeleport?: never;
1434
1285
  __isSuspense?: never;