CPL
/
banboshi_V2
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 1 Wiki Activity
版博士V2.0程序
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
61 Commits
5 Branches
6.2 GiB
 
 
 
 
Tree: d271ad1b21
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd271ad1b21'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/element-plus/es/components/steps/index.d.ts

384 lines
29 KiB
Raw Blame History 

  1. export declare const ElSteps: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  2.     readonly space: import("element-plus/es/utils").EpPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, "", boolean>;

  3.     readonly active: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;

  4.     readonly direction: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "horizontal", boolean>;

  5.     readonly alignCenter: {

  6.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;

  7.         readonly required: false;

  8.         readonly validator: ((val: unknown) => boolean) | undefined;

  9.         __epPropKey: true;

  10.     };

  11.     readonly simple: {

  12.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;

  13.         readonly required: false;

  14.         readonly validator: ((val: unknown) => boolean) | undefined;

  15.         __epPropKey: true;

  16.     };

  17.     readonly finishStatus: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "success" | "error" | "wait" | "finish" | "process", unknown, "finish", boolean>;

  18.     readonly processStatus: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "success" | "error" | "wait" | "finish" | "process", unknown, "process", boolean>;

  19. }, {

  20.     props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  21.         readonly space: import("element-plus/es/utils").EpPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, "", boolean>;

  22.         readonly active: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;

  23.         readonly direction: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "horizontal", boolean>;

  24.         readonly alignCenter: {

  25.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;

  26.             readonly required: false;

  27.             readonly validator: ((val: unknown) => boolean) | undefined;

  28.             __epPropKey: true;

  29.         };

  30.         readonly simple: {

  31.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;

  32.             readonly required: false;

  33.             readonly validator: ((val: unknown) => boolean) | undefined;

  34.             __epPropKey: true;

  35.         };

  36.         readonly finishStatus: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "success" | "error" | "wait" | "finish" | "process", unknown, "finish", boolean>;

  37.         readonly processStatus: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "success" | "error" | "wait" | "finish" | "process", unknown, "process", boolean>;

  38.     }>> & {

  39.         onChange?: ((newVal: number, oldVal: number) => any) | undefined;

  40.     }>>;

  41.     emit: (event: "change", newVal: number, oldVal: number) => void;

  42.     ns: {

  43.         namespace: import("vue").ComputedRef<string>;

  44.         b: (blockSuffix?: string) => string;

  45.         e: (element?: string | undefined) => string;

  46.         m: (modifier?: string | undefined) => string;

  47.         be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  48.         em: (element?: string | undefined, modifier?: string | undefined) => string;

  49.         bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  50.         bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  51.         is: {

  52.             (name: string, state: boolean | undefined): string;

  53.             (name: string): string;

  54.         };

  55.         cssVar: (object: Record<string, string>) => Record<string, string>;

  56.         cssVarName: (name: string) => string;

  57.         cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  58.         cssVarBlockName: (name: string) => string;

  59.     };

  60.     steps: import("vue").Ref<import("./src/item.vue").StepItemState[]>;

  61. }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  62.     change: (newVal: number, oldVal: number) => boolean;

  63. }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  64.     readonly space: import("element-plus/es/utils").EpPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, "", boolean>;

  65.     readonly active: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;

  66.     readonly direction: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "horizontal", boolean>;

  67.     readonly alignCenter: {

  68.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;

  69.         readonly required: false;

  70.         readonly validator: ((val: unknown) => boolean) | undefined;

  71.         __epPropKey: true;

  72.     };

  73.     readonly simple: {

  74.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;

  75.         readonly required: false;

  76.         readonly validator: ((val: unknown) => boolean) | undefined;

  77.         __epPropKey: true;

  78.     };

  79.     readonly finishStatus: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "success" | "error" | "wait" | "finish" | "process", unknown, "finish", boolean>;

  80.     readonly processStatus: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "success" | "error" | "wait" | "finish" | "process", unknown, "process", boolean>;

  81. }>> & {

  82.     onChange?: ((newVal: number, oldVal: number) => any) | undefined;

  83. }, {

  84.     readonly space: import("element-plus/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;

  85.     readonly active: number;

  86.     readonly direction: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>;

  87.     readonly finishStatus: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "success" | "error" | "wait" | "finish" | "process", unknown>;

  88.     readonly processStatus: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "success" | "error" | "wait" | "finish" | "process", unknown>;

  89. }>> & {

  90.     Step: import("vue").DefineComponent<{

  91.         readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  92.         readonly icon: {

  93.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  94.             readonly required: false;

  95.             readonly validator: ((val: unknown) => boolean) | undefined;

  96.             __epPropKey: true;

  97.         };

  98.         readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  99.         readonly status: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "success" | "error" | "wait" | "finish" | "process", unknown, "", boolean>;

  100.     }, {

  101.         props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  102.             readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  103.             readonly icon: {

  104.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  105.                 readonly required: false;

  106.                 readonly validator: ((val: unknown) => boolean) | undefined;

  107.                 __epPropKey: true;

  108.             };

  109.             readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  110.             readonly status: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "success" | "error" | "wait" | "finish" | "process", unknown, "", boolean>;

  111.         }>> & {

  112.             [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  113.         }>>;

  114.         ns: {

  115.             namespace: import("vue").ComputedRef<string>;

  116.             b: (blockSuffix?: string) => string;

  117.             e: (element?: string | undefined) => string;

  118.             m: (modifier?: string | undefined) => string;

  119.             be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  120.             em: (element?: string | undefined, modifier?: string | undefined) => string;

  121.             bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  122.             bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  123.             is: {

  124.                 (name: string, state: boolean | undefined): string;

  125.                 (name: string): string;

  126.             };

  127.             cssVar: (object: Record<string, string>) => Record<string, string>;

  128.             cssVarName: (name: string) => string;

  129.             cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  130.             cssVarBlockName: (name: string) => string;

  131.         };

  132.         index: import("vue").Ref<number>;

  133.         lineStyle: import("vue").Ref<{}>;

  134.         internalStatus: import("vue").Ref<string>;

  135.         parent: import("./src/item.vue").IStepsInject;

  136.         currentInstance: import("vue").ComponentInternalInstance | null;

  137.         currentStatus: import("vue").ComputedRef<string>;

  138.         prevStatus: import("vue").ComputedRef<string>;

  139.         isCenter: import("vue").ComputedRef<boolean>;

  140.         isVertical: import("vue").ComputedRef<boolean>;

  141.         isSimple: import("vue").ComputedRef<boolean>;

  142.         stepsCount: import("vue").ComputedRef<number>;

  143.         isLast: import("vue").ComputedRef<boolean>;

  144.         space: import("vue").ComputedRef<string | number>;

  145.         style: import("vue").ComputedRef<import("vue").CSSProperties>;

  146.         setIndex: (val: number) => void;

  147.         calcProgress: (status: string) => void;

  148.         updateStatus: (activeIndex: number) => void;

  149.         stepItemState: {

  150.             uid: number | undefined;

  151.             currentStatus: string;

  152.             setIndex: (val: number) => void;

  153.             calcProgress: (status: string) => void;

  154.         };

  155.         ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  156.             readonly size: {

  157.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  158.                 readonly required: false;

  159.                 readonly validator: ((val: unknown) => boolean) | undefined;

  160.                 __epPropKey: true;

  161.             };

  162.             readonly color: {

  163.                 readonly type: import("vue").PropType<string>;

  164.                 readonly required: false;

  165.                 readonly validator: ((val: unknown) => boolean) | undefined;

  166.                 __epPropKey: true;

  167.             };

  168.         }, {

  169.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  170.                 readonly size: {

  171.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  172.                     readonly required: false;

  173.                     readonly validator: ((val: unknown) => boolean) | undefined;

  174.                     __epPropKey: true;

  175.                 };

  176.                 readonly color: {

  177.                     readonly type: import("vue").PropType<string>;

  178.                     readonly required: false;

  179.                     readonly validator: ((val: unknown) => boolean) | undefined;

  180.                     __epPropKey: true;

  181.                 };

  182.             }>> & {

  183.                 [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  184.             }>>;

  185.             ns: {

  186.                 namespace: import("vue").ComputedRef<string>;

  187.                 b: (blockSuffix?: string) => string;

  188.                 e: (element?: string | undefined) => string;

  189.                 m: (modifier?: string | undefined) => string;

  190.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  191.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  192.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  193.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  194.                 is: {

  195.                     (name: string, state: boolean | undefined): string;

  196.                     (name: string): string;

  197.                 };

  198.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  199.                 cssVarName: (name: string) => string;

  200.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  201.                 cssVarBlockName: (name: string) => string;

  202.             };

  203.             style: import("vue").ComputedRef<import("vue").CSSProperties>;

  204.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  205.             readonly size: {

  206.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  207.                 readonly required: false;

  208.                 readonly validator: ((val: unknown) => boolean) | undefined;

  209.                 __epPropKey: true;

  210.             };

  211.             readonly color: {

  212.                 readonly type: import("vue").PropType<string>;

  213.                 readonly required: false;

  214.                 readonly validator: ((val: unknown) => boolean) | undefined;

  215.                 __epPropKey: true;

  216.             };

  217.         }>>, {}>> & Record<string, any>;

  218.         Check: import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;

  219.         Close: import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;

  220.     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  221.         readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  222.         readonly icon: {

  223.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  224.             readonly required: false;

  225.             readonly validator: ((val: unknown) => boolean) | undefined;

  226.             __epPropKey: true;

  227.         };

  228.         readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  229.         readonly status: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "success" | "error" | "wait" | "finish" | "process", unknown, "", boolean>;

  230.     }>>, {

  231.         readonly title: string;

  232.         readonly description: string;

  233.         readonly status: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "wait" | "finish" | "process", unknown>;

  234.     }>;

  235. };

  236. export default ElSteps;

  237. export declare const ElStep: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  238.     readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  239.     readonly icon: {

  240.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  241.         readonly required: false;

  242.         readonly validator: ((val: unknown) => boolean) | undefined;

  243.         __epPropKey: true;

  244.     };

  245.     readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  246.     readonly status: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "success" | "error" | "wait" | "finish" | "process", unknown, "", boolean>;

  247. }, {

  248.     props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  249.         readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  250.         readonly icon: {

  251.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  252.             readonly required: false;

  253.             readonly validator: ((val: unknown) => boolean) | undefined;

  254.             __epPropKey: true;

  255.         };

  256.         readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  257.         readonly status: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "success" | "error" | "wait" | "finish" | "process", unknown, "", boolean>;

  258.     }>> & {

  259.         [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  260.     }>>;

  261.     ns: {

  262.         namespace: import("vue").ComputedRef<string>;

  263.         b: (blockSuffix?: string) => string;

  264.         e: (element?: string | undefined) => string;

  265.         m: (modifier?: string | undefined) => string;

  266.         be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  267.         em: (element?: string | undefined, modifier?: string | undefined) => string;

  268.         bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  269.         bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  270.         is: {

  271.             (name: string, state: boolean | undefined): string;

  272.             (name: string): string;

  273.         };

  274.         cssVar: (object: Record<string, string>) => Record<string, string>;

  275.         cssVarName: (name: string) => string;

  276.         cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  277.         cssVarBlockName: (name: string) => string;

  278.     };

  279.     index: import("vue").Ref<number>;

  280.     lineStyle: import("vue").Ref<{}>;

  281.     internalStatus: import("vue").Ref<string>;

  282.     parent: import("./src/item.vue").IStepsInject;

  283.     currentInstance: import("vue").ComponentInternalInstance | null;

  284.     currentStatus: import("vue").ComputedRef<string>;

  285.     prevStatus: import("vue").ComputedRef<string>;

  286.     isCenter: import("vue").ComputedRef<boolean>;

  287.     isVertical: import("vue").ComputedRef<boolean>;

  288.     isSimple: import("vue").ComputedRef<boolean>;

  289.     stepsCount: import("vue").ComputedRef<number>;

  290.     isLast: import("vue").ComputedRef<boolean>;

  291.     space: import("vue").ComputedRef<string | number>;

  292.     style: import("vue").ComputedRef<import("vue").CSSProperties>;

  293.     setIndex: (val: number) => void;

  294.     calcProgress: (status: string) => void;

  295.     updateStatus: (activeIndex: number) => void;

  296.     stepItemState: {

  297.         uid: number | undefined;

  298.         currentStatus: string;

  299.         setIndex: (val: number) => void;

  300.         calcProgress: (status: string) => void;

  301.     };

  302.     ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  303.         readonly size: {

  304.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  305.             readonly required: false;

  306.             readonly validator: ((val: unknown) => boolean) | undefined;

  307.             __epPropKey: true;

  308.         };

  309.         readonly color: {

  310.             readonly type: import("vue").PropType<string>;

  311.             readonly required: false;

  312.             readonly validator: ((val: unknown) => boolean) | undefined;

  313.             __epPropKey: true;

  314.         };

  315.     }, {

  316.         props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  317.             readonly size: {

  318.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  319.                 readonly required: false;

  320.                 readonly validator: ((val: unknown) => boolean) | undefined;

  321.                 __epPropKey: true;

  322.             };

  323.             readonly color: {

  324.                 readonly type: import("vue").PropType<string>;

  325.                 readonly required: false;

  326.                 readonly validator: ((val: unknown) => boolean) | undefined;

  327.                 __epPropKey: true;

  328.             };

  329.         }>> & {

  330.             [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  331.         }>>;

  332.         ns: {

  333.             namespace: import("vue").ComputedRef<string>;

  334.             b: (blockSuffix?: string) => string;

  335.             e: (element?: string | undefined) => string;

  336.             m: (modifier?: string | undefined) => string;

  337.             be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  338.             em: (element?: string | undefined, modifier?: string | undefined) => string;

  339.             bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  340.             bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  341.             is: {

  342.                 (name: string, state: boolean | undefined): string;

  343.                 (name: string): string;

  344.             };

  345.             cssVar: (object: Record<string, string>) => Record<string, string>;

  346.             cssVarName: (name: string) => string;

  347.             cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  348.             cssVarBlockName: (name: string) => string;

  349.         };

  350.         style: import("vue").ComputedRef<import("vue").CSSProperties>;

  351.     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  352.         readonly size: {

  353.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  354.             readonly required: false;

  355.             readonly validator: ((val: unknown) => boolean) | undefined;

  356.             __epPropKey: true;

  357.         };

  358.         readonly color: {

  359.             readonly type: import("vue").PropType<string>;

  360.             readonly required: false;

  361.             readonly validator: ((val: unknown) => boolean) | undefined;

  362.             __epPropKey: true;

  363.         };

  364.     }>>, {}>> & Record<string, any>;

  365.     Check: import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;

  366.     Close: import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;

  367. }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  368.     readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  369.     readonly icon: {

  370.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  371.         readonly required: false;

  372.         readonly validator: ((val: unknown) => boolean) | undefined;

  373.         __epPropKey: true;

  374.     };

  375.     readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;

  376.     readonly status: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "success" | "error" | "wait" | "finish" | "process", unknown, "", boolean>;

  377. }>>, {

  378.     readonly title: string;

  379.     readonly description: string;

  380.     readonly status: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "wait" | "finish" | "process", unknown>;

  381. }>>;

  382. export * from './src/item';

  383. export * from './src/steps';