@tmagic/form 1.5.11 → 1.5.13

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 (5) hide show
  1. package/dist/tmagic-form.js +24 -20
  2. package/dist/tmagic-form.umd.cjs +63 -289
  3. package/package.json +3 -3
  4. package/src/containers/Table.vue +2 -0
  5. package/types/index.d.ts +1372 -3037
package/types/index.d.ts CHANGED
@@ -1,9 +1,10 @@
1
1
  import * as vue from 'vue';
2
- import { nextTick, App } from 'vue';
2
+ import { App } from 'vue';
3
3
  import * as _tmagic_design from '@tmagic/design';
4
- import { TMagicMessageBox, TMagicMessage } from '@tmagic/design';
5
- import * as _vue_reactivity from '@vue/reactivity';
4
+ import { TMagicMessageBox, TMagicMessage, TMagicButton, TMagicCol, TMagicDialog, TMagicRow, TMagicDrawer, TMagicScrollbar, TMagicCard, TMagicPagination, TMagicTable, TMagicTableColumn, TMagicTooltip, TMagicUpload } from '@tmagic/design';
6
5
  import * as _tmagic_editor from '@tmagic/editor';
6
+ import * as _vue_reactivity from '@vue/reactivity';
7
+ import { CaretBottom, CaretRight, ArrowDown, ArrowUp, Delete, DocumentCopy, FullScreen, Grid } from '@element-plus/icons-vue';
7
8
 
8
9
  interface ValidateError {
9
10
  message: string;
@@ -634,7 +635,7 @@ type FormValue = Record<string | number, any>;
634
635
 
635
636
  declare const createValues: (mForm: FormState | undefined, config?: FormConfig | TabPaneConfig[], initValue?: FormValue, value?: FormValue) => FormValue;
636
637
  declare const filterFunction: <T = any>(mForm: FormState | undefined, config: T | FilterFunction<T> | undefined, props: any) => T | undefined;
637
- declare const display: (mForm: FormState | undefined, config: any, props: any) => any;
638
+ declare const display$1: (mForm: FormState | undefined, config: any, props: any) => any;
638
639
  declare const getRules: (mForm: FormState | undefined, rules: (Rule[] | Rule) | undefined, props: any) => Rule[];
639
640
  declare const initValue: (mForm: FormState | undefined, { initValues, config }: {
640
641
  initValues: FormValue;
@@ -700,65 +701,7 @@ declare const _default$v: vue.DefineComponent<__VLS_Props$u, {
700
701
  parentValues: Record<string, any>;
701
702
  stepActive: string | number;
702
703
  height: string;
703
- }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
704
- tMagicForm: ({
705
- $: vue.ComponentInternalInstance;
706
- $data: {};
707
- $props: {
708
- readonly model?: any;
709
- readonly labelWidth?: string | number | undefined;
710
- readonly disabled?: boolean | undefined;
711
- readonly inline?: boolean | undefined;
712
- readonly labelPosition?: string | undefined;
713
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
714
- $attrs: {
715
- [x: string]: unknown;
716
- };
717
- $refs: {
718
- [x: string]: unknown;
719
- } & {
720
- form: unknown;
721
- };
722
- $slots: Readonly<{
723
- [name: string]: vue.Slot<any> | undefined;
724
- }>;
725
- $root: vue.ComponentPublicInstance | null;
726
- $parent: vue.ComponentPublicInstance | null;
727
- $host: Element | null;
728
- $emit: (event: string, ...args: any[]) => void;
729
- $el: any;
730
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
731
- validate(): any;
732
- resetFields(): any;
733
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
734
- beforeCreate?: (() => void) | (() => void)[];
735
- created?: (() => void) | (() => void)[];
736
- beforeMount?: (() => void) | (() => void)[];
737
- mounted?: (() => void) | (() => void)[];
738
- beforeUpdate?: (() => void) | (() => void)[];
739
- updated?: (() => void) | (() => void)[];
740
- activated?: (() => void) | (() => void)[];
741
- deactivated?: (() => void) | (() => void)[];
742
- beforeDestroy?: (() => void) | (() => void)[];
743
- beforeUnmount?: (() => void) | (() => void)[];
744
- destroyed?: (() => void) | (() => void)[];
745
- unmounted?: (() => void) | (() => void)[];
746
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
747
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
748
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
749
- };
750
- $forceUpdate: () => void;
751
- $nextTick: typeof vue.nextTick;
752
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
753
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
754
- validate(): any;
755
- resetFields(): any;
756
- }> & {} & vue.ComponentCustomProperties & {} & {
757
- $slots: {
758
- default?(_: {}): any;
759
- };
760
- }) | null;
761
- }, any>;
704
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
762
705
 
763
706
  type __VLS_Props$t = {
764
707
  config?: FormConfig;
@@ -776,180 +719,270 @@ type __VLS_Props$t = {
776
719
  confirmText?: string;
777
720
  preventSubmitDefault?: boolean;
778
721
  };
779
- declare function __VLS_template$4(): {
780
- attrs: Partial<{}>;
781
- slots: {
782
- default?(_: {}): any;
783
- left?(_: {}): any;
784
- footer?(_: {}): any;
785
- };
786
- refs: {
787
- form: vue.CreateComponentPublicInstanceWithMixins<Readonly<{
788
- config: FormConfig;
789
- initValues: Record<string, any>;
790
- lastValues?: Record<string, any>;
791
- isCompare?: boolean;
792
- parentValues?: Record<string, any>;
793
- labelWidth?: string;
794
- disabled?: boolean;
795
- height?: string;
796
- stepActive?: string | number;
797
- size?: "small" | "default" | "large";
798
- inline?: boolean;
799
- labelPosition?: string;
800
- keyProp?: string;
801
- popperClass?: string;
802
- preventSubmitDefault?: boolean;
803
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
804
- }> & Readonly<{
805
- onChange?: ((...args: any[]) => any) | undefined;
806
- onError?: ((...args: any[]) => any) | undefined;
807
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
808
- "onField-change"?: ((...args: any[]) => any) | undefined;
809
- "onField-input"?: ((...args: any[]) => any) | undefined;
810
- }>, {
811
- values: vue.Ref<FormValue, FormValue>;
812
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
813
- formState: _tmagic_editor.FormState;
814
- initialized: vue.Ref<boolean, boolean>;
815
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
816
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
817
- resetForm: () => void;
818
- submitForm: (native?: boolean) => Promise<any>;
819
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
820
- change: (...args: any[]) => void;
821
- error: (...args: any[]) => void;
822
- "update:stepActive": (...args: any[]) => void;
823
- "field-change": (...args: any[]) => void;
824
- "field-input": (...args: any[]) => void;
825
- }, vue.PublicProps, {
826
- disabled: boolean;
827
- labelWidth: string;
828
- inline: boolean;
829
- labelPosition: string;
830
- config: FormConfig;
831
- initValues: Record<string, any>;
832
- lastValues: Record<string, any>;
833
- isCompare: boolean;
834
- keyProp: string;
835
- parentValues: Record<string, any>;
836
- stepActive: string | number;
837
- height: string;
838
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
839
- tMagicForm: ({
840
- $: vue.ComponentInternalInstance;
841
- $data: {};
842
- $props: {
843
- readonly model?: any;
844
- readonly labelWidth?: string | number | undefined;
845
- readonly disabled?: boolean | undefined;
846
- readonly inline?: boolean | undefined;
847
- readonly labelPosition?: string | undefined;
848
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
849
- $attrs: {
850
- [x: string]: unknown;
851
- };
852
- $refs: {
853
- [x: string]: unknown;
854
- } & {
855
- form: unknown;
856
- };
857
- $slots: Readonly<{
858
- [name: string]: vue.Slot<any> | undefined;
859
- }>;
860
- $root: vue.ComponentPublicInstance | null;
861
- $parent: vue.ComponentPublicInstance | null;
862
- $host: Element | null;
863
- $emit: (event: string, ...args: any[]) => void;
864
- $el: any;
865
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
866
- validate(): any;
867
- resetFields(): any;
868
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
869
- beforeCreate?: (() => void) | (() => void)[];
870
- created?: (() => void) | (() => void)[];
871
- beforeMount?: (() => void) | (() => void)[];
872
- mounted?: (() => void) | (() => void)[];
873
- beforeUpdate?: (() => void) | (() => void)[];
874
- updated?: (() => void) | (() => void)[];
875
- activated?: (() => void) | (() => void)[];
876
- deactivated?: (() => void) | (() => void)[];
877
- beforeDestroy?: (() => void) | (() => void)[];
878
- beforeUnmount?: (() => void) | (() => void)[];
879
- destroyed?: (() => void) | (() => void)[];
880
- unmounted?: (() => void) | (() => void)[];
881
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
882
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
883
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
884
- };
885
- $forceUpdate: () => void;
886
- $nextTick: typeof vue.nextTick;
887
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
888
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
889
- validate(): any;
890
- resetFields(): any;
891
- }> & {} & vue.ComponentCustomProperties & {} & {
892
- $slots: {
893
- default?(_: {}): any;
894
- };
895
- }) | null;
896
- }, any, vue.ComponentProvideOptions, {
897
- P: {};
898
- B: {};
899
- D: {};
900
- C: {};
901
- M: {};
902
- Defaults: {};
903
- }, Readonly<{
904
- config: FormConfig;
905
- initValues: Record<string, any>;
906
- lastValues?: Record<string, any>;
907
- isCompare?: boolean;
908
- parentValues?: Record<string, any>;
909
- labelWidth?: string;
910
- disabled?: boolean;
911
- height?: string;
912
- stepActive?: string | number;
913
- size?: "small" | "default" | "large";
914
- inline?: boolean;
915
- labelPosition?: string;
916
- keyProp?: string;
917
- popperClass?: string;
918
- preventSubmitDefault?: boolean;
919
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
920
- }> & Readonly<{
921
- onChange?: ((...args: any[]) => any) | undefined;
922
- onError?: ((...args: any[]) => any) | undefined;
923
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
924
- "onField-change"?: ((...args: any[]) => any) | undefined;
925
- "onField-input"?: ((...args: any[]) => any) | undefined;
926
- }>, {
927
- values: vue.Ref<FormValue, FormValue>;
928
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
929
- formState: _tmagic_editor.FormState;
930
- initialized: vue.Ref<boolean, boolean>;
931
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
932
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
933
- resetForm: () => void;
934
- submitForm: (native?: boolean) => Promise<any>;
935
- }, {}, {}, {}, {
936
- disabled: boolean;
937
- labelWidth: string;
938
- inline: boolean;
939
- labelPosition: string;
940
- config: FormConfig;
941
- initValues: Record<string, any>;
942
- lastValues: Record<string, any>;
943
- isCompare: boolean;
944
- keyProp: string;
945
- parentValues: Record<string, any>;
946
- stepActive: string | number;
947
- height: string;
948
- }> | null;
949
- };
950
- rootEl: any;
951
- };
952
- type __VLS_TemplateResult$4 = ReturnType<typeof __VLS_template$4>;
722
+ declare const form$2: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
723
+ config: FormConfig;
724
+ initValues: Record<string, any>;
725
+ lastValues?: Record<string, any>;
726
+ isCompare?: boolean;
727
+ parentValues?: Record<string, any>;
728
+ labelWidth?: string;
729
+ disabled?: boolean;
730
+ height?: string;
731
+ stepActive?: string | number;
732
+ size?: "small" | "default" | "large";
733
+ inline?: boolean;
734
+ labelPosition?: string;
735
+ keyProp?: string;
736
+ popperClass?: string;
737
+ preventSubmitDefault?: boolean;
738
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
739
+ }> & Readonly<{
740
+ onChange?: ((...args: any[]) => any) | undefined;
741
+ onError?: ((...args: any[]) => any) | undefined;
742
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
743
+ "onField-change"?: ((...args: any[]) => any) | undefined;
744
+ "onField-input"?: ((...args: any[]) => any) | undefined;
745
+ }>, {
746
+ values: vue.Ref<FormValue, FormValue>;
747
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
748
+ formState: _tmagic_editor.FormState;
749
+ initialized: vue.Ref<boolean, boolean>;
750
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
751
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
752
+ resetForm: () => void;
753
+ submitForm: (native?: boolean) => Promise<any>;
754
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
755
+ change: (...args: any[]) => void;
756
+ error: (...args: any[]) => void;
757
+ "update:stepActive": (...args: any[]) => void;
758
+ "field-change": (...args: any[]) => void;
759
+ "field-input": (...args: any[]) => void;
760
+ }, vue.PublicProps, {
761
+ disabled: boolean;
762
+ labelWidth: string;
763
+ inline: boolean;
764
+ labelPosition: string;
765
+ config: FormConfig;
766
+ initValues: Record<string, any>;
767
+ lastValues: Record<string, any>;
768
+ isCompare: boolean;
769
+ keyProp: string;
770
+ parentValues: Record<string, any>;
771
+ stepActive: string | number;
772
+ height: string;
773
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
774
+ P: {};
775
+ B: {};
776
+ D: {};
777
+ C: {};
778
+ M: {};
779
+ Defaults: {};
780
+ }, Readonly<{
781
+ config: FormConfig;
782
+ initValues: Record<string, any>;
783
+ lastValues?: Record<string, any>;
784
+ isCompare?: boolean;
785
+ parentValues?: Record<string, any>;
786
+ labelWidth?: string;
787
+ disabled?: boolean;
788
+ height?: string;
789
+ stepActive?: string | number;
790
+ size?: "small" | "default" | "large";
791
+ inline?: boolean;
792
+ labelPosition?: string;
793
+ keyProp?: string;
794
+ popperClass?: string;
795
+ preventSubmitDefault?: boolean;
796
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
797
+ }> & Readonly<{
798
+ onChange?: ((...args: any[]) => any) | undefined;
799
+ onError?: ((...args: any[]) => any) | undefined;
800
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
801
+ "onField-change"?: ((...args: any[]) => any) | undefined;
802
+ "onField-input"?: ((...args: any[]) => any) | undefined;
803
+ }>, {
804
+ values: vue.Ref<FormValue, FormValue>;
805
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
806
+ formState: _tmagic_editor.FormState;
807
+ initialized: vue.Ref<boolean, boolean>;
808
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
809
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
810
+ resetForm: () => void;
811
+ submitForm: (native?: boolean) => Promise<any>;
812
+ }, {}, {}, {}, {
813
+ disabled: boolean;
814
+ labelWidth: string;
815
+ inline: boolean;
816
+ labelPosition: string;
817
+ config: FormConfig;
818
+ initValues: Record<string, any>;
819
+ lastValues: Record<string, any>;
820
+ isCompare: boolean;
821
+ keyProp: string;
822
+ parentValues: Record<string, any>;
823
+ stepActive: string | number;
824
+ height: string;
825
+ }> | undefined, vue.CreateComponentPublicInstanceWithMixins<Readonly<{
826
+ config: FormConfig;
827
+ initValues: Record<string, any>;
828
+ lastValues?: Record<string, any>;
829
+ isCompare?: boolean;
830
+ parentValues?: Record<string, any>;
831
+ labelWidth?: string;
832
+ disabled?: boolean;
833
+ height?: string;
834
+ stepActive?: string | number;
835
+ size?: "small" | "default" | "large";
836
+ inline?: boolean;
837
+ labelPosition?: string;
838
+ keyProp?: string;
839
+ popperClass?: string;
840
+ preventSubmitDefault?: boolean;
841
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
842
+ }> & Readonly<{
843
+ onChange?: ((...args: any[]) => any) | undefined;
844
+ onError?: ((...args: any[]) => any) | undefined;
845
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
846
+ "onField-change"?: ((...args: any[]) => any) | undefined;
847
+ "onField-input"?: ((...args: any[]) => any) | undefined;
848
+ }>, {
849
+ values: vue.Ref<FormValue, FormValue>;
850
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
851
+ formState: _tmagic_editor.FormState;
852
+ initialized: vue.Ref<boolean, boolean>;
853
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
854
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
855
+ resetForm: () => void;
856
+ submitForm: (native?: boolean) => Promise<any>;
857
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
858
+ change: (...args: any[]) => void;
859
+ error: (...args: any[]) => void;
860
+ "update:stepActive": (...args: any[]) => void;
861
+ "field-change": (...args: any[]) => void;
862
+ "field-input": (...args: any[]) => void;
863
+ }, vue.PublicProps, {
864
+ disabled: boolean;
865
+ labelWidth: string;
866
+ inline: boolean;
867
+ labelPosition: string;
868
+ config: FormConfig;
869
+ initValues: Record<string, any>;
870
+ lastValues: Record<string, any>;
871
+ isCompare: boolean;
872
+ keyProp: string;
873
+ parentValues: Record<string, any>;
874
+ stepActive: string | number;
875
+ height: string;
876
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
877
+ P: {};
878
+ B: {};
879
+ D: {};
880
+ C: {};
881
+ M: {};
882
+ Defaults: {};
883
+ }, Readonly<{
884
+ config: FormConfig;
885
+ initValues: Record<string, any>;
886
+ lastValues?: Record<string, any>;
887
+ isCompare?: boolean;
888
+ parentValues?: Record<string, any>;
889
+ labelWidth?: string;
890
+ disabled?: boolean;
891
+ height?: string;
892
+ stepActive?: string | number;
893
+ size?: "small" | "default" | "large";
894
+ inline?: boolean;
895
+ labelPosition?: string;
896
+ keyProp?: string;
897
+ popperClass?: string;
898
+ preventSubmitDefault?: boolean;
899
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
900
+ }> & Readonly<{
901
+ onChange?: ((...args: any[]) => any) | undefined;
902
+ onError?: ((...args: any[]) => any) | undefined;
903
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
904
+ "onField-change"?: ((...args: any[]) => any) | undefined;
905
+ "onField-input"?: ((...args: any[]) => any) | undefined;
906
+ }>, {
907
+ values: vue.Ref<FormValue, FormValue>;
908
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
909
+ formState: _tmagic_editor.FormState;
910
+ initialized: vue.Ref<boolean, boolean>;
911
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
912
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
913
+ resetForm: () => void;
914
+ submitForm: (native?: boolean) => Promise<any>;
915
+ }, {}, {}, {}, {
916
+ disabled: boolean;
917
+ labelWidth: string;
918
+ inline: boolean;
919
+ labelPosition: string;
920
+ config: FormConfig;
921
+ initValues: Record<string, any>;
922
+ lastValues: Record<string, any>;
923
+ isCompare: boolean;
924
+ keyProp: string;
925
+ parentValues: Record<string, any>;
926
+ stepActive: string | number;
927
+ height: string;
928
+ }> | undefined>;
929
+ declare const dialogVisible: vue.Ref<boolean, boolean>;
930
+ declare const saveFetch$2: vue.Ref<boolean, boolean>;
931
+ declare const stepActive: vue.Ref<number, number>;
932
+ declare const bodyHeight$1: vue.Ref<string, string>;
933
+ declare const stepCount: vue.ComputedRef<number>;
934
+ declare const hasStep: vue.ComputedRef<boolean>;
935
+ declare const closeHandler$1: () => void;
936
+ declare const save: () => Promise<void>;
937
+ declare const preStep: () => void;
938
+ declare const nextStep: () => void;
939
+ declare const changeHandler$4: (value: FormValue, eventData: ContainerChangeEventData) => void;
940
+ declare const cancel: () => void;
941
+ declare const __VLS_ctx$4: InstanceType<__VLS_PickNotAny<typeof __VLS_self$4, new () => {}>>;
942
+ declare var __VLS_19: {};
943
+ declare var __VLS_29: {};
944
+ declare var __VLS_35: {};
945
+ type __VLS_Slots$4 = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx$4.$slots> & {
946
+ default?: (props: typeof __VLS_19) => any;
947
+ } & {
948
+ left?: (props: typeof __VLS_29) => any;
949
+ } & {
950
+ footer?: (props: typeof __VLS_35) => any;
951
+ }>;
952
+ declare const __VLS_self$4: vue.DefineComponent<__VLS_Props$t, {
953
+ TMagicButton: typeof TMagicButton;
954
+ TMagicCol: typeof TMagicCol;
955
+ TMagicDialog: typeof TMagicDialog;
956
+ TMagicRow: typeof TMagicRow;
957
+ Form: typeof _default$v;
958
+ form: typeof form$2;
959
+ dialogVisible: typeof dialogVisible;
960
+ saveFetch: typeof saveFetch$2;
961
+ stepActive: typeof stepActive;
962
+ bodyHeight: typeof bodyHeight$1;
963
+ stepCount: typeof stepCount;
964
+ hasStep: typeof hasStep;
965
+ closeHandler: typeof closeHandler$1;
966
+ save: typeof save;
967
+ preStep: typeof preStep;
968
+ nextStep: typeof nextStep;
969
+ changeHandler: typeof changeHandler$4;
970
+ cancel: typeof cancel;
971
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
972
+ change: (...args: any[]) => void;
973
+ close: (...args: any[]) => void;
974
+ error: (...args: any[]) => void;
975
+ submit: (...args: any[]) => void;
976
+ }, string, vue.PublicProps, Readonly<__VLS_Props$t> & Readonly<{
977
+ onChange?: ((...args: any[]) => any) | undefined;
978
+ onClose?: ((...args: any[]) => any) | undefined;
979
+ onError?: ((...args: any[]) => any) | undefined;
980
+ onSubmit?: ((...args: any[]) => any) | undefined;
981
+ }>, {
982
+ values: Object;
983
+ config: FormConfig;
984
+ confirmText: string;
985
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
953
986
  declare const __VLS_component$4: vue.DefineComponent<__VLS_Props$t, {
954
987
  form: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
955
988
  config: FormConfig;
@@ -1002,65 +1035,7 @@ declare const __VLS_component$4: vue.DefineComponent<__VLS_Props$t, {
1002
1035
  parentValues: Record<string, any>;
1003
1036
  stepActive: string | number;
1004
1037
  height: string;
1005
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
1006
- tMagicForm: ({
1007
- $: vue.ComponentInternalInstance;
1008
- $data: {};
1009
- $props: {
1010
- readonly model?: any;
1011
- readonly labelWidth?: string | number | undefined;
1012
- readonly disabled?: boolean | undefined;
1013
- readonly inline?: boolean | undefined;
1014
- readonly labelPosition?: string | undefined;
1015
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1016
- $attrs: {
1017
- [x: string]: unknown;
1018
- };
1019
- $refs: {
1020
- [x: string]: unknown;
1021
- } & {
1022
- form: unknown;
1023
- };
1024
- $slots: Readonly<{
1025
- [name: string]: vue.Slot<any> | undefined;
1026
- }>;
1027
- $root: vue.ComponentPublicInstance | null;
1028
- $parent: vue.ComponentPublicInstance | null;
1029
- $host: Element | null;
1030
- $emit: (event: string, ...args: any[]) => void;
1031
- $el: any;
1032
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
1033
- validate(): any;
1034
- resetFields(): any;
1035
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1036
- beforeCreate?: (() => void) | (() => void)[];
1037
- created?: (() => void) | (() => void)[];
1038
- beforeMount?: (() => void) | (() => void)[];
1039
- mounted?: (() => void) | (() => void)[];
1040
- beforeUpdate?: (() => void) | (() => void)[];
1041
- updated?: (() => void) | (() => void)[];
1042
- activated?: (() => void) | (() => void)[];
1043
- deactivated?: (() => void) | (() => void)[];
1044
- beforeDestroy?: (() => void) | (() => void)[];
1045
- beforeUnmount?: (() => void) | (() => void)[];
1046
- destroyed?: (() => void) | (() => void)[];
1047
- unmounted?: (() => void) | (() => void)[];
1048
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1049
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1050
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
1051
- };
1052
- $forceUpdate: () => void;
1053
- $nextTick: typeof vue.nextTick;
1054
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
1055
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
1056
- validate(): any;
1057
- resetFields(): any;
1058
- }> & {} & vue.ComponentCustomProperties & {} & {
1059
- $slots: {
1060
- default?(_: {}): any;
1061
- };
1062
- }) | null;
1063
- }, any, vue.ComponentProvideOptions, {
1038
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
1064
1039
  P: {};
1065
1040
  B: {};
1066
1041
  D: {};
@@ -1163,65 +1138,7 @@ declare const __VLS_component$4: vue.DefineComponent<__VLS_Props$t, {
1163
1138
  parentValues: Record<string, any>;
1164
1139
  stepActive: string | number;
1165
1140
  height: string;
1166
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
1167
- tMagicForm: ({
1168
- $: vue.ComponentInternalInstance;
1169
- $data: {};
1170
- $props: {
1171
- readonly model?: any;
1172
- readonly labelWidth?: string | number | undefined;
1173
- readonly disabled?: boolean | undefined;
1174
- readonly inline?: boolean | undefined;
1175
- readonly labelPosition?: string | undefined;
1176
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1177
- $attrs: {
1178
- [x: string]: unknown;
1179
- };
1180
- $refs: {
1181
- [x: string]: unknown;
1182
- } & {
1183
- form: unknown;
1184
- };
1185
- $slots: Readonly<{
1186
- [name: string]: vue.Slot<any> | undefined;
1187
- }>;
1188
- $root: vue.ComponentPublicInstance | null;
1189
- $parent: vue.ComponentPublicInstance | null;
1190
- $host: Element | null;
1191
- $emit: (event: string, ...args: any[]) => void;
1192
- $el: any;
1193
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
1194
- validate(): any;
1195
- resetFields(): any;
1196
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1197
- beforeCreate?: (() => void) | (() => void)[];
1198
- created?: (() => void) | (() => void)[];
1199
- beforeMount?: (() => void) | (() => void)[];
1200
- mounted?: (() => void) | (() => void)[];
1201
- beforeUpdate?: (() => void) | (() => void)[];
1202
- updated?: (() => void) | (() => void)[];
1203
- activated?: (() => void) | (() => void)[];
1204
- deactivated?: (() => void) | (() => void)[];
1205
- beforeDestroy?: (() => void) | (() => void)[];
1206
- beforeUnmount?: (() => void) | (() => void)[];
1207
- destroyed?: (() => void) | (() => void)[];
1208
- unmounted?: (() => void) | (() => void)[];
1209
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1210
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1211
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
1212
- };
1213
- $forceUpdate: () => void;
1214
- $nextTick: typeof vue.nextTick;
1215
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
1216
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
1217
- validate(): any;
1218
- resetFields(): any;
1219
- }> & {} & vue.ComponentCustomProperties & {} & {
1220
- $slots: {
1221
- default?(_: {}): any;
1222
- };
1223
- }) | null;
1224
- }, any, vue.ComponentProvideOptions, {
1141
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
1225
1142
  P: {};
1226
1143
  B: {};
1227
1144
  D: {};
@@ -1294,618 +1211,467 @@ declare const __VLS_component$4: vue.DefineComponent<__VLS_Props$t, {
1294
1211
  values: Object;
1295
1212
  config: FormConfig;
1296
1213
  confirmText: string;
1297
- }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
1298
- form: vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1299
- config: FormConfig;
1300
- initValues: Record<string, any>;
1301
- lastValues?: Record<string, any>;
1302
- isCompare?: boolean;
1303
- parentValues?: Record<string, any>;
1304
- labelWidth?: string;
1305
- disabled?: boolean;
1306
- height?: string;
1307
- stepActive?: string | number;
1308
- size?: "small" | "default" | "large";
1309
- inline?: boolean;
1310
- labelPosition?: string;
1311
- keyProp?: string;
1312
- popperClass?: string;
1313
- preventSubmitDefault?: boolean;
1314
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1315
- }> & Readonly<{
1316
- onChange?: ((...args: any[]) => any) | undefined;
1317
- onError?: ((...args: any[]) => any) | undefined;
1318
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1319
- "onField-change"?: ((...args: any[]) => any) | undefined;
1320
- "onField-input"?: ((...args: any[]) => any) | undefined;
1214
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
1215
+ declare const _default$u: __VLS_WithSlots$4<typeof __VLS_component$4, __VLS_Slots$4>;
1216
+
1217
+ type __VLS_WithSlots$4<T, S> = T & {
1218
+ new (): {
1219
+ $slots: S;
1220
+ };
1221
+ };
1222
+
1223
+ type __VLS_Props$s = {
1224
+ config?: FormConfig;
1225
+ values?: Object;
1226
+ parentValues?: Object;
1227
+ width?: string | number;
1228
+ labelWidth?: string;
1229
+ disabled?: boolean;
1230
+ closeOnPressEscape?: boolean;
1231
+ title?: string;
1232
+ zIndex?: number;
1233
+ size?: 'small' | 'default' | 'large';
1234
+ confirmText?: string;
1235
+ inline?: boolean;
1236
+ labelPosition?: string;
1237
+ preventSubmitDefault?: boolean;
1238
+ /** 关闭前的回调，会暂停 Drawer 的关闭; done 是个 function type 接受一个 boolean 参数, 执行 done 使用 true 参数或不提供参数将会终止关闭 */
1239
+ beforeClose?: (done: (cancel?: boolean) => void) => void;
1240
+ };
1241
+ declare const drawer: vue.Ref<({
1242
+ $: vue.ComponentInternalInstance;
1243
+ $data: {};
1244
+ $props: {
1245
+ readonly modelValue?: boolean | undefined;
1246
+ readonly appendToBody?: boolean | undefined;
1247
+ readonly beforeClose?: any;
1248
+ readonly title?: string | undefined;
1249
+ readonly size?: string | number | undefined;
1250
+ readonly fullscreen?: boolean | undefined;
1251
+ readonly closeOnClickModal?: boolean | undefined;
1252
+ readonly closeOnPressEscape?: boolean | undefined;
1253
+ readonly direction?: "rtl" | "ltr" | "ttb" | "bt" | undefined;
1254
+ readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1255
+ readonly onClose?: ((...args: any[]) => any) | undefined;
1256
+ readonly onOpen?: ((...args: any[]) => any) | undefined;
1257
+ readonly onOpened?: ((...args: any[]) => any) | undefined;
1258
+ readonly onClosed?: ((...args: any[]) => any) | undefined;
1259
+ } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1260
+ $attrs: {
1261
+ [x: string]: unknown;
1262
+ };
1263
+ $refs: {
1264
+ [x: string]: unknown;
1265
+ };
1266
+ $slots: Readonly<{
1267
+ [name: string]: vue.Slot<any> | undefined;
1268
+ }>;
1269
+ $root: vue.ComponentPublicInstance | null;
1270
+ $parent: vue.ComponentPublicInstance | null;
1271
+ $host: Element | null;
1272
+ $emit: ((event: "update:modelValue", ...args: any[]) => void) & ((event: "close", ...args: any[]) => void) & ((event: "open", ...args: any[]) => void) & ((event: "opened", ...args: any[]) => void) & ((event: "closed", ...args: any[]) => void);
1273
+ $el: any;
1274
+ $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.DrawerProps> & Readonly<{
1275
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1276
+ onClose?: ((...args: any[]) => any) | undefined;
1277
+ onOpen?: ((...args: any[]) => any) | undefined;
1278
+ onOpened?: ((...args: any[]) => any) | undefined;
1279
+ onClosed?: ((...args: any[]) => any) | undefined;
1321
1280
  }>, {
1322
- values: vue.Ref<FormValue, FormValue>;
1323
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1324
- formState: _tmagic_editor.FormState;
1325
- initialized: vue.Ref<boolean, boolean>;
1326
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1327
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1328
- resetForm: () => void;
1329
- submitForm: (native?: boolean) => Promise<any>;
1281
+ handleClose: () => any;
1330
1282
  }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1331
- change: (...args: any[]) => void;
1332
- error: (...args: any[]) => void;
1333
- "update:stepActive": (...args: any[]) => void;
1334
- "field-change": (...args: any[]) => void;
1335
- "field-input": (...args: any[]) => void;
1336
- }, vue.PublicProps, {
1337
- disabled: boolean;
1338
- labelWidth: string;
1339
- inline: boolean;
1340
- labelPosition: string;
1341
- config: FormConfig;
1342
- initValues: Record<string, any>;
1343
- lastValues: Record<string, any>;
1344
- isCompare: boolean;
1345
- keyProp: string;
1346
- parentValues: Record<string, any>;
1347
- stepActive: string | number;
1348
- height: string;
1349
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
1350
- tMagicForm: ({
1351
- $: vue.ComponentInternalInstance;
1352
- $data: {};
1353
- $props: {
1354
- readonly model?: any;
1355
- readonly labelWidth?: string | number | undefined;
1356
- readonly disabled?: boolean | undefined;
1357
- readonly inline?: boolean | undefined;
1358
- readonly labelPosition?: string | undefined;
1359
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1360
- $attrs: {
1361
- [x: string]: unknown;
1362
- };
1363
- $refs: {
1364
- [x: string]: unknown;
1365
- } & {
1366
- form: unknown;
1367
- };
1368
- $slots: Readonly<{
1369
- [name: string]: vue.Slot<any> | undefined;
1370
- }>;
1371
- $root: vue.ComponentPublicInstance | null;
1372
- $parent: vue.ComponentPublicInstance | null;
1373
- $host: Element | null;
1374
- $emit: (event: string, ...args: any[]) => void;
1375
- $el: any;
1376
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
1377
- validate(): any;
1378
- resetFields(): any;
1379
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1380
- beforeCreate?: (() => void) | (() => void)[];
1381
- created?: (() => void) | (() => void)[];
1382
- beforeMount?: (() => void) | (() => void)[];
1383
- mounted?: (() => void) | (() => void)[];
1384
- beforeUpdate?: (() => void) | (() => void)[];
1385
- updated?: (() => void) | (() => void)[];
1386
- activated?: (() => void) | (() => void)[];
1387
- deactivated?: (() => void) | (() => void)[];
1388
- beforeDestroy?: (() => void) | (() => void)[];
1389
- beforeUnmount?: (() => void) | (() => void)[];
1390
- destroyed?: (() => void) | (() => void)[];
1391
- unmounted?: (() => void) | (() => void)[];
1392
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1393
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1394
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
1395
- };
1396
- $forceUpdate: () => void;
1397
- $nextTick: typeof vue.nextTick;
1398
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
1399
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
1400
- validate(): any;
1401
- resetFields(): any;
1402
- }> & {} & vue.ComponentCustomProperties & {} & {
1403
- $slots: {
1404
- default?(_: {}): any;
1405
- };
1406
- }) | null;
1407
- }, any, vue.ComponentProvideOptions, {
1408
- P: {};
1409
- B: {};
1410
- D: {};
1411
- C: {};
1412
- M: {};
1413
- Defaults: {};
1414
- }, Readonly<{
1415
- config: FormConfig;
1416
- initValues: Record<string, any>;
1417
- lastValues?: Record<string, any>;
1418
- isCompare?: boolean;
1419
- parentValues?: Record<string, any>;
1420
- labelWidth?: string;
1421
- disabled?: boolean;
1422
- height?: string;
1423
- stepActive?: string | number;
1424
- size?: "small" | "default" | "large";
1425
- inline?: boolean;
1426
- labelPosition?: string;
1427
- keyProp?: string;
1428
- popperClass?: string;
1429
- preventSubmitDefault?: boolean;
1430
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1431
- }> & Readonly<{
1432
- onChange?: ((...args: any[]) => any) | undefined;
1433
- onError?: ((...args: any[]) => any) | undefined;
1434
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1435
- "onField-change"?: ((...args: any[]) => any) | undefined;
1436
- "onField-input"?: ((...args: any[]) => any) | undefined;
1283
+ "update:modelValue": (...args: any[]) => void;
1284
+ close: (...args: any[]) => void;
1285
+ open: (...args: any[]) => void;
1286
+ opened: (...args: any[]) => void;
1287
+ closed: (...args: any[]) => void;
1288
+ }, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1289
+ beforeCreate?: (() => void) | (() => void)[];
1290
+ created?: (() => void) | (() => void)[];
1291
+ beforeMount?: (() => void) | (() => void)[];
1292
+ mounted?: (() => void) | (() => void)[];
1293
+ beforeUpdate?: (() => void) | (() => void)[];
1294
+ updated?: (() => void) | (() => void)[];
1295
+ activated?: (() => void) | (() => void)[];
1296
+ deactivated?: (() => void) | (() => void)[];
1297
+ beforeDestroy?: (() => void) | (() => void)[];
1298
+ beforeUnmount?: (() => void) | (() => void)[];
1299
+ destroyed?: (() => void) | (() => void)[];
1300
+ unmounted?: (() => void) | (() => void)[];
1301
+ renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1302
+ renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1303
+ errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
1304
+ };
1305
+ $forceUpdate: () => void;
1306
+ $nextTick: typeof vue.nextTick;
1307
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
1308
+ } & Readonly<{}> & Omit<Readonly<_tmagic_design.DrawerProps> & Readonly<{
1309
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1310
+ onClose?: ((...args: any[]) => any) | undefined;
1311
+ onOpen?: ((...args: any[]) => any) | undefined;
1312
+ onOpened?: ((...args: any[]) => any) | undefined;
1313
+ onClosed?: ((...args: any[]) => any) | undefined;
1314
+ }>, "handleClose"> & vue.ShallowUnwrapRef<{
1315
+ handleClose: () => any;
1316
+ }> & {} & vue.ComponentCustomProperties & {} & {
1317
+ $slots: {
1318
+ default?: ((props: {}) => any) | undefined;
1319
+ header?: ((props: {}) => any) | undefined;
1320
+ footer?: ((props: {}) => any) | undefined;
1321
+ };
1322
+ }) | undefined, ({
1323
+ $: vue.ComponentInternalInstance;
1324
+ $data: {};
1325
+ $props: {
1326
+ readonly modelValue?: boolean | undefined;
1327
+ readonly appendToBody?: boolean | undefined;
1328
+ readonly beforeClose?: any;
1329
+ readonly title?: string | undefined;
1330
+ readonly size?: string | number | undefined;
1331
+ readonly fullscreen?: boolean | undefined;
1332
+ readonly closeOnClickModal?: boolean | undefined;
1333
+ readonly closeOnPressEscape?: boolean | undefined;
1334
+ readonly direction?: "rtl" | "ltr" | "ttb" | "bt" | undefined;
1335
+ readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1336
+ readonly onClose?: ((...args: any[]) => any) | undefined;
1337
+ readonly onOpen?: ((...args: any[]) => any) | undefined;
1338
+ readonly onOpened?: ((...args: any[]) => any) | undefined;
1339
+ readonly onClosed?: ((...args: any[]) => any) | undefined;
1340
+ } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1341
+ $attrs: {
1342
+ [x: string]: unknown;
1343
+ };
1344
+ $refs: {
1345
+ [x: string]: unknown;
1346
+ };
1347
+ $slots: Readonly<{
1348
+ [name: string]: vue.Slot<any> | undefined;
1349
+ }>;
1350
+ $root: vue.ComponentPublicInstance | null;
1351
+ $parent: vue.ComponentPublicInstance | null;
1352
+ $host: Element | null;
1353
+ $emit: ((event: "update:modelValue", ...args: any[]) => void) & ((event: "close", ...args: any[]) => void) & ((event: "open", ...args: any[]) => void) & ((event: "opened", ...args: any[]) => void) & ((event: "closed", ...args: any[]) => void);
1354
+ $el: any;
1355
+ $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.DrawerProps> & Readonly<{
1356
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1357
+ onClose?: ((...args: any[]) => any) | undefined;
1358
+ onOpen?: ((...args: any[]) => any) | undefined;
1359
+ onOpened?: ((...args: any[]) => any) | undefined;
1360
+ onClosed?: ((...args: any[]) => any) | undefined;
1437
1361
  }>, {
1438
- values: vue.Ref<FormValue, FormValue>;
1439
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1440
- formState: _tmagic_editor.FormState;
1441
- initialized: vue.Ref<boolean, boolean>;
1442
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1443
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1444
- resetForm: () => void;
1445
- submitForm: (native?: boolean) => Promise<any>;
1446
- }, {}, {}, {}, {
1447
- disabled: boolean;
1448
- labelWidth: string;
1449
- inline: boolean;
1450
- labelPosition: string;
1451
- config: FormConfig;
1452
- initValues: Record<string, any>;
1453
- lastValues: Record<string, any>;
1454
- isCompare: boolean;
1455
- keyProp: string;
1456
- parentValues: Record<string, any>;
1457
- stepActive: string | number;
1458
- height: string;
1459
- }> | null;
1460
- }, any>;
1461
- declare const _default$u: __VLS_WithTemplateSlots$4<typeof __VLS_component$4, __VLS_TemplateResult$4["slots"]>;
1462
-
1463
- type __VLS_WithTemplateSlots$4<T, S> = T & {
1464
- new (): {
1465
- $slots: S;
1362
+ handleClose: () => any;
1363
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1364
+ "update:modelValue": (...args: any[]) => void;
1365
+ close: (...args: any[]) => void;
1366
+ open: (...args: any[]) => void;
1367
+ opened: (...args: any[]) => void;
1368
+ closed: (...args: any[]) => void;
1369
+ }, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1370
+ beforeCreate?: (() => void) | (() => void)[];
1371
+ created?: (() => void) | (() => void)[];
1372
+ beforeMount?: (() => void) | (() => void)[];
1373
+ mounted?: (() => void) | (() => void)[];
1374
+ beforeUpdate?: (() => void) | (() => void)[];
1375
+ updated?: (() => void) | (() => void)[];
1376
+ activated?: (() => void) | (() => void)[];
1377
+ deactivated?: (() => void) | (() => void)[];
1378
+ beforeDestroy?: (() => void) | (() => void)[];
1379
+ beforeUnmount?: (() => void) | (() => void)[];
1380
+ destroyed?: (() => void) | (() => void)[];
1381
+ unmounted?: (() => void) | (() => void)[];
1382
+ renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1383
+ renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1384
+ errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
1466
1385
  };
1467
- };
1468
-
1469
- type __VLS_Props$s = {
1470
- config?: FormConfig;
1471
- values?: Object;
1472
- parentValues?: Object;
1473
- width?: string | number;
1386
+ $forceUpdate: () => void;
1387
+ $nextTick: typeof vue.nextTick;
1388
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
1389
+ } & Readonly<{}> & Omit<Readonly<_tmagic_design.DrawerProps> & Readonly<{
1390
+ "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1391
+ onClose?: ((...args: any[]) => any) | undefined;
1392
+ onOpen?: ((...args: any[]) => any) | undefined;
1393
+ onOpened?: ((...args: any[]) => any) | undefined;
1394
+ onClosed?: ((...args: any[]) => any) | undefined;
1395
+ }>, "handleClose"> & vue.ShallowUnwrapRef<{
1396
+ handleClose: () => any;
1397
+ }> & {} & vue.ComponentCustomProperties & {} & {
1398
+ $slots: {
1399
+ default?: ((props: {}) => any) | undefined;
1400
+ header?: ((props: {}) => any) | undefined;
1401
+ footer?: ((props: {}) => any) | undefined;
1402
+ };
1403
+ }) | undefined>;
1404
+ declare const form$1: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1405
+ config: FormConfig;
1406
+ initValues: Record<string, any>;
1407
+ lastValues?: Record<string, any>;
1408
+ isCompare?: boolean;
1409
+ parentValues?: Record<string, any>;
1474
1410
  labelWidth?: string;
1475
1411
  disabled?: boolean;
1476
- closeOnPressEscape?: boolean;
1477
- title?: string;
1478
- zIndex?: number;
1479
- size?: 'small' | 'default' | 'large';
1480
- confirmText?: string;
1412
+ height?: string;
1413
+ stepActive?: string | number;
1414
+ size?: "small" | "default" | "large";
1481
1415
  inline?: boolean;
1482
1416
  labelPosition?: string;
1417
+ keyProp?: string;
1418
+ popperClass?: string;
1483
1419
  preventSubmitDefault?: boolean;
1484
- /** 关闭前的回调，会暂停 Drawer 的关闭; done 是个 function type 接受一个 boolean 参数, 执行 done 使用 true 参数或不提供参数将会终止关闭 */
1485
- beforeClose?: (done: (cancel?: boolean) => void) => void;
1486
- };
1487
- declare function __VLS_template$3(): {
1488
- attrs: Partial<{}>;
1489
- slots: {
1490
- default?(_: {}): any;
1491
- left?(_: {}): any;
1492
- footer?(_: {}): any;
1493
- };
1494
- refs: {
1495
- drawer: ({
1496
- $: vue.ComponentInternalInstance;
1497
- $data: {};
1498
- $props: {
1499
- readonly modelValue?: boolean | undefined;
1500
- readonly appendToBody?: boolean | undefined;
1501
- readonly beforeClose?: any;
1502
- readonly title?: string | undefined;
1503
- readonly size?: string | number | undefined;
1504
- readonly fullscreen?: boolean | undefined;
1505
- readonly closeOnClickModal?: boolean | undefined;
1506
- readonly closeOnPressEscape?: boolean | undefined;
1507
- readonly direction?: "rtl" | "ltr" | "ttb" | "bt" | undefined;
1508
- readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1509
- readonly onClose?: ((...args: any[]) => any) | undefined;
1510
- readonly onOpen?: ((...args: any[]) => any) | undefined;
1511
- readonly onOpened?: ((...args: any[]) => any) | undefined;
1512
- readonly onClosed?: ((...args: any[]) => any) | undefined;
1513
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1514
- $attrs: {
1515
- [x: string]: unknown;
1516
- };
1517
- $refs: {
1518
- [x: string]: unknown;
1519
- } & {
1520
- drawer: unknown;
1521
- };
1522
- $slots: Readonly<{
1523
- [name: string]: vue.Slot<any> | undefined;
1524
- }>;
1525
- $root: vue.ComponentPublicInstance | null;
1526
- $parent: vue.ComponentPublicInstance | null;
1527
- $host: Element | null;
1528
- $emit: ((event: "update:modelValue", ...args: any[]) => void) & ((event: "close", ...args: any[]) => void) & ((event: "open", ...args: any[]) => void) & ((event: "opened", ...args: any[]) => void) & ((event: "closed", ...args: any[]) => void);
1529
- $el: any;
1530
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.DrawerProps> & Readonly<{
1531
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1532
- onClose?: ((...args: any[]) => any) | undefined;
1533
- onOpen?: ((...args: any[]) => any) | undefined;
1534
- onOpened?: ((...args: any[]) => any) | undefined;
1535
- onClosed?: ((...args: any[]) => any) | undefined;
1536
- }>, {
1537
- handleClose: () => any;
1538
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1539
- "update:modelValue": (...args: any[]) => void;
1540
- close: (...args: any[]) => void;
1541
- open: (...args: any[]) => void;
1542
- opened: (...args: any[]) => void;
1543
- closed: (...args: any[]) => void;
1544
- }, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1545
- beforeCreate?: (() => void) | (() => void)[];
1546
- created?: (() => void) | (() => void)[];
1547
- beforeMount?: (() => void) | (() => void)[];
1548
- mounted?: (() => void) | (() => void)[];
1549
- beforeUpdate?: (() => void) | (() => void)[];
1550
- updated?: (() => void) | (() => void)[];
1551
- activated?: (() => void) | (() => void)[];
1552
- deactivated?: (() => void) | (() => void)[];
1553
- beforeDestroy?: (() => void) | (() => void)[];
1554
- beforeUnmount?: (() => void) | (() => void)[];
1555
- destroyed?: (() => void) | (() => void)[];
1556
- unmounted?: (() => void) | (() => void)[];
1557
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1558
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1559
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
1560
- };
1561
- $forceUpdate: () => void;
1562
- $nextTick: typeof vue.nextTick;
1563
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
1564
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.DrawerProps> & Readonly<{
1565
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
1566
- onClose?: ((...args: any[]) => any) | undefined;
1567
- onOpen?: ((...args: any[]) => any) | undefined;
1568
- onOpened?: ((...args: any[]) => any) | undefined;
1569
- onClosed?: ((...args: any[]) => any) | undefined;
1570
- }>, "handleClose"> & vue.ShallowUnwrapRef<{
1571
- handleClose: () => any;
1572
- }> & {} & vue.ComponentCustomProperties & {} & {
1573
- $slots: {
1574
- default?(_: {}): any;
1575
- header?(_: {}): any;
1576
- footer?(_: {}): any;
1577
- };
1578
- }) | null;
1579
- drawerBody: HTMLDivElement;
1580
- form: vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1581
- config: FormConfig;
1582
- initValues: Record<string, any>;
1583
- lastValues?: Record<string, any>;
1584
- isCompare?: boolean;
1585
- parentValues?: Record<string, any>;
1586
- labelWidth?: string;
1587
- disabled?: boolean;
1588
- height?: string;
1589
- stepActive?: string | number;
1590
- size?: "small" | "default" | "large";
1591
- inline?: boolean;
1592
- labelPosition?: string;
1593
- keyProp?: string;
1594
- popperClass?: string;
1595
- preventSubmitDefault?: boolean;
1596
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1597
- }> & Readonly<{
1598
- onChange?: ((...args: any[]) => any) | undefined;
1599
- onError?: ((...args: any[]) => any) | undefined;
1600
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1601
- "onField-change"?: ((...args: any[]) => any) | undefined;
1602
- "onField-input"?: ((...args: any[]) => any) | undefined;
1603
- }>, {
1604
- values: vue.Ref<FormValue, FormValue>;
1605
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1606
- formState: _tmagic_editor.FormState;
1607
- initialized: vue.Ref<boolean, boolean>;
1608
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1609
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1610
- resetForm: () => void;
1611
- submitForm: (native?: boolean) => Promise<any>;
1612
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1613
- change: (...args: any[]) => void;
1614
- error: (...args: any[]) => void;
1615
- "update:stepActive": (...args: any[]) => void;
1616
- "field-change": (...args: any[]) => void;
1617
- "field-input": (...args: any[]) => void;
1618
- }, vue.PublicProps, {
1619
- disabled: boolean;
1620
- labelWidth: string;
1621
- inline: boolean;
1622
- labelPosition: string;
1623
- config: FormConfig;
1624
- initValues: Record<string, any>;
1625
- lastValues: Record<string, any>;
1626
- isCompare: boolean;
1627
- keyProp: string;
1628
- parentValues: Record<string, any>;
1629
- stepActive: string | number;
1630
- height: string;
1631
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
1632
- tMagicForm: ({
1633
- $: vue.ComponentInternalInstance;
1634
- $data: {};
1635
- $props: {
1636
- readonly model?: any;
1637
- readonly labelWidth?: string | number | undefined;
1638
- readonly disabled?: boolean | undefined;
1639
- readonly inline?: boolean | undefined;
1640
- readonly labelPosition?: string | undefined;
1641
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1642
- $attrs: {
1643
- [x: string]: unknown;
1644
- };
1645
- $refs: {
1646
- [x: string]: unknown;
1647
- } & {
1648
- form: unknown;
1649
- };
1650
- $slots: Readonly<{
1651
- [name: string]: vue.Slot<any> | undefined;
1652
- }>;
1653
- $root: vue.ComponentPublicInstance | null;
1654
- $parent: vue.ComponentPublicInstance | null;
1655
- $host: Element | null;
1656
- $emit: (event: string, ...args: any[]) => void;
1657
- $el: any;
1658
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
1659
- validate(): any;
1660
- resetFields(): any;
1661
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1662
- beforeCreate?: (() => void) | (() => void)[];
1663
- created?: (() => void) | (() => void)[];
1664
- beforeMount?: (() => void) | (() => void)[];
1665
- mounted?: (() => void) | (() => void)[];
1666
- beforeUpdate?: (() => void) | (() => void)[];
1667
- updated?: (() => void) | (() => void)[];
1668
- activated?: (() => void) | (() => void)[];
1669
- deactivated?: (() => void) | (() => void)[];
1670
- beforeDestroy?: (() => void) | (() => void)[];
1671
- beforeUnmount?: (() => void) | (() => void)[];
1672
- destroyed?: (() => void) | (() => void)[];
1673
- unmounted?: (() => void) | (() => void)[];
1674
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1675
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1676
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
1677
- };
1678
- $forceUpdate: () => void;
1679
- $nextTick: typeof vue.nextTick;
1680
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
1681
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
1682
- validate(): any;
1683
- resetFields(): any;
1684
- }> & {} & vue.ComponentCustomProperties & {} & {
1685
- $slots: {
1686
- default?(_: {}): any;
1687
- };
1688
- }) | null;
1689
- }, any, vue.ComponentProvideOptions, {
1690
- P: {};
1691
- B: {};
1692
- D: {};
1693
- C: {};
1694
- M: {};
1695
- Defaults: {};
1696
- }, Readonly<{
1697
- config: FormConfig;
1698
- initValues: Record<string, any>;
1699
- lastValues?: Record<string, any>;
1700
- isCompare?: boolean;
1701
- parentValues?: Record<string, any>;
1702
- labelWidth?: string;
1703
- disabled?: boolean;
1704
- height?: string;
1705
- stepActive?: string | number;
1706
- size?: "small" | "default" | "large";
1707
- inline?: boolean;
1708
- labelPosition?: string;
1709
- keyProp?: string;
1710
- popperClass?: string;
1711
- preventSubmitDefault?: boolean;
1712
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1713
- }> & Readonly<{
1714
- onChange?: ((...args: any[]) => any) | undefined;
1715
- onError?: ((...args: any[]) => any) | undefined;
1716
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1717
- "onField-change"?: ((...args: any[]) => any) | undefined;
1718
- "onField-input"?: ((...args: any[]) => any) | undefined;
1719
- }>, {
1720
- values: vue.Ref<FormValue, FormValue>;
1721
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1722
- formState: _tmagic_editor.FormState;
1723
- initialized: vue.Ref<boolean, boolean>;
1724
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1725
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1726
- resetForm: () => void;
1727
- submitForm: (native?: boolean) => Promise<any>;
1728
- }, {}, {}, {}, {
1729
- disabled: boolean;
1730
- labelWidth: string;
1731
- inline: boolean;
1732
- labelPosition: string;
1733
- config: FormConfig;
1734
- initValues: Record<string, any>;
1735
- lastValues: Record<string, any>;
1736
- isCompare: boolean;
1737
- keyProp: string;
1738
- parentValues: Record<string, any>;
1739
- stepActive: string | number;
1740
- height: string;
1741
- }> | null;
1742
- };
1743
- rootEl: any;
1744
- };
1745
- type __VLS_TemplateResult$3 = ReturnType<typeof __VLS_template$3>;
1746
- declare const __VLS_component$3: vue.DefineComponent<__VLS_Props$s, {
1747
- form: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1748
- config: FormConfig;
1749
- initValues: Record<string, any>;
1750
- lastValues?: Record<string, any>;
1751
- isCompare?: boolean;
1752
- parentValues?: Record<string, any>;
1753
- labelWidth?: string;
1754
- disabled?: boolean;
1755
- height?: string;
1756
- stepActive?: string | number;
1757
- size?: "small" | "default" | "large";
1758
- inline?: boolean;
1759
- labelPosition?: string;
1760
- keyProp?: string;
1761
- popperClass?: string;
1762
- preventSubmitDefault?: boolean;
1763
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1764
- }> & Readonly<{
1765
- onChange?: ((...args: any[]) => any) | undefined;
1766
- onError?: ((...args: any[]) => any) | undefined;
1767
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1768
- "onField-change"?: ((...args: any[]) => any) | undefined;
1769
- "onField-input"?: ((...args: any[]) => any) | undefined;
1770
- }>, {
1771
- values: vue.Ref<FormValue, FormValue>;
1772
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1773
- formState: _tmagic_editor.FormState;
1774
- initialized: vue.Ref<boolean, boolean>;
1775
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1776
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1777
- resetForm: () => void;
1778
- submitForm: (native?: boolean) => Promise<any>;
1779
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1780
- change: (...args: any[]) => void;
1781
- error: (...args: any[]) => void;
1782
- "update:stepActive": (...args: any[]) => void;
1783
- "field-change": (...args: any[]) => void;
1784
- "field-input": (...args: any[]) => void;
1785
- }, vue.PublicProps, {
1786
- disabled: boolean;
1787
- labelWidth: string;
1788
- inline: boolean;
1789
- labelPosition: string;
1790
- config: FormConfig;
1791
- initValues: Record<string, any>;
1792
- lastValues: Record<string, any>;
1793
- isCompare: boolean;
1794
- keyProp: string;
1795
- parentValues: Record<string, any>;
1796
- stepActive: string | number;
1797
- height: string;
1798
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
1799
- tMagicForm: ({
1800
- $: vue.ComponentInternalInstance;
1801
- $data: {};
1802
- $props: {
1803
- readonly model?: any;
1804
- readonly labelWidth?: string | number | undefined;
1805
- readonly disabled?: boolean | undefined;
1806
- readonly inline?: boolean | undefined;
1807
- readonly labelPosition?: string | undefined;
1808
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1809
- $attrs: {
1810
- [x: string]: unknown;
1811
- };
1812
- $refs: {
1813
- [x: string]: unknown;
1814
- } & {
1815
- form: unknown;
1816
- };
1817
- $slots: Readonly<{
1818
- [name: string]: vue.Slot<any> | undefined;
1819
- }>;
1820
- $root: vue.ComponentPublicInstance | null;
1821
- $parent: vue.ComponentPublicInstance | null;
1822
- $host: Element | null;
1823
- $emit: (event: string, ...args: any[]) => void;
1824
- $el: any;
1825
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
1826
- validate(): any;
1827
- resetFields(): any;
1828
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1829
- beforeCreate?: (() => void) | (() => void)[];
1830
- created?: (() => void) | (() => void)[];
1831
- beforeMount?: (() => void) | (() => void)[];
1832
- mounted?: (() => void) | (() => void)[];
1833
- beforeUpdate?: (() => void) | (() => void)[];
1834
- updated?: (() => void) | (() => void)[];
1835
- activated?: (() => void) | (() => void)[];
1836
- deactivated?: (() => void) | (() => void)[];
1837
- beforeDestroy?: (() => void) | (() => void)[];
1838
- beforeUnmount?: (() => void) | (() => void)[];
1839
- destroyed?: (() => void) | (() => void)[];
1840
- unmounted?: (() => void) | (() => void)[];
1841
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1842
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
1843
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
1844
- };
1845
- $forceUpdate: () => void;
1846
- $nextTick: typeof vue.nextTick;
1847
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
1848
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
1849
- validate(): any;
1850
- resetFields(): any;
1851
- }> & {} & vue.ComponentCustomProperties & {} & {
1852
- $slots: {
1853
- default?(_: {}): any;
1854
- };
1855
- }) | null;
1856
- }, any, vue.ComponentProvideOptions, {
1857
- P: {};
1858
- B: {};
1859
- D: {};
1860
- C: {};
1861
- M: {};
1862
- Defaults: {};
1863
- }, Readonly<{
1864
- config: FormConfig;
1865
- initValues: Record<string, any>;
1866
- lastValues?: Record<string, any>;
1867
- isCompare?: boolean;
1868
- parentValues?: Record<string, any>;
1869
- labelWidth?: string;
1870
- disabled?: boolean;
1871
- height?: string;
1872
- stepActive?: string | number;
1873
- size?: "small" | "default" | "large";
1874
- inline?: boolean;
1875
- labelPosition?: string;
1876
- keyProp?: string;
1877
- popperClass?: string;
1878
- preventSubmitDefault?: boolean;
1879
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1880
- }> & Readonly<{
1881
- onChange?: ((...args: any[]) => any) | undefined;
1882
- onError?: ((...args: any[]) => any) | undefined;
1883
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1884
- "onField-change"?: ((...args: any[]) => any) | undefined;
1885
- "onField-input"?: ((...args: any[]) => any) | undefined;
1886
- }>, {
1887
- values: vue.Ref<FormValue, FormValue>;
1888
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1889
- formState: _tmagic_editor.FormState;
1890
- initialized: vue.Ref<boolean, boolean>;
1891
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1892
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1893
- resetForm: () => void;
1894
- submitForm: (native?: boolean) => Promise<any>;
1895
- }, {}, {}, {}, {
1896
- disabled: boolean;
1897
- labelWidth: string;
1898
- inline: boolean;
1899
- labelPosition: string;
1900
- config: FormConfig;
1901
- initValues: Record<string, any>;
1902
- lastValues: Record<string, any>;
1903
- isCompare: boolean;
1904
- keyProp: string;
1905
- parentValues: Record<string, any>;
1906
- stepActive: string | number;
1907
- height: string;
1908
- }> | undefined, vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1420
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1421
+ }> & Readonly<{
1422
+ onChange?: ((...args: any[]) => any) | undefined;
1423
+ onError?: ((...args: any[]) => any) | undefined;
1424
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1425
+ "onField-change"?: ((...args: any[]) => any) | undefined;
1426
+ "onField-input"?: ((...args: any[]) => any) | undefined;
1427
+ }>, {
1428
+ values: vue.Ref<FormValue, FormValue>;
1429
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1430
+ formState: _tmagic_editor.FormState;
1431
+ initialized: vue.Ref<boolean, boolean>;
1432
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1433
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1434
+ resetForm: () => void;
1435
+ submitForm: (native?: boolean) => Promise<any>;
1436
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1437
+ change: (...args: any[]) => void;
1438
+ error: (...args: any[]) => void;
1439
+ "update:stepActive": (...args: any[]) => void;
1440
+ "field-change": (...args: any[]) => void;
1441
+ "field-input": (...args: any[]) => void;
1442
+ }, vue.PublicProps, {
1443
+ disabled: boolean;
1444
+ labelWidth: string;
1445
+ inline: boolean;
1446
+ labelPosition: string;
1447
+ config: FormConfig;
1448
+ initValues: Record<string, any>;
1449
+ lastValues: Record<string, any>;
1450
+ isCompare: boolean;
1451
+ keyProp: string;
1452
+ parentValues: Record<string, any>;
1453
+ stepActive: string | number;
1454
+ height: string;
1455
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
1456
+ P: {};
1457
+ B: {};
1458
+ D: {};
1459
+ C: {};
1460
+ M: {};
1461
+ Defaults: {};
1462
+ }, Readonly<{
1463
+ config: FormConfig;
1464
+ initValues: Record<string, any>;
1465
+ lastValues?: Record<string, any>;
1466
+ isCompare?: boolean;
1467
+ parentValues?: Record<string, any>;
1468
+ labelWidth?: string;
1469
+ disabled?: boolean;
1470
+ height?: string;
1471
+ stepActive?: string | number;
1472
+ size?: "small" | "default" | "large";
1473
+ inline?: boolean;
1474
+ labelPosition?: string;
1475
+ keyProp?: string;
1476
+ popperClass?: string;
1477
+ preventSubmitDefault?: boolean;
1478
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1479
+ }> & Readonly<{
1480
+ onChange?: ((...args: any[]) => any) | undefined;
1481
+ onError?: ((...args: any[]) => any) | undefined;
1482
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1483
+ "onField-change"?: ((...args: any[]) => any) | undefined;
1484
+ "onField-input"?: ((...args: any[]) => any) | undefined;
1485
+ }>, {
1486
+ values: vue.Ref<FormValue, FormValue>;
1487
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1488
+ formState: _tmagic_editor.FormState;
1489
+ initialized: vue.Ref<boolean, boolean>;
1490
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1491
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1492
+ resetForm: () => void;
1493
+ submitForm: (native?: boolean) => Promise<any>;
1494
+ }, {}, {}, {}, {
1495
+ disabled: boolean;
1496
+ labelWidth: string;
1497
+ inline: boolean;
1498
+ labelPosition: string;
1499
+ config: FormConfig;
1500
+ initValues: Record<string, any>;
1501
+ lastValues: Record<string, any>;
1502
+ isCompare: boolean;
1503
+ keyProp: string;
1504
+ parentValues: Record<string, any>;
1505
+ stepActive: string | number;
1506
+ height: string;
1507
+ }> | undefined, vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1508
+ config: FormConfig;
1509
+ initValues: Record<string, any>;
1510
+ lastValues?: Record<string, any>;
1511
+ isCompare?: boolean;
1512
+ parentValues?: Record<string, any>;
1513
+ labelWidth?: string;
1514
+ disabled?: boolean;
1515
+ height?: string;
1516
+ stepActive?: string | number;
1517
+ size?: "small" | "default" | "large";
1518
+ inline?: boolean;
1519
+ labelPosition?: string;
1520
+ keyProp?: string;
1521
+ popperClass?: string;
1522
+ preventSubmitDefault?: boolean;
1523
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1524
+ }> & Readonly<{
1525
+ onChange?: ((...args: any[]) => any) | undefined;
1526
+ onError?: ((...args: any[]) => any) | undefined;
1527
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1528
+ "onField-change"?: ((...args: any[]) => any) | undefined;
1529
+ "onField-input"?: ((...args: any[]) => any) | undefined;
1530
+ }>, {
1531
+ values: vue.Ref<FormValue, FormValue>;
1532
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1533
+ formState: _tmagic_editor.FormState;
1534
+ initialized: vue.Ref<boolean, boolean>;
1535
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1536
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1537
+ resetForm: () => void;
1538
+ submitForm: (native?: boolean) => Promise<any>;
1539
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1540
+ change: (...args: any[]) => void;
1541
+ error: (...args: any[]) => void;
1542
+ "update:stepActive": (...args: any[]) => void;
1543
+ "field-change": (...args: any[]) => void;
1544
+ "field-input": (...args: any[]) => void;
1545
+ }, vue.PublicProps, {
1546
+ disabled: boolean;
1547
+ labelWidth: string;
1548
+ inline: boolean;
1549
+ labelPosition: string;
1550
+ config: FormConfig;
1551
+ initValues: Record<string, any>;
1552
+ lastValues: Record<string, any>;
1553
+ isCompare: boolean;
1554
+ keyProp: string;
1555
+ parentValues: Record<string, any>;
1556
+ stepActive: string | number;
1557
+ height: string;
1558
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
1559
+ P: {};
1560
+ B: {};
1561
+ D: {};
1562
+ C: {};
1563
+ M: {};
1564
+ Defaults: {};
1565
+ }, Readonly<{
1566
+ config: FormConfig;
1567
+ initValues: Record<string, any>;
1568
+ lastValues?: Record<string, any>;
1569
+ isCompare?: boolean;
1570
+ parentValues?: Record<string, any>;
1571
+ labelWidth?: string;
1572
+ disabled?: boolean;
1573
+ height?: string;
1574
+ stepActive?: string | number;
1575
+ size?: "small" | "default" | "large";
1576
+ inline?: boolean;
1577
+ labelPosition?: string;
1578
+ keyProp?: string;
1579
+ popperClass?: string;
1580
+ preventSubmitDefault?: boolean;
1581
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1582
+ }> & Readonly<{
1583
+ onChange?: ((...args: any[]) => any) | undefined;
1584
+ onError?: ((...args: any[]) => any) | undefined;
1585
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1586
+ "onField-change"?: ((...args: any[]) => any) | undefined;
1587
+ "onField-input"?: ((...args: any[]) => any) | undefined;
1588
+ }>, {
1589
+ values: vue.Ref<FormValue, FormValue>;
1590
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1591
+ formState: _tmagic_editor.FormState;
1592
+ initialized: vue.Ref<boolean, boolean>;
1593
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1594
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1595
+ resetForm: () => void;
1596
+ submitForm: (native?: boolean) => Promise<any>;
1597
+ }, {}, {}, {}, {
1598
+ disabled: boolean;
1599
+ labelWidth: string;
1600
+ inline: boolean;
1601
+ labelPosition: string;
1602
+ config: FormConfig;
1603
+ initValues: Record<string, any>;
1604
+ lastValues: Record<string, any>;
1605
+ isCompare: boolean;
1606
+ keyProp: string;
1607
+ parentValues: Record<string, any>;
1608
+ stepActive: string | number;
1609
+ height: string;
1610
+ }> | undefined>;
1611
+ declare const drawerBody: vue.Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
1612
+ declare const visible: vue.Ref<boolean, boolean>;
1613
+ declare const saveFetch$1: vue.Ref<boolean, boolean>;
1614
+ declare const submitHandler$1: () => Promise<void>;
1615
+ declare const changeHandler$3: (value: FormValue, eventData: ContainerChangeEventData) => void;
1616
+ declare const openHandler: () => void;
1617
+ declare const openedHandler: () => void;
1618
+ declare const closeHandler: () => void;
1619
+ declare const closedHandler: () => void;
1620
+ /** 用于关闭 Drawer, 该方法会调用传入的 before-close 方法 */
1621
+ declare const handleClose: () => void;
1622
+ declare const __VLS_ctx$3: InstanceType<__VLS_PickNotAny<typeof __VLS_self$3, new () => {}>>;
1623
+ declare var __VLS_23: {};
1624
+ declare var __VLS_33: {};
1625
+ declare var __VLS_39: {};
1626
+ type __VLS_Slots$3 = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx$3.$slots> & {
1627
+ default?: (props: typeof __VLS_23) => any;
1628
+ } & {
1629
+ left?: (props: typeof __VLS_33) => any;
1630
+ } & {
1631
+ footer?: (props: typeof __VLS_39) => any;
1632
+ }>;
1633
+ declare const __VLS_self$3: vue.DefineComponent<__VLS_Props$s, {
1634
+ TMagicButton: typeof TMagicButton;
1635
+ TMagicCol: typeof TMagicCol;
1636
+ TMagicDrawer: typeof TMagicDrawer;
1637
+ TMagicRow: typeof TMagicRow;
1638
+ Form: typeof _default$v;
1639
+ drawer: typeof drawer;
1640
+ form: typeof form$1;
1641
+ drawerBody: typeof drawerBody;
1642
+ visible: typeof visible;
1643
+ saveFetch: typeof saveFetch$1;
1644
+ submitHandler: typeof submitHandler$1;
1645
+ changeHandler: typeof changeHandler$3;
1646
+ openHandler: typeof openHandler;
1647
+ openedHandler: typeof openedHandler;
1648
+ closeHandler: typeof closeHandler;
1649
+ closedHandler: typeof closedHandler;
1650
+ handleClose: typeof handleClose;
1651
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1652
+ change: (...args: any[]) => void;
1653
+ close: (...args: any[]) => void;
1654
+ open: (...args: any[]) => void;
1655
+ opened: (...args: any[]) => void;
1656
+ closed: (...args: any[]) => void;
1657
+ error: (...args: any[]) => void;
1658
+ submit: (...args: any[]) => void;
1659
+ }, string, vue.PublicProps, Readonly<__VLS_Props$s> & Readonly<{
1660
+ onChange?: ((...args: any[]) => any) | undefined;
1661
+ onClose?: ((...args: any[]) => any) | undefined;
1662
+ onOpen?: ((...args: any[]) => any) | undefined;
1663
+ onOpened?: ((...args: any[]) => any) | undefined;
1664
+ onClosed?: ((...args: any[]) => any) | undefined;
1665
+ onError?: ((...args: any[]) => any) | undefined;
1666
+ onSubmit?: ((...args: any[]) => any) | undefined;
1667
+ }>, {
1668
+ values: Object;
1669
+ closeOnPressEscape: boolean;
1670
+ config: FormConfig;
1671
+ confirmText: string;
1672
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
1673
+ declare const __VLS_component$3: vue.DefineComponent<__VLS_Props$s, {
1674
+ form: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1909
1675
  config: FormConfig;
1910
1676
  initValues: Record<string, any>;
1911
1677
  lastValues?: Record<string, any>;
@@ -1956,65 +1722,7 @@ declare const __VLS_component$3: vue.DefineComponent<__VLS_Props$s, {
1956
1722
  parentValues: Record<string, any>;
1957
1723
  stepActive: string | number;
1958
1724
  height: string;
1959
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
1960
- tMagicForm: ({
1961
- $: vue.ComponentInternalInstance;
1962
- $data: {};
1963
- $props: {
1964
- readonly model?: any;
1965
- readonly labelWidth?: string | number | undefined;
1966
- readonly disabled?: boolean | undefined;
1967
- readonly inline?: boolean | undefined;
1968
- readonly labelPosition?: string | undefined;
1969
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
1970
- $attrs: {
1971
- [x: string]: unknown;
1972
- };
1973
- $refs: {
1974
- [x: string]: unknown;
1975
- } & {
1976
- form: unknown;
1977
- };
1978
- $slots: Readonly<{
1979
- [name: string]: vue.Slot<any> | undefined;
1980
- }>;
1981
- $root: vue.ComponentPublicInstance | null;
1982
- $parent: vue.ComponentPublicInstance | null;
1983
- $host: Element | null;
1984
- $emit: (event: string, ...args: any[]) => void;
1985
- $el: any;
1986
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
1987
- validate(): any;
1988
- resetFields(): any;
1989
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
1990
- beforeCreate?: (() => void) | (() => void)[];
1991
- created?: (() => void) | (() => void)[];
1992
- beforeMount?: (() => void) | (() => void)[];
1993
- mounted?: (() => void) | (() => void)[];
1994
- beforeUpdate?: (() => void) | (() => void)[];
1995
- updated?: (() => void) | (() => void)[];
1996
- activated?: (() => void) | (() => void)[];
1997
- deactivated?: (() => void) | (() => void)[];
1998
- beforeDestroy?: (() => void) | (() => void)[];
1999
- beforeUnmount?: (() => void) | (() => void)[];
2000
- destroyed?: (() => void) | (() => void)[];
2001
- unmounted?: (() => void) | (() => void)[];
2002
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2003
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2004
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2005
- };
2006
- $forceUpdate: () => void;
2007
- $nextTick: typeof vue.nextTick;
2008
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2009
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
2010
- validate(): any;
2011
- resetFields(): any;
2012
- }> & {} & vue.ComponentCustomProperties & {} & {
2013
- $slots: {
2014
- default?(_: {}): any;
2015
- };
2016
- }) | null;
2017
- }, any, vue.ComponentProvideOptions, {
1725
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
2018
1726
  P: {};
2019
1727
  B: {};
2020
1728
  D: {};
@@ -2066,120 +1774,7 @@ declare const __VLS_component$3: vue.DefineComponent<__VLS_Props$s, {
2066
1774
  parentValues: Record<string, any>;
2067
1775
  stepActive: string | number;
2068
1776
  height: string;
2069
- }> | undefined>;
2070
- saveFetch: vue.Ref<boolean, boolean>;
2071
- bodyHeight: vue.Ref<number, number>;
2072
- show: () => void;
2073
- hide: () => void;
2074
- handleClose: () => void;
2075
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2076
- change: (...args: any[]) => void;
2077
- close: (...args: any[]) => void;
2078
- open: (...args: any[]) => void;
2079
- opened: (...args: any[]) => void;
2080
- closed: (...args: any[]) => void;
2081
- error: (...args: any[]) => void;
2082
- submit: (...args: any[]) => void;
2083
- }, string, vue.PublicProps, Readonly<__VLS_Props$s> & Readonly<{
2084
- onChange?: ((...args: any[]) => any) | undefined;
2085
- onClose?: ((...args: any[]) => any) | undefined;
2086
- onOpen?: ((...args: any[]) => any) | undefined;
2087
- onOpened?: ((...args: any[]) => any) | undefined;
2088
- onClosed?: ((...args: any[]) => any) | undefined;
2089
- onError?: ((...args: any[]) => any) | undefined;
2090
- onSubmit?: ((...args: any[]) => any) | undefined;
2091
- }>, {
2092
- values: Object;
2093
- closeOnPressEscape: boolean;
2094
- config: FormConfig;
2095
- confirmText: string;
2096
- }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
2097
- drawer: ({
2098
- $: vue.ComponentInternalInstance;
2099
- $data: {};
2100
- $props: {
2101
- readonly modelValue?: boolean | undefined;
2102
- readonly appendToBody?: boolean | undefined;
2103
- readonly beforeClose?: any;
2104
- readonly title?: string | undefined;
2105
- readonly size?: string | number | undefined;
2106
- readonly fullscreen?: boolean | undefined;
2107
- readonly closeOnClickModal?: boolean | undefined;
2108
- readonly closeOnPressEscape?: boolean | undefined;
2109
- readonly direction?: "rtl" | "ltr" | "ttb" | "bt" | undefined;
2110
- readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
2111
- readonly onClose?: ((...args: any[]) => any) | undefined;
2112
- readonly onOpen?: ((...args: any[]) => any) | undefined;
2113
- readonly onOpened?: ((...args: any[]) => any) | undefined;
2114
- readonly onClosed?: ((...args: any[]) => any) | undefined;
2115
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
2116
- $attrs: {
2117
- [x: string]: unknown;
2118
- };
2119
- $refs: {
2120
- [x: string]: unknown;
2121
- } & {
2122
- drawer: unknown;
2123
- };
2124
- $slots: Readonly<{
2125
- [name: string]: vue.Slot<any> | undefined;
2126
- }>;
2127
- $root: vue.ComponentPublicInstance | null;
2128
- $parent: vue.ComponentPublicInstance | null;
2129
- $host: Element | null;
2130
- $emit: ((event: "update:modelValue", ...args: any[]) => void) & ((event: "close", ...args: any[]) => void) & ((event: "open", ...args: any[]) => void) & ((event: "opened", ...args: any[]) => void) & ((event: "closed", ...args: any[]) => void);
2131
- $el: any;
2132
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.DrawerProps> & Readonly<{
2133
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
2134
- onClose?: ((...args: any[]) => any) | undefined;
2135
- onOpen?: ((...args: any[]) => any) | undefined;
2136
- onOpened?: ((...args: any[]) => any) | undefined;
2137
- onClosed?: ((...args: any[]) => any) | undefined;
2138
- }>, {
2139
- handleClose: () => any;
2140
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2141
- "update:modelValue": (...args: any[]) => void;
2142
- close: (...args: any[]) => void;
2143
- open: (...args: any[]) => void;
2144
- opened: (...args: any[]) => void;
2145
- closed: (...args: any[]) => void;
2146
- }, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
2147
- beforeCreate?: (() => void) | (() => void)[];
2148
- created?: (() => void) | (() => void)[];
2149
- beforeMount?: (() => void) | (() => void)[];
2150
- mounted?: (() => void) | (() => void)[];
2151
- beforeUpdate?: (() => void) | (() => void)[];
2152
- updated?: (() => void) | (() => void)[];
2153
- activated?: (() => void) | (() => void)[];
2154
- deactivated?: (() => void) | (() => void)[];
2155
- beforeDestroy?: (() => void) | (() => void)[];
2156
- beforeUnmount?: (() => void) | (() => void)[];
2157
- destroyed?: (() => void) | (() => void)[];
2158
- unmounted?: (() => void) | (() => void)[];
2159
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2160
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2161
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2162
- };
2163
- $forceUpdate: () => void;
2164
- $nextTick: typeof vue.nextTick;
2165
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2166
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.DrawerProps> & Readonly<{
2167
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
2168
- onClose?: ((...args: any[]) => any) | undefined;
2169
- onOpen?: ((...args: any[]) => any) | undefined;
2170
- onOpened?: ((...args: any[]) => any) | undefined;
2171
- onClosed?: ((...args: any[]) => any) | undefined;
2172
- }>, "handleClose"> & vue.ShallowUnwrapRef<{
2173
- handleClose: () => any;
2174
- }> & {} & vue.ComponentCustomProperties & {} & {
2175
- $slots: {
2176
- default?(_: {}): any;
2177
- header?(_: {}): any;
2178
- footer?(_: {}): any;
2179
- };
2180
- }) | null;
2181
- drawerBody: HTMLDivElement;
2182
- form: vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1777
+ }> | undefined, vue.CreateComponentPublicInstanceWithMixins<Readonly<{
2183
1778
  config: FormConfig;
2184
1779
  initValues: Record<string, any>;
2185
1780
  lastValues?: Record<string, any>;
@@ -2230,65 +1825,7 @@ declare const __VLS_component$3: vue.DefineComponent<__VLS_Props$s, {
2230
1825
  parentValues: Record<string, any>;
2231
1826
  stepActive: string | number;
2232
1827
  height: string;
2233
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
2234
- tMagicForm: ({
2235
- $: vue.ComponentInternalInstance;
2236
- $data: {};
2237
- $props: {
2238
- readonly model?: any;
2239
- readonly labelWidth?: string | number | undefined;
2240
- readonly disabled?: boolean | undefined;
2241
- readonly inline?: boolean | undefined;
2242
- readonly labelPosition?: string | undefined;
2243
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
2244
- $attrs: {
2245
- [x: string]: unknown;
2246
- };
2247
- $refs: {
2248
- [x: string]: unknown;
2249
- } & {
2250
- form: unknown;
2251
- };
2252
- $slots: Readonly<{
2253
- [name: string]: vue.Slot<any> | undefined;
2254
- }>;
2255
- $root: vue.ComponentPublicInstance | null;
2256
- $parent: vue.ComponentPublicInstance | null;
2257
- $host: Element | null;
2258
- $emit: (event: string, ...args: any[]) => void;
2259
- $el: any;
2260
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
2261
- validate(): any;
2262
- resetFields(): any;
2263
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
2264
- beforeCreate?: (() => void) | (() => void)[];
2265
- created?: (() => void) | (() => void)[];
2266
- beforeMount?: (() => void) | (() => void)[];
2267
- mounted?: (() => void) | (() => void)[];
2268
- beforeUpdate?: (() => void) | (() => void)[];
2269
- updated?: (() => void) | (() => void)[];
2270
- activated?: (() => void) | (() => void)[];
2271
- deactivated?: (() => void) | (() => void)[];
2272
- beforeDestroy?: (() => void) | (() => void)[];
2273
- beforeUnmount?: (() => void) | (() => void)[];
2274
- destroyed?: (() => void) | (() => void)[];
2275
- unmounted?: (() => void) | (() => void)[];
2276
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2277
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2278
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2279
- };
2280
- $forceUpdate: () => void;
2281
- $nextTick: typeof vue.nextTick;
2282
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2283
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
2284
- validate(): any;
2285
- resetFields(): any;
2286
- }> & {} & vue.ComponentCustomProperties & {} & {
2287
- $slots: {
2288
- default?(_: {}): any;
2289
- };
2290
- }) | null;
2291
- }, any, vue.ComponentProvideOptions, {
1828
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
2292
1829
  P: {};
2293
1830
  B: {};
2294
1831
  D: {};
@@ -2340,11 +1877,37 @@ declare const __VLS_component$3: vue.DefineComponent<__VLS_Props$s, {
2340
1877
  parentValues: Record<string, any>;
2341
1878
  stepActive: string | number;
2342
1879
  height: string;
2343
- }> | null;
2344
- }, any>;
2345
- declare const _default$t: __VLS_WithTemplateSlots$3<typeof __VLS_component$3, __VLS_TemplateResult$3["slots"]>;
1880
+ }> | undefined>;
1881
+ saveFetch: vue.Ref<boolean, boolean>;
1882
+ bodyHeight: vue.Ref<number, number>;
1883
+ show: () => void;
1884
+ hide: () => void;
1885
+ handleClose: () => void;
1886
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1887
+ change: (...args: any[]) => void;
1888
+ close: (...args: any[]) => void;
1889
+ open: (...args: any[]) => void;
1890
+ opened: (...args: any[]) => void;
1891
+ closed: (...args: any[]) => void;
1892
+ error: (...args: any[]) => void;
1893
+ submit: (...args: any[]) => void;
1894
+ }, string, vue.PublicProps, Readonly<__VLS_Props$s> & Readonly<{
1895
+ onChange?: ((...args: any[]) => any) | undefined;
1896
+ onClose?: ((...args: any[]) => any) | undefined;
1897
+ onOpen?: ((...args: any[]) => any) | undefined;
1898
+ onOpened?: ((...args: any[]) => any) | undefined;
1899
+ onClosed?: ((...args: any[]) => any) | undefined;
1900
+ onError?: ((...args: any[]) => any) | undefined;
1901
+ onSubmit?: ((...args: any[]) => any) | undefined;
1902
+ }>, {
1903
+ values: Object;
1904
+ closeOnPressEscape: boolean;
1905
+ config: FormConfig;
1906
+ confirmText: string;
1907
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
1908
+ declare const _default$t: __VLS_WithSlots$3<typeof __VLS_component$3, __VLS_Slots$3>;
2346
1909
 
2347
- type __VLS_WithTemplateSlots$3<T, S> = T & {
1910
+ type __VLS_WithSlots$3<T, S> = T & {
2348
1911
  new (): {
2349
1912
  $slots: S;
2350
1913
  };
@@ -2364,180 +1927,257 @@ type __VLS_Props$r = {
2364
1927
  labelPosition?: string;
2365
1928
  preventSubmitDefault?: boolean;
2366
1929
  };
2367
- declare function __VLS_template$2(): {
2368
- attrs: Partial<{}>;
2369
- slots: {
2370
- default?(_: {}): any;
2371
- left?(_: {}): any;
2372
- footer?(_: {}): any;
2373
- };
2374
- refs: {
2375
- form: vue.CreateComponentPublicInstanceWithMixins<Readonly<{
2376
- config: FormConfig;
2377
- initValues: Record<string, any>;
2378
- lastValues?: Record<string, any>;
2379
- isCompare?: boolean;
2380
- parentValues?: Record<string, any>;
2381
- labelWidth?: string;
2382
- disabled?: boolean;
2383
- height?: string;
2384
- stepActive?: string | number;
2385
- size?: "small" | "default" | "large";
2386
- inline?: boolean;
2387
- labelPosition?: string;
2388
- keyProp?: string;
2389
- popperClass?: string;
2390
- preventSubmitDefault?: boolean;
2391
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
2392
- }> & Readonly<{
2393
- onChange?: ((...args: any[]) => any) | undefined;
2394
- onError?: ((...args: any[]) => any) | undefined;
2395
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
2396
- "onField-change"?: ((...args: any[]) => any) | undefined;
2397
- "onField-input"?: ((...args: any[]) => any) | undefined;
2398
- }>, {
2399
- values: vue.Ref<FormValue, FormValue>;
2400
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
2401
- formState: _tmagic_editor.FormState;
2402
- initialized: vue.Ref<boolean, boolean>;
2403
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
2404
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
2405
- resetForm: () => void;
2406
- submitForm: (native?: boolean) => Promise<any>;
2407
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2408
- change: (...args: any[]) => void;
2409
- error: (...args: any[]) => void;
2410
- "update:stepActive": (...args: any[]) => void;
2411
- "field-change": (...args: any[]) => void;
2412
- "field-input": (...args: any[]) => void;
2413
- }, vue.PublicProps, {
2414
- disabled: boolean;
2415
- labelWidth: string;
2416
- inline: boolean;
2417
- labelPosition: string;
2418
- config: FormConfig;
2419
- initValues: Record<string, any>;
2420
- lastValues: Record<string, any>;
2421
- isCompare: boolean;
2422
- keyProp: string;
2423
- parentValues: Record<string, any>;
2424
- stepActive: string | number;
2425
- height: string;
2426
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
2427
- tMagicForm: ({
2428
- $: vue.ComponentInternalInstance;
2429
- $data: {};
2430
- $props: {
2431
- readonly model?: any;
2432
- readonly labelWidth?: string | number | undefined;
2433
- readonly disabled?: boolean | undefined;
2434
- readonly inline?: boolean | undefined;
2435
- readonly labelPosition?: string | undefined;
2436
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
2437
- $attrs: {
2438
- [x: string]: unknown;
2439
- };
2440
- $refs: {
2441
- [x: string]: unknown;
2442
- } & {
2443
- form: unknown;
2444
- };
2445
- $slots: Readonly<{
2446
- [name: string]: vue.Slot<any> | undefined;
2447
- }>;
2448
- $root: vue.ComponentPublicInstance | null;
2449
- $parent: vue.ComponentPublicInstance | null;
2450
- $host: Element | null;
2451
- $emit: (event: string, ...args: any[]) => void;
2452
- $el: any;
2453
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
2454
- validate(): any;
2455
- resetFields(): any;
2456
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
2457
- beforeCreate?: (() => void) | (() => void)[];
2458
- created?: (() => void) | (() => void)[];
2459
- beforeMount?: (() => void) | (() => void)[];
2460
- mounted?: (() => void) | (() => void)[];
2461
- beforeUpdate?: (() => void) | (() => void)[];
2462
- updated?: (() => void) | (() => void)[];
2463
- activated?: (() => void) | (() => void)[];
2464
- deactivated?: (() => void) | (() => void)[];
2465
- beforeDestroy?: (() => void) | (() => void)[];
2466
- beforeUnmount?: (() => void) | (() => void)[];
2467
- destroyed?: (() => void) | (() => void)[];
2468
- unmounted?: (() => void) | (() => void)[];
2469
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2470
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2471
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2472
- };
2473
- $forceUpdate: () => void;
2474
- $nextTick: typeof vue.nextTick;
2475
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2476
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
2477
- validate(): any;
2478
- resetFields(): any;
2479
- }> & {} & vue.ComponentCustomProperties & {} & {
2480
- $slots: {
2481
- default?(_: {}): any;
2482
- };
2483
- }) | null;
2484
- }, any, vue.ComponentProvideOptions, {
2485
- P: {};
2486
- B: {};
2487
- D: {};
2488
- C: {};
2489
- M: {};
2490
- Defaults: {};
2491
- }, Readonly<{
2492
- config: FormConfig;
2493
- initValues: Record<string, any>;
2494
- lastValues?: Record<string, any>;
2495
- isCompare?: boolean;
2496
- parentValues?: Record<string, any>;
2497
- labelWidth?: string;
2498
- disabled?: boolean;
2499
- height?: string;
2500
- stepActive?: string | number;
2501
- size?: "small" | "default" | "large";
2502
- inline?: boolean;
2503
- labelPosition?: string;
2504
- keyProp?: string;
2505
- popperClass?: string;
2506
- preventSubmitDefault?: boolean;
2507
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
2508
- }> & Readonly<{
2509
- onChange?: ((...args: any[]) => any) | undefined;
2510
- onError?: ((...args: any[]) => any) | undefined;
2511
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
2512
- "onField-change"?: ((...args: any[]) => any) | undefined;
2513
- "onField-input"?: ((...args: any[]) => any) | undefined;
2514
- }>, {
2515
- values: vue.Ref<FormValue, FormValue>;
2516
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
2517
- formState: _tmagic_editor.FormState;
2518
- initialized: vue.Ref<boolean, boolean>;
2519
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
2520
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
2521
- resetForm: () => void;
2522
- submitForm: (native?: boolean) => Promise<any>;
2523
- }, {}, {}, {}, {
2524
- disabled: boolean;
2525
- labelWidth: string;
2526
- inline: boolean;
2527
- labelPosition: string;
2528
- config: FormConfig;
2529
- initValues: Record<string, any>;
2530
- lastValues: Record<string, any>;
2531
- isCompare: boolean;
2532
- keyProp: string;
2533
- parentValues: Record<string, any>;
2534
- stepActive: string | number;
2535
- height: string;
2536
- }> | null;
2537
- };
2538
- rootEl: HTMLDivElement;
2539
- };
2540
- type __VLS_TemplateResult$2 = ReturnType<typeof __VLS_template$2>;
1930
+ declare const footerHeight = 60;
1931
+ declare const style: vue.ComputedRef<{
1932
+ width?: string;
1933
+ height?: string;
1934
+ }>;
1935
+ declare const form: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
1936
+ config: FormConfig;
1937
+ initValues: Record<string, any>;
1938
+ lastValues?: Record<string, any>;
1939
+ isCompare?: boolean;
1940
+ parentValues?: Record<string, any>;
1941
+ labelWidth?: string;
1942
+ disabled?: boolean;
1943
+ height?: string;
1944
+ stepActive?: string | number;
1945
+ size?: "small" | "default" | "large";
1946
+ inline?: boolean;
1947
+ labelPosition?: string;
1948
+ keyProp?: string;
1949
+ popperClass?: string;
1950
+ preventSubmitDefault?: boolean;
1951
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
1952
+ }> & Readonly<{
1953
+ onChange?: ((...args: any[]) => any) | undefined;
1954
+ onError?: ((...args: any[]) => any) | undefined;
1955
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
1956
+ "onField-change"?: ((...args: any[]) => any) | undefined;
1957
+ "onField-input"?: ((...args: any[]) => any) | undefined;
1958
+ }>, {
1959
+ values: vue.Ref<FormValue, FormValue>;
1960
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
1961
+ formState: _tmagic_editor.FormState;
1962
+ initialized: vue.Ref<boolean, boolean>;
1963
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
1964
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
1965
+ resetForm: () => void;
1966
+ submitForm: (native?: boolean) => Promise<any>;
1967
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
1968
+ change: (...args: any[]) => void;
1969
+ error: (...args: any[]) => void;
1970
+ "update:stepActive": (...args: any[]) => void;
1971
+ "field-change": (...args: any[]) => void;
1972
+ "field-input": (...args: any[]) => void;
1973
+ }, vue.PublicProps, {
1974
+ disabled: boolean;
1975
+ labelWidth: string;
1976
+ inline: boolean;
1977
+ labelPosition: string;
1978
+ config: FormConfig;
1979
+ initValues: Record<string, any>;
1980
+ lastValues: Record<string, any>;
1981
+ isCompare: boolean;
1982
+ keyProp: string;
1983
+ parentValues: Record<string, any>;
1984
+ stepActive: string | number;
1985
+ height: string;
1986
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
1987
+ P: {};
1988
+ B: {};
1989
+ D: {};
1990
+ C: {};
1991
+ M: {};
1992
+ Defaults: {};
1993
+ }, Readonly<{
1994
+ config: FormConfig;
1995
+ initValues: Record<string, any>;
1996
+ lastValues?: Record<string, any>;
1997
+ isCompare?: boolean;
1998
+ parentValues?: Record<string, any>;
1999
+ labelWidth?: string;
2000
+ disabled?: boolean;
2001
+ height?: string;
2002
+ stepActive?: string | number;
2003
+ size?: "small" | "default" | "large";
2004
+ inline?: boolean;
2005
+ labelPosition?: string;
2006
+ keyProp?: string;
2007
+ popperClass?: string;
2008
+ preventSubmitDefault?: boolean;
2009
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
2010
+ }> & Readonly<{
2011
+ onChange?: ((...args: any[]) => any) | undefined;
2012
+ onError?: ((...args: any[]) => any) | undefined;
2013
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
2014
+ "onField-change"?: ((...args: any[]) => any) | undefined;
2015
+ "onField-input"?: ((...args: any[]) => any) | undefined;
2016
+ }>, {
2017
+ values: vue.Ref<FormValue, FormValue>;
2018
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
2019
+ formState: _tmagic_editor.FormState;
2020
+ initialized: vue.Ref<boolean, boolean>;
2021
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
2022
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
2023
+ resetForm: () => void;
2024
+ submitForm: (native?: boolean) => Promise<any>;
2025
+ }, {}, {}, {}, {
2026
+ disabled: boolean;
2027
+ labelWidth: string;
2028
+ inline: boolean;
2029
+ labelPosition: string;
2030
+ config: FormConfig;
2031
+ initValues: Record<string, any>;
2032
+ lastValues: Record<string, any>;
2033
+ isCompare: boolean;
2034
+ keyProp: string;
2035
+ parentValues: Record<string, any>;
2036
+ stepActive: string | number;
2037
+ height: string;
2038
+ }> | undefined, vue.CreateComponentPublicInstanceWithMixins<Readonly<{
2039
+ config: FormConfig;
2040
+ initValues: Record<string, any>;
2041
+ lastValues?: Record<string, any>;
2042
+ isCompare?: boolean;
2043
+ parentValues?: Record<string, any>;
2044
+ labelWidth?: string;
2045
+ disabled?: boolean;
2046
+ height?: string;
2047
+ stepActive?: string | number;
2048
+ size?: "small" | "default" | "large";
2049
+ inline?: boolean;
2050
+ labelPosition?: string;
2051
+ keyProp?: string;
2052
+ popperClass?: string;
2053
+ preventSubmitDefault?: boolean;
2054
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
2055
+ }> & Readonly<{
2056
+ onChange?: ((...args: any[]) => any) | undefined;
2057
+ onError?: ((...args: any[]) => any) | undefined;
2058
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
2059
+ "onField-change"?: ((...args: any[]) => any) | undefined;
2060
+ "onField-input"?: ((...args: any[]) => any) | undefined;
2061
+ }>, {
2062
+ values: vue.Ref<FormValue, FormValue>;
2063
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
2064
+ formState: _tmagic_editor.FormState;
2065
+ initialized: vue.Ref<boolean, boolean>;
2066
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
2067
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
2068
+ resetForm: () => void;
2069
+ submitForm: (native?: boolean) => Promise<any>;
2070
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2071
+ change: (...args: any[]) => void;
2072
+ error: (...args: any[]) => void;
2073
+ "update:stepActive": (...args: any[]) => void;
2074
+ "field-change": (...args: any[]) => void;
2075
+ "field-input": (...args: any[]) => void;
2076
+ }, vue.PublicProps, {
2077
+ disabled: boolean;
2078
+ labelWidth: string;
2079
+ inline: boolean;
2080
+ labelPosition: string;
2081
+ config: FormConfig;
2082
+ initValues: Record<string, any>;
2083
+ lastValues: Record<string, any>;
2084
+ isCompare: boolean;
2085
+ keyProp: string;
2086
+ parentValues: Record<string, any>;
2087
+ stepActive: string | number;
2088
+ height: string;
2089
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
2090
+ P: {};
2091
+ B: {};
2092
+ D: {};
2093
+ C: {};
2094
+ M: {};
2095
+ Defaults: {};
2096
+ }, Readonly<{
2097
+ config: FormConfig;
2098
+ initValues: Record<string, any>;
2099
+ lastValues?: Record<string, any>;
2100
+ isCompare?: boolean;
2101
+ parentValues?: Record<string, any>;
2102
+ labelWidth?: string;
2103
+ disabled?: boolean;
2104
+ height?: string;
2105
+ stepActive?: string | number;
2106
+ size?: "small" | "default" | "large";
2107
+ inline?: boolean;
2108
+ labelPosition?: string;
2109
+ keyProp?: string;
2110
+ popperClass?: string;
2111
+ preventSubmitDefault?: boolean;
2112
+ extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
2113
+ }> & Readonly<{
2114
+ onChange?: ((...args: any[]) => any) | undefined;
2115
+ onError?: ((...args: any[]) => any) | undefined;
2116
+ "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
2117
+ "onField-change"?: ((...args: any[]) => any) | undefined;
2118
+ "onField-input"?: ((...args: any[]) => any) | undefined;
2119
+ }>, {
2120
+ values: vue.Ref<FormValue, FormValue>;
2121
+ lastValuesProcessed: vue.Ref<FormValue, FormValue>;
2122
+ formState: _tmagic_editor.FormState;
2123
+ initialized: vue.Ref<boolean, boolean>;
2124
+ changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
2125
+ changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
2126
+ resetForm: () => void;
2127
+ submitForm: (native?: boolean) => Promise<any>;
2128
+ }, {}, {}, {}, {
2129
+ disabled: boolean;
2130
+ labelWidth: string;
2131
+ inline: boolean;
2132
+ labelPosition: string;
2133
+ config: FormConfig;
2134
+ initValues: Record<string, any>;
2135
+ lastValues: Record<string, any>;
2136
+ isCompare: boolean;
2137
+ keyProp: string;
2138
+ parentValues: Record<string, any>;
2139
+ stepActive: string | number;
2140
+ height: string;
2141
+ }> | undefined>;
2142
+ declare const saveFetch: vue.Ref<boolean, boolean>;
2143
+ declare const bodyHeight: vue.Ref<number, number>;
2144
+ declare const submitHandler: () => Promise<void>;
2145
+ declare const changeHandler$2: (value: FormValue, eventData: ContainerChangeEventData) => void;
2146
+ declare const __VLS_ctx$2: InstanceType<__VLS_PickNotAny<typeof __VLS_self$2, new () => {}>>;
2147
+ declare var __VLS_14$1: {};
2148
+ declare var __VLS_16$1: {};
2149
+ declare var __VLS_18: {};
2150
+ type __VLS_Slots$2 = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx$2.$slots> & {
2151
+ default?: (props: typeof __VLS_14$1) => any;
2152
+ } & {
2153
+ left?: (props: typeof __VLS_16$1) => any;
2154
+ } & {
2155
+ footer?: (props: typeof __VLS_18) => any;
2156
+ }>;
2157
+ declare const __VLS_self$2: vue.DefineComponent<__VLS_Props$r, {
2158
+ TMagicButton: typeof TMagicButton;
2159
+ TMagicScrollbar: typeof TMagicScrollbar;
2160
+ Form: typeof _default$v;
2161
+ footerHeight: typeof footerHeight;
2162
+ style: typeof style;
2163
+ form: typeof form;
2164
+ saveFetch: typeof saveFetch;
2165
+ bodyHeight: typeof bodyHeight;
2166
+ submitHandler: typeof submitHandler;
2167
+ changeHandler: typeof changeHandler$2;
2168
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2169
+ change: (v: any, eventData: ContainerChangeEventData) => any;
2170
+ error: (e: any) => any;
2171
+ submit: (v: any, eventData: ContainerChangeEventData) => any;
2172
+ }, string, vue.PublicProps, Readonly<__VLS_Props$r> & Readonly<{
2173
+ onChange?: ((v: any, eventData: ContainerChangeEventData) => any) | undefined;
2174
+ onError?: ((e: any) => any) | undefined;
2175
+ onSubmit?: ((v: any, eventData: ContainerChangeEventData) => any) | undefined;
2176
+ }>, {
2177
+ values: Object;
2178
+ config: FormConfig;
2179
+ confirmText: string;
2180
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
2541
2181
  declare const __VLS_component$2: vue.DefineComponent<__VLS_Props$r, {
2542
2182
  form: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
2543
2183
  config: FormConfig;
@@ -2590,65 +2230,7 @@ declare const __VLS_component$2: vue.DefineComponent<__VLS_Props$r, {
2590
2230
  parentValues: Record<string, any>;
2591
2231
  stepActive: string | number;
2592
2232
  height: string;
2593
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
2594
- tMagicForm: ({
2595
- $: vue.ComponentInternalInstance;
2596
- $data: {};
2597
- $props: {
2598
- readonly model?: any;
2599
- readonly labelWidth?: string | number | undefined;
2600
- readonly disabled?: boolean | undefined;
2601
- readonly inline?: boolean | undefined;
2602
- readonly labelPosition?: string | undefined;
2603
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
2604
- $attrs: {
2605
- [x: string]: unknown;
2606
- };
2607
- $refs: {
2608
- [x: string]: unknown;
2609
- } & {
2610
- form: unknown;
2611
- };
2612
- $slots: Readonly<{
2613
- [name: string]: vue.Slot<any> | undefined;
2614
- }>;
2615
- $root: vue.ComponentPublicInstance | null;
2616
- $parent: vue.ComponentPublicInstance | null;
2617
- $host: Element | null;
2618
- $emit: (event: string, ...args: any[]) => void;
2619
- $el: any;
2620
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
2621
- validate(): any;
2622
- resetFields(): any;
2623
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
2624
- beforeCreate?: (() => void) | (() => void)[];
2625
- created?: (() => void) | (() => void)[];
2626
- beforeMount?: (() => void) | (() => void)[];
2627
- mounted?: (() => void) | (() => void)[];
2628
- beforeUpdate?: (() => void) | (() => void)[];
2629
- updated?: (() => void) | (() => void)[];
2630
- activated?: (() => void) | (() => void)[];
2631
- deactivated?: (() => void) | (() => void)[];
2632
- beforeDestroy?: (() => void) | (() => void)[];
2633
- beforeUnmount?: (() => void) | (() => void)[];
2634
- destroyed?: (() => void) | (() => void)[];
2635
- unmounted?: (() => void) | (() => void)[];
2636
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2637
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2638
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2639
- };
2640
- $forceUpdate: () => void;
2641
- $nextTick: typeof vue.nextTick;
2642
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2643
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
2644
- validate(): any;
2645
- resetFields(): any;
2646
- }> & {} & vue.ComponentCustomProperties & {} & {
2647
- $slots: {
2648
- default?(_: {}): any;
2649
- };
2650
- }) | null;
2651
- }, any, vue.ComponentProvideOptions, {
2233
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
2652
2234
  P: {};
2653
2235
  B: {};
2654
2236
  D: {};
@@ -2751,65 +2333,7 @@ declare const __VLS_component$2: vue.DefineComponent<__VLS_Props$r, {
2751
2333
  parentValues: Record<string, any>;
2752
2334
  stepActive: string | number;
2753
2335
  height: string;
2754
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
2755
- tMagicForm: ({
2756
- $: vue.ComponentInternalInstance;
2757
- $data: {};
2758
- $props: {
2759
- readonly model?: any;
2760
- readonly labelWidth?: string | number | undefined;
2761
- readonly disabled?: boolean | undefined;
2762
- readonly inline?: boolean | undefined;
2763
- readonly labelPosition?: string | undefined;
2764
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
2765
- $attrs: {
2766
- [x: string]: unknown;
2767
- };
2768
- $refs: {
2769
- [x: string]: unknown;
2770
- } & {
2771
- form: unknown;
2772
- };
2773
- $slots: Readonly<{
2774
- [name: string]: vue.Slot<any> | undefined;
2775
- }>;
2776
- $root: vue.ComponentPublicInstance | null;
2777
- $parent: vue.ComponentPublicInstance | null;
2778
- $host: Element | null;
2779
- $emit: (event: string, ...args: any[]) => void;
2780
- $el: any;
2781
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
2782
- validate(): any;
2783
- resetFields(): any;
2784
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
2785
- beforeCreate?: (() => void) | (() => void)[];
2786
- created?: (() => void) | (() => void)[];
2787
- beforeMount?: (() => void) | (() => void)[];
2788
- mounted?: (() => void) | (() => void)[];
2789
- beforeUpdate?: (() => void) | (() => void)[];
2790
- updated?: (() => void) | (() => void)[];
2791
- activated?: (() => void) | (() => void)[];
2792
- deactivated?: (() => void) | (() => void)[];
2793
- beforeDestroy?: (() => void) | (() => void)[];
2794
- beforeUnmount?: (() => void) | (() => void)[];
2795
- destroyed?: (() => void) | (() => void)[];
2796
- unmounted?: (() => void) | (() => void)[];
2797
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2798
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2799
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2800
- };
2801
- $forceUpdate: () => void;
2802
- $nextTick: typeof vue.nextTick;
2803
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2804
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
2805
- validate(): any;
2806
- resetFields(): any;
2807
- }> & {} & vue.ComponentCustomProperties & {} & {
2808
- $slots: {
2809
- default?(_: {}): any;
2810
- };
2811
- }) | null;
2812
- }, any, vue.ComponentProvideOptions, {
2336
+ }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
2813
2337
  P: {};
2814
2338
  B: {};
2815
2339
  D: {};
@@ -2877,173 +2401,10 @@ declare const __VLS_component$2: vue.DefineComponent<__VLS_Props$r, {
2877
2401
  values: Object;
2878
2402
  config: FormConfig;
2879
2403
  confirmText: string;
2880
- }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
2881
- form: vue.CreateComponentPublicInstanceWithMixins<Readonly<{
2882
- config: FormConfig;
2883
- initValues: Record<string, any>;
2884
- lastValues?: Record<string, any>;
2885
- isCompare?: boolean;
2886
- parentValues?: Record<string, any>;
2887
- labelWidth?: string;
2888
- disabled?: boolean;
2889
- height?: string;
2890
- stepActive?: string | number;
2891
- size?: "small" | "default" | "large";
2892
- inline?: boolean;
2893
- labelPosition?: string;
2894
- keyProp?: string;
2895
- popperClass?: string;
2896
- preventSubmitDefault?: boolean;
2897
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
2898
- }> & Readonly<{
2899
- onChange?: ((...args: any[]) => any) | undefined;
2900
- onError?: ((...args: any[]) => any) | undefined;
2901
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
2902
- "onField-change"?: ((...args: any[]) => any) | undefined;
2903
- "onField-input"?: ((...args: any[]) => any) | undefined;
2904
- }>, {
2905
- values: vue.Ref<FormValue, FormValue>;
2906
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
2907
- formState: _tmagic_editor.FormState;
2908
- initialized: vue.Ref<boolean, boolean>;
2909
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
2910
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
2911
- resetForm: () => void;
2912
- submitForm: (native?: boolean) => Promise<any>;
2913
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2914
- change: (...args: any[]) => void;
2915
- error: (...args: any[]) => void;
2916
- "update:stepActive": (...args: any[]) => void;
2917
- "field-change": (...args: any[]) => void;
2918
- "field-input": (...args: any[]) => void;
2919
- }, vue.PublicProps, {
2920
- disabled: boolean;
2921
- labelWidth: string;
2922
- inline: boolean;
2923
- labelPosition: string;
2924
- config: FormConfig;
2925
- initValues: Record<string, any>;
2926
- lastValues: Record<string, any>;
2927
- isCompare: boolean;
2928
- keyProp: string;
2929
- parentValues: Record<string, any>;
2930
- stepActive: string | number;
2931
- height: string;
2932
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
2933
- tMagicForm: ({
2934
- $: vue.ComponentInternalInstance;
2935
- $data: {};
2936
- $props: {
2937
- readonly model?: any;
2938
- readonly labelWidth?: string | number | undefined;
2939
- readonly disabled?: boolean | undefined;
2940
- readonly inline?: boolean | undefined;
2941
- readonly labelPosition?: string | undefined;
2942
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
2943
- $attrs: {
2944
- [x: string]: unknown;
2945
- };
2946
- $refs: {
2947
- [x: string]: unknown;
2948
- } & {
2949
- form: unknown;
2950
- };
2951
- $slots: Readonly<{
2952
- [name: string]: vue.Slot<any> | undefined;
2953
- }>;
2954
- $root: vue.ComponentPublicInstance | null;
2955
- $parent: vue.ComponentPublicInstance | null;
2956
- $host: Element | null;
2957
- $emit: (event: string, ...args: any[]) => void;
2958
- $el: any;
2959
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
2960
- validate(): any;
2961
- resetFields(): any;
2962
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
2963
- beforeCreate?: (() => void) | (() => void)[];
2964
- created?: (() => void) | (() => void)[];
2965
- beforeMount?: (() => void) | (() => void)[];
2966
- mounted?: (() => void) | (() => void)[];
2967
- beforeUpdate?: (() => void) | (() => void)[];
2968
- updated?: (() => void) | (() => void)[];
2969
- activated?: (() => void) | (() => void)[];
2970
- deactivated?: (() => void) | (() => void)[];
2971
- beforeDestroy?: (() => void) | (() => void)[];
2972
- beforeUnmount?: (() => void) | (() => void)[];
2973
- destroyed?: (() => void) | (() => void)[];
2974
- unmounted?: (() => void) | (() => void)[];
2975
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2976
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2977
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2978
- };
2979
- $forceUpdate: () => void;
2980
- $nextTick: typeof vue.nextTick;
2981
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2982
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
2983
- validate(): any;
2984
- resetFields(): any;
2985
- }> & {} & vue.ComponentCustomProperties & {} & {
2986
- $slots: {
2987
- default?(_: {}): any;
2988
- };
2989
- }) | null;
2990
- }, any, vue.ComponentProvideOptions, {
2991
- P: {};
2992
- B: {};
2993
- D: {};
2994
- C: {};
2995
- M: {};
2996
- Defaults: {};
2997
- }, Readonly<{
2998
- config: FormConfig;
2999
- initValues: Record<string, any>;
3000
- lastValues?: Record<string, any>;
3001
- isCompare?: boolean;
3002
- parentValues?: Record<string, any>;
3003
- labelWidth?: string;
3004
- disabled?: boolean;
3005
- height?: string;
3006
- stepActive?: string | number;
3007
- size?: "small" | "default" | "large";
3008
- inline?: boolean;
3009
- labelPosition?: string;
3010
- keyProp?: string;
3011
- popperClass?: string;
3012
- preventSubmitDefault?: boolean;
3013
- extendState?: (state: _tmagic_editor.FormState) => Record<string, any> | Promise<Record<string, any>>;
3014
- }> & Readonly<{
3015
- onChange?: ((...args: any[]) => any) | undefined;
3016
- onError?: ((...args: any[]) => any) | undefined;
3017
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
3018
- "onField-change"?: ((...args: any[]) => any) | undefined;
3019
- "onField-input"?: ((...args: any[]) => any) | undefined;
3020
- }>, {
3021
- values: vue.Ref<FormValue, FormValue>;
3022
- lastValuesProcessed: vue.Ref<FormValue, FormValue>;
3023
- formState: _tmagic_editor.FormState;
3024
- initialized: vue.Ref<boolean, boolean>;
3025
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
3026
- changeHandler: (v: FormValue, eventData: ContainerChangeEventData) => void;
3027
- resetForm: () => void;
3028
- submitForm: (native?: boolean) => Promise<any>;
3029
- }, {}, {}, {}, {
3030
- disabled: boolean;
3031
- labelWidth: string;
3032
- inline: boolean;
3033
- labelPosition: string;
3034
- config: FormConfig;
3035
- initValues: Record<string, any>;
3036
- lastValues: Record<string, any>;
3037
- isCompare: boolean;
3038
- keyProp: string;
3039
- parentValues: Record<string, any>;
3040
- stepActive: string | number;
3041
- height: string;
3042
- }> | null;
3043
- }, HTMLDivElement>;
3044
- declare const _default$s: __VLS_WithTemplateSlots$2<typeof __VLS_component$2, __VLS_TemplateResult$2["slots"]>;
2404
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
2405
+ declare const _default$s: __VLS_WithSlots$2<typeof __VLS_component$2, __VLS_Slots$2>;
3045
2406
 
3046
- type __VLS_WithTemplateSlots$2<T, S> = T & {
2407
+ type __VLS_WithSlots$2<T, S> = T & {
3047
2408
  new (): {
3048
2409
  $slots: S;
3049
2410
  };
@@ -3113,16 +2474,39 @@ type __VLS_Props$o = {
3113
2474
  size?: string;
3114
2475
  disabled?: boolean;
3115
2476
  };
3116
- declare function __VLS_template$1(): {
3117
- attrs: Partial<{}>;
3118
- slots: {
3119
- header?(_: {}): any;
3120
- default?(_: {}): any;
3121
- };
3122
- refs: {};
3123
- rootEl: any;
3124
- };
3125
- type __VLS_TemplateResult$1 = ReturnType<typeof __VLS_template$1>;
2477
+ declare const mForm$1: FormState | undefined;
2478
+ declare const expand: vue.Ref<boolean, boolean>;
2479
+ declare const items: vue.ComputedRef<_tmagic_editor.FormConfig>;
2480
+ declare const filter: (config: any) => any;
2481
+ declare const changeHandler$1: (v: any, eventData: ContainerChangeEventData) => void;
2482
+ declare const onAddDiffCount$1: () => void;
2483
+ declare const __VLS_ctx$1: InstanceType<__VLS_PickNotAny<typeof __VLS_self$1, new () => {}>>;
2484
+ declare var __VLS_14: {};
2485
+ declare var __VLS_16: {};
2486
+ type __VLS_Slots$1 = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx$1.$slots> & {
2487
+ header?: (props: typeof __VLS_14) => any;
2488
+ } & {
2489
+ default?: (props: typeof __VLS_16) => any;
2490
+ }>;
2491
+ declare const __VLS_self$1: vue.DefineComponent<__VLS_Props$o, {
2492
+ CaretBottom: typeof CaretBottom;
2493
+ CaretRight: typeof CaretRight;
2494
+ TMagicButton: typeof TMagicButton;
2495
+ TMagicCard: typeof TMagicCard;
2496
+ Container: typeof _default$r;
2497
+ mForm: typeof mForm$1;
2498
+ expand: typeof expand;
2499
+ items: typeof items;
2500
+ filter: typeof filter;
2501
+ changeHandler: typeof changeHandler$1;
2502
+ onAddDiffCount: typeof onAddDiffCount$1;
2503
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2504
+ change: (v: any, eventData: ContainerChangeEventData) => any;
2505
+ addDiffCount: () => any;
2506
+ }, string, vue.PublicProps, Readonly<__VLS_Props$o> & Readonly<{
2507
+ onChange?: ((v: any, eventData: ContainerChangeEventData) => any) | undefined;
2508
+ onAddDiffCount?: (() => any) | undefined;
2509
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
3126
2510
  declare const __VLS_component$1: vue.DefineComponent<__VLS_Props$o, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
3127
2511
  change: (v: any, eventData: ContainerChangeEventData) => any;
3128
2512
  addDiffCount: () => any;
@@ -3130,9 +2514,9 @@ declare const __VLS_component$1: vue.DefineComponent<__VLS_Props$o, {}, {}, {},
3130
2514
  onChange?: ((v: any, eventData: ContainerChangeEventData) => any) | undefined;
3131
2515
  onAddDiffCount?: (() => any) | undefined;
3132
2516
  }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
3133
- declare const _default$p: __VLS_WithTemplateSlots$1<typeof __VLS_component$1, __VLS_TemplateResult$1["slots"]>;
2517
+ declare const _default$p: __VLS_WithSlots$1<typeof __VLS_component$1, __VLS_Slots$1>;
3134
2518
 
3135
- type __VLS_WithTemplateSlots$1<T, S> = T & {
2519
+ type __VLS_WithSlots$1<T, S> = T & {
3136
2520
  new (): {
3137
2521
  $slots: S;
3138
2522
  };
@@ -3197,128 +2581,321 @@ type __VLS_Props$l = {
3197
2581
  enableToggleMode?: boolean;
3198
2582
  showIndex?: boolean;
3199
2583
  };
3200
- declare function __VLS_template(): {
3201
- attrs: Partial<{}>;
3202
- slots: {
3203
- operateCol?(_: {
3204
- scope: {
3205
- $index: any;
3206
- row: any;
3207
- };
3208
- }): any;
3209
- default?(_: {}): any;
2584
+ declare const mForm: FormState | undefined;
2585
+ declare const tMagicTable: vue.Ref<({
2586
+ $: vue.ComponentInternalInstance;
2587
+ $data: {};
2588
+ $props: {
2589
+ readonly data?: any[] | undefined;
2590
+ readonly border?: boolean | undefined;
2591
+ readonly maxHeight?: number | string | undefined;
2592
+ readonly defaultExpandAll?: boolean | undefined;
2593
+ readonly onSelect?: ((...args: any[]) => any) | undefined;
2594
+ readonly "onSort-change"?: ((...args: any[]) => any) | undefined;
2595
+ readonly "onExpand-change"?: ((...args: any[]) => any) | undefined;
2596
+ readonly "onCell-click"?: ((...args: any[]) => any) | undefined;
2597
+ } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
2598
+ $attrs: {
2599
+ [x: string]: unknown;
2600
+ };
2601
+ $refs: {
2602
+ [x: string]: unknown;
2603
+ };
2604
+ $slots: Readonly<{
2605
+ [name: string]: vue.Slot<any> | undefined;
2606
+ }>;
2607
+ $root: vue.ComponentPublicInstance | null;
2608
+ $parent: vue.ComponentPublicInstance | null;
2609
+ $host: Element | null;
2610
+ $emit: ((event: "select", ...args: any[]) => void) & ((event: "sort-change", ...args: any[]) => void) & ((event: "expand-change", ...args: any[]) => void) & ((event: "cell-click", ...args: any[]) => void);
2611
+ $el: any;
2612
+ $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.TableProps> & Readonly<{
2613
+ onSelect?: ((...args: any[]) => any) | undefined;
2614
+ "onSort-change"?: ((...args: any[]) => any) | undefined;
2615
+ "onExpand-change"?: ((...args: any[]) => any) | undefined;
2616
+ "onCell-click"?: ((...args: any[]) => any) | undefined;
2617
+ }>, {
2618
+ instance: vue.Ref<any, any>;
2619
+ $el: HTMLDivElement | undefined;
2620
+ clearSelection(...args: any[]): any;
2621
+ toggleRowSelection(...args: any[]): any;
2622
+ toggleRowExpansion(...args: any[]): any;
2623
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2624
+ select: (...args: any[]) => void;
2625
+ "sort-change": (...args: any[]) => void;
2626
+ "expand-change": (...args: any[]) => void;
2627
+ "cell-click": (...args: any[]) => void;
2628
+ }, string, {
2629
+ data: any[];
2630
+ }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
2631
+ beforeCreate?: (() => void) | (() => void)[];
2632
+ created?: (() => void) | (() => void)[];
2633
+ beforeMount?: (() => void) | (() => void)[];
2634
+ mounted?: (() => void) | (() => void)[];
2635
+ beforeUpdate?: (() => void) | (() => void)[];
2636
+ updated?: (() => void) | (() => void)[];
2637
+ activated?: (() => void) | (() => void)[];
2638
+ deactivated?: (() => void) | (() => void)[];
2639
+ beforeDestroy?: (() => void) | (() => void)[];
2640
+ beforeUnmount?: (() => void) | (() => void)[];
2641
+ destroyed?: (() => void) | (() => void)[];
2642
+ unmounted?: (() => void) | (() => void)[];
2643
+ renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2644
+ renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2645
+ errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2646
+ };
2647
+ $forceUpdate: () => void;
2648
+ $nextTick: typeof vue.nextTick;
2649
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2650
+ } & Readonly<{
2651
+ data: any[];
2652
+ }> & Omit<Readonly<_tmagic_design.TableProps> & Readonly<{
2653
+ onSelect?: ((...args: any[]) => any) | undefined;
2654
+ "onSort-change"?: ((...args: any[]) => any) | undefined;
2655
+ "onExpand-change"?: ((...args: any[]) => any) | undefined;
2656
+ "onCell-click"?: ((...args: any[]) => any) | undefined;
2657
+ }>, "instance" | "data" | "$el" | "clearSelection" | "toggleRowSelection" | "toggleRowExpansion"> & vue.ShallowUnwrapRef<{
2658
+ instance: vue.Ref<any, any>;
2659
+ $el: HTMLDivElement | undefined;
2660
+ clearSelection(...args: any[]): any;
2661
+ toggleRowSelection(...args: any[]): any;
2662
+ toggleRowExpansion(...args: any[]): any;
2663
+ }> & {} & vue.ComponentCustomProperties & {} & {
2664
+ $slots: {
2665
+ default?: ((props: {}) => any) | undefined;
2666
+ };
2667
+ }) | undefined, ({
2668
+ $: vue.ComponentInternalInstance;
2669
+ $data: {};
2670
+ $props: {
2671
+ readonly data?: any[] | undefined;
2672
+ readonly border?: boolean | undefined;
2673
+ readonly maxHeight?: number | string | undefined;
2674
+ readonly defaultExpandAll?: boolean | undefined;
2675
+ readonly onSelect?: ((...args: any[]) => any) | undefined;
2676
+ readonly "onSort-change"?: ((...args: any[]) => any) | undefined;
2677
+ readonly "onExpand-change"?: ((...args: any[]) => any) | undefined;
2678
+ readonly "onCell-click"?: ((...args: any[]) => any) | undefined;
2679
+ } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
2680
+ $attrs: {
2681
+ [x: string]: unknown;
2682
+ };
2683
+ $refs: {
2684
+ [x: string]: unknown;
2685
+ };
2686
+ $slots: Readonly<{
2687
+ [name: string]: vue.Slot<any> | undefined;
2688
+ }>;
2689
+ $root: vue.ComponentPublicInstance | null;
2690
+ $parent: vue.ComponentPublicInstance | null;
2691
+ $host: Element | null;
2692
+ $emit: ((event: "select", ...args: any[]) => void) & ((event: "sort-change", ...args: any[]) => void) & ((event: "expand-change", ...args: any[]) => void) & ((event: "cell-click", ...args: any[]) => void);
2693
+ $el: any;
2694
+ $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.TableProps> & Readonly<{
2695
+ onSelect?: ((...args: any[]) => any) | undefined;
2696
+ "onSort-change"?: ((...args: any[]) => any) | undefined;
2697
+ "onExpand-change"?: ((...args: any[]) => any) | undefined;
2698
+ "onCell-click"?: ((...args: any[]) => any) | undefined;
2699
+ }>, {
2700
+ instance: vue.Ref<any, any>;
2701
+ $el: HTMLDivElement | undefined;
2702
+ clearSelection(...args: any[]): any;
2703
+ toggleRowSelection(...args: any[]): any;
2704
+ toggleRowExpansion(...args: any[]): any;
2705
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2706
+ select: (...args: any[]) => void;
2707
+ "sort-change": (...args: any[]) => void;
2708
+ "expand-change": (...args: any[]) => void;
2709
+ "cell-click": (...args: any[]) => void;
2710
+ }, string, {
2711
+ data: any[];
2712
+ }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
2713
+ beforeCreate?: (() => void) | (() => void)[];
2714
+ created?: (() => void) | (() => void)[];
2715
+ beforeMount?: (() => void) | (() => void)[];
2716
+ mounted?: (() => void) | (() => void)[];
2717
+ beforeUpdate?: (() => void) | (() => void)[];
2718
+ updated?: (() => void) | (() => void)[];
2719
+ activated?: (() => void) | (() => void)[];
2720
+ deactivated?: (() => void) | (() => void)[];
2721
+ beforeDestroy?: (() => void) | (() => void)[];
2722
+ beforeUnmount?: (() => void) | (() => void)[];
2723
+ destroyed?: (() => void) | (() => void)[];
2724
+ unmounted?: (() => void) | (() => void)[];
2725
+ renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2726
+ renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
2727
+ errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
2728
+ };
2729
+ $forceUpdate: () => void;
2730
+ $nextTick: typeof vue.nextTick;
2731
+ $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
2732
+ } & Readonly<{
2733
+ data: any[];
2734
+ }> & Omit<Readonly<_tmagic_design.TableProps> & Readonly<{
2735
+ onSelect?: ((...args: any[]) => any) | undefined;
2736
+ "onSort-change"?: ((...args: any[]) => any) | undefined;
2737
+ "onExpand-change"?: ((...args: any[]) => any) | undefined;
2738
+ "onCell-click"?: ((...args: any[]) => any) | undefined;
2739
+ }>, "instance" | "data" | "$el" | "clearSelection" | "toggleRowSelection" | "toggleRowExpansion"> & vue.ShallowUnwrapRef<{
2740
+ instance: vue.Ref<any, any>;
2741
+ $el: HTMLDivElement | undefined;
2742
+ clearSelection(...args: any[]): any;
2743
+ toggleRowSelection(...args: any[]): any;
2744
+ toggleRowExpansion(...args: any[]): any;
2745
+ }> & {} & vue.ComponentCustomProperties & {} & {
2746
+ $slots: {
2747
+ default?: ((props: {}) => any) | undefined;
3210
2748
  };
3211
- refs: {
3212
- mTable: HTMLDivElement;
3213
- tMagicTable: ({
3214
- $: vue.ComponentInternalInstance;
3215
- $data: {};
3216
- $props: {
3217
- readonly data?: any[] | undefined;
3218
- readonly border?: boolean | undefined;
3219
- readonly maxHeight?: number | string | undefined;
3220
- readonly defaultExpandAll?: boolean | undefined;
3221
- readonly onSelect?: ((...args: any[]) => any) | undefined;
3222
- readonly "onSort-change"?: ((...args: any[]) => any) | undefined;
3223
- readonly "onExpand-change"?: ((...args: any[]) => any) | undefined;
3224
- readonly "onCell-click"?: ((...args: any[]) => any) | undefined;
3225
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
3226
- $attrs: {
3227
- [x: string]: unknown;
3228
- };
3229
- $refs: {
3230
- [x: string]: unknown;
3231
- } & {
3232
- table: unknown;
3233
- };
3234
- $slots: Readonly<{
3235
- [name: string]: vue.Slot<any> | undefined;
3236
- }>;
3237
- $root: vue.ComponentPublicInstance | null;
3238
- $parent: vue.ComponentPublicInstance | null;
3239
- $host: Element | null;
3240
- $emit: ((event: "select", ...args: any[]) => void) & ((event: "sort-change", ...args: any[]) => void) & ((event: "expand-change", ...args: any[]) => void) & ((event: "cell-click", ...args: any[]) => void);
3241
- $el: any;
3242
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.TableProps> & Readonly<{
3243
- onSelect?: ((...args: any[]) => any) | undefined;
3244
- "onSort-change"?: ((...args: any[]) => any) | undefined;
3245
- "onExpand-change"?: ((...args: any[]) => any) | undefined;
3246
- "onCell-click"?: ((...args: any[]) => any) | undefined;
3247
- }>, {
3248
- instance: vue.Ref<any, any>;
3249
- $el: HTMLDivElement | undefined;
3250
- clearSelection(...args: any[]): any;
3251
- toggleRowSelection(...args: any[]): any;
3252
- toggleRowExpansion(...args: any[]): any;
3253
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
3254
- select: (...args: any[]) => void;
3255
- "sort-change": (...args: any[]) => void;
3256
- "expand-change": (...args: any[]) => void;
3257
- "cell-click": (...args: any[]) => void;
3258
- }, string, {
3259
- data: any[];
3260
- }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
3261
- beforeCreate?: (() => void) | (() => void)[];
3262
- created?: (() => void) | (() => void)[];
3263
- beforeMount?: (() => void) | (() => void)[];
3264
- mounted?: (() => void) | (() => void)[];
3265
- beforeUpdate?: (() => void) | (() => void)[];
3266
- updated?: (() => void) | (() => void)[];
3267
- activated?: (() => void) | (() => void)[];
3268
- deactivated?: (() => void) | (() => void)[];
3269
- beforeDestroy?: (() => void) | (() => void)[];
3270
- beforeUnmount?: (() => void) | (() => void)[];
3271
- destroyed?: (() => void) | (() => void)[];
3272
- unmounted?: (() => void) | (() => void)[];
3273
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3274
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3275
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
3276
- };
3277
- $forceUpdate: () => void;
3278
- $nextTick: typeof vue.nextTick;
3279
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
3280
- } & Readonly<{
3281
- data: any[];
3282
- }> & Omit<Readonly<_tmagic_design.TableProps> & Readonly<{
3283
- onSelect?: ((...args: any[]) => any) | undefined;
3284
- "onSort-change"?: ((...args: any[]) => any) | undefined;
3285
- "onExpand-change"?: ((...args: any[]) => any) | undefined;
3286
- "onCell-click"?: ((...args: any[]) => any) | undefined;
3287
- }>, "instance" | "data" | "$el" | "clearSelection" | "toggleRowSelection" | "toggleRowExpansion"> & vue.ShallowUnwrapRef<{
3288
- instance: vue.Ref<any, any>;
3289
- $el: HTMLDivElement | undefined;
3290
- clearSelection(...args: any[]): any;
3291
- toggleRowSelection(...args: any[]): any;
3292
- toggleRowExpansion(...args: any[]): any;
3293
- }> & {} & vue.ComponentCustomProperties & {} & {
3294
- $slots: {
3295
- default?(_: {}): any;
3296
- };
3297
- }) | null;
3298
- excelBtn: vue.CreateComponentPublicInstanceWithMixins<Readonly<_tmagic_design.UploadProps> & Readonly<{
3299
- onChange?: ((...args: any[]) => any) | undefined;
3300
- }>, {
3301
- clearFiles(...args: any[]): any;
3302
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
3303
- change: (...args: any[]) => void;
3304
- }, vue.PublicProps, {}, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
3305
- upload: unknown;
3306
- }, any, vue.ComponentProvideOptions, {
3307
- P: {};
3308
- B: {};
3309
- D: {};
3310
- C: {};
3311
- M: {};
3312
- Defaults: {};
3313
- }, Readonly<_tmagic_design.UploadProps> & Readonly<{
3314
- onChange?: ((...args: any[]) => any) | undefined;
3315
- }>, {
3316
- clearFiles(...args: any[]): any;
3317
- }, {}, {}, {}, {}> | null;
2749
+ }) | undefined>;
2750
+ declare const excelBtn: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<_tmagic_design.UploadProps> & Readonly<{
2751
+ onChange?: ((...args: any[]) => any) | undefined;
2752
+ }>, {
2753
+ clearFiles(...args: any[]): any;
2754
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2755
+ change: (...args: any[]) => void;
2756
+ }, vue.PublicProps, {}, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
2757
+ P: {};
2758
+ B: {};
2759
+ D: {};
2760
+ C: {};
2761
+ M: {};
2762
+ Defaults: {};
2763
+ }, Readonly<_tmagic_design.UploadProps> & Readonly<{
2764
+ onChange?: ((...args: any[]) => any) | undefined;
2765
+ }>, {
2766
+ clearFiles(...args: any[]): any;
2767
+ }, {}, {}, {}, {}> | undefined, vue.CreateComponentPublicInstanceWithMixins<Readonly<_tmagic_design.UploadProps> & Readonly<{
2768
+ onChange?: ((...args: any[]) => any) | undefined;
2769
+ }>, {
2770
+ clearFiles(...args: any[]): any;
2771
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2772
+ change: (...args: any[]) => void;
2773
+ }, vue.PublicProps, {}, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {}, any, vue.ComponentProvideOptions, {
2774
+ P: {};
2775
+ B: {};
2776
+ D: {};
2777
+ C: {};
2778
+ M: {};
2779
+ Defaults: {};
2780
+ }, Readonly<_tmagic_design.UploadProps> & Readonly<{
2781
+ onChange?: ((...args: any[]) => any) | undefined;
2782
+ }>, {
2783
+ clearFiles(...args: any[]): any;
2784
+ }, {}, {}, {}, {}> | undefined>;
2785
+ declare const mTable: vue.Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
2786
+ declare const pagesize: vue.Ref<number, number>;
2787
+ declare const pagecontext: vue.Ref<number, number>;
2788
+ declare const updateKey: vue.Ref<number, number>;
2789
+ declare const isFullscreen: vue.Ref<boolean, boolean>;
2790
+ declare const modelName: vue.ComputedRef<string | number>;
2791
+ declare const data: vue.ComputedRef<any>;
2792
+ declare const lastData: vue.ComputedRef<any>;
2793
+ declare const sortChange: ({ prop, order }: SortProp) => void;
2794
+ declare const newHandler: (row?: any) => Promise<void>;
2795
+ declare const addable: vue.ComputedRef<boolean | "undefined">;
2796
+ declare const selection: vue.ComputedRef<boolean | "single" | undefined>;
2797
+ declare const importable: vue.ComputedRef<boolean | "undefined">;
2798
+ declare const display: (fuc: any) => any;
2799
+ declare const itemExtra: (fuc: any, index: number) => any;
2800
+ declare const removeHandler: (index: number) => void;
2801
+ declare const selectHandle: (selection: any, row: any) => void;
2802
+ declare const makeConfig: (config: TableColumnConfig, row: any) => TableColumnConfig;
2803
+ declare const upHandler: (index: number) => void;
2804
+ declare const topHandler: (index: number) => void;
2805
+ declare const downHandler: (index: number) => void;
2806
+ declare const bottomHandler: (index: number) => void;
2807
+ declare const showDelete: (index: number) => boolean;
2808
+ declare const copyable: (index: number) => boolean;
2809
+ declare const clearHandler: () => void;
2810
+ declare const excelHandler: (file: any) => Promise<boolean>;
2811
+ declare const handleSizeChange: (val: number) => void;
2812
+ declare const handleCurrentChange: (val: number) => void;
2813
+ declare const copyHandler: (index: number) => void;
2814
+ declare const toggleMode: () => void;
2815
+ declare const toggleFullscreen: () => void;
2816
+ declare const getProp: (index: number) => string;
2817
+ declare const onAddDiffCount: () => void;
2818
+ declare const changeHandler: (v: any, eventData: ContainerChangeEventData) => void;
2819
+ declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
2820
+ declare var __VLS_28: {
2821
+ scope: {
2822
+ $index: any;
2823
+ row: any;
3318
2824
  };
3319
- rootEl: HTMLDivElement;
3320
2825
  };
3321
- type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
2826
+ declare var __VLS_96: {};
2827
+ type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
2828
+ operateCol?: (props: typeof __VLS_28) => any;
2829
+ } & {
2830
+ default?: (props: typeof __VLS_96) => any;
2831
+ }>;
2832
+ declare const __VLS_self: vue.DefineComponent<__VLS_Props$l, {
2833
+ ArrowDown: typeof ArrowDown;
2834
+ ArrowUp: typeof ArrowUp;
2835
+ Delete: typeof Delete;
2836
+ DocumentCopy: typeof DocumentCopy;
2837
+ FullScreen: typeof FullScreen;
2838
+ Grid: typeof Grid;
2839
+ TMagicButton: typeof TMagicButton;
2840
+ TMagicPagination: typeof TMagicPagination;
2841
+ TMagicTable: typeof TMagicTable;
2842
+ TMagicTableColumn: typeof TMagicTableColumn;
2843
+ TMagicTooltip: typeof TMagicTooltip;
2844
+ TMagicUpload: typeof TMagicUpload;
2845
+ Container: typeof _default$r;
2846
+ mForm: typeof mForm;
2847
+ tMagicTable: typeof tMagicTable;
2848
+ excelBtn: typeof excelBtn;
2849
+ mTable: typeof mTable;
2850
+ pagesize: typeof pagesize;
2851
+ pagecontext: typeof pagecontext;
2852
+ updateKey: typeof updateKey;
2853
+ isFullscreen: typeof isFullscreen;
2854
+ modelName: typeof modelName;
2855
+ data: typeof data;
2856
+ lastData: typeof lastData;
2857
+ sortChange: typeof sortChange;
2858
+ newHandler: typeof newHandler;
2859
+ addable: typeof addable;
2860
+ selection: typeof selection;
2861
+ importable: typeof importable;
2862
+ display: typeof display;
2863
+ itemExtra: typeof itemExtra;
2864
+ removeHandler: typeof removeHandler;
2865
+ selectHandle: typeof selectHandle;
2866
+ makeConfig: typeof makeConfig;
2867
+ upHandler: typeof upHandler;
2868
+ topHandler: typeof topHandler;
2869
+ downHandler: typeof downHandler;
2870
+ bottomHandler: typeof bottomHandler;
2871
+ showDelete: typeof showDelete;
2872
+ copyable: typeof copyable;
2873
+ clearHandler: typeof clearHandler;
2874
+ excelHandler: typeof excelHandler;
2875
+ handleSizeChange: typeof handleSizeChange;
2876
+ handleCurrentChange: typeof handleCurrentChange;
2877
+ copyHandler: typeof copyHandler;
2878
+ toggleMode: typeof toggleMode;
2879
+ toggleFullscreen: typeof toggleFullscreen;
2880
+ getProp: typeof getProp;
2881
+ onAddDiffCount: typeof onAddDiffCount;
2882
+ changeHandler: typeof changeHandler;
2883
+ }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
2884
+ change: (...args: any[]) => void;
2885
+ select: (...args: any[]) => void;
2886
+ addDiffCount: (...args: any[]) => void;
2887
+ }, string, vue.PublicProps, Readonly<__VLS_Props$l> & Readonly<{
2888
+ onChange?: ((...args: any[]) => any) | undefined;
2889
+ onSelect?: ((...args: any[]) => any) | undefined;
2890
+ onAddDiffCount?: ((...args: any[]) => any) | undefined;
2891
+ }>, {
2892
+ prop: string;
2893
+ lastValues: any;
2894
+ isCompare: boolean;
2895
+ enableToggleMode: boolean;
2896
+ showIndex: boolean;
2897
+ sortKey: string;
2898
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
3322
2899
  declare const __VLS_component: vue.DefineComponent<__VLS_Props$l, {
3323
2900
  toggleRowSelection: (row: any, selected: boolean) => void;
3324
2901
  }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
@@ -3336,117 +2913,10 @@ declare const __VLS_component: vue.DefineComponent<__VLS_Props$l, {
3336
2913
  enableToggleMode: boolean;
3337
2914
  showIndex: boolean;
3338
2915
  sortKey: string;
3339
- }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
3340
- mTable: HTMLDivElement;
3341
- tMagicTable: ({
3342
- $: vue.ComponentInternalInstance;
3343
- $data: {};
3344
- $props: {
3345
- readonly data?: any[] | undefined;
3346
- readonly border?: boolean | undefined;
3347
- readonly maxHeight?: number | string | undefined;
3348
- readonly defaultExpandAll?: boolean | undefined;
3349
- readonly onSelect?: ((...args: any[]) => any) | undefined;
3350
- readonly "onSort-change"?: ((...args: any[]) => any) | undefined;
3351
- readonly "onExpand-change"?: ((...args: any[]) => any) | undefined;
3352
- readonly "onCell-click"?: ((...args: any[]) => any) | undefined;
3353
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
3354
- $attrs: {
3355
- [x: string]: unknown;
3356
- };
3357
- $refs: {
3358
- [x: string]: unknown;
3359
- } & {
3360
- table: unknown;
3361
- };
3362
- $slots: Readonly<{
3363
- [name: string]: vue.Slot<any> | undefined;
3364
- }>;
3365
- $root: vue.ComponentPublicInstance | null;
3366
- $parent: vue.ComponentPublicInstance | null;
3367
- $host: Element | null;
3368
- $emit: ((event: "select", ...args: any[]) => void) & ((event: "sort-change", ...args: any[]) => void) & ((event: "expand-change", ...args: any[]) => void) & ((event: "cell-click", ...args: any[]) => void);
3369
- $el: any;
3370
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.TableProps> & Readonly<{
3371
- onSelect?: ((...args: any[]) => any) | undefined;
3372
- "onSort-change"?: ((...args: any[]) => any) | undefined;
3373
- "onExpand-change"?: ((...args: any[]) => any) | undefined;
3374
- "onCell-click"?: ((...args: any[]) => any) | undefined;
3375
- }>, {
3376
- instance: vue.Ref<any, any>;
3377
- $el: HTMLDivElement | undefined;
3378
- clearSelection(...args: any[]): any;
3379
- toggleRowSelection(...args: any[]): any;
3380
- toggleRowExpansion(...args: any[]): any;
3381
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
3382
- select: (...args: any[]) => void;
3383
- "sort-change": (...args: any[]) => void;
3384
- "expand-change": (...args: any[]) => void;
3385
- "cell-click": (...args: any[]) => void;
3386
- }, string, {
3387
- data: any[];
3388
- }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
3389
- beforeCreate?: (() => void) | (() => void)[];
3390
- created?: (() => void) | (() => void)[];
3391
- beforeMount?: (() => void) | (() => void)[];
3392
- mounted?: (() => void) | (() => void)[];
3393
- beforeUpdate?: (() => void) | (() => void)[];
3394
- updated?: (() => void) | (() => void)[];
3395
- activated?: (() => void) | (() => void)[];
3396
- deactivated?: (() => void) | (() => void)[];
3397
- beforeDestroy?: (() => void) | (() => void)[];
3398
- beforeUnmount?: (() => void) | (() => void)[];
3399
- destroyed?: (() => void) | (() => void)[];
3400
- unmounted?: (() => void) | (() => void)[];
3401
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3402
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3403
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
3404
- };
3405
- $forceUpdate: () => void;
3406
- $nextTick: typeof vue.nextTick;
3407
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
3408
- } & Readonly<{
3409
- data: any[];
3410
- }> & Omit<Readonly<_tmagic_design.TableProps> & Readonly<{
3411
- onSelect?: ((...args: any[]) => any) | undefined;
3412
- "onSort-change"?: ((...args: any[]) => any) | undefined;
3413
- "onExpand-change"?: ((...args: any[]) => any) | undefined;
3414
- "onCell-click"?: ((...args: any[]) => any) | undefined;
3415
- }>, "instance" | "data" | "$el" | "clearSelection" | "toggleRowSelection" | "toggleRowExpansion"> & vue.ShallowUnwrapRef<{
3416
- instance: vue.Ref<any, any>;
3417
- $el: HTMLDivElement | undefined;
3418
- clearSelection(...args: any[]): any;
3419
- toggleRowSelection(...args: any[]): any;
3420
- toggleRowExpansion(...args: any[]): any;
3421
- }> & {} & vue.ComponentCustomProperties & {} & {
3422
- $slots: {
3423
- default?(_: {}): any;
3424
- };
3425
- }) | null;
3426
- excelBtn: vue.CreateComponentPublicInstanceWithMixins<Readonly<_tmagic_design.UploadProps> & Readonly<{
3427
- onChange?: ((...args: any[]) => any) | undefined;
3428
- }>, {
3429
- clearFiles(...args: any[]): any;
3430
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
3431
- change: (...args: any[]) => void;
3432
- }, vue.PublicProps, {}, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
3433
- upload: unknown;
3434
- }, any, vue.ComponentProvideOptions, {
3435
- P: {};
3436
- B: {};
3437
- D: {};
3438
- C: {};
3439
- M: {};
3440
- Defaults: {};
3441
- }, Readonly<_tmagic_design.UploadProps> & Readonly<{
3442
- onChange?: ((...args: any[]) => any) | undefined;
3443
- }>, {
3444
- clearFiles(...args: any[]): any;
3445
- }, {}, {}, {}, {}> | null;
3446
- }, HTMLDivElement>;
3447
- declare const _default$m: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
2916
+ }, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
2917
+ declare const _default$m: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
3448
2918
 
3449
- type __VLS_WithTemplateSlots<T, S> = T & {
2919
+ type __VLS_WithSlots<T, S> = T & {
3450
2920
  new (): {
3451
2921
  $slots: S;
3452
2922
  };
@@ -3469,7 +2939,7 @@ declare const _default$l: vue.DefineComponent<__VLS_Props$k, {}, {}, {}, {}, vue
3469
2939
  }, string, vue.PublicProps, Readonly<__VLS_Props$k> & Readonly<{
3470
2940
  onChange?: ((v: any, eventData?: ContainerChangeEventData | undefined) => any) | undefined;
3471
2941
  onAddDiffCount?: (() => any) | undefined;
3472
- }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;
2942
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
3473
2943
 
3474
2944
  type __VLS_Props$j = FieldProps<TextConfig>;
3475
2945
  declare const _default$k: vue.DefineComponent<__VLS_Props$j, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
@@ -3478,88 +2948,7 @@ declare const _default$k: vue.DefineComponent<__VLS_Props$j, {}, {}, {}, {}, vue
3478
2948
  }, string, vue.PublicProps, Readonly<__VLS_Props$j> & Readonly<{
3479
2949
  onChange?: ((value: string) => any) | undefined;
3480
2950
  onInput?: ((value: string) => any) | undefined;
3481
- }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
3482
- input: ({
3483
- $: vue.ComponentInternalInstance;
3484
- $data: {};
3485
- $props: {
3486
- readonly modelValue?: string | number | undefined;
3487
- readonly clearable?: boolean | undefined;
3488
- readonly disabled?: boolean | undefined;
3489
- readonly placeholder?: string | undefined;
3490
- readonly rows?: number | undefined;
3491
- readonly type?: string | undefined;
3492
- readonly size?: _tmagic_design.FieldSize | undefined;
3493
- readonly onChange?: ((...args: any[]) => any) | undefined;
3494
- readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
3495
- readonly onInput?: ((...args: any[]) => any) | undefined;
3496
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
3497
- $attrs: {
3498
- [x: string]: unknown;
3499
- };
3500
- $refs: {
3501
- [x: string]: unknown;
3502
- } & {
3503
- instance: unknown;
3504
- };
3505
- $slots: Readonly<{
3506
- [name: string]: vue.Slot<any> | undefined;
3507
- }>;
3508
- $root: vue.ComponentPublicInstance | null;
3509
- $parent: vue.ComponentPublicInstance | null;
3510
- $host: Element | null;
3511
- $emit: ((event: "change", ...args: any[]) => void) & ((event: "update:modelValue", ...args: any[]) => void) & ((event: "input", ...args: any[]) => void);
3512
- $el: any;
3513
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.InputProps> & Readonly<{
3514
- onChange?: ((...args: any[]) => any) | undefined;
3515
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
3516
- onInput?: ((...args: any[]) => any) | undefined;
3517
- }>, {
3518
- instance: vue.Ref<any, any>;
3519
- getInput(): any;
3520
- getTextarea(): any;
3521
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
3522
- change: (...args: any[]) => void;
3523
- "update:modelValue": (...args: any[]) => void;
3524
- input: (...args: any[]) => void;
3525
- }, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
3526
- beforeCreate?: (() => void) | (() => void)[];
3527
- created?: (() => void) | (() => void)[];
3528
- beforeMount?: (() => void) | (() => void)[];
3529
- mounted?: (() => void) | (() => void)[];
3530
- beforeUpdate?: (() => void) | (() => void)[];
3531
- updated?: (() => void) | (() => void)[];
3532
- activated?: (() => void) | (() => void)[];
3533
- deactivated?: (() => void) | (() => void)[];
3534
- beforeDestroy?: (() => void) | (() => void)[];
3535
- beforeUnmount?: (() => void) | (() => void)[];
3536
- destroyed?: (() => void) | (() => void)[];
3537
- unmounted?: (() => void) | (() => void)[];
3538
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3539
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3540
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
3541
- };
3542
- $forceUpdate: () => void;
3543
- $nextTick: typeof vue.nextTick;
3544
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
3545
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.InputProps> & Readonly<{
3546
- onChange?: ((...args: any[]) => any) | undefined;
3547
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
3548
- onInput?: ((...args: any[]) => any) | undefined;
3549
- }>, "instance" | "getInput" | "getTextarea"> & vue.ShallowUnwrapRef<{
3550
- instance: vue.Ref<any, any>;
3551
- getInput(): any;
3552
- getTextarea(): any;
3553
- }> & {} & vue.ComponentCustomProperties & {} & {
3554
- $slots: {
3555
- prepend?(_: {}): any;
3556
- append?(_: {}): any;
3557
- prefix?(_: {}): any;
3558
- suffix?(_: {}): any;
3559
- };
3560
- }) | null;
3561
- popoverEl: HTMLDivElement;
3562
- }, HTMLDivElement>;
2951
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
3563
2952
 
3564
2953
  type __VLS_Props$i = FieldProps<NumberConfig>;
3565
2954
  declare const _default$j: vue.DefineComponent<__VLS_Props$i, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
@@ -3575,7 +2964,7 @@ declare const _default$i: vue.DefineComponent<__VLS_Props$h, {}, {}, {}, {}, vue
3575
2964
  change: (values: [number, number]) => any;
3576
2965
  }, string, vue.PublicProps, Readonly<__VLS_Props$h> & Readonly<{
3577
2966
  onChange?: ((values: [number, number]) => any) | undefined;
3578
- }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;
2967
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
3579
2968
 
3580
2969
  type __VLS_Props$g = FieldProps<TextareaConfig>;
3581
2970
  declare const _default$h: vue.DefineComponent<__VLS_Props$g, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
@@ -3667,1083 +3056,28 @@ declare const _default$4: vue.DefineComponent<__VLS_Props$3, {}, {}, {}, {}, vue
3667
3056
  change: (...args: any[]) => void;
3668
3057
  }, string, vue.PublicProps, Readonly<__VLS_Props$3> & Readonly<{
3669
3058
  onChange?: ((...args: any[]) => any) | undefined;
3670
- }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
3671
- editor: ({
3672
- $: vue.ComponentInternalInstance;
3673
- $data: {};
3674
- $props: {
3675
- readonly config?: _tmagic_editor.FormConfig | undefined;
3676
- readonly values?: Object | undefined;
3677
- readonly parentValues?: Object | undefined;
3678
- readonly width?: string | number | undefined;
3679
- readonly labelWidth?: string | undefined;
3680
- readonly fullscreen?: boolean | undefined;
3681
- readonly disabled?: boolean | undefined;
3682
- readonly title?: string | undefined;
3683
- readonly inline?: boolean | undefined;
3684
- readonly labelPosition?: string | undefined;
3685
- readonly zIndex?: number | undefined;
3686
- readonly size?: "small" | "default" | "large" | undefined;
3687
- readonly confirmText?: string | undefined;
3688
- readonly preventSubmitDefault?: boolean | undefined;
3689
- readonly onChange?: ((...args: any[]) => any) | undefined;
3690
- readonly onClose?: ((...args: any[]) => any) | undefined;
3691
- readonly onError?: ((...args: any[]) => any) | undefined;
3692
- readonly onSubmit?: ((...args: any[]) => any) | undefined;
3693
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
3694
- $attrs: {
3695
- [x: string]: unknown;
3696
- };
3697
- $refs: {
3698
- [x: string]: unknown;
3699
- } & {
3700
- form: vue.CreateComponentPublicInstanceWithMixins<Readonly<{
3701
- config: _tmagic_editor.FormConfig;
3702
- initValues: Record<string, any>;
3703
- lastValues?: Record<string, any>;
3704
- isCompare?: boolean;
3705
- parentValues?: Record<string, any>;
3706
- labelWidth?: string;
3707
- disabled?: boolean;
3708
- height?: string;
3709
- stepActive?: string | number;
3710
- size?: "small" | "default" | "large";
3711
- inline?: boolean;
3712
- labelPosition?: string;
3713
- keyProp?: string;
3714
- popperClass?: string;
3715
- preventSubmitDefault?: boolean;
3716
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
3717
- }> & Readonly<{
3718
- onChange?: ((...args: any[]) => any) | undefined;
3719
- onError?: ((...args: any[]) => any) | undefined;
3720
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
3721
- "onField-change"?: ((...args: any[]) => any) | undefined;
3722
- "onField-input"?: ((...args: any[]) => any) | undefined;
3723
- }>, {
3724
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
3725
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
3726
- formState: FormState;
3727
- initialized: vue.Ref<boolean, boolean>;
3728
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
3729
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
3730
- resetForm: () => void;
3731
- submitForm: (native?: boolean) => Promise<any>;
3732
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
3733
- change: (...args: any[]) => void;
3734
- error: (...args: any[]) => void;
3735
- "update:stepActive": (...args: any[]) => void;
3736
- "field-change": (...args: any[]) => void;
3737
- "field-input": (...args: any[]) => void;
3738
- }, vue.PublicProps, {
3739
- disabled: boolean;
3740
- labelWidth: string;
3741
- inline: boolean;
3742
- labelPosition: string;
3743
- config: _tmagic_editor.FormConfig;
3744
- initValues: Record<string, any>;
3745
- lastValues: Record<string, any>;
3746
- isCompare: boolean;
3747
- keyProp: string;
3748
- parentValues: Record<string, any>;
3749
- stepActive: string | number;
3750
- height: string;
3751
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
3752
- tMagicForm: ({
3753
- $: vue.ComponentInternalInstance;
3754
- $data: {};
3755
- $props: {
3756
- readonly model?: any;
3757
- readonly labelWidth?: string | number | undefined;
3758
- readonly disabled?: boolean | undefined;
3759
- readonly inline?: boolean | undefined;
3760
- readonly labelPosition?: string | undefined;
3761
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
3762
- $attrs: {
3763
- [x: string]: unknown;
3764
- };
3765
- $refs: {
3766
- [x: string]: unknown;
3767
- } & {
3768
- form: unknown;
3769
- };
3770
- $slots: Readonly<{
3771
- [name: string]: vue.Slot<any> | undefined;
3772
- }>;
3773
- $root: vue.ComponentPublicInstance | null;
3774
- $parent: vue.ComponentPublicInstance | null;
3775
- $host: Element | null;
3776
- $emit: (event: string, ...args: any[]) => void;
3777
- $el: any;
3778
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
3779
- validate(): any;
3780
- resetFields(): any;
3781
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
3782
- beforeCreate?: (() => void) | (() => void)[];
3783
- created?: (() => void) | (() => void)[];
3784
- beforeMount?: (() => void) | (() => void)[];
3785
- mounted?: (() => void) | (() => void)[];
3786
- beforeUpdate?: (() => void) | (() => void)[];
3787
- updated?: (() => void) | (() => void)[];
3788
- activated?: (() => void) | (() => void)[];
3789
- deactivated?: (() => void) | (() => void)[];
3790
- beforeDestroy?: (() => void) | (() => void)[];
3791
- beforeUnmount?: (() => void) | (() => void)[];
3792
- destroyed?: (() => void) | (() => void)[];
3793
- unmounted?: (() => void) | (() => void)[];
3794
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3795
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3796
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
3797
- };
3798
- $forceUpdate: () => void;
3799
- $nextTick: typeof vue.nextTick;
3800
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
3801
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
3802
- validate(): any;
3803
- resetFields(): any;
3804
- }> & {} & vue.ComponentCustomProperties & {} & {
3805
- $slots: {
3806
- default?(_: {}): any;
3807
- };
3808
- }) | null;
3809
- }, any, vue.ComponentProvideOptions, {
3810
- P: {};
3811
- B: {};
3812
- D: {};
3813
- C: {};
3814
- M: {};
3815
- Defaults: {};
3816
- }, Readonly<{
3817
- config: _tmagic_editor.FormConfig;
3818
- initValues: Record<string, any>;
3819
- lastValues?: Record<string, any>;
3820
- isCompare?: boolean;
3821
- parentValues?: Record<string, any>;
3822
- labelWidth?: string;
3823
- disabled?: boolean;
3824
- height?: string;
3825
- stepActive?: string | number;
3826
- size?: "small" | "default" | "large";
3827
- inline?: boolean;
3828
- labelPosition?: string;
3829
- keyProp?: string;
3830
- popperClass?: string;
3831
- preventSubmitDefault?: boolean;
3832
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
3833
- }> & Readonly<{
3834
- onChange?: ((...args: any[]) => any) | undefined;
3835
- onError?: ((...args: any[]) => any) | undefined;
3836
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
3837
- "onField-change"?: ((...args: any[]) => any) | undefined;
3838
- "onField-input"?: ((...args: any[]) => any) | undefined;
3839
- }>, {
3840
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
3841
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
3842
- formState: FormState;
3843
- initialized: vue.Ref<boolean, boolean>;
3844
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
3845
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
3846
- resetForm: () => void;
3847
- submitForm: (native?: boolean) => Promise<any>;
3848
- }, {}, {}, {}, {
3849
- disabled: boolean;
3850
- labelWidth: string;
3851
- inline: boolean;
3852
- labelPosition: string;
3853
- config: _tmagic_editor.FormConfig;
3854
- initValues: Record<string, any>;
3855
- lastValues: Record<string, any>;
3856
- isCompare: boolean;
3857
- keyProp: string;
3858
- parentValues: Record<string, any>;
3859
- stepActive: string | number;
3860
- height: string;
3861
- }> | null;
3862
- };
3863
- $slots: Readonly<{
3864
- [name: string]: vue.Slot<any> | undefined;
3865
- }>;
3866
- $root: vue.ComponentPublicInstance | null;
3867
- $parent: vue.ComponentPublicInstance | null;
3868
- $host: Element | null;
3869
- $emit: ((event: "change", ...args: any[]) => void) & ((event: "close", ...args: any[]) => void) & ((event: "error", ...args: any[]) => void) & ((event: "submit", ...args: any[]) => void);
3870
- $el: any;
3871
- $options: vue.ComponentOptionsBase<Readonly<{
3872
- config?: _tmagic_editor.FormConfig;
3873
- values?: Object;
3874
- parentValues?: Object;
3875
- width?: string | number;
3876
- labelWidth?: string;
3877
- fullscreen?: boolean;
3878
- disabled?: boolean;
3879
- title?: string;
3880
- inline?: boolean;
3881
- labelPosition?: string;
3882
- zIndex?: number;
3883
- size?: "small" | "default" | "large";
3884
- confirmText?: string;
3885
- preventSubmitDefault?: boolean;
3886
- }> & Readonly<{
3887
- onChange?: ((...args: any[]) => any) | undefined;
3888
- onClose?: ((...args: any[]) => any) | undefined;
3889
- onError?: ((...args: any[]) => any) | undefined;
3890
- onSubmit?: ((...args: any[]) => any) | undefined;
3891
- }>, {
3892
- form: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
3893
- config: _tmagic_editor.FormConfig;
3894
- initValues: Record<string, any>;
3895
- lastValues?: Record<string, any>;
3896
- isCompare?: boolean;
3897
- parentValues?: Record<string, any>;
3898
- labelWidth?: string;
3899
- disabled?: boolean;
3900
- height?: string;
3901
- stepActive?: string | number;
3902
- size?: "small" | "default" | "large";
3903
- inline?: boolean;
3904
- labelPosition?: string;
3905
- keyProp?: string;
3906
- popperClass?: string;
3907
- preventSubmitDefault?: boolean;
3908
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
3909
- }> & Readonly<{
3910
- onChange?: ((...args: any[]) => any) | undefined;
3911
- onError?: ((...args: any[]) => any) | undefined;
3912
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
3913
- "onField-change"?: ((...args: any[]) => any) | undefined;
3914
- "onField-input"?: ((...args: any[]) => any) | undefined;
3915
- }>, {
3916
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
3917
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
3918
- formState: FormState;
3919
- initialized: vue.Ref<boolean, boolean>;
3920
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
3921
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
3922
- resetForm: () => void;
3923
- submitForm: (native?: boolean) => Promise<any>;
3924
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
3925
- change: (...args: any[]) => void;
3926
- error: (...args: any[]) => void;
3927
- "update:stepActive": (...args: any[]) => void;
3928
- "field-change": (...args: any[]) => void;
3929
- "field-input": (...args: any[]) => void;
3930
- }, vue.PublicProps, {
3931
- disabled: boolean;
3932
- labelWidth: string;
3933
- inline: boolean;
3934
- labelPosition: string;
3935
- config: _tmagic_editor.FormConfig;
3936
- initValues: Record<string, any>;
3937
- lastValues: Record<string, any>;
3938
- isCompare: boolean;
3939
- keyProp: string;
3940
- parentValues: Record<string, any>;
3941
- stepActive: string | number;
3942
- height: string;
3943
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
3944
- tMagicForm: ({
3945
- $: vue.ComponentInternalInstance;
3946
- $data: {};
3947
- $props: {
3948
- readonly model?: any;
3949
- readonly labelWidth?: string | number | undefined;
3950
- readonly disabled?: boolean | undefined;
3951
- readonly inline?: boolean | undefined;
3952
- readonly labelPosition?: string | undefined;
3953
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
3954
- $attrs: {
3955
- [x: string]: unknown;
3956
- };
3957
- $refs: {
3958
- [x: string]: unknown;
3959
- } & {
3960
- form: unknown;
3961
- };
3962
- $slots: Readonly<{
3963
- [name: string]: vue.Slot<any> | undefined;
3964
- }>;
3965
- $root: vue.ComponentPublicInstance | null;
3966
- $parent: vue.ComponentPublicInstance | null;
3967
- $host: Element | null;
3968
- $emit: (event: string, ...args: any[]) => void;
3969
- $el: any;
3970
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
3971
- validate(): any;
3972
- resetFields(): any;
3973
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
3974
- beforeCreate?: (() => void) | (() => void)[];
3975
- created?: (() => void) | (() => void)[];
3976
- beforeMount?: (() => void) | (() => void)[];
3977
- mounted?: (() => void) | (() => void)[];
3978
- beforeUpdate?: (() => void) | (() => void)[];
3979
- updated?: (() => void) | (() => void)[];
3980
- activated?: (() => void) | (() => void)[];
3981
- deactivated?: (() => void) | (() => void)[];
3982
- beforeDestroy?: (() => void) | (() => void)[];
3983
- beforeUnmount?: (() => void) | (() => void)[];
3984
- destroyed?: (() => void) | (() => void)[];
3985
- unmounted?: (() => void) | (() => void)[];
3986
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3987
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
3988
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
3989
- };
3990
- $forceUpdate: () => void;
3991
- $nextTick: typeof vue.nextTick;
3992
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
3993
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
3994
- validate(): any;
3995
- resetFields(): any;
3996
- }> & {} & vue.ComponentCustomProperties & {} & {
3997
- $slots: {
3998
- default?(_: {}): any;
3999
- };
4000
- }) | null;
4001
- }, any, vue.ComponentProvideOptions, {
4002
- P: {};
4003
- B: {};
4004
- D: {};
4005
- C: {};
4006
- M: {};
4007
- Defaults: {};
4008
- }, Readonly<{
4009
- config: _tmagic_editor.FormConfig;
4010
- initValues: Record<string, any>;
4011
- lastValues?: Record<string, any>;
4012
- isCompare?: boolean;
4013
- parentValues?: Record<string, any>;
4014
- labelWidth?: string;
4015
- disabled?: boolean;
4016
- height?: string;
4017
- stepActive?: string | number;
4018
- size?: "small" | "default" | "large";
4019
- inline?: boolean;
4020
- labelPosition?: string;
4021
- keyProp?: string;
4022
- popperClass?: string;
4023
- preventSubmitDefault?: boolean;
4024
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
4025
- }> & Readonly<{
4026
- onChange?: ((...args: any[]) => any) | undefined;
4027
- onError?: ((...args: any[]) => any) | undefined;
4028
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
4029
- "onField-change"?: ((...args: any[]) => any) | undefined;
4030
- "onField-input"?: ((...args: any[]) => any) | undefined;
4031
- }>, {
4032
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4033
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4034
- formState: FormState;
4035
- initialized: vue.Ref<boolean, boolean>;
4036
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
4037
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
4038
- resetForm: () => void;
4039
- submitForm: (native?: boolean) => Promise<any>;
4040
- }, {}, {}, {}, {
4041
- disabled: boolean;
4042
- labelWidth: string;
4043
- inline: boolean;
4044
- labelPosition: string;
4045
- config: _tmagic_editor.FormConfig;
4046
- initValues: Record<string, any>;
4047
- lastValues: Record<string, any>;
4048
- isCompare: boolean;
4049
- keyProp: string;
4050
- parentValues: Record<string, any>;
4051
- stepActive: string | number;
4052
- height: string;
4053
- }> | undefined, vue.CreateComponentPublicInstanceWithMixins<Readonly<{
4054
- config: _tmagic_editor.FormConfig;
4055
- initValues: Record<string, any>;
4056
- lastValues?: Record<string, any>;
4057
- isCompare?: boolean;
4058
- parentValues?: Record<string, any>;
4059
- labelWidth?: string;
4060
- disabled?: boolean;
4061
- height?: string;
4062
- stepActive?: string | number;
4063
- size?: "small" | "default" | "large";
4064
- inline?: boolean;
4065
- labelPosition?: string;
4066
- keyProp?: string;
4067
- popperClass?: string;
4068
- preventSubmitDefault?: boolean;
4069
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
4070
- }> & Readonly<{
4071
- onChange?: ((...args: any[]) => any) | undefined;
4072
- onError?: ((...args: any[]) => any) | undefined;
4073
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
4074
- "onField-change"?: ((...args: any[]) => any) | undefined;
4075
- "onField-input"?: ((...args: any[]) => any) | undefined;
4076
- }>, {
4077
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4078
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4079
- formState: FormState;
4080
- initialized: vue.Ref<boolean, boolean>;
4081
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
4082
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
4083
- resetForm: () => void;
4084
- submitForm: (native?: boolean) => Promise<any>;
4085
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4086
- change: (...args: any[]) => void;
4087
- error: (...args: any[]) => void;
4088
- "update:stepActive": (...args: any[]) => void;
4089
- "field-change": (...args: any[]) => void;
4090
- "field-input": (...args: any[]) => void;
4091
- }, vue.PublicProps, {
4092
- disabled: boolean;
4093
- labelWidth: string;
4094
- inline: boolean;
4095
- labelPosition: string;
4096
- config: _tmagic_editor.FormConfig;
4097
- initValues: Record<string, any>;
4098
- lastValues: Record<string, any>;
4099
- isCompare: boolean;
4100
- keyProp: string;
4101
- parentValues: Record<string, any>;
4102
- stepActive: string | number;
4103
- height: string;
4104
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
4105
- tMagicForm: ({
4106
- $: vue.ComponentInternalInstance;
4107
- $data: {};
4108
- $props: {
4109
- readonly model?: any;
4110
- readonly labelWidth?: string | number | undefined;
4111
- readonly disabled?: boolean | undefined;
4112
- readonly inline?: boolean | undefined;
4113
- readonly labelPosition?: string | undefined;
4114
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
4115
- $attrs: {
4116
- [x: string]: unknown;
4117
- };
4118
- $refs: {
4119
- [x: string]: unknown;
4120
- } & {
4121
- form: unknown;
4122
- };
4123
- $slots: Readonly<{
4124
- [name: string]: vue.Slot<any> | undefined;
4125
- }>;
4126
- $root: vue.ComponentPublicInstance | null;
4127
- $parent: vue.ComponentPublicInstance | null;
4128
- $host: Element | null;
4129
- $emit: (event: string, ...args: any[]) => void;
4130
- $el: any;
4131
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
4132
- validate(): any;
4133
- resetFields(): any;
4134
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
4135
- beforeCreate?: (() => void) | (() => void)[];
4136
- created?: (() => void) | (() => void)[];
4137
- beforeMount?: (() => void) | (() => void)[];
4138
- mounted?: (() => void) | (() => void)[];
4139
- beforeUpdate?: (() => void) | (() => void)[];
4140
- updated?: (() => void) | (() => void)[];
4141
- activated?: (() => void) | (() => void)[];
4142
- deactivated?: (() => void) | (() => void)[];
4143
- beforeDestroy?: (() => void) | (() => void)[];
4144
- beforeUnmount?: (() => void) | (() => void)[];
4145
- destroyed?: (() => void) | (() => void)[];
4146
- unmounted?: (() => void) | (() => void)[];
4147
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4148
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4149
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
4150
- };
4151
- $forceUpdate: () => void;
4152
- $nextTick: typeof vue.nextTick;
4153
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
4154
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
4155
- validate(): any;
4156
- resetFields(): any;
4157
- }> & {} & vue.ComponentCustomProperties & {} & {
4158
- $slots: {
4159
- default?(_: {}): any;
4160
- };
4161
- }) | null;
4162
- }, any, vue.ComponentProvideOptions, {
4163
- P: {};
4164
- B: {};
4165
- D: {};
4166
- C: {};
4167
- M: {};
4168
- Defaults: {};
4169
- }, Readonly<{
4170
- config: _tmagic_editor.FormConfig;
4171
- initValues: Record<string, any>;
4172
- lastValues?: Record<string, any>;
4173
- isCompare?: boolean;
4174
- parentValues?: Record<string, any>;
4175
- labelWidth?: string;
4176
- disabled?: boolean;
4177
- height?: string;
4178
- stepActive?: string | number;
4179
- size?: "small" | "default" | "large";
4180
- inline?: boolean;
4181
- labelPosition?: string;
4182
- keyProp?: string;
4183
- popperClass?: string;
4184
- preventSubmitDefault?: boolean;
4185
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
4186
- }> & Readonly<{
4187
- onChange?: ((...args: any[]) => any) | undefined;
4188
- onError?: ((...args: any[]) => any) | undefined;
4189
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
4190
- "onField-change"?: ((...args: any[]) => any) | undefined;
4191
- "onField-input"?: ((...args: any[]) => any) | undefined;
4192
- }>, {
4193
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4194
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4195
- formState: FormState;
4196
- initialized: vue.Ref<boolean, boolean>;
4197
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
4198
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
4199
- resetForm: () => void;
4200
- submitForm: (native?: boolean) => Promise<any>;
4201
- }, {}, {}, {}, {
4202
- disabled: boolean;
4203
- labelWidth: string;
4204
- inline: boolean;
4205
- labelPosition: string;
4206
- config: _tmagic_editor.FormConfig;
4207
- initValues: Record<string, any>;
4208
- lastValues: Record<string, any>;
4209
- isCompare: boolean;
4210
- keyProp: string;
4211
- parentValues: Record<string, any>;
4212
- stepActive: string | number;
4213
- height: string;
4214
- }> | undefined>;
4215
- saveFetch: vue.Ref<boolean, boolean>;
4216
- dialogVisible: vue.Ref<boolean, boolean>;
4217
- cancel: () => void;
4218
- save: () => Promise<void>;
4219
- show: () => void;
4220
- hide: () => void;
4221
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4222
- change: (...args: any[]) => void;
4223
- close: (...args: any[]) => void;
4224
- error: (...args: any[]) => void;
4225
- submit: (...args: any[]) => void;
4226
- }, string, {
4227
- values: Object;
4228
- config: _tmagic_editor.FormConfig;
4229
- confirmText: string;
4230
- }, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
4231
- beforeCreate?: (() => void) | (() => void)[];
4232
- created?: (() => void) | (() => void)[];
4233
- beforeMount?: (() => void) | (() => void)[];
4234
- mounted?: (() => void) | (() => void)[];
4235
- beforeUpdate?: (() => void) | (() => void)[];
4236
- updated?: (() => void) | (() => void)[];
4237
- activated?: (() => void) | (() => void)[];
4238
- deactivated?: (() => void) | (() => void)[];
4239
- beforeDestroy?: (() => void) | (() => void)[];
4240
- beforeUnmount?: (() => void) | (() => void)[];
4241
- destroyed?: (() => void) | (() => void)[];
4242
- unmounted?: (() => void) | (() => void)[];
4243
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4244
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4245
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
4246
- };
4247
- $forceUpdate: () => void;
4248
- $nextTick: typeof vue.nextTick;
4249
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
4250
- } & Readonly<{
4251
- values: Object;
4252
- config: _tmagic_editor.FormConfig;
4253
- confirmText: string;
4254
- }> & Omit<Readonly<{
4255
- config?: _tmagic_editor.FormConfig;
4256
- values?: Object;
4257
- parentValues?: Object;
4258
- width?: string | number;
4259
- labelWidth?: string;
4260
- fullscreen?: boolean;
4261
- disabled?: boolean;
4262
- title?: string;
4263
- inline?: boolean;
4264
- labelPosition?: string;
4265
- zIndex?: number;
4266
- size?: "small" | "default" | "large";
4267
- confirmText?: string;
4268
- preventSubmitDefault?: boolean;
4269
- }> & Readonly<{
4270
- onChange?: ((...args: any[]) => any) | undefined;
4271
- onClose?: ((...args: any[]) => any) | undefined;
4272
- onError?: ((...args: any[]) => any) | undefined;
4273
- onSubmit?: ((...args: any[]) => any) | undefined;
4274
- }>, "form" | "cancel" | "show" | "saveFetch" | "dialogVisible" | "save" | "hide" | ("values" | "config" | "confirmText")> & vue.ShallowUnwrapRef<{
4275
- form: vue.Ref<vue.CreateComponentPublicInstanceWithMixins<Readonly<{
4276
- config: _tmagic_editor.FormConfig;
4277
- initValues: Record<string, any>;
4278
- lastValues?: Record<string, any>;
4279
- isCompare?: boolean;
4280
- parentValues?: Record<string, any>;
4281
- labelWidth?: string;
4282
- disabled?: boolean;
4283
- height?: string;
4284
- stepActive?: string | number;
4285
- size?: "small" | "default" | "large";
4286
- inline?: boolean;
4287
- labelPosition?: string;
4288
- keyProp?: string;
4289
- popperClass?: string;
4290
- preventSubmitDefault?: boolean;
4291
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
4292
- }> & Readonly<{
4293
- onChange?: ((...args: any[]) => any) | undefined;
4294
- onError?: ((...args: any[]) => any) | undefined;
4295
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
4296
- "onField-change"?: ((...args: any[]) => any) | undefined;
4297
- "onField-input"?: ((...args: any[]) => any) | undefined;
4298
- }>, {
4299
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4300
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4301
- formState: FormState;
4302
- initialized: vue.Ref<boolean, boolean>;
4303
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
4304
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
4305
- resetForm: () => void;
4306
- submitForm: (native?: boolean) => Promise<any>;
4307
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4308
- change: (...args: any[]) => void;
4309
- error: (...args: any[]) => void;
4310
- "update:stepActive": (...args: any[]) => void;
4311
- "field-change": (...args: any[]) => void;
4312
- "field-input": (...args: any[]) => void;
4313
- }, vue.PublicProps, {
4314
- disabled: boolean;
4315
- labelWidth: string;
4316
- inline: boolean;
4317
- labelPosition: string;
4318
- config: _tmagic_editor.FormConfig;
4319
- initValues: Record<string, any>;
4320
- lastValues: Record<string, any>;
4321
- isCompare: boolean;
4322
- keyProp: string;
4323
- parentValues: Record<string, any>;
4324
- stepActive: string | number;
4325
- height: string;
4326
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
4327
- tMagicForm: ({
4328
- $: vue.ComponentInternalInstance;
4329
- $data: {};
4330
- $props: {
4331
- readonly model?: any;
4332
- readonly labelWidth?: string | number | undefined;
4333
- readonly disabled?: boolean | undefined;
4334
- readonly inline?: boolean | undefined;
4335
- readonly labelPosition?: string | undefined;
4336
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
4337
- $attrs: {
4338
- [x: string]: unknown;
4339
- };
4340
- $refs: {
4341
- [x: string]: unknown;
4342
- } & {
4343
- form: unknown;
4344
- };
4345
- $slots: Readonly<{
4346
- [name: string]: vue.Slot<any> | undefined;
4347
- }>;
4348
- $root: vue.ComponentPublicInstance | null;
4349
- $parent: vue.ComponentPublicInstance | null;
4350
- $host: Element | null;
4351
- $emit: (event: string, ...args: any[]) => void;
4352
- $el: any;
4353
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
4354
- validate(): any;
4355
- resetFields(): any;
4356
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
4357
- beforeCreate?: (() => void) | (() => void)[];
4358
- created?: (() => void) | (() => void)[];
4359
- beforeMount?: (() => void) | (() => void)[];
4360
- mounted?: (() => void) | (() => void)[];
4361
- beforeUpdate?: (() => void) | (() => void)[];
4362
- updated?: (() => void) | (() => void)[];
4363
- activated?: (() => void) | (() => void)[];
4364
- deactivated?: (() => void) | (() => void)[];
4365
- beforeDestroy?: (() => void) | (() => void)[];
4366
- beforeUnmount?: (() => void) | (() => void)[];
4367
- destroyed?: (() => void) | (() => void)[];
4368
- unmounted?: (() => void) | (() => void)[];
4369
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4370
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4371
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
4372
- };
4373
- $forceUpdate: () => void;
4374
- $nextTick: typeof vue.nextTick;
4375
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
4376
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
4377
- validate(): any;
4378
- resetFields(): any;
4379
- }> & {} & vue.ComponentCustomProperties & {} & {
4380
- $slots: {
4381
- default?(_: {}): any;
4382
- };
4383
- }) | null;
4384
- }, any, vue.ComponentProvideOptions, {
4385
- P: {};
4386
- B: {};
4387
- D: {};
4388
- C: {};
4389
- M: {};
4390
- Defaults: {};
4391
- }, Readonly<{
4392
- config: _tmagic_editor.FormConfig;
4393
- initValues: Record<string, any>;
4394
- lastValues?: Record<string, any>;
4395
- isCompare?: boolean;
4396
- parentValues?: Record<string, any>;
4397
- labelWidth?: string;
4398
- disabled?: boolean;
4399
- height?: string;
4400
- stepActive?: string | number;
4401
- size?: "small" | "default" | "large";
4402
- inline?: boolean;
4403
- labelPosition?: string;
4404
- keyProp?: string;
4405
- popperClass?: string;
4406
- preventSubmitDefault?: boolean;
4407
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
4408
- }> & Readonly<{
4409
- onChange?: ((...args: any[]) => any) | undefined;
4410
- onError?: ((...args: any[]) => any) | undefined;
4411
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
4412
- "onField-change"?: ((...args: any[]) => any) | undefined;
4413
- "onField-input"?: ((...args: any[]) => any) | undefined;
4414
- }>, {
4415
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4416
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4417
- formState: FormState;
4418
- initialized: vue.Ref<boolean, boolean>;
4419
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
4420
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
4421
- resetForm: () => void;
4422
- submitForm: (native?: boolean) => Promise<any>;
4423
- }, {}, {}, {}, {
4424
- disabled: boolean;
4425
- labelWidth: string;
4426
- inline: boolean;
4427
- labelPosition: string;
4428
- config: _tmagic_editor.FormConfig;
4429
- initValues: Record<string, any>;
4430
- lastValues: Record<string, any>;
4431
- isCompare: boolean;
4432
- keyProp: string;
4433
- parentValues: Record<string, any>;
4434
- stepActive: string | number;
4435
- height: string;
4436
- }> | undefined, vue.CreateComponentPublicInstanceWithMixins<Readonly<{
4437
- config: _tmagic_editor.FormConfig;
4438
- initValues: Record<string, any>;
4439
- lastValues?: Record<string, any>;
4440
- isCompare?: boolean;
4441
- parentValues?: Record<string, any>;
4442
- labelWidth?: string;
4443
- disabled?: boolean;
4444
- height?: string;
4445
- stepActive?: string | number;
4446
- size?: "small" | "default" | "large";
4447
- inline?: boolean;
4448
- labelPosition?: string;
4449
- keyProp?: string;
4450
- popperClass?: string;
4451
- preventSubmitDefault?: boolean;
4452
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
4453
- }> & Readonly<{
4454
- onChange?: ((...args: any[]) => any) | undefined;
4455
- onError?: ((...args: any[]) => any) | undefined;
4456
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
4457
- "onField-change"?: ((...args: any[]) => any) | undefined;
4458
- "onField-input"?: ((...args: any[]) => any) | undefined;
4459
- }>, {
4460
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4461
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4462
- formState: FormState;
4463
- initialized: vue.Ref<boolean, boolean>;
4464
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
4465
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
4466
- resetForm: () => void;
4467
- submitForm: (native?: boolean) => Promise<any>;
4468
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4469
- change: (...args: any[]) => void;
4470
- error: (...args: any[]) => void;
4471
- "update:stepActive": (...args: any[]) => void;
4472
- "field-change": (...args: any[]) => void;
4473
- "field-input": (...args: any[]) => void;
4474
- }, vue.PublicProps, {
4475
- disabled: boolean;
4476
- labelWidth: string;
4477
- inline: boolean;
4478
- labelPosition: string;
4479
- config: _tmagic_editor.FormConfig;
4480
- initValues: Record<string, any>;
4481
- lastValues: Record<string, any>;
4482
- isCompare: boolean;
4483
- keyProp: string;
4484
- parentValues: Record<string, any>;
4485
- stepActive: string | number;
4486
- height: string;
4487
- }, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
4488
- tMagicForm: ({
4489
- $: vue.ComponentInternalInstance;
4490
- $data: {};
4491
- $props: {
4492
- readonly model?: any;
4493
- readonly labelWidth?: string | number | undefined;
4494
- readonly disabled?: boolean | undefined;
4495
- readonly inline?: boolean | undefined;
4496
- readonly labelPosition?: string | undefined;
4497
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
4498
- $attrs: {
4499
- [x: string]: unknown;
4500
- };
4501
- $refs: {
4502
- [x: string]: unknown;
4503
- } & {
4504
- form: unknown;
4505
- };
4506
- $slots: Readonly<{
4507
- [name: string]: vue.Slot<any> | undefined;
4508
- }>;
4509
- $root: vue.ComponentPublicInstance | null;
4510
- $parent: vue.ComponentPublicInstance | null;
4511
- $host: Element | null;
4512
- $emit: (event: string, ...args: any[]) => void;
4513
- $el: any;
4514
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.FormProps> & Readonly<{}>, {
4515
- validate(): any;
4516
- resetFields(): any;
4517
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
4518
- beforeCreate?: (() => void) | (() => void)[];
4519
- created?: (() => void) | (() => void)[];
4520
- beforeMount?: (() => void) | (() => void)[];
4521
- mounted?: (() => void) | (() => void)[];
4522
- beforeUpdate?: (() => void) | (() => void)[];
4523
- updated?: (() => void) | (() => void)[];
4524
- activated?: (() => void) | (() => void)[];
4525
- deactivated?: (() => void) | (() => void)[];
4526
- beforeDestroy?: (() => void) | (() => void)[];
4527
- beforeUnmount?: (() => void) | (() => void)[];
4528
- destroyed?: (() => void) | (() => void)[];
4529
- unmounted?: (() => void) | (() => void)[];
4530
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4531
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4532
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
4533
- };
4534
- $forceUpdate: () => void;
4535
- $nextTick: typeof vue.nextTick;
4536
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
4537
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.FormProps> & Readonly<{}>, "validate" | "resetFields"> & vue.ShallowUnwrapRef<{
4538
- validate(): any;
4539
- resetFields(): any;
4540
- }> & {} & vue.ComponentCustomProperties & {} & {
4541
- $slots: {
4542
- default?(_: {}): any;
4543
- };
4544
- }) | null;
4545
- }, any, vue.ComponentProvideOptions, {
4546
- P: {};
4547
- B: {};
4548
- D: {};
4549
- C: {};
4550
- M: {};
4551
- Defaults: {};
4552
- }, Readonly<{
4553
- config: _tmagic_editor.FormConfig;
4554
- initValues: Record<string, any>;
4555
- lastValues?: Record<string, any>;
4556
- isCompare?: boolean;
4557
- parentValues?: Record<string, any>;
4558
- labelWidth?: string;
4559
- disabled?: boolean;
4560
- height?: string;
4561
- stepActive?: string | number;
4562
- size?: "small" | "default" | "large";
4563
- inline?: boolean;
4564
- labelPosition?: string;
4565
- keyProp?: string;
4566
- popperClass?: string;
4567
- preventSubmitDefault?: boolean;
4568
- extendState?: (state: FormState) => Record<string, any> | Promise<Record<string, any>>;
4569
- }> & Readonly<{
4570
- onChange?: ((...args: any[]) => any) | undefined;
4571
- onError?: ((...args: any[]) => any) | undefined;
4572
- "onUpdate:stepActive"?: ((...args: any[]) => any) | undefined;
4573
- "onField-change"?: ((...args: any[]) => any) | undefined;
4574
- "onField-input"?: ((...args: any[]) => any) | undefined;
4575
- }>, {
4576
- values: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4577
- lastValuesProcessed: vue.Ref<_tmagic_editor.FormValue, _tmagic_editor.FormValue>;
4578
- formState: FormState;
4579
- initialized: vue.Ref<boolean, boolean>;
4580
- changeRecords: vue.ShallowRef<_tmagic_editor.ChangeRecord[], _tmagic_editor.ChangeRecord[]>;
4581
- changeHandler: (v: _tmagic_editor.FormValue, eventData: _tmagic_editor.ContainerChangeEventData) => void;
4582
- resetForm: () => void;
4583
- submitForm: (native?: boolean) => Promise<any>;
4584
- }, {}, {}, {}, {
4585
- disabled: boolean;
4586
- labelWidth: string;
4587
- inline: boolean;
4588
- labelPosition: string;
4589
- config: _tmagic_editor.FormConfig;
4590
- initValues: Record<string, any>;
4591
- lastValues: Record<string, any>;
4592
- isCompare: boolean;
4593
- keyProp: string;
4594
- parentValues: Record<string, any>;
4595
- stepActive: string | number;
4596
- height: string;
4597
- }> | undefined>;
4598
- saveFetch: vue.Ref<boolean, boolean>;
4599
- dialogVisible: vue.Ref<boolean, boolean>;
4600
- cancel: () => void;
4601
- save: () => Promise<void>;
4602
- show: () => void;
4603
- hide: () => void;
4604
- }> & {} & vue.ComponentCustomProperties & {} & {
4605
- $slots: {
4606
- default?(_: {}): any;
4607
- left?(_: {}): any;
4608
- footer?(_: {}): any;
4609
- };
4610
- }) | null;
4611
- }, any>;
3059
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
4612
3060
 
4613
3061
  type __VLS_Props$2 = FieldProps<SelectConfig>;
4614
3062
  declare const _default$3: vue.DefineComponent<__VLS_Props$2, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4615
3063
  change: (...args: any[]) => void;
4616
3064
  }, string, vue.PublicProps, Readonly<__VLS_Props$2> & Readonly<{
4617
3065
  onChange?: ((...args: any[]) => any) | undefined;
4618
- }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
4619
- tMagicSelect: ({
4620
- $: vue.ComponentInternalInstance;
4621
- $data: {};
4622
- $props: {
4623
- readonly modelValue?: any;
4624
- readonly clearable?: boolean | undefined;
4625
- readonly filterable?: boolean | undefined;
4626
- readonly popperClass?: string | undefined;
4627
- readonly disabled?: boolean | undefined;
4628
- readonly placeholder?: string | undefined;
4629
- readonly remote?: boolean | undefined;
4630
- readonly multiple?: boolean | undefined;
4631
- readonly allowCreate?: boolean | undefined;
4632
- readonly valueKey?: string | undefined;
4633
- readonly remoteMethod?: any;
4634
- readonly loading?: boolean | undefined;
4635
- readonly size?: _tmagic_design.FieldSize | undefined;
4636
- readonly onSearch?: any;
4637
- readonly onChange?: ((...args: any[]) => any) | undefined;
4638
- readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
4639
- readonly onVisibleHandler?: ((...args: any[]) => any) | undefined;
4640
- } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps;
4641
- $attrs: {
4642
- [x: string]: unknown;
4643
- };
4644
- $refs: {
4645
- [x: string]: unknown;
4646
- } & {
4647
- select: unknown;
4648
- };
4649
- $slots: Readonly<{
4650
- [name: string]: vue.Slot<any> | undefined;
4651
- }>;
4652
- $root: vue.ComponentPublicInstance | null;
4653
- $parent: vue.ComponentPublicInstance | null;
4654
- $host: Element | null;
4655
- $emit: ((event: "change", ...args: any[]) => void) & ((event: "update:modelValue", ...args: any[]) => void) & ((event: "visibleHandler", ...args: any[]) => void);
4656
- $el: any;
4657
- $options: vue.ComponentOptionsBase<Readonly<_tmagic_design.SelectProps> & Readonly<{
4658
- onChange?: ((...args: any[]) => any) | undefined;
4659
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
4660
- onVisibleHandler?: ((...args: any[]) => any) | undefined;
4661
- }>, {
4662
- scrollbarWrap: vue.Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
4663
- setQuery(v: string): void;
4664
- setPreviousQuery(v: string): void;
4665
- setSelectedLabel(v: string): void;
4666
- setSelected(): any;
4667
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4668
- change: (...args: any[]) => void;
4669
- "update:modelValue": (...args: any[]) => void;
4670
- visibleHandler: (...args: any[]) => void;
4671
- }, string, {}, {}, string, {}, vue.GlobalComponents, vue.GlobalDirectives, string, vue.ComponentProvideOptions> & {
4672
- beforeCreate?: (() => void) | (() => void)[];
4673
- created?: (() => void) | (() => void)[];
4674
- beforeMount?: (() => void) | (() => void)[];
4675
- mounted?: (() => void) | (() => void)[];
4676
- beforeUpdate?: (() => void) | (() => void)[];
4677
- updated?: (() => void) | (() => void)[];
4678
- activated?: (() => void) | (() => void)[];
4679
- deactivated?: (() => void) | (() => void)[];
4680
- beforeDestroy?: (() => void) | (() => void)[];
4681
- beforeUnmount?: (() => void) | (() => void)[];
4682
- destroyed?: (() => void) | (() => void)[];
4683
- unmounted?: (() => void) | (() => void)[];
4684
- renderTracked?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4685
- renderTriggered?: ((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[];
4686
- errorCaptured?: ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance | null, info: string) => boolean | void)[];
4687
- };
4688
- $forceUpdate: () => void;
4689
- $nextTick: typeof nextTick;
4690
- $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, _vue_reactivity.OnCleanup]) => any : (...args: [any, any, _vue_reactivity.OnCleanup]) => any, options?: vue.WatchOptions): vue.WatchStopHandle;
4691
- } & Readonly<{}> & Omit<Readonly<_tmagic_design.SelectProps> & Readonly<{
4692
- onChange?: ((...args: any[]) => any) | undefined;
4693
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
4694
- onVisibleHandler?: ((...args: any[]) => any) | undefined;
4695
- }>, "scrollbarWrap" | "setQuery" | "setPreviousQuery" | "setSelectedLabel" | "setSelected"> & vue.ShallowUnwrapRef<{
4696
- scrollbarWrap: vue.Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
4697
- setQuery(v: string): void;
4698
- setPreviousQuery(v: string): void;
4699
- setSelectedLabel(v: string): void;
4700
- setSelected(): any;
4701
- }> & {} & vue.ComponentCustomProperties & {} & {
4702
- $slots: {
4703
- default?(_: {}): any;
4704
- };
4705
- }) | null;
4706
- }, any>;
3066
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
4707
3067
 
4708
3068
  type __VLS_Props$1 = FieldProps<CascaderConfig>;
4709
3069
  declare const _default$2: vue.DefineComponent<__VLS_Props$1, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4710
3070
  change: (...args: any[]) => void;
4711
3071
  }, string, vue.PublicProps, Readonly<__VLS_Props$1> & Readonly<{
4712
3072
  onChange?: ((...args: any[]) => any) | undefined;
4713
- }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {
4714
- tMagicCascader: vue.CreateComponentPublicInstanceWithMixins<Readonly<_tmagic_design.CascaderProps> & Readonly<{
4715
- onChange?: ((...args: any[]) => any) | undefined;
4716
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
4717
- }>, {
4718
- setQuery(v: any): void;
4719
- setPreviousQuery(v: any): void;
4720
- }, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4721
- change: (...args: any[]) => void;
4722
- "update:modelValue": (...args: any[]) => void;
4723
- }, vue.PublicProps, {}, false, {}, {}, vue.GlobalComponents, vue.GlobalDirectives, string, {
4724
- cascader: unknown;
4725
- }, any, vue.ComponentProvideOptions, {
4726
- P: {};
4727
- B: {};
4728
- D: {};
4729
- C: {};
4730
- M: {};
4731
- Defaults: {};
4732
- }, Readonly<_tmagic_design.CascaderProps> & Readonly<{
4733
- onChange?: ((...args: any[]) => any) | undefined;
4734
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
4735
- }>, {
4736
- setQuery(v: any): void;
4737
- setPreviousQuery(v: any): void;
4738
- }, {}, {}, {}, {}> | null;
4739
- }, any>;
3073
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
4740
3074
 
4741
3075
  type __VLS_Props = FieldProps<DynamicFieldConfig>;
4742
3076
  declare const _default$1: vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
4743
3077
  change: (...args: any[]) => void;
4744
3078
  }, string, vue.PublicProps, Readonly<__VLS_Props> & Readonly<{
4745
3079
  onChange?: ((...args: any[]) => any) | undefined;
4746
- }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, HTMLDivElement>;
3080
+ }>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
4747
3081
 
4748
3082
  declare const createForm: <T extends [] = []>(config: FormConfig | T) => FormConfig | T;
4749
3083
  interface FormInstallOptions {
@@ -4753,4 +3087,5 @@ declare const _default: {
4753
3087
  install(app: App, opt?: FormInstallOptions): void;
4754
3088
  };
4755
3089
 
4756
- export { type CascaderConfig, type CascaderOption, type ChangeRecord, type CheckboxConfig, type CheckboxGroupConfig, type CheckboxGroupOption, type ChildConfig, type ColorPickConfig, type ComponentConfig, type ContainerChangeEventData, type ContainerCommonConfig, type DateConfig, type DateTimeConfig, type DaterangeConfig, type DisplayConfig, type DynamicFieldConfig, type FieldProps, type FieldsetConfig, type FilterFunction, type FormConfig, type FormInstallOptions, type FormItem, type FormState, type FormValue, type GroupListConfig, type HiddenConfig, type HtmlField, type Input, type LinkConfig, _default$2 as MCascader, _default$c as MCheckbox, _default$7 as MCheckboxGroup, _default$8 as MColorPicker, _default$r as MContainer, _default$f as MDate, _default$e as MDateTime, _default$a as MDaterange, _default$5 as MDisplay, _default$1 as MDynamicField, _default$q as MFieldset, _default$v as MForm, _default$s as MFormBox, _default$u as MFormDialog, _default$t as MFormDrawer, _default$l as MGroupList, _default$g as MHidden, _default$4 as MLink, _default$j as MNumber, _default$i as MNumberRange, _default$p as MPanel, _default$6 as MRadioGroup, _default$o as MRow, _default$3 as MSelect, _default$b as MSwitch, _default$m as MTable, _default$n as MTabs, _default$k as MText, _default$h as MTextarea, _default$d as MTime, _default$9 as MTimerange, type NumberConfig, type NumberRangeConfig, type OnChangeHandler, type OnChangeHandlerData, type PanelConfig, type RadioGroupConfig, type RowConfig, type Rule, type SelectConfig, type SelectConfigGroupOption, type SelectConfigOption, type SelectGroupOption, type SelectOption, type SortProp, type StepConfig, type SwitchConfig, type TabConfig, type TabPaneConfig, type TableColumnConfig, type TableConfig, type TextConfig, type TextareaConfig, type TimeConfig, type TypeFunction, type ValidateError, createForm, createValues, datetimeFormatter, _default as default, display, filterFunction, getRules, initValue, useAddField };
3090
+ export { _default$2 as MCascader, _default$c as MCheckbox, _default$7 as MCheckboxGroup, _default$8 as MColorPicker, _default$r as MContainer, _default$f as MDate, _default$e as MDateTime, _default$a as MDaterange, _default$5 as MDisplay, _default$1 as MDynamicField, _default$q as MFieldset, _default$v as MForm, _default$s as MFormBox, _default$u as MFormDialog, _default$t as MFormDrawer, _default$l as MGroupList, _default$g as MHidden, _default$4 as MLink, _default$j as MNumber, _default$i as MNumberRange, _default$p as MPanel, _default$6 as MRadioGroup, _default$o as MRow, _default$3 as MSelect, _default$b as MSwitch, _default$m as MTable, _default$n as MTabs, _default$k as MText, _default$h as MTextarea, _default$d as MTime, _default$9 as MTimerange, createForm, createValues, datetimeFormatter, _default as default, display$1 as display, filterFunction, getRules, initValue, useAddField };
3091
+ export type { CascaderConfig, CascaderOption, ChangeRecord, CheckboxConfig, CheckboxGroupConfig, CheckboxGroupOption, ChildConfig, ColorPickConfig, ComponentConfig, ContainerChangeEventData, ContainerCommonConfig, DateConfig, DateTimeConfig, DaterangeConfig, DisplayConfig, DynamicFieldConfig, FieldProps, FieldsetConfig, FilterFunction, FormConfig, FormInstallOptions, FormItem, FormState, FormValue, GroupListConfig, HiddenConfig, HtmlField, Input, LinkConfig, NumberConfig, NumberRangeConfig, OnChangeHandler, OnChangeHandlerData, PanelConfig, RadioGroupConfig, RowConfig, Rule, SelectConfig, SelectConfigGroupOption, SelectConfigOption, SelectGroupOption, SelectOption, SortProp, StepConfig, SwitchConfig, TabConfig, TabPaneConfig, TableColumnConfig, TableConfig, TextConfig, TextareaConfig, TimeConfig, TypeFunction, ValidateError };