CPL
/
banboshi_V2
1
0
Креирај огранак 0
Код Дискусије 0 Захтеви за спајање 0 Издања 1 Вики 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 Комити
5 Гране
6.2 GiB
 
 
 
 
Дрво: d271ad1b21
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from 'd271ad1b21'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/element-plus/es/components/transfer/index.d.ts

6094 lines
440 KiB
Датотека Blame Историја 

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

  2.     readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  3.     readonly titles: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;

  4.     readonly buttonTexts: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;

  5.     readonly filterPlaceholder: StringConstructor;

  6.     readonly filterMethod: {

  7.         readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  8.         readonly required: false;

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

  10.         __epPropKey: true;

  11.     };

  12.     readonly leftDefaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  13.     readonly rightDefaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  14.     readonly renderContent: {

  15.         readonly type: import("vue").PropType<import("./src/transfer").renderContent>;

  16.         readonly required: false;

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

  18.         __epPropKey: true;

  19.     };

  20.     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  21.     readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  22.     readonly filterable: BooleanConstructor;

  23.     readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  24.         readonly label: "label";

  25.         readonly key: "key";

  26.         readonly disabled: "disabled";

  27.     }>, boolean>;

  28.     readonly targetOrder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "push" | "unshift" | "original", unknown, "original", boolean>;

  29.     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  30. }, {

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

  32.         readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  33.         readonly titles: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;

  34.         readonly buttonTexts: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;

  35.         readonly filterPlaceholder: StringConstructor;

  36.         readonly filterMethod: {

  37.             readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  38.             readonly required: false;

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

  40.             __epPropKey: true;

  41.         };

  42.         readonly leftDefaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  43.         readonly rightDefaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  44.         readonly renderContent: {

  45.             readonly type: import("vue").PropType<import("./src/transfer").renderContent>;

  46.             readonly required: false;

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

  48.             __epPropKey: true;

  49.         };

  50.         readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  51.         readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  52.         readonly filterable: BooleanConstructor;

  53.         readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  54.             readonly label: "label";

  55.             readonly key: "key";

  56.             readonly disabled: "disabled";

  57.         }>, boolean>;

  58.         readonly targetOrder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "push" | "unshift" | "original", unknown, "original", boolean>;

  59.         readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  60.     }>> & {

  61.         onChange?: ((value: import("./src/transfer").TransferKey[], direction: import("./src/transfer").TransferDirection, movedKeys: import("./src/transfer").TransferKey[]) => any) | undefined;

  62.         "onUpdate:modelValue"?: ((value: import("./src/transfer").TransferKey[]) => any) | undefined;

  63.         "onLeft-check-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  64.         "onRight-check-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  65.     }>>;

  66.     emit: ((event: "update:modelValue", value: import("./src/transfer").TransferKey[]) => void) & ((event: "change", value: import("./src/transfer").TransferKey[], direction: import("./src/transfer").TransferDirection, movedKeys: import("./src/transfer").TransferKey[]) => void) & ((event: "left-check-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void) & ((event: "right-check-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void);

  67.     slots: Readonly<{

  68.         [name: string]: import("vue").Slot | undefined;

  69.     }>;

  70.     t: import("../..").Translator;

  71.     ns: {

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

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

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

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

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

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

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

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

  80.         is: {

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

  82.             (name: string): string;

  83.         };

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

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

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

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

  88.     };

  89.     formItem: import("..").FormItemContext | undefined;

  90.     checkedState: {

  91.         leftChecked: import("./src/transfer").TransferKey[];

  92.         rightChecked: import("./src/transfer").TransferKey[];

  93.     };

  94.     propsAlias: import("vue").ComputedRef<{

  95.         label: string;

  96.         key: string;

  97.         disabled: string;

  98.     }>;

  99.     sourceData: import("vue").ComputedRef<import("./src/transfer").TransferDataItem[]>;

  100.     targetData: import("vue").ComputedRef<import("./src/transfer").TransferDataItem[]>;

  101.     onSourceCheckedChange: (val: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  102.     onTargetCheckedChange: (val: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  103.     addToLeft: () => void;

  104.     addToRight: () => void;

  105.     leftPanel: import("vue").Ref<({

  106.         $: import("vue").ComponentInternalInstance;

  107.         $data: {};

  108.         $props: Partial<{

  109.             readonly props: import("./src/transfer").TransferPropsAlias;

  110.             readonly data: import("./src/transfer").TransferDataItem[];

  111.             readonly filterable: boolean;

  112.             readonly format: import("./src/transfer").TransferFormat;

  113.             readonly defaultChecked: import("./src/transfer").TransferKey[];

  114.         }> & Omit<Readonly<import("vue").ExtractPropTypes<{

  115.             readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  116.             readonly optionRender: {

  117.                 readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  118.                     [key: string]: any;

  119.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  120.                     [key: string]: any;

  121.                 }>[]>;

  122.                 readonly required: false;

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

  124.                 __epPropKey: true;

  125.             };

  126.             readonly placeholder: StringConstructor;

  127.             readonly title: StringConstructor;

  128.             readonly filterable: BooleanConstructor;

  129.             readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  130.             readonly filterMethod: {

  131.                 readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  132.                 readonly required: false;

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

  134.                 __epPropKey: true;

  135.             };

  136.             readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  137.             readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  138.                 readonly label: "label";

  139.                 readonly key: "key";

  140.                 readonly disabled: "disabled";

  141.             }>, boolean>;

  142.         }>> & {

  143.             "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  144.         } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "props" | "data" | "filterable" | "format" | "defaultChecked">;

  145.         $attrs: {

  146.             [x: string]: unknown;

  147.         };

  148.         $refs: {

  149.             [x: string]: unknown;

  150.         };

  151.         $slots: Readonly<{

  152.             [name: string]: import("vue").Slot | undefined;

  153.         }>;

  154.         $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;

  155.         $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;

  156.         $emit: (event: "checked-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  157.         $el: any;

  158.         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{

  159.             readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  160.             readonly optionRender: {

  161.                 readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  162.                     [key: string]: any;

  163.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  164.                     [key: string]: any;

  165.                 }>[]>;

  166.                 readonly required: false;

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

  168.                 __epPropKey: true;

  169.             };

  170.             readonly placeholder: StringConstructor;

  171.             readonly title: StringConstructor;

  172.             readonly filterable: BooleanConstructor;

  173.             readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  174.             readonly filterMethod: {

  175.                 readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  176.                 readonly required: false;

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

  178.                 __epPropKey: true;

  179.             };

  180.             readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  181.             readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  182.                 readonly label: "label";

  183.                 readonly key: "key";

  184.                 readonly disabled: "disabled";

  185.             }>, boolean>;

  186.         }>> & {

  187.             "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  188.         }, {

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

  190.                 readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  191.                 readonly optionRender: {

  192.                     readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  193.                         [key: string]: any;

  194.                     }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  195.                         [key: string]: any;

  196.                     }>[]>;

  197.                     readonly required: false;

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

  199.                     __epPropKey: true;

  200.                 };

  201.                 readonly placeholder: StringConstructor;

  202.                 readonly title: StringConstructor;

  203.                 readonly filterable: BooleanConstructor;

  204.                 readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  205.                 readonly filterMethod: {

  206.                     readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  207.                     readonly required: false;

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

  209.                     __epPropKey: true;

  210.                 };

  211.                 readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  212.                 readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  213.                     readonly label: "label";

  214.                     readonly key: "key";

  215.                     readonly disabled: "disabled";

  216.                 }>, boolean>;

  217.             }>> & {

  218.                 "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  219.             }>>;

  220.             emit: (event: "checked-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  221.             slots: Readonly<{

  222.                 [name: string]: import("vue").Slot | undefined;

  223.             }>;

  224.             OptionContent: ({ option }: {

  225.                 option: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  226.                     [key: string]: any;

  227.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  228.                     [key: string]: any;

  229.                 }>[];

  230.             }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  231.                 [key: string]: any;

  232.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  233.                 [key: string]: any;

  234.             }>[];

  235.             t: import("../..").Translator;

  236.             ns: {

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

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

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

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

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

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

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

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

  245.                 is: {

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

  247.                     (name: string): string;

  248.                 };

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

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

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

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

  253.             };

  254.             panelState: {

  255.                 checked: import("./src/transfer").TransferKey[];

  256.                 allChecked: boolean;

  257.                 query: string;

  258.                 checkChangeByUser: boolean;

  259.             };

  260.             propsAlias: import("vue").ComputedRef<{

  261.                 label: string;

  262.                 key: string;

  263.                 disabled: string;

  264.             }>;

  265.             filteredData: import("vue").ComputedRef<import("./src/transfer").TransferDataItem[]>;

  266.             checkedSummary: import("vue").ComputedRef<string>;

  267.             isIndeterminate: import("vue").ComputedRef<boolean>;

  268.             handleAllCheckedChange: (value: import("..").CheckboxValueType) => void;

  269.             hasNoMatch: import("vue").ComputedRef<boolean>;

  270.             hasFooter: import("vue").ComputedRef<boolean>;

  271.             checked: import("vue").Ref<import("./src/transfer").TransferKey[]>;

  272.             allChecked: import("vue").Ref<boolean>;

  273.             query: import("vue").Ref<string>;

  274.             isEmpty: (val: unknown) => boolean;

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

  276.                 modelValue: {

  277.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  278.                     default: undefined;

  279.                 };

  280.                 label: {

  281.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  282.                 };

  283.                 indeterminate: BooleanConstructor;

  284.                 disabled: BooleanConstructor;

  285.                 checked: BooleanConstructor;

  286.                 name: {

  287.                     type: StringConstructor;

  288.                     default: undefined;

  289.                 };

  290.                 trueLabel: {

  291.                     type: (NumberConstructor | StringConstructor)[];

  292.                     default: undefined;

  293.                 };

  294.                 falseLabel: {

  295.                     type: (NumberConstructor | StringConstructor)[];

  296.                     default: undefined;

  297.                 };

  298.                 id: {

  299.                     type: StringConstructor;

  300.                     default: undefined;

  301.                 };

  302.                 controls: {

  303.                     type: StringConstructor;

  304.                     default: undefined;

  305.                 };

  306.                 border: BooleanConstructor;

  307.                 size: {

  308.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  309.                     readonly required: false;

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

  311.                     __epPropKey: true;

  312.                 };

  313.                 tabindex: (NumberConstructor | StringConstructor)[];

  314.                 validateEvent: {

  315.                     type: BooleanConstructor;

  316.                     default: boolean;

  317.                 };

  318.             }, {

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

  320.                     modelValue: {

  321.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  322.                         default: undefined;

  323.                     };

  324.                     label: {

  325.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  326.                     };

  327.                     indeterminate: BooleanConstructor;

  328.                     disabled: BooleanConstructor;

  329.                     checked: BooleanConstructor;

  330.                     name: {

  331.                         type: StringConstructor;

  332.                         default: undefined;

  333.                     };

  334.                     trueLabel: {

  335.                         type: (NumberConstructor | StringConstructor)[];

  336.                         default: undefined;

  337.                     };

  338.                     falseLabel: {

  339.                         type: (NumberConstructor | StringConstructor)[];

  340.                         default: undefined;

  341.                     };

  342.                     id: {

  343.                         type: StringConstructor;

  344.                         default: undefined;

  345.                     };

  346.                     controls: {

  347.                         type: StringConstructor;

  348.                         default: undefined;

  349.                     };

  350.                     border: BooleanConstructor;

  351.                     size: {

  352.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  353.                         readonly required: false;

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

  355.                         __epPropKey: true;

  356.                     };

  357.                     tabindex: (NumberConstructor | StringConstructor)[];

  358.                     validateEvent: {

  359.                         type: BooleanConstructor;

  360.                         default: boolean;

  361.                     };

  362.                 }>> & {

  363.                     onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  364.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  365.                 }>>;

  366.                 slots: Readonly<{

  367.                     [name: string]: import("vue").Slot | undefined;

  368.                 }>;

  369.                 inputId: import("vue").Ref<string | undefined>;

  370.                 isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  371.                 isChecked: import("vue").ComputedRef<boolean>;

  372.                 isDisabled: import("vue").ComputedRef<boolean>;

  373.                 isFocused: import("vue").Ref<boolean>;

  374.                 checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  375.                 hasOwnLabel: import("vue").ComputedRef<boolean>;

  376.                 model: import("vue").WritableComputedRef<any>;

  377.                 handleChange: (e: Event) => void;

  378.                 onClickRoot: (e: MouseEvent) => Promise<void>;

  379.                 ns: {

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

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

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

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

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

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

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

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

  388.                     is: {

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

  390.                         (name: string): string;

  391.                     };

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

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

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

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

  396.                 };

  397.                 compKls: import("vue").ComputedRef<string[]>;

  398.                 spanKls: import("vue").ComputedRef<string[]>;

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

  400.                 "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  401.                 change: (val: import("..").CheckboxValueType) => boolean;

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

  403.                 modelValue: {

  404.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  405.                     default: undefined;

  406.                 };

  407.                 label: {

  408.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  409.                 };

  410.                 indeterminate: BooleanConstructor;

  411.                 disabled: BooleanConstructor;

  412.                 checked: BooleanConstructor;

  413.                 name: {

  414.                     type: StringConstructor;

  415.                     default: undefined;

  416.                 };

  417.                 trueLabel: {

  418.                     type: (NumberConstructor | StringConstructor)[];

  419.                     default: undefined;

  420.                 };

  421.                 falseLabel: {

  422.                     type: (NumberConstructor | StringConstructor)[];

  423.                     default: undefined;

  424.                 };

  425.                 id: {

  426.                     type: StringConstructor;

  427.                     default: undefined;

  428.                 };

  429.                 controls: {

  430.                     type: StringConstructor;

  431.                     default: undefined;

  432.                 };

  433.                 border: BooleanConstructor;

  434.                 size: {

  435.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  436.                     readonly required: false;

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

  438.                     __epPropKey: true;

  439.                 };

  440.                 tabindex: (NumberConstructor | StringConstructor)[];

  441.                 validateEvent: {

  442.                     type: BooleanConstructor;

  443.                     default: boolean;

  444.                 };

  445.             }>> & {

  446.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  447.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  448.             }, {

  449.                 modelValue: string | number | boolean;

  450.                 id: string;

  451.                 disabled: boolean;

  452.                 name: string;

  453.                 validateEvent: boolean;

  454.                 border: boolean;

  455.                 indeterminate: boolean;

  456.                 checked: boolean;

  457.                 trueLabel: string | number;

  458.                 falseLabel: string | number;

  459.                 controls: string;

  460.             }>> & {

  461.                 CheckboxButton: import("vue").DefineComponent<{

  462.                     modelValue: {

  463.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  464.                         default: undefined;

  465.                     };

  466.                     label: {

  467.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  468.                     };

  469.                     indeterminate: BooleanConstructor;

  470.                     disabled: BooleanConstructor;

  471.                     checked: BooleanConstructor;

  472.                     name: {

  473.                         type: StringConstructor;

  474.                         default: undefined;

  475.                     };

  476.                     trueLabel: {

  477.                         type: (NumberConstructor | StringConstructor)[];

  478.                         default: undefined;

  479.                     };

  480.                     falseLabel: {

  481.                         type: (NumberConstructor | StringConstructor)[];

  482.                         default: undefined;

  483.                     };

  484.                     id: {

  485.                         type: StringConstructor;

  486.                         default: undefined;

  487.                     };

  488.                     controls: {

  489.                         type: StringConstructor;

  490.                         default: undefined;

  491.                     };

  492.                     border: BooleanConstructor;

  493.                     size: {

  494.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  495.                         readonly required: false;

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

  497.                         __epPropKey: true;

  498.                     };

  499.                     tabindex: (NumberConstructor | StringConstructor)[];

  500.                     validateEvent: {

  501.                         type: BooleanConstructor;

  502.                         default: boolean;

  503.                     };

  504.                 }, {

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

  506.                         modelValue: {

  507.                             type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  508.                             default: undefined;

  509.                         };

  510.                         label: {

  511.                             type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  512.                         };

  513.                         indeterminate: BooleanConstructor;

  514.                         disabled: BooleanConstructor;

  515.                         checked: BooleanConstructor;

  516.                         name: {

  517.                             type: StringConstructor;

  518.                             default: undefined;

  519.                         };

  520.                         trueLabel: {

  521.                             type: (NumberConstructor | StringConstructor)[];

  522.                             default: undefined;

  523.                         };

  524.                         falseLabel: {

  525.                             type: (NumberConstructor | StringConstructor)[];

  526.                             default: undefined;

  527.                         };

  528.                         id: {

  529.                             type: StringConstructor;

  530.                             default: undefined;

  531.                         };

  532.                         controls: {

  533.                             type: StringConstructor;

  534.                             default: undefined;

  535.                         };

  536.                         border: BooleanConstructor;

  537.                         size: {

  538.                             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  539.                             readonly required: false;

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

  541.                             __epPropKey: true;

  542.                         };

  543.                         tabindex: (NumberConstructor | StringConstructor)[];

  544.                         validateEvent: {

  545.                             type: BooleanConstructor;

  546.                             default: boolean;

  547.                         };

  548.                     }>> & {

  549.                         onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  550.                         "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  551.                     }>>;

  552.                     slots: Readonly<{

  553.                         [name: string]: import("vue").Slot | undefined;

  554.                     }>;

  555.                     isFocused: import("vue").Ref<boolean>;

  556.                     isChecked: import("vue").ComputedRef<boolean>;

  557.                     isDisabled: import("vue").ComputedRef<boolean>;

  558.                     checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  559.                     model: import("vue").WritableComputedRef<any>;

  560.                     handleChange: (e: Event) => void;

  561.                     checkboxGroup: ({

  562.                         modelValue?: import("vue").WritableComputedRef<any> | undefined;

  563.                         changeEvent?: ((...args: any) => any) | undefined;

  564.                     } & import("vue").ToRefs<Pick<import("..").CheckboxGroupProps, "fill" | "size" | "disabled" | "validateEvent" | "max" | "min" | "textColor">>) | undefined;

  565.                     ns: {

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

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

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

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

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

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

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

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

  574.                         is: {

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

  576.                             (name: string): string;

  577.                         };

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

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

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

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

  582.                     };

  583.                     activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  584.                     labelKls: import("vue").ComputedRef<string[]>;

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

  586.                     "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  587.                     change: (val: import("..").CheckboxValueType) => boolean;

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

  589.                     modelValue: {

  590.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  591.                         default: undefined;

  592.                     };

  593.                     label: {

  594.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  595.                     };

  596.                     indeterminate: BooleanConstructor;

  597.                     disabled: BooleanConstructor;

  598.                     checked: BooleanConstructor;

  599.                     name: {

  600.                         type: StringConstructor;

  601.                         default: undefined;

  602.                     };

  603.                     trueLabel: {

  604.                         type: (NumberConstructor | StringConstructor)[];

  605.                         default: undefined;

  606.                     };

  607.                     falseLabel: {

  608.                         type: (NumberConstructor | StringConstructor)[];

  609.                         default: undefined;

  610.                     };

  611.                     id: {

  612.                         type: StringConstructor;

  613.                         default: undefined;

  614.                     };

  615.                     controls: {

  616.                         type: StringConstructor;

  617.                         default: undefined;

  618.                     };

  619.                     border: BooleanConstructor;

  620.                     size: {

  621.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  622.                         readonly required: false;

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

  624.                         __epPropKey: true;

  625.                     };

  626.                     tabindex: (NumberConstructor | StringConstructor)[];

  627.                     validateEvent: {

  628.                         type: BooleanConstructor;

  629.                         default: boolean;

  630.                     };

  631.                 }>> & {

  632.                     onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  633.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  634.                 }, {

  635.                     modelValue: string | number | boolean;

  636.                     id: string;

  637.                     disabled: boolean;

  638.                     name: string;

  639.                     validateEvent: boolean;

  640.                     border: boolean;

  641.                     indeterminate: boolean;

  642.                     checked: boolean;

  643.                     trueLabel: string | number;

  644.                     falseLabel: string | number;

  645.                     controls: string;

  646.                 }>;

  647.                 CheckboxGroup: import("vue").DefineComponent<{

  648.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  649.                     readonly disabled: BooleanConstructor;

  650.                     readonly min: NumberConstructor;

  651.                     readonly max: NumberConstructor;

  652.                     readonly size: {

  653.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  654.                         readonly required: false;

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

  656.                         __epPropKey: true;

  657.                     };

  658.                     readonly label: StringConstructor;

  659.                     readonly fill: StringConstructor;

  660.                     readonly textColor: StringConstructor;

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

  662.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  663.                 }, {

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

  665.                         readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  666.                         readonly disabled: BooleanConstructor;

  667.                         readonly min: NumberConstructor;

  668.                         readonly max: NumberConstructor;

  669.                         readonly size: {

  670.                             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  671.                             readonly required: false;

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

  673.                             __epPropKey: true;

  674.                         };

  675.                         readonly label: StringConstructor;

  676.                         readonly fill: StringConstructor;

  677.                         readonly textColor: StringConstructor;

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

  679.                         readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  680.                     }>> & {

  681.                         onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  682.                         "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  683.                     }>>;

  684.                     emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  685.                     ns: {

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

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

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

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

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

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

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

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

  694.                         is: {

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

  696.                             (name: string): string;

  697.                         };

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

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

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

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

  702.                     };

  703.                     formItem: import("..").FormItemContext | undefined;

  704.                     groupId: import("vue").Ref<string | undefined>;

  705.                     isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  706.                     changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  707.                     modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

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

  709.                     "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  710.                     change: (val: import("..").CheckboxValueType[]) => boolean;

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

  712.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  713.                     readonly disabled: BooleanConstructor;

  714.                     readonly min: NumberConstructor;

  715.                     readonly max: NumberConstructor;

  716.                     readonly size: {

  717.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  718.                         readonly required: false;

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

  720.                         __epPropKey: true;

  721.                     };

  722.                     readonly label: StringConstructor;

  723.                     readonly fill: StringConstructor;

  724.                     readonly textColor: StringConstructor;

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

  726.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  727.                 }>> & {

  728.                     onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  729.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  730.                 }, {

  731.                     readonly modelValue: import("..").CheckboxGroupValueType;

  732.                     readonly disabled: boolean;

  733.                     readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  734.                     readonly tag: string;

  735.                 }>;

  736.             };

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

  738.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  739.                 readonly disabled: BooleanConstructor;

  740.                 readonly min: NumberConstructor;

  741.                 readonly max: NumberConstructor;

  742.                 readonly size: {

  743.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  744.                     readonly required: false;

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

  746.                     __epPropKey: true;

  747.                 };

  748.                 readonly label: StringConstructor;

  749.                 readonly fill: StringConstructor;

  750.                 readonly textColor: StringConstructor;

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

  752.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  753.             }, {

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

  755.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  756.                     readonly disabled: BooleanConstructor;

  757.                     readonly min: NumberConstructor;

  758.                     readonly max: NumberConstructor;

  759.                     readonly size: {

  760.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  761.                         readonly required: false;

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

  763.                         __epPropKey: true;

  764.                     };

  765.                     readonly label: StringConstructor;

  766.                     readonly fill: StringConstructor;

  767.                     readonly textColor: StringConstructor;

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

  769.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  770.                 }>> & {

  771.                     onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  772.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  773.                 }>>;

  774.                 emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  775.                 ns: {

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

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

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

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

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

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

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

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

  784.                     is: {

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

  786.                         (name: string): string;

  787.                     };

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

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

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

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

  792.                 };

  793.                 formItem: import("..").FormItemContext | undefined;

  794.                 groupId: import("vue").Ref<string | undefined>;

  795.                 isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  796.                 changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  797.                 modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

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

  799.                 "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  800.                 change: (val: import("..").CheckboxValueType[]) => boolean;

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

  802.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  803.                 readonly disabled: BooleanConstructor;

  804.                 readonly min: NumberConstructor;

  805.                 readonly max: NumberConstructor;

  806.                 readonly size: {

  807.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  808.                     readonly required: false;

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

  810.                     __epPropKey: true;

  811.                 };

  812.                 readonly label: StringConstructor;

  813.                 readonly fill: StringConstructor;

  814.                 readonly textColor: StringConstructor;

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

  816.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  817.             }>> & {

  818.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  819.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  820.             }, {

  821.                 readonly modelValue: import("..").CheckboxGroupValueType;

  822.                 readonly disabled: boolean;

  823.                 readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  824.                 readonly tag: string;

  825.             }>>;

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

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

  828.                 readonly size: {

  829.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  830.                     readonly required: false;

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

  832.                     __epPropKey: true;

  833.                 };

  834.                 readonly disabled: BooleanConstructor;

  835.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  837.                 readonly resize: {

  838.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  839.                     readonly required: false;

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

  841.                     __epPropKey: true;

  842.                 };

  843.                 readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  845.                 readonly formatter: {

  846.                     readonly type: import("vue").PropType<Function>;

  847.                     readonly required: false;

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

  849.                     __epPropKey: true;

  850.                 };

  851.                 readonly parser: {

  852.                     readonly type: import("vue").PropType<Function>;

  853.                     readonly required: false;

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

  855.                     __epPropKey: true;

  856.                 };

  857.                 readonly placeholder: {

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

  859.                     readonly required: false;

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

  861.                     __epPropKey: true;

  862.                 };

  863.                 readonly form: {

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

  865.                     readonly required: false;

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

  867.                     __epPropKey: true;

  868.                 };

  869.                 readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  870.                 readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  871.                 readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  872.                 readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  873.                 readonly suffixIcon: {

  874.                     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>>;

  875.                     readonly required: false;

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

  877.                     __epPropKey: true;

  878.                 };

  879.                 readonly prefixIcon: {

  880.                     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>>;

  881.                     readonly required: false;

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

  883.                     __epPropKey: true;

  884.                 };

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

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

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

  888.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  889.                 readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  890.             }, {

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

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

  893.                     readonly size: {

  894.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  895.                         readonly required: false;

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

  897.                         __epPropKey: true;

  898.                     };

  899.                     readonly disabled: BooleanConstructor;

  900.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  902.                     readonly resize: {

  903.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  904.                         readonly required: false;

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

  906.                         __epPropKey: true;

  907.                     };

  908.                     readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  910.                     readonly formatter: {

  911.                         readonly type: import("vue").PropType<Function>;

  912.                         readonly required: false;

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

  914.                         __epPropKey: true;

  915.                     };

  916.                     readonly parser: {

  917.                         readonly type: import("vue").PropType<Function>;

  918.                         readonly required: false;

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

  920.                         __epPropKey: true;

  921.                     };

  922.                     readonly placeholder: {

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

  924.                         readonly required: false;

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

  926.                         __epPropKey: true;

  927.                     };

  928.                     readonly form: {

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

  930.                         readonly required: false;

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

  932.                         __epPropKey: true;

  933.                     };

  934.                     readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  935.                     readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  936.                     readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  937.                     readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  938.                     readonly suffixIcon: {

  939.                         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>>;

  940.                         readonly required: false;

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

  942.                         __epPropKey: true;

  943.                     };

  944.                     readonly prefixIcon: {

  945.                         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>>;

  946.                         readonly required: false;

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

  948.                         __epPropKey: true;

  949.                     };

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

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

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

  953.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  954.                     readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  955.                 }>> & {

  956.                     onChange?: ((value: string) => any) | undefined;

  957.                     "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  958.                     onInput?: ((value: string) => any) | undefined;

  959.                     onFocus?: ((evt: FocusEvent) => any) | undefined;

  960.                     onBlur?: ((evt: FocusEvent) => any) | undefined;

  961.                     onClear?: (() => any) | undefined;

  962.                     onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  963.                     onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  964.                     onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  965.                     onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  966.                     onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  967.                     onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  968.                 }>>;

  969.                 emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void);

  970.                 rawAttrs: {

  971.                     [x: string]: unknown;

  972.                 };

  973.                 slots: Readonly<{

  974.                     [name: string]: import("vue").Slot | undefined;

  975.                 }>;

  976.                 containerAttrs: import("vue").ComputedRef<Record<string, unknown>>;

  977.                 containerKls: import("vue").ComputedRef<unknown[]>;

  978.                 wrapperKls: import("vue").ComputedRef<string[]>;

  979.                 attrs: import("vue").ComputedRef<Record<string, unknown>>;

  980.                 form: import("..").FormContext | undefined;

  981.                 formItem: import("..").FormItemContext | undefined;

  982.                 inputId: import("vue").Ref<string | undefined>;

  983.                 inputSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  984.                 inputDisabled: import("vue").ComputedRef<boolean>;

  985.                 nsInput: {

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

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

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

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

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

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

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

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

  994.                     is: {

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

  996.                         (name: string): string;

  997.                     };

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

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

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

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

  1002.                 };

  1003.                 nsTextarea: {

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

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

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

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

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

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

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

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

  1012.                     is: {

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

  1014.                         (name: string): string;

  1015.                     };

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

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

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

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

  1020.                 };

  1021.                 input: import("vue").ShallowRef<HTMLInputElement | undefined>;

  1022.                 textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined>;

  1023.                 focused: import("vue").Ref<boolean>;

  1024.                 hovering: import("vue").Ref<boolean>;

  1025.                 isComposing: import("vue").Ref<boolean>;

  1026.                 passwordVisible: import("vue").Ref<boolean>;

  1027.                 countStyle: import("vue").Ref<import("vue").StyleValue | undefined>;

  1028.                 textareaCalcStyle: import("vue").ShallowRef<import("vue").StyleValue>;

  1029.                 _ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;

  1030.                 needStatusIcon: import("vue").ComputedRef<boolean>;

  1031.                 validateState: import("vue").ComputedRef<"" | "success" | "error" | "validating">;

  1032.                 validateIcon: import("vue").ComputedRef<"" | 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<{}>>, {}>>;

  1033.                 passwordIcon: import("vue").ComputedRef<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<{}>>, {}>>;

  1034.                 containerStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  1035.                 textareaStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  1036.                 nativeInputValue: import("vue").ComputedRef<string>;

  1037.                 showClear: import("vue").ComputedRef<boolean>;

  1038.                 showPwdVisible: import("vue").ComputedRef<boolean>;

  1039.                 isWordLimitVisible: import("vue").ComputedRef<boolean>;

  1040.                 textLength: import("vue").ComputedRef<number>;

  1041.                 inputExceed: import("vue").ComputedRef<boolean>;

  1042.                 suffixVisible: import("vue").ComputedRef<boolean>;

  1043.                 recordCursor: () => void;

  1044.                 setCursor: () => void;

  1045.                 resizeTextarea: () => void;

  1046.                 createOnceInitResize: (resizeTextarea: () => void) => () => void;

  1047.                 onceInitSizeTextarea: () => void;

  1048.                 setNativeInputValue: () => void;

  1049.                 handleInput: (event: Event) => Promise<void>;

  1050.                 handleChange: (event: Event) => void;

  1051.                 handleCompositionStart: (event: CompositionEvent) => void;

  1052.                 handleCompositionUpdate: (event: CompositionEvent) => void;

  1053.                 handleCompositionEnd: (event: CompositionEvent) => void;

  1054.                 handlePasswordVisible: () => void;

  1055.                 focus: () => Promise<void>;

  1056.                 blur: () => void | undefined;

  1057.                 handleFocus: (event: FocusEvent) => void;

  1058.                 handleBlur: (event: FocusEvent) => void;

  1059.                 handleMouseLeave: (evt: MouseEvent) => void;

  1060.                 handleMouseEnter: (evt: MouseEvent) => void;

  1061.                 handleKeydown: (evt: KeyboardEvent) => void;

  1062.                 select: () => void;

  1063.                 clear: () => void;

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

  1065.                     readonly size: {

  1066.                         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>>;

  1067.                         readonly required: false;

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

  1069.                         __epPropKey: true;

  1070.                     };

  1071.                     readonly color: {

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

  1073.                         readonly required: false;

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

  1075.                         __epPropKey: true;

  1076.                     };

  1077.                 }, {

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

  1079.                         readonly size: {

  1080.                             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>>;

  1081.                             readonly required: false;

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

  1083.                             __epPropKey: true;

  1084.                         };

  1085.                         readonly color: {

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

  1087.                             readonly required: false;

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

  1089.                             __epPropKey: true;

  1090.                         };

  1091.                     }>> & {

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

  1093.                     }>>;

  1094.                     ns: {

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

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

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

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

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

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

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

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

  1103.                         is: {

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

  1105.                             (name: string): string;

  1106.                         };

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

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

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

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

  1111.                     };

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

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

  1114.                     readonly size: {

  1115.                         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>>;

  1116.                         readonly required: false;

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

  1118.                         __epPropKey: true;

  1119.                     };

  1120.                     readonly color: {

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

  1122.                         readonly required: false;

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

  1124.                         __epPropKey: true;

  1125.                     };

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

  1127.                 CircleClose: 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<{}>>, {}>;

  1128.                 NOOP: () => void;

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

  1130.                 "update:modelValue": (value: string) => boolean;

  1131.                 input: (value: string) => boolean;

  1132.                 change: (value: string) => boolean;

  1133.                 focus: (evt: FocusEvent) => boolean;

  1134.                 blur: (evt: FocusEvent) => boolean;

  1135.                 clear: () => boolean;

  1136.                 mouseleave: (evt: MouseEvent) => boolean;

  1137.                 mouseenter: (evt: MouseEvent) => boolean;

  1138.                 keydown: (evt: Event | KeyboardEvent) => boolean;

  1139.                 compositionstart: (evt: CompositionEvent) => boolean;

  1140.                 compositionupdate: (evt: CompositionEvent) => boolean;

  1141.                 compositionend: (evt: CompositionEvent) => boolean;

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

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

  1144.                 readonly size: {

  1145.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1146.                     readonly required: false;

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

  1148.                     __epPropKey: true;

  1149.                 };

  1150.                 readonly disabled: BooleanConstructor;

  1151.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  1153.                 readonly resize: {

  1154.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  1155.                     readonly required: false;

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

  1157.                     __epPropKey: true;

  1158.                 };

  1159.                 readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  1161.                 readonly formatter: {

  1162.                     readonly type: import("vue").PropType<Function>;

  1163.                     readonly required: false;

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

  1165.                     __epPropKey: true;

  1166.                 };

  1167.                 readonly parser: {

  1168.                     readonly type: import("vue").PropType<Function>;

  1169.                     readonly required: false;

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

  1171.                     __epPropKey: true;

  1172.                 };

  1173.                 readonly placeholder: {

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

  1175.                     readonly required: false;

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

  1177.                     __epPropKey: true;

  1178.                 };

  1179.                 readonly form: {

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

  1181.                     readonly required: false;

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

  1183.                     __epPropKey: true;

  1184.                 };

  1185.                 readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  1186.                 readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  1187.                 readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  1188.                 readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  1189.                 readonly suffixIcon: {

  1190.                     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>>;

  1191.                     readonly required: false;

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

  1193.                     __epPropKey: true;

  1194.                 };

  1195.                 readonly prefixIcon: {

  1196.                     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>>;

  1197.                     readonly required: false;

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

  1199.                     __epPropKey: true;

  1200.                 };

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

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

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

  1204.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1205.                 readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  1206.             }>> & {

  1207.                 onChange?: ((value: string) => any) | undefined;

  1208.                 "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  1209.                 onInput?: ((value: string) => any) | undefined;

  1210.                 onFocus?: ((evt: FocusEvent) => any) | undefined;

  1211.                 onBlur?: ((evt: FocusEvent) => any) | undefined;

  1212.                 onClear?: (() => any) | undefined;

  1213.                 onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  1214.                 onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  1215.                 onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  1216.                 onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  1217.                 onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  1218.                 onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  1219.             }, {

  1220.                 readonly type: string;

  1221.                 readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown>;

  1222.                 readonly label: string;

  1223.                 readonly id: string;

  1224.                 readonly disabled: boolean;

  1225.                 readonly clearable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1226.                 readonly autosize: import("..").InputAutoSize;

  1227.                 readonly autocomplete: string;

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

  1229.                 readonly showPassword: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1230.                 readonly showWordLimit: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1231.                 readonly containerRole: string;

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

  1233.                 readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1234.                 readonly inputStyle: import("vue").StyleValue;

  1235.             }>> & Record<string, any>;

  1236.             Search: 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<{}>>, {}>;

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

  1238.             "checked-change": (value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => boolean;

  1239.         }, string, {

  1240.             readonly props: import("./src/transfer").TransferPropsAlias;

  1241.             readonly data: import("./src/transfer").TransferDataItem[];

  1242.             readonly filterable: boolean;

  1243.             readonly format: import("./src/transfer").TransferFormat;

  1244.             readonly defaultChecked: import("./src/transfer").TransferKey[];

  1245.         }> & {

  1246.             beforeCreate?: ((() => void) | (() => void)[]) | undefined;

  1247.             created?: ((() => void) | (() => void)[]) | undefined;

  1248.             beforeMount?: ((() => void) | (() => void)[]) | undefined;

  1249.             mounted?: ((() => void) | (() => void)[]) | undefined;

  1250.             beforeUpdate?: ((() => void) | (() => void)[]) | undefined;

  1251.             updated?: ((() => void) | (() => void)[]) | undefined;

  1252.             activated?: ((() => void) | (() => void)[]) | undefined;

  1253.             deactivated?: ((() => void) | (() => void)[]) | undefined;

  1254.             beforeDestroy?: ((() => void) | (() => void)[]) | undefined;

  1255.             beforeUnmount?: ((() => void) | (() => void)[]) | undefined;

  1256.             destroyed?: ((() => void) | (() => void)[]) | undefined;

  1257.             unmounted?: ((() => void) | (() => void)[]) | undefined;

  1258.             renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;

  1259.             renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;

  1260.             errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;

  1261.         };

  1262.         $forceUpdate: () => void;

  1263.         $nextTick: typeof import("vue").nextTick;

  1264.         $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;

  1265.     } & Readonly<import("vue").ExtractPropTypes<{

  1266.         readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  1267.         readonly optionRender: {

  1268.             readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  1269.                 [key: string]: any;

  1270.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  1271.                 [key: string]: any;

  1272.             }>[]>;

  1273.             readonly required: false;

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

  1275.             __epPropKey: true;

  1276.         };

  1277.         readonly placeholder: StringConstructor;

  1278.         readonly title: StringConstructor;

  1279.         readonly filterable: BooleanConstructor;

  1280.         readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  1281.         readonly filterMethod: {

  1282.             readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  1283.             readonly required: false;

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

  1285.             __epPropKey: true;

  1286.         };

  1287.         readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  1288.         readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  1289.             readonly label: "label";

  1290.             readonly key: "key";

  1291.             readonly disabled: "disabled";

  1292.         }>, boolean>;

  1293.     }>> & {

  1294.         "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  1295.     } & import("vue").ShallowUnwrapRef<{

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

  1297.             readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  1298.             readonly optionRender: {

  1299.                 readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  1300.                     [key: string]: any;

  1301.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  1302.                     [key: string]: any;

  1303.                 }>[]>;

  1304.                 readonly required: false;

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

  1306.                 __epPropKey: true;

  1307.             };

  1308.             readonly placeholder: StringConstructor;

  1309.             readonly title: StringConstructor;

  1310.             readonly filterable: BooleanConstructor;

  1311.             readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  1312.             readonly filterMethod: {

  1313.                 readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  1314.                 readonly required: false;

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

  1316.                 __epPropKey: true;

  1317.             };

  1318.             readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  1319.             readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  1320.                 readonly label: "label";

  1321.                 readonly key: "key";

  1322.                 readonly disabled: "disabled";

  1323.             }>, boolean>;

  1324.         }>> & {

  1325.             "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  1326.         }>>;

  1327.         emit: (event: "checked-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  1328.         slots: Readonly<{

  1329.             [name: string]: import("vue").Slot | undefined;

  1330.         }>;

  1331.         OptionContent: ({ option }: {

  1332.             option: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  1333.                 [key: string]: any;

  1334.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  1335.                 [key: string]: any;

  1336.             }>[];

  1337.         }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  1338.             [key: string]: any;

  1339.         }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  1340.             [key: string]: any;

  1341.         }>[];

  1342.         t: import("../..").Translator;

  1343.         ns: {

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

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

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

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

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

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

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

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

  1352.             is: {

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

  1354.                 (name: string): string;

  1355.             };

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

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

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

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

  1360.         };

  1361.         panelState: {

  1362.             checked: import("./src/transfer").TransferKey[];

  1363.             allChecked: boolean;

  1364.             query: string;

  1365.             checkChangeByUser: boolean;

  1366.         };

  1367.         propsAlias: import("vue").ComputedRef<{

  1368.             label: string;

  1369.             key: string;

  1370.             disabled: string;

  1371.         }>;

  1372.         filteredData: import("vue").ComputedRef<import("./src/transfer").TransferDataItem[]>;

  1373.         checkedSummary: import("vue").ComputedRef<string>;

  1374.         isIndeterminate: import("vue").ComputedRef<boolean>;

  1375.         handleAllCheckedChange: (value: import("..").CheckboxValueType) => void;

  1376.         hasNoMatch: import("vue").ComputedRef<boolean>;

  1377.         hasFooter: import("vue").ComputedRef<boolean>;

  1378.         checked: import("vue").Ref<import("./src/transfer").TransferKey[]>;

  1379.         allChecked: import("vue").Ref<boolean>;

  1380.         query: import("vue").Ref<string>;

  1381.         isEmpty: (val: unknown) => boolean;

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

  1383.             modelValue: {

  1384.                 type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  1385.                 default: undefined;

  1386.             };

  1387.             label: {

  1388.                 type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  1389.             };

  1390.             indeterminate: BooleanConstructor;

  1391.             disabled: BooleanConstructor;

  1392.             checked: BooleanConstructor;

  1393.             name: {

  1394.                 type: StringConstructor;

  1395.                 default: undefined;

  1396.             };

  1397.             trueLabel: {

  1398.                 type: (NumberConstructor | StringConstructor)[];

  1399.                 default: undefined;

  1400.             };

  1401.             falseLabel: {

  1402.                 type: (NumberConstructor | StringConstructor)[];

  1403.                 default: undefined;

  1404.             };

  1405.             id: {

  1406.                 type: StringConstructor;

  1407.                 default: undefined;

  1408.             };

  1409.             controls: {

  1410.                 type: StringConstructor;

  1411.                 default: undefined;

  1412.             };

  1413.             border: BooleanConstructor;

  1414.             size: {

  1415.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1416.                 readonly required: false;

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

  1418.                 __epPropKey: true;

  1419.             };

  1420.             tabindex: (NumberConstructor | StringConstructor)[];

  1421.             validateEvent: {

  1422.                 type: BooleanConstructor;

  1423.                 default: boolean;

  1424.             };

  1425.         }, {

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

  1427.                 modelValue: {

  1428.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  1429.                     default: undefined;

  1430.                 };

  1431.                 label: {

  1432.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  1433.                 };

  1434.                 indeterminate: BooleanConstructor;

  1435.                 disabled: BooleanConstructor;

  1436.                 checked: BooleanConstructor;

  1437.                 name: {

  1438.                     type: StringConstructor;

  1439.                     default: undefined;

  1440.                 };

  1441.                 trueLabel: {

  1442.                     type: (NumberConstructor | StringConstructor)[];

  1443.                     default: undefined;

  1444.                 };

  1445.                 falseLabel: {

  1446.                     type: (NumberConstructor | StringConstructor)[];

  1447.                     default: undefined;

  1448.                 };

  1449.                 id: {

  1450.                     type: StringConstructor;

  1451.                     default: undefined;

  1452.                 };

  1453.                 controls: {

  1454.                     type: StringConstructor;

  1455.                     default: undefined;

  1456.                 };

  1457.                 border: BooleanConstructor;

  1458.                 size: {

  1459.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1460.                     readonly required: false;

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

  1462.                     __epPropKey: true;

  1463.                 };

  1464.                 tabindex: (NumberConstructor | StringConstructor)[];

  1465.                 validateEvent: {

  1466.                     type: BooleanConstructor;

  1467.                     default: boolean;

  1468.                 };

  1469.             }>> & {

  1470.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  1471.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  1472.             }>>;

  1473.             slots: Readonly<{

  1474.                 [name: string]: import("vue").Slot | undefined;

  1475.             }>;

  1476.             inputId: import("vue").Ref<string | undefined>;

  1477.             isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  1478.             isChecked: import("vue").ComputedRef<boolean>;

  1479.             isDisabled: import("vue").ComputedRef<boolean>;

  1480.             isFocused: import("vue").Ref<boolean>;

  1481.             checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  1482.             hasOwnLabel: import("vue").ComputedRef<boolean>;

  1483.             model: import("vue").WritableComputedRef<any>;

  1484.             handleChange: (e: Event) => void;

  1485.             onClickRoot: (e: MouseEvent) => Promise<void>;

  1486.             ns: {

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

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

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

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

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

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

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

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

  1495.                 is: {

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

  1497.                     (name: string): string;

  1498.                 };

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

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

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

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

  1503.             };

  1504.             compKls: import("vue").ComputedRef<string[]>;

  1505.             spanKls: import("vue").ComputedRef<string[]>;

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

  1507.             "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  1508.             change: (val: import("..").CheckboxValueType) => boolean;

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

  1510.             modelValue: {

  1511.                 type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  1512.                 default: undefined;

  1513.             };

  1514.             label: {

  1515.                 type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  1516.             };

  1517.             indeterminate: BooleanConstructor;

  1518.             disabled: BooleanConstructor;

  1519.             checked: BooleanConstructor;

  1520.             name: {

  1521.                 type: StringConstructor;

  1522.                 default: undefined;

  1523.             };

  1524.             trueLabel: {

  1525.                 type: (NumberConstructor | StringConstructor)[];

  1526.                 default: undefined;

  1527.             };

  1528.             falseLabel: {

  1529.                 type: (NumberConstructor | StringConstructor)[];

  1530.                 default: undefined;

  1531.             };

  1532.             id: {

  1533.                 type: StringConstructor;

  1534.                 default: undefined;

  1535.             };

  1536.             controls: {

  1537.                 type: StringConstructor;

  1538.                 default: undefined;

  1539.             };

  1540.             border: BooleanConstructor;

  1541.             size: {

  1542.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1543.                 readonly required: false;

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

  1545.                 __epPropKey: true;

  1546.             };

  1547.             tabindex: (NumberConstructor | StringConstructor)[];

  1548.             validateEvent: {

  1549.                 type: BooleanConstructor;

  1550.                 default: boolean;

  1551.             };

  1552.         }>> & {

  1553.             onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  1554.             "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  1555.         }, {

  1556.             modelValue: string | number | boolean;

  1557.             id: string;

  1558.             disabled: boolean;

  1559.             name: string;

  1560.             validateEvent: boolean;

  1561.             border: boolean;

  1562.             indeterminate: boolean;

  1563.             checked: boolean;

  1564.             trueLabel: string | number;

  1565.             falseLabel: string | number;

  1566.             controls: string;

  1567.         }>> & {

  1568.             CheckboxButton: import("vue").DefineComponent<{

  1569.                 modelValue: {

  1570.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  1571.                     default: undefined;

  1572.                 };

  1573.                 label: {

  1574.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  1575.                 };

  1576.                 indeterminate: BooleanConstructor;

  1577.                 disabled: BooleanConstructor;

  1578.                 checked: BooleanConstructor;

  1579.                 name: {

  1580.                     type: StringConstructor;

  1581.                     default: undefined;

  1582.                 };

  1583.                 trueLabel: {

  1584.                     type: (NumberConstructor | StringConstructor)[];

  1585.                     default: undefined;

  1586.                 };

  1587.                 falseLabel: {

  1588.                     type: (NumberConstructor | StringConstructor)[];

  1589.                     default: undefined;

  1590.                 };

  1591.                 id: {

  1592.                     type: StringConstructor;

  1593.                     default: undefined;

  1594.                 };

  1595.                 controls: {

  1596.                     type: StringConstructor;

  1597.                     default: undefined;

  1598.                 };

  1599.                 border: BooleanConstructor;

  1600.                 size: {

  1601.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1602.                     readonly required: false;

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

  1604.                     __epPropKey: true;

  1605.                 };

  1606.                 tabindex: (NumberConstructor | StringConstructor)[];

  1607.                 validateEvent: {

  1608.                     type: BooleanConstructor;

  1609.                     default: boolean;

  1610.                 };

  1611.             }, {

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

  1613.                     modelValue: {

  1614.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  1615.                         default: undefined;

  1616.                     };

  1617.                     label: {

  1618.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  1619.                     };

  1620.                     indeterminate: BooleanConstructor;

  1621.                     disabled: BooleanConstructor;

  1622.                     checked: BooleanConstructor;

  1623.                     name: {

  1624.                         type: StringConstructor;

  1625.                         default: undefined;

  1626.                     };

  1627.                     trueLabel: {

  1628.                         type: (NumberConstructor | StringConstructor)[];

  1629.                         default: undefined;

  1630.                     };

  1631.                     falseLabel: {

  1632.                         type: (NumberConstructor | StringConstructor)[];

  1633.                         default: undefined;

  1634.                     };

  1635.                     id: {

  1636.                         type: StringConstructor;

  1637.                         default: undefined;

  1638.                     };

  1639.                     controls: {

  1640.                         type: StringConstructor;

  1641.                         default: undefined;

  1642.                     };

  1643.                     border: BooleanConstructor;

  1644.                     size: {

  1645.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1646.                         readonly required: false;

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

  1648.                         __epPropKey: true;

  1649.                     };

  1650.                     tabindex: (NumberConstructor | StringConstructor)[];

  1651.                     validateEvent: {

  1652.                         type: BooleanConstructor;

  1653.                         default: boolean;

  1654.                     };

  1655.                 }>> & {

  1656.                     onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  1657.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  1658.                 }>>;

  1659.                 slots: Readonly<{

  1660.                     [name: string]: import("vue").Slot | undefined;

  1661.                 }>;

  1662.                 isFocused: import("vue").Ref<boolean>;

  1663.                 isChecked: import("vue").ComputedRef<boolean>;

  1664.                 isDisabled: import("vue").ComputedRef<boolean>;

  1665.                 checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  1666.                 model: import("vue").WritableComputedRef<any>;

  1667.                 handleChange: (e: Event) => void;

  1668.                 checkboxGroup: ({

  1669.                     modelValue?: import("vue").WritableComputedRef<any> | undefined;

  1670.                     changeEvent?: ((...args: any) => any) | undefined;

  1671.                 } & import("vue").ToRefs<Pick<import("..").CheckboxGroupProps, "fill" | "size" | "disabled" | "validateEvent" | "max" | "min" | "textColor">>) | undefined;

  1672.                 ns: {

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

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

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

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

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

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

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

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

  1681.                     is: {

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

  1683.                         (name: string): string;

  1684.                     };

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

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

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

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

  1689.                 };

  1690.                 activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  1691.                 labelKls: import("vue").ComputedRef<string[]>;

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

  1693.                 "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  1694.                 change: (val: import("..").CheckboxValueType) => boolean;

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

  1696.                 modelValue: {

  1697.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  1698.                     default: undefined;

  1699.                 };

  1700.                 label: {

  1701.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  1702.                 };

  1703.                 indeterminate: BooleanConstructor;

  1704.                 disabled: BooleanConstructor;

  1705.                 checked: BooleanConstructor;

  1706.                 name: {

  1707.                     type: StringConstructor;

  1708.                     default: undefined;

  1709.                 };

  1710.                 trueLabel: {

  1711.                     type: (NumberConstructor | StringConstructor)[];

  1712.                     default: undefined;

  1713.                 };

  1714.                 falseLabel: {

  1715.                     type: (NumberConstructor | StringConstructor)[];

  1716.                     default: undefined;

  1717.                 };

  1718.                 id: {

  1719.                     type: StringConstructor;

  1720.                     default: undefined;

  1721.                 };

  1722.                 controls: {

  1723.                     type: StringConstructor;

  1724.                     default: undefined;

  1725.                 };

  1726.                 border: BooleanConstructor;

  1727.                 size: {

  1728.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1729.                     readonly required: false;

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

  1731.                     __epPropKey: true;

  1732.                 };

  1733.                 tabindex: (NumberConstructor | StringConstructor)[];

  1734.                 validateEvent: {

  1735.                     type: BooleanConstructor;

  1736.                     default: boolean;

  1737.                 };

  1738.             }>> & {

  1739.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  1740.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  1741.             }, {

  1742.                 modelValue: string | number | boolean;

  1743.                 id: string;

  1744.                 disabled: boolean;

  1745.                 name: string;

  1746.                 validateEvent: boolean;

  1747.                 border: boolean;

  1748.                 indeterminate: boolean;

  1749.                 checked: boolean;

  1750.                 trueLabel: string | number;

  1751.                 falseLabel: string | number;

  1752.                 controls: string;

  1753.             }>;

  1754.             CheckboxGroup: import("vue").DefineComponent<{

  1755.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  1756.                 readonly disabled: BooleanConstructor;

  1757.                 readonly min: NumberConstructor;

  1758.                 readonly max: NumberConstructor;

  1759.                 readonly size: {

  1760.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1761.                     readonly required: false;

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

  1763.                     __epPropKey: true;

  1764.                 };

  1765.                 readonly label: StringConstructor;

  1766.                 readonly fill: StringConstructor;

  1767.                 readonly textColor: StringConstructor;

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

  1769.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1770.             }, {

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

  1772.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  1773.                     readonly disabled: BooleanConstructor;

  1774.                     readonly min: NumberConstructor;

  1775.                     readonly max: NumberConstructor;

  1776.                     readonly size: {

  1777.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1778.                         readonly required: false;

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

  1780.                         __epPropKey: true;

  1781.                     };

  1782.                     readonly label: StringConstructor;

  1783.                     readonly fill: StringConstructor;

  1784.                     readonly textColor: StringConstructor;

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

  1786.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1787.                 }>> & {

  1788.                     onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  1789.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  1790.                 }>>;

  1791.                 emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  1792.                 ns: {

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

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

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

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

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

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

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

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

  1801.                     is: {

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

  1803.                         (name: string): string;

  1804.                     };

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

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

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

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

  1809.                 };

  1810.                 formItem: import("..").FormItemContext | undefined;

  1811.                 groupId: import("vue").Ref<string | undefined>;

  1812.                 isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  1813.                 changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  1814.                 modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

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

  1816.                 "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  1817.                 change: (val: import("..").CheckboxValueType[]) => boolean;

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

  1819.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  1820.                 readonly disabled: BooleanConstructor;

  1821.                 readonly min: NumberConstructor;

  1822.                 readonly max: NumberConstructor;

  1823.                 readonly size: {

  1824.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1825.                     readonly required: false;

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

  1827.                     __epPropKey: true;

  1828.                 };

  1829.                 readonly label: StringConstructor;

  1830.                 readonly fill: StringConstructor;

  1831.                 readonly textColor: StringConstructor;

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

  1833.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1834.             }>> & {

  1835.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  1836.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  1837.             }, {

  1838.                 readonly modelValue: import("..").CheckboxGroupValueType;

  1839.                 readonly disabled: boolean;

  1840.                 readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1841.                 readonly tag: string;

  1842.             }>;

  1843.         };

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

  1845.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  1846.             readonly disabled: BooleanConstructor;

  1847.             readonly min: NumberConstructor;

  1848.             readonly max: NumberConstructor;

  1849.             readonly size: {

  1850.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1851.                 readonly required: false;

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

  1853.                 __epPropKey: true;

  1854.             };

  1855.             readonly label: StringConstructor;

  1856.             readonly fill: StringConstructor;

  1857.             readonly textColor: StringConstructor;

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

  1859.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1860.         }, {

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

  1862.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  1863.                 readonly disabled: BooleanConstructor;

  1864.                 readonly min: NumberConstructor;

  1865.                 readonly max: NumberConstructor;

  1866.                 readonly size: {

  1867.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1868.                     readonly required: false;

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

  1870.                     __epPropKey: true;

  1871.                 };

  1872.                 readonly label: StringConstructor;

  1873.                 readonly fill: StringConstructor;

  1874.                 readonly textColor: StringConstructor;

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

  1876.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1877.             }>> & {

  1878.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  1879.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  1880.             }>>;

  1881.             emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  1882.             ns: {

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

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

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

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

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

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

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

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

  1891.                 is: {

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

  1893.                     (name: string): string;

  1894.                 };

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

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

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

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

  1899.             };

  1900.             formItem: import("..").FormItemContext | undefined;

  1901.             groupId: import("vue").Ref<string | undefined>;

  1902.             isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  1903.             changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  1904.             modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

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

  1906.             "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  1907.             change: (val: import("..").CheckboxValueType[]) => boolean;

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

  1909.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  1910.             readonly disabled: BooleanConstructor;

  1911.             readonly min: NumberConstructor;

  1912.             readonly max: NumberConstructor;

  1913.             readonly size: {

  1914.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1915.                 readonly required: false;

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

  1917.                 __epPropKey: true;

  1918.             };

  1919.             readonly label: StringConstructor;

  1920.             readonly fill: StringConstructor;

  1921.             readonly textColor: StringConstructor;

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

  1923.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1924.         }>> & {

  1925.             onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  1926.             "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  1927.         }, {

  1928.             readonly modelValue: import("..").CheckboxGroupValueType;

  1929.             readonly disabled: boolean;

  1930.             readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  1931.             readonly tag: string;

  1932.         }>>;

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

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

  1935.             readonly size: {

  1936.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  1937.                 readonly required: false;

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

  1939.                 __epPropKey: true;

  1940.             };

  1941.             readonly disabled: BooleanConstructor;

  1942.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  1944.             readonly resize: {

  1945.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  1946.                 readonly required: false;

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

  1948.                 __epPropKey: true;

  1949.             };

  1950.             readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  1952.             readonly formatter: {

  1953.                 readonly type: import("vue").PropType<Function>;

  1954.                 readonly required: false;

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

  1956.                 __epPropKey: true;

  1957.             };

  1958.             readonly parser: {

  1959.                 readonly type: import("vue").PropType<Function>;

  1960.                 readonly required: false;

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

  1962.                 __epPropKey: true;

  1963.             };

  1964.             readonly placeholder: {

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

  1966.                 readonly required: false;

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

  1968.                 __epPropKey: true;

  1969.             };

  1970.             readonly form: {

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

  1972.                 readonly required: false;

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

  1974.                 __epPropKey: true;

  1975.             };

  1976.             readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  1977.             readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  1978.             readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  1979.             readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  1980.             readonly suffixIcon: {

  1981.                 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>>;

  1982.                 readonly required: false;

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

  1984.                 __epPropKey: true;

  1985.             };

  1986.             readonly prefixIcon: {

  1987.                 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>>;

  1988.                 readonly required: false;

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

  1990.                 __epPropKey: true;

  1991.             };

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

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

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

  1995.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  1996.             readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  1997.         }, {

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

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

  2000.                 readonly size: {

  2001.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2002.                     readonly required: false;

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

  2004.                     __epPropKey: true;

  2005.                 };

  2006.                 readonly disabled: BooleanConstructor;

  2007.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  2009.                 readonly resize: {

  2010.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  2011.                     readonly required: false;

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

  2013.                     __epPropKey: true;

  2014.                 };

  2015.                 readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  2017.                 readonly formatter: {

  2018.                     readonly type: import("vue").PropType<Function>;

  2019.                     readonly required: false;

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

  2021.                     __epPropKey: true;

  2022.                 };

  2023.                 readonly parser: {

  2024.                     readonly type: import("vue").PropType<Function>;

  2025.                     readonly required: false;

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

  2027.                     __epPropKey: true;

  2028.                 };

  2029.                 readonly placeholder: {

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

  2031.                     readonly required: false;

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

  2033.                     __epPropKey: true;

  2034.                 };

  2035.                 readonly form: {

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

  2037.                     readonly required: false;

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

  2039.                     __epPropKey: true;

  2040.                 };

  2041.                 readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  2042.                 readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  2043.                 readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  2044.                 readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  2045.                 readonly suffixIcon: {

  2046.                     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>>;

  2047.                     readonly required: false;

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

  2049.                     __epPropKey: true;

  2050.                 };

  2051.                 readonly prefixIcon: {

  2052.                     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>>;

  2053.                     readonly required: false;

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

  2055.                     __epPropKey: true;

  2056.                 };

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

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

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

  2060.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  2061.                 readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  2062.             }>> & {

  2063.                 onChange?: ((value: string) => any) | undefined;

  2064.                 "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  2065.                 onInput?: ((value: string) => any) | undefined;

  2066.                 onFocus?: ((evt: FocusEvent) => any) | undefined;

  2067.                 onBlur?: ((evt: FocusEvent) => any) | undefined;

  2068.                 onClear?: (() => any) | undefined;

  2069.                 onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  2070.                 onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  2071.                 onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  2072.                 onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  2073.                 onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  2074.                 onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  2075.             }>>;

  2076.             emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void);

  2077.             rawAttrs: {

  2078.                 [x: string]: unknown;

  2079.             };

  2080.             slots: Readonly<{

  2081.                 [name: string]: import("vue").Slot | undefined;

  2082.             }>;

  2083.             containerAttrs: import("vue").ComputedRef<Record<string, unknown>>;

  2084.             containerKls: import("vue").ComputedRef<unknown[]>;

  2085.             wrapperKls: import("vue").ComputedRef<string[]>;

  2086.             attrs: import("vue").ComputedRef<Record<string, unknown>>;

  2087.             form: import("..").FormContext | undefined;

  2088.             formItem: import("..").FormItemContext | undefined;

  2089.             inputId: import("vue").Ref<string | undefined>;

  2090.             inputSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  2091.             inputDisabled: import("vue").ComputedRef<boolean>;

  2092.             nsInput: {

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

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

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

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

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

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

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

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

  2101.                 is: {

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

  2103.                     (name: string): string;

  2104.                 };

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

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

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

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

  2109.             };

  2110.             nsTextarea: {

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

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

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

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

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

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

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

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

  2119.                 is: {

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

  2121.                     (name: string): string;

  2122.                 };

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

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

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

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

  2127.             };

  2128.             input: import("vue").ShallowRef<HTMLInputElement | undefined>;

  2129.             textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined>;

  2130.             focused: import("vue").Ref<boolean>;

  2131.             hovering: import("vue").Ref<boolean>;

  2132.             isComposing: import("vue").Ref<boolean>;

  2133.             passwordVisible: import("vue").Ref<boolean>;

  2134.             countStyle: import("vue").Ref<import("vue").StyleValue | undefined>;

  2135.             textareaCalcStyle: import("vue").ShallowRef<import("vue").StyleValue>;

  2136.             _ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;

  2137.             needStatusIcon: import("vue").ComputedRef<boolean>;

  2138.             validateState: import("vue").ComputedRef<"" | "success" | "error" | "validating">;

  2139.             validateIcon: import("vue").ComputedRef<"" | 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<{}>>, {}>>;

  2140.             passwordIcon: import("vue").ComputedRef<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<{}>>, {}>>;

  2141.             containerStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  2142.             textareaStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  2143.             nativeInputValue: import("vue").ComputedRef<string>;

  2144.             showClear: import("vue").ComputedRef<boolean>;

  2145.             showPwdVisible: import("vue").ComputedRef<boolean>;

  2146.             isWordLimitVisible: import("vue").ComputedRef<boolean>;

  2147.             textLength: import("vue").ComputedRef<number>;

  2148.             inputExceed: import("vue").ComputedRef<boolean>;

  2149.             suffixVisible: import("vue").ComputedRef<boolean>;

  2150.             recordCursor: () => void;

  2151.             setCursor: () => void;

  2152.             resizeTextarea: () => void;

  2153.             createOnceInitResize: (resizeTextarea: () => void) => () => void;

  2154.             onceInitSizeTextarea: () => void;

  2155.             setNativeInputValue: () => void;

  2156.             handleInput: (event: Event) => Promise<void>;

  2157.             handleChange: (event: Event) => void;

  2158.             handleCompositionStart: (event: CompositionEvent) => void;

  2159.             handleCompositionUpdate: (event: CompositionEvent) => void;

  2160.             handleCompositionEnd: (event: CompositionEvent) => void;

  2161.             handlePasswordVisible: () => void;

  2162.             focus: () => Promise<void>;

  2163.             blur: () => void | undefined;

  2164.             handleFocus: (event: FocusEvent) => void;

  2165.             handleBlur: (event: FocusEvent) => void;

  2166.             handleMouseLeave: (evt: MouseEvent) => void;

  2167.             handleMouseEnter: (evt: MouseEvent) => void;

  2168.             handleKeydown: (evt: KeyboardEvent) => void;

  2169.             select: () => void;

  2170.             clear: () => void;

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

  2172.                 readonly size: {

  2173.                     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>>;

  2174.                     readonly required: false;

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

  2176.                     __epPropKey: true;

  2177.                 };

  2178.                 readonly color: {

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

  2180.                     readonly required: false;

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

  2182.                     __epPropKey: true;

  2183.                 };

  2184.             }, {

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

  2186.                     readonly size: {

  2187.                         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>>;

  2188.                         readonly required: false;

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

  2190.                         __epPropKey: true;

  2191.                     };

  2192.                     readonly color: {

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

  2194.                         readonly required: false;

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

  2196.                         __epPropKey: true;

  2197.                     };

  2198.                 }>> & {

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

  2200.                 }>>;

  2201.                 ns: {

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

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

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

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

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

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

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

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

  2210.                     is: {

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

  2212.                         (name: string): string;

  2213.                     };

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

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

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

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

  2218.                 };

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

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

  2221.                 readonly size: {

  2222.                     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>>;

  2223.                     readonly required: false;

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

  2225.                     __epPropKey: true;

  2226.                 };

  2227.                 readonly color: {

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

  2229.                     readonly required: false;

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

  2231.                     __epPropKey: true;

  2232.                 };

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

  2234.             CircleClose: 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<{}>>, {}>;

  2235.             NOOP: () => void;

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

  2237.             "update:modelValue": (value: string) => boolean;

  2238.             input: (value: string) => boolean;

  2239.             change: (value: string) => boolean;

  2240.             focus: (evt: FocusEvent) => boolean;

  2241.             blur: (evt: FocusEvent) => boolean;

  2242.             clear: () => boolean;

  2243.             mouseleave: (evt: MouseEvent) => boolean;

  2244.             mouseenter: (evt: MouseEvent) => boolean;

  2245.             keydown: (evt: Event | KeyboardEvent) => boolean;

  2246.             compositionstart: (evt: CompositionEvent) => boolean;

  2247.             compositionupdate: (evt: CompositionEvent) => boolean;

  2248.             compositionend: (evt: CompositionEvent) => boolean;

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

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

  2251.             readonly size: {

  2252.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2253.                 readonly required: false;

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

  2255.                 __epPropKey: true;

  2256.             };

  2257.             readonly disabled: BooleanConstructor;

  2258.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  2260.             readonly resize: {

  2261.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  2262.                 readonly required: false;

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

  2264.                 __epPropKey: true;

  2265.             };

  2266.             readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  2268.             readonly formatter: {

  2269.                 readonly type: import("vue").PropType<Function>;

  2270.                 readonly required: false;

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

  2272.                 __epPropKey: true;

  2273.             };

  2274.             readonly parser: {

  2275.                 readonly type: import("vue").PropType<Function>;

  2276.                 readonly required: false;

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

  2278.                 __epPropKey: true;

  2279.             };

  2280.             readonly placeholder: {

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

  2282.                 readonly required: false;

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

  2284.                 __epPropKey: true;

  2285.             };

  2286.             readonly form: {

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

  2288.                 readonly required: false;

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

  2290.                 __epPropKey: true;

  2291.             };

  2292.             readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  2293.             readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  2294.             readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  2295.             readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  2296.             readonly suffixIcon: {

  2297.                 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>>;

  2298.                 readonly required: false;

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

  2300.                 __epPropKey: true;

  2301.             };

  2302.             readonly prefixIcon: {

  2303.                 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>>;

  2304.                 readonly required: false;

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

  2306.                 __epPropKey: true;

  2307.             };

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

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

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

  2311.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  2312.             readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  2313.         }>> & {

  2314.             onChange?: ((value: string) => any) | undefined;

  2315.             "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  2316.             onInput?: ((value: string) => any) | undefined;

  2317.             onFocus?: ((evt: FocusEvent) => any) | undefined;

  2318.             onBlur?: ((evt: FocusEvent) => any) | undefined;

  2319.             onClear?: (() => any) | undefined;

  2320.             onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  2321.             onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  2322.             onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  2323.             onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  2324.             onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  2325.             onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  2326.         }, {

  2327.             readonly type: string;

  2328.             readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown>;

  2329.             readonly label: string;

  2330.             readonly id: string;

  2331.             readonly disabled: boolean;

  2332.             readonly clearable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  2333.             readonly autosize: import("..").InputAutoSize;

  2334.             readonly autocomplete: string;

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

  2336.             readonly showPassword: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  2337.             readonly showWordLimit: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  2338.             readonly containerRole: string;

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

  2340.             readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  2341.             readonly inputStyle: import("vue").StyleValue;

  2342.         }>> & Record<string, any>;

  2343.         Search: 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<{}>>, {}>;

  2344.     }> & {} & import("vue").ComponentCustomProperties) | undefined>;

  2345.     rightPanel: import("vue").Ref<({

  2346.         $: import("vue").ComponentInternalInstance;

  2347.         $data: {};

  2348.         $props: Partial<{

  2349.             readonly props: import("./src/transfer").TransferPropsAlias;

  2350.             readonly data: import("./src/transfer").TransferDataItem[];

  2351.             readonly filterable: boolean;

  2352.             readonly format: import("./src/transfer").TransferFormat;

  2353.             readonly defaultChecked: import("./src/transfer").TransferKey[];

  2354.         }> & Omit<Readonly<import("vue").ExtractPropTypes<{

  2355.             readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  2356.             readonly optionRender: {

  2357.                 readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2358.                     [key: string]: any;

  2359.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2360.                     [key: string]: any;

  2361.                 }>[]>;

  2362.                 readonly required: false;

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

  2364.                 __epPropKey: true;

  2365.             };

  2366.             readonly placeholder: StringConstructor;

  2367.             readonly title: StringConstructor;

  2368.             readonly filterable: BooleanConstructor;

  2369.             readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  2370.             readonly filterMethod: {

  2371.                 readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  2372.                 readonly required: false;

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

  2374.                 __epPropKey: true;

  2375.             };

  2376.             readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  2377.             readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  2378.                 readonly label: "label";

  2379.                 readonly key: "key";

  2380.                 readonly disabled: "disabled";

  2381.             }>, boolean>;

  2382.         }>> & {

  2383.             "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  2384.         } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "props" | "data" | "filterable" | "format" | "defaultChecked">;

  2385.         $attrs: {

  2386.             [x: string]: unknown;

  2387.         };

  2388.         $refs: {

  2389.             [x: string]: unknown;

  2390.         };

  2391.         $slots: Readonly<{

  2392.             [name: string]: import("vue").Slot | undefined;

  2393.         }>;

  2394.         $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;

  2395.         $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;

  2396.         $emit: (event: "checked-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  2397.         $el: any;

  2398.         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{

  2399.             readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  2400.             readonly optionRender: {

  2401.                 readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2402.                     [key: string]: any;

  2403.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2404.                     [key: string]: any;

  2405.                 }>[]>;

  2406.                 readonly required: false;

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

  2408.                 __epPropKey: true;

  2409.             };

  2410.             readonly placeholder: StringConstructor;

  2411.             readonly title: StringConstructor;

  2412.             readonly filterable: BooleanConstructor;

  2413.             readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  2414.             readonly filterMethod: {

  2415.                 readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  2416.                 readonly required: false;

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

  2418.                 __epPropKey: true;

  2419.             };

  2420.             readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  2421.             readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  2422.                 readonly label: "label";

  2423.                 readonly key: "key";

  2424.                 readonly disabled: "disabled";

  2425.             }>, boolean>;

  2426.         }>> & {

  2427.             "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  2428.         }, {

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

  2430.                 readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  2431.                 readonly optionRender: {

  2432.                     readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2433.                         [key: string]: any;

  2434.                     }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2435.                         [key: string]: any;

  2436.                     }>[]>;

  2437.                     readonly required: false;

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

  2439.                     __epPropKey: true;

  2440.                 };

  2441.                 readonly placeholder: StringConstructor;

  2442.                 readonly title: StringConstructor;

  2443.                 readonly filterable: BooleanConstructor;

  2444.                 readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  2445.                 readonly filterMethod: {

  2446.                     readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  2447.                     readonly required: false;

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

  2449.                     __epPropKey: true;

  2450.                 };

  2451.                 readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  2452.                 readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  2453.                     readonly label: "label";

  2454.                     readonly key: "key";

  2455.                     readonly disabled: "disabled";

  2456.                 }>, boolean>;

  2457.             }>> & {

  2458.                 "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  2459.             }>>;

  2460.             emit: (event: "checked-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  2461.             slots: Readonly<{

  2462.                 [name: string]: import("vue").Slot | undefined;

  2463.             }>;

  2464.             OptionContent: ({ option }: {

  2465.                 option: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2466.                     [key: string]: any;

  2467.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2468.                     [key: string]: any;

  2469.                 }>[];

  2470.             }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2471.                 [key: string]: any;

  2472.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  2473.                 [key: string]: any;

  2474.             }>[];

  2475.             t: import("../..").Translator;

  2476.             ns: {

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

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

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

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

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

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

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

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

  2485.                 is: {

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

  2487.                     (name: string): string;

  2488.                 };

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

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

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

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

  2493.             };

  2494.             panelState: {

  2495.                 checked: import("./src/transfer").TransferKey[];

  2496.                 allChecked: boolean;

  2497.                 query: string;

  2498.                 checkChangeByUser: boolean;

  2499.             };

  2500.             propsAlias: import("vue").ComputedRef<{

  2501.                 label: string;

  2502.                 key: string;

  2503.                 disabled: string;

  2504.             }>;

  2505.             filteredData: import("vue").ComputedRef<import("./src/transfer").TransferDataItem[]>;

  2506.             checkedSummary: import("vue").ComputedRef<string>;

  2507.             isIndeterminate: import("vue").ComputedRef<boolean>;

  2508.             handleAllCheckedChange: (value: import("..").CheckboxValueType) => void;

  2509.             hasNoMatch: import("vue").ComputedRef<boolean>;

  2510.             hasFooter: import("vue").ComputedRef<boolean>;

  2511.             checked: import("vue").Ref<import("./src/transfer").TransferKey[]>;

  2512.             allChecked: import("vue").Ref<boolean>;

  2513.             query: import("vue").Ref<string>;

  2514.             isEmpty: (val: unknown) => boolean;

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

  2516.                 modelValue: {

  2517.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  2518.                     default: undefined;

  2519.                 };

  2520.                 label: {

  2521.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  2522.                 };

  2523.                 indeterminate: BooleanConstructor;

  2524.                 disabled: BooleanConstructor;

  2525.                 checked: BooleanConstructor;

  2526.                 name: {

  2527.                     type: StringConstructor;

  2528.                     default: undefined;

  2529.                 };

  2530.                 trueLabel: {

  2531.                     type: (NumberConstructor | StringConstructor)[];

  2532.                     default: undefined;

  2533.                 };

  2534.                 falseLabel: {

  2535.                     type: (NumberConstructor | StringConstructor)[];

  2536.                     default: undefined;

  2537.                 };

  2538.                 id: {

  2539.                     type: StringConstructor;

  2540.                     default: undefined;

  2541.                 };

  2542.                 controls: {

  2543.                     type: StringConstructor;

  2544.                     default: undefined;

  2545.                 };

  2546.                 border: BooleanConstructor;

  2547.                 size: {

  2548.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2549.                     readonly required: false;

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

  2551.                     __epPropKey: true;

  2552.                 };

  2553.                 tabindex: (NumberConstructor | StringConstructor)[];

  2554.                 validateEvent: {

  2555.                     type: BooleanConstructor;

  2556.                     default: boolean;

  2557.                 };

  2558.             }, {

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

  2560.                     modelValue: {

  2561.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  2562.                         default: undefined;

  2563.                     };

  2564.                     label: {

  2565.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  2566.                     };

  2567.                     indeterminate: BooleanConstructor;

  2568.                     disabled: BooleanConstructor;

  2569.                     checked: BooleanConstructor;

  2570.                     name: {

  2571.                         type: StringConstructor;

  2572.                         default: undefined;

  2573.                     };

  2574.                     trueLabel: {

  2575.                         type: (NumberConstructor | StringConstructor)[];

  2576.                         default: undefined;

  2577.                     };

  2578.                     falseLabel: {

  2579.                         type: (NumberConstructor | StringConstructor)[];

  2580.                         default: undefined;

  2581.                     };

  2582.                     id: {

  2583.                         type: StringConstructor;

  2584.                         default: undefined;

  2585.                     };

  2586.                     controls: {

  2587.                         type: StringConstructor;

  2588.                         default: undefined;

  2589.                     };

  2590.                     border: BooleanConstructor;

  2591.                     size: {

  2592.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2593.                         readonly required: false;

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

  2595.                         __epPropKey: true;

  2596.                     };

  2597.                     tabindex: (NumberConstructor | StringConstructor)[];

  2598.                     validateEvent: {

  2599.                         type: BooleanConstructor;

  2600.                         default: boolean;

  2601.                     };

  2602.                 }>> & {

  2603.                     onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  2604.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  2605.                 }>>;

  2606.                 slots: Readonly<{

  2607.                     [name: string]: import("vue").Slot | undefined;

  2608.                 }>;

  2609.                 inputId: import("vue").Ref<string | undefined>;

  2610.                 isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  2611.                 isChecked: import("vue").ComputedRef<boolean>;

  2612.                 isDisabled: import("vue").ComputedRef<boolean>;

  2613.                 isFocused: import("vue").Ref<boolean>;

  2614.                 checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  2615.                 hasOwnLabel: import("vue").ComputedRef<boolean>;

  2616.                 model: import("vue").WritableComputedRef<any>;

  2617.                 handleChange: (e: Event) => void;

  2618.                 onClickRoot: (e: MouseEvent) => Promise<void>;

  2619.                 ns: {

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

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

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

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

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

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

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

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

  2628.                     is: {

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

  2630.                         (name: string): string;

  2631.                     };

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

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

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

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

  2636.                 };

  2637.                 compKls: import("vue").ComputedRef<string[]>;

  2638.                 spanKls: import("vue").ComputedRef<string[]>;

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

  2640.                 "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  2641.                 change: (val: import("..").CheckboxValueType) => boolean;

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

  2643.                 modelValue: {

  2644.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  2645.                     default: undefined;

  2646.                 };

  2647.                 label: {

  2648.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  2649.                 };

  2650.                 indeterminate: BooleanConstructor;

  2651.                 disabled: BooleanConstructor;

  2652.                 checked: BooleanConstructor;

  2653.                 name: {

  2654.                     type: StringConstructor;

  2655.                     default: undefined;

  2656.                 };

  2657.                 trueLabel: {

  2658.                     type: (NumberConstructor | StringConstructor)[];

  2659.                     default: undefined;

  2660.                 };

  2661.                 falseLabel: {

  2662.                     type: (NumberConstructor | StringConstructor)[];

  2663.                     default: undefined;

  2664.                 };

  2665.                 id: {

  2666.                     type: StringConstructor;

  2667.                     default: undefined;

  2668.                 };

  2669.                 controls: {

  2670.                     type: StringConstructor;

  2671.                     default: undefined;

  2672.                 };

  2673.                 border: BooleanConstructor;

  2674.                 size: {

  2675.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2676.                     readonly required: false;

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

  2678.                     __epPropKey: true;

  2679.                 };

  2680.                 tabindex: (NumberConstructor | StringConstructor)[];

  2681.                 validateEvent: {

  2682.                     type: BooleanConstructor;

  2683.                     default: boolean;

  2684.                 };

  2685.             }>> & {

  2686.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  2687.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  2688.             }, {

  2689.                 modelValue: string | number | boolean;

  2690.                 id: string;

  2691.                 disabled: boolean;

  2692.                 name: string;

  2693.                 validateEvent: boolean;

  2694.                 border: boolean;

  2695.                 indeterminate: boolean;

  2696.                 checked: boolean;

  2697.                 trueLabel: string | number;

  2698.                 falseLabel: string | number;

  2699.                 controls: string;

  2700.             }>> & {

  2701.                 CheckboxButton: import("vue").DefineComponent<{

  2702.                     modelValue: {

  2703.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  2704.                         default: undefined;

  2705.                     };

  2706.                     label: {

  2707.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  2708.                     };

  2709.                     indeterminate: BooleanConstructor;

  2710.                     disabled: BooleanConstructor;

  2711.                     checked: BooleanConstructor;

  2712.                     name: {

  2713.                         type: StringConstructor;

  2714.                         default: undefined;

  2715.                     };

  2716.                     trueLabel: {

  2717.                         type: (NumberConstructor | StringConstructor)[];

  2718.                         default: undefined;

  2719.                     };

  2720.                     falseLabel: {

  2721.                         type: (NumberConstructor | StringConstructor)[];

  2722.                         default: undefined;

  2723.                     };

  2724.                     id: {

  2725.                         type: StringConstructor;

  2726.                         default: undefined;

  2727.                     };

  2728.                     controls: {

  2729.                         type: StringConstructor;

  2730.                         default: undefined;

  2731.                     };

  2732.                     border: BooleanConstructor;

  2733.                     size: {

  2734.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2735.                         readonly required: false;

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

  2737.                         __epPropKey: true;

  2738.                     };

  2739.                     tabindex: (NumberConstructor | StringConstructor)[];

  2740.                     validateEvent: {

  2741.                         type: BooleanConstructor;

  2742.                         default: boolean;

  2743.                     };

  2744.                 }, {

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

  2746.                         modelValue: {

  2747.                             type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  2748.                             default: undefined;

  2749.                         };

  2750.                         label: {

  2751.                             type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  2752.                         };

  2753.                         indeterminate: BooleanConstructor;

  2754.                         disabled: BooleanConstructor;

  2755.                         checked: BooleanConstructor;

  2756.                         name: {

  2757.                             type: StringConstructor;

  2758.                             default: undefined;

  2759.                         };

  2760.                         trueLabel: {

  2761.                             type: (NumberConstructor | StringConstructor)[];

  2762.                             default: undefined;

  2763.                         };

  2764.                         falseLabel: {

  2765.                             type: (NumberConstructor | StringConstructor)[];

  2766.                             default: undefined;

  2767.                         };

  2768.                         id: {

  2769.                             type: StringConstructor;

  2770.                             default: undefined;

  2771.                         };

  2772.                         controls: {

  2773.                             type: StringConstructor;

  2774.                             default: undefined;

  2775.                         };

  2776.                         border: BooleanConstructor;

  2777.                         size: {

  2778.                             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2779.                             readonly required: false;

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

  2781.                             __epPropKey: true;

  2782.                         };

  2783.                         tabindex: (NumberConstructor | StringConstructor)[];

  2784.                         validateEvent: {

  2785.                             type: BooleanConstructor;

  2786.                             default: boolean;

  2787.                         };

  2788.                     }>> & {

  2789.                         onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  2790.                         "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  2791.                     }>>;

  2792.                     slots: Readonly<{

  2793.                         [name: string]: import("vue").Slot | undefined;

  2794.                     }>;

  2795.                     isFocused: import("vue").Ref<boolean>;

  2796.                     isChecked: import("vue").ComputedRef<boolean>;

  2797.                     isDisabled: import("vue").ComputedRef<boolean>;

  2798.                     checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  2799.                     model: import("vue").WritableComputedRef<any>;

  2800.                     handleChange: (e: Event) => void;

  2801.                     checkboxGroup: ({

  2802.                         modelValue?: import("vue").WritableComputedRef<any> | undefined;

  2803.                         changeEvent?: ((...args: any) => any) | undefined;

  2804.                     } & import("vue").ToRefs<Pick<import("..").CheckboxGroupProps, "fill" | "size" | "disabled" | "validateEvent" | "max" | "min" | "textColor">>) | undefined;

  2805.                     ns: {

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

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

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

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

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

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

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

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

  2814.                         is: {

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

  2816.                             (name: string): string;

  2817.                         };

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

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

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

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

  2822.                     };

  2823.                     activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  2824.                     labelKls: import("vue").ComputedRef<string[]>;

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

  2826.                     "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  2827.                     change: (val: import("..").CheckboxValueType) => boolean;

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

  2829.                     modelValue: {

  2830.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  2831.                         default: undefined;

  2832.                     };

  2833.                     label: {

  2834.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  2835.                     };

  2836.                     indeterminate: BooleanConstructor;

  2837.                     disabled: BooleanConstructor;

  2838.                     checked: BooleanConstructor;

  2839.                     name: {

  2840.                         type: StringConstructor;

  2841.                         default: undefined;

  2842.                     };

  2843.                     trueLabel: {

  2844.                         type: (NumberConstructor | StringConstructor)[];

  2845.                         default: undefined;

  2846.                     };

  2847.                     falseLabel: {

  2848.                         type: (NumberConstructor | StringConstructor)[];

  2849.                         default: undefined;

  2850.                     };

  2851.                     id: {

  2852.                         type: StringConstructor;

  2853.                         default: undefined;

  2854.                     };

  2855.                     controls: {

  2856.                         type: StringConstructor;

  2857.                         default: undefined;

  2858.                     };

  2859.                     border: BooleanConstructor;

  2860.                     size: {

  2861.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2862.                         readonly required: false;

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

  2864.                         __epPropKey: true;

  2865.                     };

  2866.                     tabindex: (NumberConstructor | StringConstructor)[];

  2867.                     validateEvent: {

  2868.                         type: BooleanConstructor;

  2869.                         default: boolean;

  2870.                     };

  2871.                 }>> & {

  2872.                     onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  2873.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  2874.                 }, {

  2875.                     modelValue: string | number | boolean;

  2876.                     id: string;

  2877.                     disabled: boolean;

  2878.                     name: string;

  2879.                     validateEvent: boolean;

  2880.                     border: boolean;

  2881.                     indeterminate: boolean;

  2882.                     checked: boolean;

  2883.                     trueLabel: string | number;

  2884.                     falseLabel: string | number;

  2885.                     controls: string;

  2886.                 }>;

  2887.                 CheckboxGroup: import("vue").DefineComponent<{

  2888.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  2889.                     readonly disabled: BooleanConstructor;

  2890.                     readonly min: NumberConstructor;

  2891.                     readonly max: NumberConstructor;

  2892.                     readonly size: {

  2893.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2894.                         readonly required: false;

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

  2896.                         __epPropKey: true;

  2897.                     };

  2898.                     readonly label: StringConstructor;

  2899.                     readonly fill: StringConstructor;

  2900.                     readonly textColor: StringConstructor;

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

  2902.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  2903.                 }, {

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

  2905.                         readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  2906.                         readonly disabled: BooleanConstructor;

  2907.                         readonly min: NumberConstructor;

  2908.                         readonly max: NumberConstructor;

  2909.                         readonly size: {

  2910.                             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2911.                             readonly required: false;

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

  2913.                             __epPropKey: true;

  2914.                         };

  2915.                         readonly label: StringConstructor;

  2916.                         readonly fill: StringConstructor;

  2917.                         readonly textColor: StringConstructor;

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

  2919.                         readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  2920.                     }>> & {

  2921.                         onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  2922.                         "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  2923.                     }>>;

  2924.                     emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  2925.                     ns: {

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

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

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

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

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

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

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

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

  2934.                         is: {

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

  2936.                             (name: string): string;

  2937.                         };

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

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

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

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

  2942.                     };

  2943.                     formItem: import("..").FormItemContext | undefined;

  2944.                     groupId: import("vue").Ref<string | undefined>;

  2945.                     isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  2946.                     changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  2947.                     modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

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

  2949.                     "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  2950.                     change: (val: import("..").CheckboxValueType[]) => boolean;

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

  2952.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  2953.                     readonly disabled: BooleanConstructor;

  2954.                     readonly min: NumberConstructor;

  2955.                     readonly max: NumberConstructor;

  2956.                     readonly size: {

  2957.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2958.                         readonly required: false;

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

  2960.                         __epPropKey: true;

  2961.                     };

  2962.                     readonly label: StringConstructor;

  2963.                     readonly fill: StringConstructor;

  2964.                     readonly textColor: StringConstructor;

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

  2966.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  2967.                 }>> & {

  2968.                     onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  2969.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  2970.                 }, {

  2971.                     readonly modelValue: import("..").CheckboxGroupValueType;

  2972.                     readonly disabled: boolean;

  2973.                     readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  2974.                     readonly tag: string;

  2975.                 }>;

  2976.             };

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

  2978.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  2979.                 readonly disabled: BooleanConstructor;

  2980.                 readonly min: NumberConstructor;

  2981.                 readonly max: NumberConstructor;

  2982.                 readonly size: {

  2983.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  2984.                     readonly required: false;

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

  2986.                     __epPropKey: true;

  2987.                 };

  2988.                 readonly label: StringConstructor;

  2989.                 readonly fill: StringConstructor;

  2990.                 readonly textColor: StringConstructor;

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

  2992.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  2993.             }, {

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

  2995.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  2996.                     readonly disabled: BooleanConstructor;

  2997.                     readonly min: NumberConstructor;

  2998.                     readonly max: NumberConstructor;

  2999.                     readonly size: {

  3000.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3001.                         readonly required: false;

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

  3003.                         __epPropKey: true;

  3004.                     };

  3005.                     readonly label: StringConstructor;

  3006.                     readonly fill: StringConstructor;

  3007.                     readonly textColor: StringConstructor;

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

  3009.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  3010.                 }>> & {

  3011.                     onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  3012.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  3013.                 }>>;

  3014.                 emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  3015.                 ns: {

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

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

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

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

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

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

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

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

  3024.                     is: {

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

  3026.                         (name: string): string;

  3027.                     };

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

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

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

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

  3032.                 };

  3033.                 formItem: import("..").FormItemContext | undefined;

  3034.                 groupId: import("vue").Ref<string | undefined>;

  3035.                 isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  3036.                 changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  3037.                 modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

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

  3039.                 "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  3040.                 change: (val: import("..").CheckboxValueType[]) => boolean;

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

  3042.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  3043.                 readonly disabled: BooleanConstructor;

  3044.                 readonly min: NumberConstructor;

  3045.                 readonly max: NumberConstructor;

  3046.                 readonly size: {

  3047.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3048.                     readonly required: false;

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

  3050.                     __epPropKey: true;

  3051.                 };

  3052.                 readonly label: StringConstructor;

  3053.                 readonly fill: StringConstructor;

  3054.                 readonly textColor: StringConstructor;

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

  3056.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  3057.             }>> & {

  3058.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  3059.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  3060.             }, {

  3061.                 readonly modelValue: import("..").CheckboxGroupValueType;

  3062.                 readonly disabled: boolean;

  3063.                 readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  3064.                 readonly tag: string;

  3065.             }>>;

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

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

  3068.                 readonly size: {

  3069.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3070.                     readonly required: false;

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

  3072.                     __epPropKey: true;

  3073.                 };

  3074.                 readonly disabled: BooleanConstructor;

  3075.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  3077.                 readonly resize: {

  3078.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  3079.                     readonly required: false;

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

  3081.                     __epPropKey: true;

  3082.                 };

  3083.                 readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  3085.                 readonly formatter: {

  3086.                     readonly type: import("vue").PropType<Function>;

  3087.                     readonly required: false;

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

  3089.                     __epPropKey: true;

  3090.                 };

  3091.                 readonly parser: {

  3092.                     readonly type: import("vue").PropType<Function>;

  3093.                     readonly required: false;

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

  3095.                     __epPropKey: true;

  3096.                 };

  3097.                 readonly placeholder: {

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

  3099.                     readonly required: false;

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

  3101.                     __epPropKey: true;

  3102.                 };

  3103.                 readonly form: {

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

  3105.                     readonly required: false;

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

  3107.                     __epPropKey: true;

  3108.                 };

  3109.                 readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3110.                 readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3111.                 readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3112.                 readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3113.                 readonly suffixIcon: {

  3114.                     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>>;

  3115.                     readonly required: false;

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

  3117.                     __epPropKey: true;

  3118.                 };

  3119.                 readonly prefixIcon: {

  3120.                     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>>;

  3121.                     readonly required: false;

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

  3123.                     __epPropKey: true;

  3124.                 };

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

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

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

  3128.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  3129.                 readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  3130.             }, {

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

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

  3133.                     readonly size: {

  3134.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3135.                         readonly required: false;

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

  3137.                         __epPropKey: true;

  3138.                     };

  3139.                     readonly disabled: BooleanConstructor;

  3140.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  3142.                     readonly resize: {

  3143.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  3144.                         readonly required: false;

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

  3146.                         __epPropKey: true;

  3147.                     };

  3148.                     readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  3150.                     readonly formatter: {

  3151.                         readonly type: import("vue").PropType<Function>;

  3152.                         readonly required: false;

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

  3154.                         __epPropKey: true;

  3155.                     };

  3156.                     readonly parser: {

  3157.                         readonly type: import("vue").PropType<Function>;

  3158.                         readonly required: false;

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

  3160.                         __epPropKey: true;

  3161.                     };

  3162.                     readonly placeholder: {

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

  3164.                         readonly required: false;

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

  3166.                         __epPropKey: true;

  3167.                     };

  3168.                     readonly form: {

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

  3170.                         readonly required: false;

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

  3172.                         __epPropKey: true;

  3173.                     };

  3174.                     readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3175.                     readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3176.                     readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3177.                     readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3178.                     readonly suffixIcon: {

  3179.                         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>>;

  3180.                         readonly required: false;

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

  3182.                         __epPropKey: true;

  3183.                     };

  3184.                     readonly prefixIcon: {

  3185.                         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>>;

  3186.                         readonly required: false;

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

  3188.                         __epPropKey: true;

  3189.                     };

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

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

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

  3193.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  3194.                     readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  3195.                 }>> & {

  3196.                     onChange?: ((value: string) => any) | undefined;

  3197.                     "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  3198.                     onInput?: ((value: string) => any) | undefined;

  3199.                     onFocus?: ((evt: FocusEvent) => any) | undefined;

  3200.                     onBlur?: ((evt: FocusEvent) => any) | undefined;

  3201.                     onClear?: (() => any) | undefined;

  3202.                     onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  3203.                     onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  3204.                     onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  3205.                     onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  3206.                     onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  3207.                     onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  3208.                 }>>;

  3209.                 emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void);

  3210.                 rawAttrs: {

  3211.                     [x: string]: unknown;

  3212.                 };

  3213.                 slots: Readonly<{

  3214.                     [name: string]: import("vue").Slot | undefined;

  3215.                 }>;

  3216.                 containerAttrs: import("vue").ComputedRef<Record<string, unknown>>;

  3217.                 containerKls: import("vue").ComputedRef<unknown[]>;

  3218.                 wrapperKls: import("vue").ComputedRef<string[]>;

  3219.                 attrs: import("vue").ComputedRef<Record<string, unknown>>;

  3220.                 form: import("..").FormContext | undefined;

  3221.                 formItem: import("..").FormItemContext | undefined;

  3222.                 inputId: import("vue").Ref<string | undefined>;

  3223.                 inputSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  3224.                 inputDisabled: import("vue").ComputedRef<boolean>;

  3225.                 nsInput: {

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

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

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

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

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

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

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

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

  3234.                     is: {

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

  3236.                         (name: string): string;

  3237.                     };

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

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

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

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

  3242.                 };

  3243.                 nsTextarea: {

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

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

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

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

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

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

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

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

  3252.                     is: {

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

  3254.                         (name: string): string;

  3255.                     };

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

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

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

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

  3260.                 };

  3261.                 input: import("vue").ShallowRef<HTMLInputElement | undefined>;

  3262.                 textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined>;

  3263.                 focused: import("vue").Ref<boolean>;

  3264.                 hovering: import("vue").Ref<boolean>;

  3265.                 isComposing: import("vue").Ref<boolean>;

  3266.                 passwordVisible: import("vue").Ref<boolean>;

  3267.                 countStyle: import("vue").Ref<import("vue").StyleValue | undefined>;

  3268.                 textareaCalcStyle: import("vue").ShallowRef<import("vue").StyleValue>;

  3269.                 _ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;

  3270.                 needStatusIcon: import("vue").ComputedRef<boolean>;

  3271.                 validateState: import("vue").ComputedRef<"" | "success" | "error" | "validating">;

  3272.                 validateIcon: import("vue").ComputedRef<"" | 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<{}>>, {}>>;

  3273.                 passwordIcon: import("vue").ComputedRef<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<{}>>, {}>>;

  3274.                 containerStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  3275.                 textareaStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  3276.                 nativeInputValue: import("vue").ComputedRef<string>;

  3277.                 showClear: import("vue").ComputedRef<boolean>;

  3278.                 showPwdVisible: import("vue").ComputedRef<boolean>;

  3279.                 isWordLimitVisible: import("vue").ComputedRef<boolean>;

  3280.                 textLength: import("vue").ComputedRef<number>;

  3281.                 inputExceed: import("vue").ComputedRef<boolean>;

  3282.                 suffixVisible: import("vue").ComputedRef<boolean>;

  3283.                 recordCursor: () => void;

  3284.                 setCursor: () => void;

  3285.                 resizeTextarea: () => void;

  3286.                 createOnceInitResize: (resizeTextarea: () => void) => () => void;

  3287.                 onceInitSizeTextarea: () => void;

  3288.                 setNativeInputValue: () => void;

  3289.                 handleInput: (event: Event) => Promise<void>;

  3290.                 handleChange: (event: Event) => void;

  3291.                 handleCompositionStart: (event: CompositionEvent) => void;

  3292.                 handleCompositionUpdate: (event: CompositionEvent) => void;

  3293.                 handleCompositionEnd: (event: CompositionEvent) => void;

  3294.                 handlePasswordVisible: () => void;

  3295.                 focus: () => Promise<void>;

  3296.                 blur: () => void | undefined;

  3297.                 handleFocus: (event: FocusEvent) => void;

  3298.                 handleBlur: (event: FocusEvent) => void;

  3299.                 handleMouseLeave: (evt: MouseEvent) => void;

  3300.                 handleMouseEnter: (evt: MouseEvent) => void;

  3301.                 handleKeydown: (evt: KeyboardEvent) => void;

  3302.                 select: () => void;

  3303.                 clear: () => void;

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

  3305.                     readonly size: {

  3306.                         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>>;

  3307.                         readonly required: false;

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

  3309.                         __epPropKey: true;

  3310.                     };

  3311.                     readonly color: {

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

  3313.                         readonly required: false;

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

  3315.                         __epPropKey: true;

  3316.                     };

  3317.                 }, {

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

  3319.                         readonly size: {

  3320.                             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>>;

  3321.                             readonly required: false;

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

  3323.                             __epPropKey: true;

  3324.                         };

  3325.                         readonly color: {

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

  3327.                             readonly required: false;

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

  3329.                             __epPropKey: true;

  3330.                         };

  3331.                     }>> & {

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

  3333.                     }>>;

  3334.                     ns: {

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

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

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

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

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

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

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

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

  3343.                         is: {

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

  3345.                             (name: string): string;

  3346.                         };

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

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

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

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

  3351.                     };

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

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

  3354.                     readonly size: {

  3355.                         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>>;

  3356.                         readonly required: false;

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

  3358.                         __epPropKey: true;

  3359.                     };

  3360.                     readonly color: {

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

  3362.                         readonly required: false;

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

  3364.                         __epPropKey: true;

  3365.                     };

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

  3367.                 CircleClose: 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<{}>>, {}>;

  3368.                 NOOP: () => void;

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

  3370.                 "update:modelValue": (value: string) => boolean;

  3371.                 input: (value: string) => boolean;

  3372.                 change: (value: string) => boolean;

  3373.                 focus: (evt: FocusEvent) => boolean;

  3374.                 blur: (evt: FocusEvent) => boolean;

  3375.                 clear: () => boolean;

  3376.                 mouseleave: (evt: MouseEvent) => boolean;

  3377.                 mouseenter: (evt: MouseEvent) => boolean;

  3378.                 keydown: (evt: Event | KeyboardEvent) => boolean;

  3379.                 compositionstart: (evt: CompositionEvent) => boolean;

  3380.                 compositionupdate: (evt: CompositionEvent) => boolean;

  3381.                 compositionend: (evt: CompositionEvent) => boolean;

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

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

  3384.                 readonly size: {

  3385.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3386.                     readonly required: false;

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

  3388.                     __epPropKey: true;

  3389.                 };

  3390.                 readonly disabled: BooleanConstructor;

  3391.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  3393.                 readonly resize: {

  3394.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  3395.                     readonly required: false;

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

  3397.                     __epPropKey: true;

  3398.                 };

  3399.                 readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  3401.                 readonly formatter: {

  3402.                     readonly type: import("vue").PropType<Function>;

  3403.                     readonly required: false;

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

  3405.                     __epPropKey: true;

  3406.                 };

  3407.                 readonly parser: {

  3408.                     readonly type: import("vue").PropType<Function>;

  3409.                     readonly required: false;

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

  3411.                     __epPropKey: true;

  3412.                 };

  3413.                 readonly placeholder: {

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

  3415.                     readonly required: false;

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

  3417.                     __epPropKey: true;

  3418.                 };

  3419.                 readonly form: {

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

  3421.                     readonly required: false;

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

  3423.                     __epPropKey: true;

  3424.                 };

  3425.                 readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3426.                 readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3427.                 readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3428.                 readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  3429.                 readonly suffixIcon: {

  3430.                     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>>;

  3431.                     readonly required: false;

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

  3433.                     __epPropKey: true;

  3434.                 };

  3435.                 readonly prefixIcon: {

  3436.                     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>>;

  3437.                     readonly required: false;

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

  3439.                     __epPropKey: true;

  3440.                 };

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

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

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

  3444.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  3445.                 readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  3446.             }>> & {

  3447.                 onChange?: ((value: string) => any) | undefined;

  3448.                 "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  3449.                 onInput?: ((value: string) => any) | undefined;

  3450.                 onFocus?: ((evt: FocusEvent) => any) | undefined;

  3451.                 onBlur?: ((evt: FocusEvent) => any) | undefined;

  3452.                 onClear?: (() => any) | undefined;

  3453.                 onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  3454.                 onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  3455.                 onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  3456.                 onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  3457.                 onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  3458.                 onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  3459.             }, {

  3460.                 readonly type: string;

  3461.                 readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown>;

  3462.                 readonly label: string;

  3463.                 readonly id: string;

  3464.                 readonly disabled: boolean;

  3465.                 readonly clearable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  3466.                 readonly autosize: import("..").InputAutoSize;

  3467.                 readonly autocomplete: string;

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

  3469.                 readonly showPassword: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  3470.                 readonly showWordLimit: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  3471.                 readonly containerRole: string;

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

  3473.                 readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  3474.                 readonly inputStyle: import("vue").StyleValue;

  3475.             }>> & Record<string, any>;

  3476.             Search: 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<{}>>, {}>;

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

  3478.             "checked-change": (value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => boolean;

  3479.         }, string, {

  3480.             readonly props: import("./src/transfer").TransferPropsAlias;

  3481.             readonly data: import("./src/transfer").TransferDataItem[];

  3482.             readonly filterable: boolean;

  3483.             readonly format: import("./src/transfer").TransferFormat;

  3484.             readonly defaultChecked: import("./src/transfer").TransferKey[];

  3485.         }> & {

  3486.             beforeCreate?: ((() => void) | (() => void)[]) | undefined;

  3487.             created?: ((() => void) | (() => void)[]) | undefined;

  3488.             beforeMount?: ((() => void) | (() => void)[]) | undefined;

  3489.             mounted?: ((() => void) | (() => void)[]) | undefined;

  3490.             beforeUpdate?: ((() => void) | (() => void)[]) | undefined;

  3491.             updated?: ((() => void) | (() => void)[]) | undefined;

  3492.             activated?: ((() => void) | (() => void)[]) | undefined;

  3493.             deactivated?: ((() => void) | (() => void)[]) | undefined;

  3494.             beforeDestroy?: ((() => void) | (() => void)[]) | undefined;

  3495.             beforeUnmount?: ((() => void) | (() => void)[]) | undefined;

  3496.             destroyed?: ((() => void) | (() => void)[]) | undefined;

  3497.             unmounted?: ((() => void) | (() => void)[]) | undefined;

  3498.             renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;

  3499.             renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;

  3500.             errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;

  3501.         };

  3502.         $forceUpdate: () => void;

  3503.         $nextTick: typeof import("vue").nextTick;

  3504.         $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;

  3505.     } & Readonly<import("vue").ExtractPropTypes<{

  3506.         readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  3507.         readonly optionRender: {

  3508.             readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  3509.                 [key: string]: any;

  3510.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  3511.                 [key: string]: any;

  3512.             }>[]>;

  3513.             readonly required: false;

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

  3515.             __epPropKey: true;

  3516.         };

  3517.         readonly placeholder: StringConstructor;

  3518.         readonly title: StringConstructor;

  3519.         readonly filterable: BooleanConstructor;

  3520.         readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  3521.         readonly filterMethod: {

  3522.             readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  3523.             readonly required: false;

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

  3525.             __epPropKey: true;

  3526.         };

  3527.         readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  3528.         readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  3529.             readonly label: "label";

  3530.             readonly key: "key";

  3531.             readonly disabled: "disabled";

  3532.         }>, boolean>;

  3533.     }>> & {

  3534.         "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  3535.     } & import("vue").ShallowUnwrapRef<{

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

  3537.             readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  3538.             readonly optionRender: {

  3539.                 readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  3540.                     [key: string]: any;

  3541.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  3542.                     [key: string]: any;

  3543.                 }>[]>;

  3544.                 readonly required: false;

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

  3546.                 __epPropKey: true;

  3547.             };

  3548.             readonly placeholder: StringConstructor;

  3549.             readonly title: StringConstructor;

  3550.             readonly filterable: BooleanConstructor;

  3551.             readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  3552.             readonly filterMethod: {

  3553.                 readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  3554.                 readonly required: false;

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

  3556.                 __epPropKey: true;

  3557.             };

  3558.             readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  3559.             readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  3560.                 readonly label: "label";

  3561.                 readonly key: "key";

  3562.                 readonly disabled: "disabled";

  3563.             }>, boolean>;

  3564.         }>> & {

  3565.             "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  3566.         }>>;

  3567.         emit: (event: "checked-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  3568.         slots: Readonly<{

  3569.             [name: string]: import("vue").Slot | undefined;

  3570.         }>;

  3571.         OptionContent: ({ option }: {

  3572.             option: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  3573.                 [key: string]: any;

  3574.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  3575.                 [key: string]: any;

  3576.             }>[];

  3577.         }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  3578.             [key: string]: any;

  3579.         }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  3580.             [key: string]: any;

  3581.         }>[];

  3582.         t: import("../..").Translator;

  3583.         ns: {

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

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

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

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

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

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

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

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

  3592.             is: {

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

  3594.                 (name: string): string;

  3595.             };

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

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

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

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

  3600.         };

  3601.         panelState: {

  3602.             checked: import("./src/transfer").TransferKey[];

  3603.             allChecked: boolean;

  3604.             query: string;

  3605.             checkChangeByUser: boolean;

  3606.         };

  3607.         propsAlias: import("vue").ComputedRef<{

  3608.             label: string;

  3609.             key: string;

  3610.             disabled: string;

  3611.         }>;

  3612.         filteredData: import("vue").ComputedRef<import("./src/transfer").TransferDataItem[]>;

  3613.         checkedSummary: import("vue").ComputedRef<string>;

  3614.         isIndeterminate: import("vue").ComputedRef<boolean>;

  3615.         handleAllCheckedChange: (value: import("..").CheckboxValueType) => void;

  3616.         hasNoMatch: import("vue").ComputedRef<boolean>;

  3617.         hasFooter: import("vue").ComputedRef<boolean>;

  3618.         checked: import("vue").Ref<import("./src/transfer").TransferKey[]>;

  3619.         allChecked: import("vue").Ref<boolean>;

  3620.         query: import("vue").Ref<string>;

  3621.         isEmpty: (val: unknown) => boolean;

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

  3623.             modelValue: {

  3624.                 type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  3625.                 default: undefined;

  3626.             };

  3627.             label: {

  3628.                 type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  3629.             };

  3630.             indeterminate: BooleanConstructor;

  3631.             disabled: BooleanConstructor;

  3632.             checked: BooleanConstructor;

  3633.             name: {

  3634.                 type: StringConstructor;

  3635.                 default: undefined;

  3636.             };

  3637.             trueLabel: {

  3638.                 type: (NumberConstructor | StringConstructor)[];

  3639.                 default: undefined;

  3640.             };

  3641.             falseLabel: {

  3642.                 type: (NumberConstructor | StringConstructor)[];

  3643.                 default: undefined;

  3644.             };

  3645.             id: {

  3646.                 type: StringConstructor;

  3647.                 default: undefined;

  3648.             };

  3649.             controls: {

  3650.                 type: StringConstructor;

  3651.                 default: undefined;

  3652.             };

  3653.             border: BooleanConstructor;

  3654.             size: {

  3655.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3656.                 readonly required: false;

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

  3658.                 __epPropKey: true;

  3659.             };

  3660.             tabindex: (NumberConstructor | StringConstructor)[];

  3661.             validateEvent: {

  3662.                 type: BooleanConstructor;

  3663.                 default: boolean;

  3664.             };

  3665.         }, {

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

  3667.                 modelValue: {

  3668.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  3669.                     default: undefined;

  3670.                 };

  3671.                 label: {

  3672.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  3673.                 };

  3674.                 indeterminate: BooleanConstructor;

  3675.                 disabled: BooleanConstructor;

  3676.                 checked: BooleanConstructor;

  3677.                 name: {

  3678.                     type: StringConstructor;

  3679.                     default: undefined;

  3680.                 };

  3681.                 trueLabel: {

  3682.                     type: (NumberConstructor | StringConstructor)[];

  3683.                     default: undefined;

  3684.                 };

  3685.                 falseLabel: {

  3686.                     type: (NumberConstructor | StringConstructor)[];

  3687.                     default: undefined;

  3688.                 };

  3689.                 id: {

  3690.                     type: StringConstructor;

  3691.                     default: undefined;

  3692.                 };

  3693.                 controls: {

  3694.                     type: StringConstructor;

  3695.                     default: undefined;

  3696.                 };

  3697.                 border: BooleanConstructor;

  3698.                 size: {

  3699.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3700.                     readonly required: false;

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

  3702.                     __epPropKey: true;

  3703.                 };

  3704.                 tabindex: (NumberConstructor | StringConstructor)[];

  3705.                 validateEvent: {

  3706.                     type: BooleanConstructor;

  3707.                     default: boolean;

  3708.                 };

  3709.             }>> & {

  3710.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  3711.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  3712.             }>>;

  3713.             slots: Readonly<{

  3714.                 [name: string]: import("vue").Slot | undefined;

  3715.             }>;

  3716.             inputId: import("vue").Ref<string | undefined>;

  3717.             isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  3718.             isChecked: import("vue").ComputedRef<boolean>;

  3719.             isDisabled: import("vue").ComputedRef<boolean>;

  3720.             isFocused: import("vue").Ref<boolean>;

  3721.             checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  3722.             hasOwnLabel: import("vue").ComputedRef<boolean>;

  3723.             model: import("vue").WritableComputedRef<any>;

  3724.             handleChange: (e: Event) => void;

  3725.             onClickRoot: (e: MouseEvent) => Promise<void>;

  3726.             ns: {

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

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

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

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

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

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

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

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

  3735.                 is: {

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

  3737.                     (name: string): string;

  3738.                 };

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

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

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

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

  3743.             };

  3744.             compKls: import("vue").ComputedRef<string[]>;

  3745.             spanKls: import("vue").ComputedRef<string[]>;

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

  3747.             "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  3748.             change: (val: import("..").CheckboxValueType) => boolean;

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

  3750.             modelValue: {

  3751.                 type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  3752.                 default: undefined;

  3753.             };

  3754.             label: {

  3755.                 type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  3756.             };

  3757.             indeterminate: BooleanConstructor;

  3758.             disabled: BooleanConstructor;

  3759.             checked: BooleanConstructor;

  3760.             name: {

  3761.                 type: StringConstructor;

  3762.                 default: undefined;

  3763.             };

  3764.             trueLabel: {

  3765.                 type: (NumberConstructor | StringConstructor)[];

  3766.                 default: undefined;

  3767.             };

  3768.             falseLabel: {

  3769.                 type: (NumberConstructor | StringConstructor)[];

  3770.                 default: undefined;

  3771.             };

  3772.             id: {

  3773.                 type: StringConstructor;

  3774.                 default: undefined;

  3775.             };

  3776.             controls: {

  3777.                 type: StringConstructor;

  3778.                 default: undefined;

  3779.             };

  3780.             border: BooleanConstructor;

  3781.             size: {

  3782.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3783.                 readonly required: false;

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

  3785.                 __epPropKey: true;

  3786.             };

  3787.             tabindex: (NumberConstructor | StringConstructor)[];

  3788.             validateEvent: {

  3789.                 type: BooleanConstructor;

  3790.                 default: boolean;

  3791.             };

  3792.         }>> & {

  3793.             onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  3794.             "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  3795.         }, {

  3796.             modelValue: string | number | boolean;

  3797.             id: string;

  3798.             disabled: boolean;

  3799.             name: string;

  3800.             validateEvent: boolean;

  3801.             border: boolean;

  3802.             indeterminate: boolean;

  3803.             checked: boolean;

  3804.             trueLabel: string | number;

  3805.             falseLabel: string | number;

  3806.             controls: string;

  3807.         }>> & {

  3808.             CheckboxButton: import("vue").DefineComponent<{

  3809.                 modelValue: {

  3810.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  3811.                     default: undefined;

  3812.                 };

  3813.                 label: {

  3814.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  3815.                 };

  3816.                 indeterminate: BooleanConstructor;

  3817.                 disabled: BooleanConstructor;

  3818.                 checked: BooleanConstructor;

  3819.                 name: {

  3820.                     type: StringConstructor;

  3821.                     default: undefined;

  3822.                 };

  3823.                 trueLabel: {

  3824.                     type: (NumberConstructor | StringConstructor)[];

  3825.                     default: undefined;

  3826.                 };

  3827.                 falseLabel: {

  3828.                     type: (NumberConstructor | StringConstructor)[];

  3829.                     default: undefined;

  3830.                 };

  3831.                 id: {

  3832.                     type: StringConstructor;

  3833.                     default: undefined;

  3834.                 };

  3835.                 controls: {

  3836.                     type: StringConstructor;

  3837.                     default: undefined;

  3838.                 };

  3839.                 border: BooleanConstructor;

  3840.                 size: {

  3841.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3842.                     readonly required: false;

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

  3844.                     __epPropKey: true;

  3845.                 };

  3846.                 tabindex: (NumberConstructor | StringConstructor)[];

  3847.                 validateEvent: {

  3848.                     type: BooleanConstructor;

  3849.                     default: boolean;

  3850.                 };

  3851.             }, {

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

  3853.                     modelValue: {

  3854.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  3855.                         default: undefined;

  3856.                     };

  3857.                     label: {

  3858.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  3859.                     };

  3860.                     indeterminate: BooleanConstructor;

  3861.                     disabled: BooleanConstructor;

  3862.                     checked: BooleanConstructor;

  3863.                     name: {

  3864.                         type: StringConstructor;

  3865.                         default: undefined;

  3866.                     };

  3867.                     trueLabel: {

  3868.                         type: (NumberConstructor | StringConstructor)[];

  3869.                         default: undefined;

  3870.                     };

  3871.                     falseLabel: {

  3872.                         type: (NumberConstructor | StringConstructor)[];

  3873.                         default: undefined;

  3874.                     };

  3875.                     id: {

  3876.                         type: StringConstructor;

  3877.                         default: undefined;

  3878.                     };

  3879.                     controls: {

  3880.                         type: StringConstructor;

  3881.                         default: undefined;

  3882.                     };

  3883.                     border: BooleanConstructor;

  3884.                     size: {

  3885.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3886.                         readonly required: false;

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

  3888.                         __epPropKey: true;

  3889.                     };

  3890.                     tabindex: (NumberConstructor | StringConstructor)[];

  3891.                     validateEvent: {

  3892.                         type: BooleanConstructor;

  3893.                         default: boolean;

  3894.                     };

  3895.                 }>> & {

  3896.                     onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  3897.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  3898.                 }>>;

  3899.                 slots: Readonly<{

  3900.                     [name: string]: import("vue").Slot | undefined;

  3901.                 }>;

  3902.                 isFocused: import("vue").Ref<boolean>;

  3903.                 isChecked: import("vue").ComputedRef<boolean>;

  3904.                 isDisabled: import("vue").ComputedRef<boolean>;

  3905.                 checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  3906.                 model: import("vue").WritableComputedRef<any>;

  3907.                 handleChange: (e: Event) => void;

  3908.                 checkboxGroup: ({

  3909.                     modelValue?: import("vue").WritableComputedRef<any> | undefined;

  3910.                     changeEvent?: ((...args: any) => any) | undefined;

  3911.                 } & import("vue").ToRefs<Pick<import("..").CheckboxGroupProps, "fill" | "size" | "disabled" | "validateEvent" | "max" | "min" | "textColor">>) | undefined;

  3912.                 ns: {

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

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

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

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

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

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

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

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

  3921.                     is: {

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

  3923.                         (name: string): string;

  3924.                     };

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

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

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

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

  3929.                 };

  3930.                 activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  3931.                 labelKls: import("vue").ComputedRef<string[]>;

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

  3933.                 "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  3934.                 change: (val: import("..").CheckboxValueType) => boolean;

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

  3936.                 modelValue: {

  3937.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  3938.                     default: undefined;

  3939.                 };

  3940.                 label: {

  3941.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  3942.                 };

  3943.                 indeterminate: BooleanConstructor;

  3944.                 disabled: BooleanConstructor;

  3945.                 checked: BooleanConstructor;

  3946.                 name: {

  3947.                     type: StringConstructor;

  3948.                     default: undefined;

  3949.                 };

  3950.                 trueLabel: {

  3951.                     type: (NumberConstructor | StringConstructor)[];

  3952.                     default: undefined;

  3953.                 };

  3954.                 falseLabel: {

  3955.                     type: (NumberConstructor | StringConstructor)[];

  3956.                     default: undefined;

  3957.                 };

  3958.                 id: {

  3959.                     type: StringConstructor;

  3960.                     default: undefined;

  3961.                 };

  3962.                 controls: {

  3963.                     type: StringConstructor;

  3964.                     default: undefined;

  3965.                 };

  3966.                 border: BooleanConstructor;

  3967.                 size: {

  3968.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  3969.                     readonly required: false;

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

  3971.                     __epPropKey: true;

  3972.                 };

  3973.                 tabindex: (NumberConstructor | StringConstructor)[];

  3974.                 validateEvent: {

  3975.                     type: BooleanConstructor;

  3976.                     default: boolean;

  3977.                 };

  3978.             }>> & {

  3979.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  3980.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  3981.             }, {

  3982.                 modelValue: string | number | boolean;

  3983.                 id: string;

  3984.                 disabled: boolean;

  3985.                 name: string;

  3986.                 validateEvent: boolean;

  3987.                 border: boolean;

  3988.                 indeterminate: boolean;

  3989.                 checked: boolean;

  3990.                 trueLabel: string | number;

  3991.                 falseLabel: string | number;

  3992.                 controls: string;

  3993.             }>;

  3994.             CheckboxGroup: import("vue").DefineComponent<{

  3995.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  3996.                 readonly disabled: BooleanConstructor;

  3997.                 readonly min: NumberConstructor;

  3998.                 readonly max: NumberConstructor;

  3999.                 readonly size: {

  4000.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4001.                     readonly required: false;

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

  4003.                     __epPropKey: true;

  4004.                 };

  4005.                 readonly label: StringConstructor;

  4006.                 readonly fill: StringConstructor;

  4007.                 readonly textColor: StringConstructor;

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

  4009.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4010.             }, {

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

  4012.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  4013.                     readonly disabled: BooleanConstructor;

  4014.                     readonly min: NumberConstructor;

  4015.                     readonly max: NumberConstructor;

  4016.                     readonly size: {

  4017.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4018.                         readonly required: false;

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

  4020.                         __epPropKey: true;

  4021.                     };

  4022.                     readonly label: StringConstructor;

  4023.                     readonly fill: StringConstructor;

  4024.                     readonly textColor: StringConstructor;

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

  4026.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4027.                 }>> & {

  4028.                     onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  4029.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  4030.                 }>>;

  4031.                 emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  4032.                 ns: {

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

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

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

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

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

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

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

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

  4041.                     is: {

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

  4043.                         (name: string): string;

  4044.                     };

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

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

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

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

  4049.                 };

  4050.                 formItem: import("..").FormItemContext | undefined;

  4051.                 groupId: import("vue").Ref<string | undefined>;

  4052.                 isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  4053.                 changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  4054.                 modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

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

  4056.                 "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  4057.                 change: (val: import("..").CheckboxValueType[]) => boolean;

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

  4059.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  4060.                 readonly disabled: BooleanConstructor;

  4061.                 readonly min: NumberConstructor;

  4062.                 readonly max: NumberConstructor;

  4063.                 readonly size: {

  4064.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4065.                     readonly required: false;

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

  4067.                     __epPropKey: true;

  4068.                 };

  4069.                 readonly label: StringConstructor;

  4070.                 readonly fill: StringConstructor;

  4071.                 readonly textColor: StringConstructor;

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

  4073.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4074.             }>> & {

  4075.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  4076.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  4077.             }, {

  4078.                 readonly modelValue: import("..").CheckboxGroupValueType;

  4079.                 readonly disabled: boolean;

  4080.                 readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  4081.                 readonly tag: string;

  4082.             }>;

  4083.         };

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

  4085.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  4086.             readonly disabled: BooleanConstructor;

  4087.             readonly min: NumberConstructor;

  4088.             readonly max: NumberConstructor;

  4089.             readonly size: {

  4090.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4091.                 readonly required: false;

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

  4093.                 __epPropKey: true;

  4094.             };

  4095.             readonly label: StringConstructor;

  4096.             readonly fill: StringConstructor;

  4097.             readonly textColor: StringConstructor;

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

  4099.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4100.         }, {

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

  4102.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  4103.                 readonly disabled: BooleanConstructor;

  4104.                 readonly min: NumberConstructor;

  4105.                 readonly max: NumberConstructor;

  4106.                 readonly size: {

  4107.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4108.                     readonly required: false;

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

  4110.                     __epPropKey: true;

  4111.                 };

  4112.                 readonly label: StringConstructor;

  4113.                 readonly fill: StringConstructor;

  4114.                 readonly textColor: StringConstructor;

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

  4116.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4117.             }>> & {

  4118.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  4119.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  4120.             }>>;

  4121.             emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  4122.             ns: {

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

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

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

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

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

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

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

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

  4131.                 is: {

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

  4133.                     (name: string): string;

  4134.                 };

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

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

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

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

  4139.             };

  4140.             formItem: import("..").FormItemContext | undefined;

  4141.             groupId: import("vue").Ref<string | undefined>;

  4142.             isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  4143.             changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  4144.             modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

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

  4146.             "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  4147.             change: (val: import("..").CheckboxValueType[]) => boolean;

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

  4149.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  4150.             readonly disabled: BooleanConstructor;

  4151.             readonly min: NumberConstructor;

  4152.             readonly max: NumberConstructor;

  4153.             readonly size: {

  4154.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4155.                 readonly required: false;

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

  4157.                 __epPropKey: true;

  4158.             };

  4159.             readonly label: StringConstructor;

  4160.             readonly fill: StringConstructor;

  4161.             readonly textColor: StringConstructor;

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

  4163.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4164.         }>> & {

  4165.             onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  4166.             "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  4167.         }, {

  4168.             readonly modelValue: import("..").CheckboxGroupValueType;

  4169.             readonly disabled: boolean;

  4170.             readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  4171.             readonly tag: string;

  4172.         }>>;

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

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

  4175.             readonly size: {

  4176.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4177.                 readonly required: false;

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

  4179.                 __epPropKey: true;

  4180.             };

  4181.             readonly disabled: BooleanConstructor;

  4182.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  4184.             readonly resize: {

  4185.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  4186.                 readonly required: false;

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

  4188.                 __epPropKey: true;

  4189.             };

  4190.             readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  4192.             readonly formatter: {

  4193.                 readonly type: import("vue").PropType<Function>;

  4194.                 readonly required: false;

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

  4196.                 __epPropKey: true;

  4197.             };

  4198.             readonly parser: {

  4199.                 readonly type: import("vue").PropType<Function>;

  4200.                 readonly required: false;

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

  4202.                 __epPropKey: true;

  4203.             };

  4204.             readonly placeholder: {

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

  4206.                 readonly required: false;

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

  4208.                 __epPropKey: true;

  4209.             };

  4210.             readonly form: {

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

  4212.                 readonly required: false;

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

  4214.                 __epPropKey: true;

  4215.             };

  4216.             readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4217.             readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4218.             readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4219.             readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4220.             readonly suffixIcon: {

  4221.                 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>>;

  4222.                 readonly required: false;

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

  4224.                 __epPropKey: true;

  4225.             };

  4226.             readonly prefixIcon: {

  4227.                 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>>;

  4228.                 readonly required: false;

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

  4230.                 __epPropKey: true;

  4231.             };

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

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

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

  4235.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4236.             readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  4237.         }, {

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

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

  4240.                 readonly size: {

  4241.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4242.                     readonly required: false;

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

  4244.                     __epPropKey: true;

  4245.                 };

  4246.                 readonly disabled: BooleanConstructor;

  4247.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

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

  4249.                 readonly resize: {

  4250.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  4251.                     readonly required: false;

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

  4253.                     __epPropKey: true;

  4254.                 };

  4255.                 readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

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

  4257.                 readonly formatter: {

  4258.                     readonly type: import("vue").PropType<Function>;

  4259.                     readonly required: false;

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

  4261.                     __epPropKey: true;

  4262.                 };

  4263.                 readonly parser: {

  4264.                     readonly type: import("vue").PropType<Function>;

  4265.                     readonly required: false;

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

  4267.                     __epPropKey: true;

  4268.                 };

  4269.                 readonly placeholder: {

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

  4271.                     readonly required: false;

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

  4273.                     __epPropKey: true;

  4274.                 };

  4275.                 readonly form: {

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

  4277.                     readonly required: false;

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

  4279.                     __epPropKey: true;

  4280.                 };

  4281.                 readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4282.                 readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4283.                 readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4284.                 readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4285.                 readonly suffixIcon: {

  4286.                     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>>;

  4287.                     readonly required: false;

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

  4289.                     __epPropKey: true;

  4290.                 };

  4291.                 readonly prefixIcon: {

  4292.                     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>>;

  4293.                     readonly required: false;

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

  4295.                     __epPropKey: true;

  4296.                 };

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

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

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

  4300.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4301.                 readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  4302.             }>> & {

  4303.                 onChange?: ((value: string) => any) | undefined;

  4304.                 "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  4305.                 onInput?: ((value: string) => any) | undefined;

  4306.                 onFocus?: ((evt: FocusEvent) => any) | undefined;

  4307.                 onBlur?: ((evt: FocusEvent) => any) | undefined;

  4308.                 onClear?: (() => any) | undefined;

  4309.                 onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  4310.                 onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  4311.                 onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  4312.                 onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  4313.                 onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  4314.                 onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  4315.             }>>;

  4316.             emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void);

  4317.             rawAttrs: {

  4318.                 [x: string]: unknown;

  4319.             };

  4320.             slots: Readonly<{

  4321.                 [name: string]: import("vue").Slot | undefined;

  4322.             }>;

  4323.             containerAttrs: import("vue").ComputedRef<Record<string, unknown>>;

  4324.             containerKls: import("vue").ComputedRef<unknown[]>;

  4325.             wrapperKls: import("vue").ComputedRef<string[]>;

  4326.             attrs: import("vue").ComputedRef<Record<string, unknown>>;

  4327.             form: import("..").FormContext | undefined;

  4328.             formItem: import("..").FormItemContext | undefined;

  4329.             inputId: import("vue").Ref<string | undefined>;

  4330.             inputSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  4331.             inputDisabled: import("vue").ComputedRef<boolean>;

  4332.             nsInput: {

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

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

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

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

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

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

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

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

  4341.                 is: {

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

  4343.                     (name: string): string;

  4344.                 };

  4345.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  4346.                 cssVarName: (name: string) => string;

  4347.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  4348.                 cssVarBlockName: (name: string) => string;

  4349.             };

  4350.             nsTextarea: {

  4351.                 namespace: import("vue").ComputedRef<string>;

  4352.                 b: (blockSuffix?: string) => string;

  4353.                 e: (element?: string | undefined) => string;

  4354.                 m: (modifier?: string | undefined) => string;

  4355.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  4356.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  4357.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  4358.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  4359.                 is: {

  4360.                     (name: string, state: boolean | undefined): string;

  4361.                     (name: string): string;

  4362.                 };

  4363.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  4364.                 cssVarName: (name: string) => string;

  4365.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  4366.                 cssVarBlockName: (name: string) => string;

  4367.             };

  4368.             input: import("vue").ShallowRef<HTMLInputElement | undefined>;

  4369.             textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined>;

  4370.             focused: import("vue").Ref<boolean>;

  4371.             hovering: import("vue").Ref<boolean>;

  4372.             isComposing: import("vue").Ref<boolean>;

  4373.             passwordVisible: import("vue").Ref<boolean>;

  4374.             countStyle: import("vue").Ref<import("vue").StyleValue | undefined>;

  4375.             textareaCalcStyle: import("vue").ShallowRef<import("vue").StyleValue>;

  4376.             _ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;

  4377.             needStatusIcon: import("vue").ComputedRef<boolean>;

  4378.             validateState: import("vue").ComputedRef<"" | "success" | "error" | "validating">;

  4379.             validateIcon: import("vue").ComputedRef<"" | 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<{}>>, {}>>;

  4380.             passwordIcon: import("vue").ComputedRef<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<{}>>, {}>>;

  4381.             containerStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  4382.             textareaStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  4383.             nativeInputValue: import("vue").ComputedRef<string>;

  4384.             showClear: import("vue").ComputedRef<boolean>;

  4385.             showPwdVisible: import("vue").ComputedRef<boolean>;

  4386.             isWordLimitVisible: import("vue").ComputedRef<boolean>;

  4387.             textLength: import("vue").ComputedRef<number>;

  4388.             inputExceed: import("vue").ComputedRef<boolean>;

  4389.             suffixVisible: import("vue").ComputedRef<boolean>;

  4390.             recordCursor: () => void;

  4391.             setCursor: () => void;

  4392.             resizeTextarea: () => void;

  4393.             createOnceInitResize: (resizeTextarea: () => void) => () => void;

  4394.             onceInitSizeTextarea: () => void;

  4395.             setNativeInputValue: () => void;

  4396.             handleInput: (event: Event) => Promise<void>;

  4397.             handleChange: (event: Event) => void;

  4398.             handleCompositionStart: (event: CompositionEvent) => void;

  4399.             handleCompositionUpdate: (event: CompositionEvent) => void;

  4400.             handleCompositionEnd: (event: CompositionEvent) => void;

  4401.             handlePasswordVisible: () => void;

  4402.             focus: () => Promise<void>;

  4403.             blur: () => void | undefined;

  4404.             handleFocus: (event: FocusEvent) => void;

  4405.             handleBlur: (event: FocusEvent) => void;

  4406.             handleMouseLeave: (evt: MouseEvent) => void;

  4407.             handleMouseEnter: (evt: MouseEvent) => void;

  4408.             handleKeydown: (evt: KeyboardEvent) => void;

  4409.             select: () => void;

  4410.             clear: () => void;

  4411.             ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  4412.                 readonly size: {

  4413.                     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>>;

  4414.                     readonly required: false;

  4415.                     readonly validator: ((val: unknown) => boolean) | undefined;

  4416.                     __epPropKey: true;

  4417.                 };

  4418.                 readonly color: {

  4419.                     readonly type: import("vue").PropType<string>;

  4420.                     readonly required: false;

  4421.                     readonly validator: ((val: unknown) => boolean) | undefined;

  4422.                     __epPropKey: true;

  4423.                 };

  4424.             }, {

  4425.                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  4426.                     readonly size: {

  4427.                         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>>;

  4428.                         readonly required: false;

  4429.                         readonly validator: ((val: unknown) => boolean) | undefined;

  4430.                         __epPropKey: true;

  4431.                     };

  4432.                     readonly color: {

  4433.                         readonly type: import("vue").PropType<string>;

  4434.                         readonly required: false;

  4435.                         readonly validator: ((val: unknown) => boolean) | undefined;

  4436.                         __epPropKey: true;

  4437.                     };

  4438.                 }>> & {

  4439.                     [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  4440.                 }>>;

  4441.                 ns: {

  4442.                     namespace: import("vue").ComputedRef<string>;

  4443.                     b: (blockSuffix?: string) => string;

  4444.                     e: (element?: string | undefined) => string;

  4445.                     m: (modifier?: string | undefined) => string;

  4446.                     be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  4447.                     em: (element?: string | undefined, modifier?: string | undefined) => string;

  4448.                     bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  4449.                     bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  4450.                     is: {

  4451.                         (name: string, state: boolean | undefined): string;

  4452.                         (name: string): string;

  4453.                     };

  4454.                     cssVar: (object: Record<string, string>) => Record<string, string>;

  4455.                     cssVarName: (name: string) => string;

  4456.                     cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  4457.                     cssVarBlockName: (name: string) => string;

  4458.                 };

  4459.                 style: import("vue").ComputedRef<import("vue").CSSProperties>;

  4460.             }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  4461.                 readonly size: {

  4462.                     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>>;

  4463.                     readonly required: false;

  4464.                     readonly validator: ((val: unknown) => boolean) | undefined;

  4465.                     __epPropKey: true;

  4466.                 };

  4467.                 readonly color: {

  4468.                     readonly type: import("vue").PropType<string>;

  4469.                     readonly required: false;

  4470.                     readonly validator: ((val: unknown) => boolean) | undefined;

  4471.                     __epPropKey: true;

  4472.                 };

  4473.             }>>, {}>> & Record<string, any>;

  4474.             CircleClose: 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<{}>>, {}>;

  4475.             NOOP: () => void;

  4476.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  4477.             "update:modelValue": (value: string) => boolean;

  4478.             input: (value: string) => boolean;

  4479.             change: (value: string) => boolean;

  4480.             focus: (evt: FocusEvent) => boolean;

  4481.             blur: (evt: FocusEvent) => boolean;

  4482.             clear: () => boolean;

  4483.             mouseleave: (evt: MouseEvent) => boolean;

  4484.             mouseenter: (evt: MouseEvent) => boolean;

  4485.             keydown: (evt: Event | KeyboardEvent) => boolean;

  4486.             compositionstart: (evt: CompositionEvent) => boolean;

  4487.             compositionupdate: (evt: CompositionEvent) => boolean;

  4488.             compositionend: (evt: CompositionEvent) => boolean;

  4489.         }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  4490.             readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  4491.             readonly size: {

  4492.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4493.                 readonly required: false;

  4494.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4495.                 __epPropKey: true;

  4496.             };

  4497.             readonly disabled: BooleanConstructor;

  4498.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

  4499.             readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;

  4500.             readonly resize: {

  4501.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  4502.                 readonly required: false;

  4503.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4504.                 __epPropKey: true;

  4505.             };

  4506.             readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

  4507.             readonly autocomplete: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;

  4508.             readonly formatter: {

  4509.                 readonly type: import("vue").PropType<Function>;

  4510.                 readonly required: false;

  4511.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4512.                 __epPropKey: true;

  4513.             };

  4514.             readonly parser: {

  4515.                 readonly type: import("vue").PropType<Function>;

  4516.                 readonly required: false;

  4517.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4518.                 __epPropKey: true;

  4519.             };

  4520.             readonly placeholder: {

  4521.                 readonly type: import("vue").PropType<string>;

  4522.                 readonly required: false;

  4523.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4524.                 __epPropKey: true;

  4525.             };

  4526.             readonly form: {

  4527.                 readonly type: import("vue").PropType<string>;

  4528.                 readonly required: false;

  4529.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4530.                 __epPropKey: true;

  4531.             };

  4532.             readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4533.             readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4534.             readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4535.             readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  4536.             readonly suffixIcon: {

  4537.                 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>>;

  4538.                 readonly required: false;

  4539.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4540.                 __epPropKey: true;

  4541.             };

  4542.             readonly prefixIcon: {

  4543.                 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>>;

  4544.                 readonly required: false;

  4545.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4546.                 __epPropKey: true;

  4547.             };

  4548.             readonly containerRole: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  4549.             readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  4550.             readonly tabindex: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;

  4551.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  4552.             readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  4553.         }>> & {

  4554.             onChange?: ((value: string) => any) | undefined;

  4555.             "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  4556.             onInput?: ((value: string) => any) | undefined;

  4557.             onFocus?: ((evt: FocusEvent) => any) | undefined;

  4558.             onBlur?: ((evt: FocusEvent) => any) | undefined;

  4559.             onClear?: (() => any) | undefined;

  4560.             onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  4561.             onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  4562.             onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  4563.             onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  4564.             onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  4565.             onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  4566.         }, {

  4567.             readonly type: string;

  4568.             readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown>;

  4569.             readonly label: string;

  4570.             readonly id: string;

  4571.             readonly disabled: boolean;

  4572.             readonly clearable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  4573.             readonly autosize: import("..").InputAutoSize;

  4574.             readonly autocomplete: string;

  4575.             readonly readonly: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  4576.             readonly showPassword: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  4577.             readonly showWordLimit: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  4578.             readonly containerRole: string;

  4579.             readonly tabindex: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;

  4580.             readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  4581.             readonly inputStyle: import("vue").StyleValue;

  4582.         }>> & Record<string, any>;

  4583.         Search: 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<{}>>, {}>;

  4584.     }> & {} & import("vue").ComponentCustomProperties) | undefined>;

  4585.     clearQuery: (which: import("./src/transfer").TransferDirection) => void;

  4586.     hasButtonTexts: import("vue").ComputedRef<boolean>;

  4587.     leftPanelTitle: import("vue").ComputedRef<string>;

  4588.     rightPanelTitle: import("vue").ComputedRef<string>;

  4589.     panelFilterPlaceholder: import("vue").ComputedRef<string>;

  4590.     optionRender: import("vue").ComputedRef<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4591.         [key: string]: any;

  4592.     }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4593.         [key: string]: any;

  4594.     }>[]>;

  4595.     isEmpty: (val: unknown) => boolean;

  4596.     isUndefined: (val: any) => val is undefined;

  4597.     ElButton: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  4598.         readonly size: {

  4599.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4600.             readonly required: false;

  4601.             readonly validator: ((val: unknown) => boolean) | undefined;

  4602.             __epPropKey: true;

  4603.         };

  4604.         readonly disabled: BooleanConstructor;

  4605.         readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger", unknown, "", boolean>;

  4606.         readonly icon: {

  4607.             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>>;

  4608.             readonly required: false;

  4609.             readonly validator: ((val: unknown) => boolean) | undefined;

  4610.             __epPropKey: true;

  4611.         };

  4612.         readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;

  4613.         readonly loading: BooleanConstructor;

  4614.         readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(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, () => 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<{}>>, {}>, boolean>;

  4615.         readonly plain: BooleanConstructor;

  4616.         readonly text: BooleanConstructor;

  4617.         readonly link: BooleanConstructor;

  4618.         readonly bg: BooleanConstructor;

  4619.         readonly autofocus: BooleanConstructor;

  4620.         readonly round: BooleanConstructor;

  4621.         readonly circle: BooleanConstructor;

  4622.         readonly color: StringConstructor;

  4623.         readonly dark: BooleanConstructor;

  4624.         readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;

  4625.         readonly tag: import("element-plus/es/utils").EpPropFinalized<(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, "button", boolean>;

  4626.     }, {

  4627.         props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  4628.             readonly size: {

  4629.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4630.                 readonly required: false;

  4631.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4632.                 __epPropKey: true;

  4633.             };

  4634.             readonly disabled: BooleanConstructor;

  4635.             readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger", unknown, "", boolean>;

  4636.             readonly icon: {

  4637.                 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>>;

  4638.                 readonly required: false;

  4639.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4640.                 __epPropKey: true;

  4641.             };

  4642.             readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;

  4643.             readonly loading: BooleanConstructor;

  4644.             readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(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, () => 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<{}>>, {}>, boolean>;

  4645.             readonly plain: BooleanConstructor;

  4646.             readonly text: BooleanConstructor;

  4647.             readonly link: BooleanConstructor;

  4648.             readonly bg: BooleanConstructor;

  4649.             readonly autofocus: BooleanConstructor;

  4650.             readonly round: BooleanConstructor;

  4651.             readonly circle: BooleanConstructor;

  4652.             readonly color: StringConstructor;

  4653.             readonly dark: BooleanConstructor;

  4654.             readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;

  4655.             readonly tag: import("element-plus/es/utils").EpPropFinalized<(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, "button", boolean>;

  4656.         }>> & {

  4657.             onClick?: ((evt: MouseEvent) => any) | undefined;

  4658.         }>>;

  4659.         emit: (event: "click", evt: MouseEvent) => void;

  4660.         buttonStyle: import("vue").ComputedRef<Record<string, string>>;

  4661.         ns: {

  4662.             namespace: import("vue").ComputedRef<string>;

  4663.             b: (blockSuffix?: string) => string;

  4664.             e: (element?: string | undefined) => string;

  4665.             m: (modifier?: string | undefined) => string;

  4666.             be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  4667.             em: (element?: string | undefined, modifier?: string | undefined) => string;

  4668.             bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  4669.             bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  4670.             is: {

  4671.                 (name: string, state: boolean | undefined): string;

  4672.                 (name: string): string;

  4673.             };

  4674.             cssVar: (object: Record<string, string>) => Record<string, string>;

  4675.             cssVarName: (name: string) => string;

  4676.             cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  4677.             cssVarBlockName: (name: string) => string;

  4678.         };

  4679.         _ref: import("vue").Ref<HTMLButtonElement | undefined>;

  4680.         _size: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  4681.         _type: import("vue").ComputedRef<"" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger">;

  4682.         _disabled: import("vue").ComputedRef<boolean>;

  4683.         _props: import("vue").ComputedRef<{

  4684.             ariaDisabled: boolean;

  4685.             disabled: boolean;

  4686.             autofocus: boolean;

  4687.             type: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "button" | "reset" | "submit", unknown>;

  4688.         } | {

  4689.             ariaDisabled?: undefined;

  4690.             disabled?: undefined;

  4691.             autofocus?: undefined;

  4692.             type?: undefined;

  4693.         }>;

  4694.         shouldAddSpace: import("vue").ComputedRef<boolean>;

  4695.         handleClick: (evt: MouseEvent) => void;

  4696.         ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  4697.             readonly size: {

  4698.                 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>>;

  4699.                 readonly required: false;

  4700.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4701.                 __epPropKey: true;

  4702.             };

  4703.             readonly color: {

  4704.                 readonly type: import("vue").PropType<string>;

  4705.                 readonly required: false;

  4706.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4707.                 __epPropKey: true;

  4708.             };

  4709.         }, {

  4710.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  4711.                 readonly size: {

  4712.                     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>>;

  4713.                     readonly required: false;

  4714.                     readonly validator: ((val: unknown) => boolean) | undefined;

  4715.                     __epPropKey: true;

  4716.                 };

  4717.                 readonly color: {

  4718.                     readonly type: import("vue").PropType<string>;

  4719.                     readonly required: false;

  4720.                     readonly validator: ((val: unknown) => boolean) | undefined;

  4721.                     __epPropKey: true;

  4722.                 };

  4723.             }>> & {

  4724.                 [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  4725.             }>>;

  4726.             ns: {

  4727.                 namespace: import("vue").ComputedRef<string>;

  4728.                 b: (blockSuffix?: string) => string;

  4729.                 e: (element?: string | undefined) => string;

  4730.                 m: (modifier?: string | undefined) => string;

  4731.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  4732.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  4733.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  4734.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  4735.                 is: {

  4736.                     (name: string, state: boolean | undefined): string;

  4737.                     (name: string): string;

  4738.                 };

  4739.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  4740.                 cssVarName: (name: string) => string;

  4741.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  4742.                 cssVarBlockName: (name: string) => string;

  4743.             };

  4744.             style: import("vue").ComputedRef<import("vue").CSSProperties>;

  4745.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  4746.             readonly size: {

  4747.                 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>>;

  4748.                 readonly required: false;

  4749.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4750.                 __epPropKey: true;

  4751.             };

  4752.             readonly color: {

  4753.                 readonly type: import("vue").PropType<string>;

  4754.                 readonly required: false;

  4755.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4756.                 __epPropKey: true;

  4757.             };

  4758.         }>>, {}>> & Record<string, any>;

  4759.     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  4760.         click: (evt: MouseEvent) => boolean;

  4761.     }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  4762.         readonly size: {

  4763.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4764.             readonly required: false;

  4765.             readonly validator: ((val: unknown) => boolean) | undefined;

  4766.             __epPropKey: true;

  4767.         };

  4768.         readonly disabled: BooleanConstructor;

  4769.         readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger", unknown, "", boolean>;

  4770.         readonly icon: {

  4771.             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>>;

  4772.             readonly required: false;

  4773.             readonly validator: ((val: unknown) => boolean) | undefined;

  4774.             __epPropKey: true;

  4775.         };

  4776.         readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;

  4777.         readonly loading: BooleanConstructor;

  4778.         readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(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, () => 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<{}>>, {}>, boolean>;

  4779.         readonly plain: BooleanConstructor;

  4780.         readonly text: BooleanConstructor;

  4781.         readonly link: BooleanConstructor;

  4782.         readonly bg: BooleanConstructor;

  4783.         readonly autofocus: BooleanConstructor;

  4784.         readonly round: BooleanConstructor;

  4785.         readonly circle: BooleanConstructor;

  4786.         readonly color: StringConstructor;

  4787.         readonly dark: BooleanConstructor;

  4788.         readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;

  4789.         readonly tag: import("element-plus/es/utils").EpPropFinalized<(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, "button", boolean>;

  4790.     }>> & {

  4791.         onClick?: ((evt: MouseEvent) => any) | undefined;

  4792.     }, {

  4793.         readonly type: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger", unknown>;

  4794.         readonly link: boolean;

  4795.         readonly dark: boolean;

  4796.         readonly disabled: boolean;

  4797.         readonly text: boolean;

  4798.         readonly round: boolean;

  4799.         readonly circle: boolean;

  4800.         readonly tag: 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>;

  4801.         readonly nativeType: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "button" | "reset" | "submit", unknown>;

  4802.         readonly loadingIcon: 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>;

  4803.         readonly autoInsertSpace: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  4804.         readonly loading: boolean;

  4805.         readonly plain: boolean;

  4806.         readonly bg: boolean;

  4807.         readonly autofocus: boolean;

  4808.     }>> & {

  4809.         ButtonGroup: import("vue").DefineComponent<{

  4810.             readonly size: {

  4811.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4812.                 readonly required: false;

  4813.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4814.                 __epPropKey: true;

  4815.             };

  4816.             readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger", unknown, "", boolean>;

  4817.         }, {

  4818.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  4819.                 readonly size: {

  4820.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4821.                     readonly required: false;

  4822.                     readonly validator: ((val: unknown) => boolean) | undefined;

  4823.                     __epPropKey: true;

  4824.                 };

  4825.                 readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger", unknown, "", boolean>;

  4826.             }>> & {

  4827.                 [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  4828.             }>>;

  4829.             ns: {

  4830.                 namespace: import("vue").ComputedRef<string>;

  4831.                 b: (blockSuffix?: string) => string;

  4832.                 e: (element?: string | undefined) => string;

  4833.                 m: (modifier?: string | undefined) => string;

  4834.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  4835.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  4836.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  4837.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  4838.                 is: {

  4839.                     (name: string, state: boolean | undefined): string;

  4840.                     (name: string): string;

  4841.                 };

  4842.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  4843.                 cssVarName: (name: string) => string;

  4844.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  4845.                 cssVarBlockName: (name: string) => string;

  4846.             };

  4847.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  4848.             readonly size: {

  4849.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  4850.                 readonly required: false;

  4851.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4852.                 __epPropKey: true;

  4853.             };

  4854.             readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger", unknown, "", boolean>;

  4855.         }>>, {

  4856.             readonly type: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "success" | "warning" | "info" | "text" | "primary" | "danger", unknown>;

  4857.         }>;

  4858.     };

  4859.     ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  4860.         readonly size: {

  4861.             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>>;

  4862.             readonly required: false;

  4863.             readonly validator: ((val: unknown) => boolean) | undefined;

  4864.             __epPropKey: true;

  4865.         };

  4866.         readonly color: {

  4867.             readonly type: import("vue").PropType<string>;

  4868.             readonly required: false;

  4869.             readonly validator: ((val: unknown) => boolean) | undefined;

  4870.             __epPropKey: true;

  4871.         };

  4872.     }, {

  4873.         props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  4874.             readonly size: {

  4875.                 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>>;

  4876.                 readonly required: false;

  4877.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4878.                 __epPropKey: true;

  4879.             };

  4880.             readonly color: {

  4881.                 readonly type: import("vue").PropType<string>;

  4882.                 readonly required: false;

  4883.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4884.                 __epPropKey: true;

  4885.             };

  4886.         }>> & {

  4887.             [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  4888.         }>>;

  4889.         ns: {

  4890.             namespace: import("vue").ComputedRef<string>;

  4891.             b: (blockSuffix?: string) => string;

  4892.             e: (element?: string | undefined) => string;

  4893.             m: (modifier?: string | undefined) => string;

  4894.             be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  4895.             em: (element?: string | undefined, modifier?: string | undefined) => string;

  4896.             bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  4897.             bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  4898.             is: {

  4899.                 (name: string, state: boolean | undefined): string;

  4900.                 (name: string): string;

  4901.             };

  4902.             cssVar: (object: Record<string, string>) => Record<string, string>;

  4903.             cssVarName: (name: string) => string;

  4904.             cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  4905.             cssVarBlockName: (name: string) => string;

  4906.         };

  4907.         style: import("vue").ComputedRef<import("vue").CSSProperties>;

  4908.     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  4909.         readonly size: {

  4910.             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>>;

  4911.             readonly required: false;

  4912.             readonly validator: ((val: unknown) => boolean) | undefined;

  4913.             __epPropKey: true;

  4914.         };

  4915.         readonly color: {

  4916.             readonly type: import("vue").PropType<string>;

  4917.             readonly required: false;

  4918.             readonly validator: ((val: unknown) => boolean) | undefined;

  4919.             __epPropKey: true;

  4920.         };

  4921.     }>>, {}>> & Record<string, any>;

  4922.     ArrowLeft: 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<{}>>, {}>;

  4923.     ArrowRight: 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<{}>>, {}>;

  4924.     TransferPanel: import("vue").DefineComponent<{

  4925.         readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  4926.         readonly optionRender: {

  4927.             readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4928.                 [key: string]: any;

  4929.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4930.                 [key: string]: any;

  4931.             }>[]>;

  4932.             readonly required: false;

  4933.             readonly validator: ((val: unknown) => boolean) | undefined;

  4934.             __epPropKey: true;

  4935.         };

  4936.         readonly placeholder: StringConstructor;

  4937.         readonly title: StringConstructor;

  4938.         readonly filterable: BooleanConstructor;

  4939.         readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  4940.         readonly filterMethod: {

  4941.             readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  4942.             readonly required: false;

  4943.             readonly validator: ((val: unknown) => boolean) | undefined;

  4944.             __epPropKey: true;

  4945.         };

  4946.         readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  4947.         readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  4948.             readonly label: "label";

  4949.             readonly key: "key";

  4950.             readonly disabled: "disabled";

  4951.         }>, boolean>;

  4952.     }, {

  4953.         props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  4954.             readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  4955.             readonly optionRender: {

  4956.                 readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4957.                     [key: string]: any;

  4958.                 }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4959.                     [key: string]: any;

  4960.                 }>[]>;

  4961.                 readonly required: false;

  4962.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4963.                 __epPropKey: true;

  4964.             };

  4965.             readonly placeholder: StringConstructor;

  4966.             readonly title: StringConstructor;

  4967.             readonly filterable: BooleanConstructor;

  4968.             readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  4969.             readonly filterMethod: {

  4970.                 readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  4971.                 readonly required: false;

  4972.                 readonly validator: ((val: unknown) => boolean) | undefined;

  4973.                 __epPropKey: true;

  4974.             };

  4975.             readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  4976.             readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  4977.                 readonly label: "label";

  4978.                 readonly key: "key";

  4979.                 readonly disabled: "disabled";

  4980.             }>, boolean>;

  4981.         }>> & {

  4982.             "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  4983.         }>>;

  4984.         emit: (event: "checked-change", value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => void;

  4985.         slots: Readonly<{

  4986.             [name: string]: import("vue").Slot | undefined;

  4987.         }>;

  4988.         OptionContent: ({ option }: {

  4989.             option: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4990.                 [key: string]: any;

  4991.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4992.                 [key: string]: any;

  4993.             }>[];

  4994.         }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4995.             [key: string]: any;

  4996.         }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  4997.             [key: string]: any;

  4998.         }>[];

  4999.         t: import("../..").Translator;

  5000.         ns: {

  5001.             namespace: import("vue").ComputedRef<string>;

  5002.             b: (blockSuffix?: string) => string;

  5003.             e: (element?: string | undefined) => string;

  5004.             m: (modifier?: string | undefined) => string;

  5005.             be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  5006.             em: (element?: string | undefined, modifier?: string | undefined) => string;

  5007.             bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  5008.             bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  5009.             is: {

  5010.                 (name: string, state: boolean | undefined): string;

  5011.                 (name: string): string;

  5012.             };

  5013.             cssVar: (object: Record<string, string>) => Record<string, string>;

  5014.             cssVarName: (name: string) => string;

  5015.             cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  5016.             cssVarBlockName: (name: string) => string;

  5017.         };

  5018.         panelState: {

  5019.             checked: import("./src/transfer").TransferKey[];

  5020.             allChecked: boolean;

  5021.             query: string;

  5022.             checkChangeByUser: boolean;

  5023.         };

  5024.         propsAlias: import("vue").ComputedRef<{

  5025.             label: string;

  5026.             key: string;

  5027.             disabled: string;

  5028.         }>;

  5029.         filteredData: import("vue").ComputedRef<import("./src/transfer").TransferDataItem[]>;

  5030.         checkedSummary: import("vue").ComputedRef<string>;

  5031.         isIndeterminate: import("vue").ComputedRef<boolean>;

  5032.         handleAllCheckedChange: (value: import("..").CheckboxValueType) => void;

  5033.         hasNoMatch: import("vue").ComputedRef<boolean>;

  5034.         hasFooter: import("vue").ComputedRef<boolean>;

  5035.         checked: import("vue").Ref<import("./src/transfer").TransferKey[]>;

  5036.         allChecked: import("vue").Ref<boolean>;

  5037.         query: import("vue").Ref<string>;

  5038.         isEmpty: (val: unknown) => boolean;

  5039.         ElCheckbox: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  5040.             modelValue: {

  5041.                 type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  5042.                 default: undefined;

  5043.             };

  5044.             label: {

  5045.                 type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  5046.             };

  5047.             indeterminate: BooleanConstructor;

  5048.             disabled: BooleanConstructor;

  5049.             checked: BooleanConstructor;

  5050.             name: {

  5051.                 type: StringConstructor;

  5052.                 default: undefined;

  5053.             };

  5054.             trueLabel: {

  5055.                 type: (NumberConstructor | StringConstructor)[];

  5056.                 default: undefined;

  5057.             };

  5058.             falseLabel: {

  5059.                 type: (NumberConstructor | StringConstructor)[];

  5060.                 default: undefined;

  5061.             };

  5062.             id: {

  5063.                 type: StringConstructor;

  5064.                 default: undefined;

  5065.             };

  5066.             controls: {

  5067.                 type: StringConstructor;

  5068.                 default: undefined;

  5069.             };

  5070.             border: BooleanConstructor;

  5071.             size: {

  5072.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5073.                 readonly required: false;

  5074.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5075.                 __epPropKey: true;

  5076.             };

  5077.             tabindex: (NumberConstructor | StringConstructor)[];

  5078.             validateEvent: {

  5079.                 type: BooleanConstructor;

  5080.                 default: boolean;

  5081.             };

  5082.         }, {

  5083.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  5084.                 modelValue: {

  5085.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  5086.                     default: undefined;

  5087.                 };

  5088.                 label: {

  5089.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  5090.                 };

  5091.                 indeterminate: BooleanConstructor;

  5092.                 disabled: BooleanConstructor;

  5093.                 checked: BooleanConstructor;

  5094.                 name: {

  5095.                     type: StringConstructor;

  5096.                     default: undefined;

  5097.                 };

  5098.                 trueLabel: {

  5099.                     type: (NumberConstructor | StringConstructor)[];

  5100.                     default: undefined;

  5101.                 };

  5102.                 falseLabel: {

  5103.                     type: (NumberConstructor | StringConstructor)[];

  5104.                     default: undefined;

  5105.                 };

  5106.                 id: {

  5107.                     type: StringConstructor;

  5108.                     default: undefined;

  5109.                 };

  5110.                 controls: {

  5111.                     type: StringConstructor;

  5112.                     default: undefined;

  5113.                 };

  5114.                 border: BooleanConstructor;

  5115.                 size: {

  5116.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5117.                     readonly required: false;

  5118.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5119.                     __epPropKey: true;

  5120.                 };

  5121.                 tabindex: (NumberConstructor | StringConstructor)[];

  5122.                 validateEvent: {

  5123.                     type: BooleanConstructor;

  5124.                     default: boolean;

  5125.                 };

  5126.             }>> & {

  5127.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  5128.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  5129.             }>>;

  5130.             slots: Readonly<{

  5131.                 [name: string]: import("vue").Slot | undefined;

  5132.             }>;

  5133.             inputId: import("vue").Ref<string | undefined>;

  5134.             isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  5135.             isChecked: import("vue").ComputedRef<boolean>;

  5136.             isDisabled: import("vue").ComputedRef<boolean>;

  5137.             isFocused: import("vue").Ref<boolean>;

  5138.             checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  5139.             hasOwnLabel: import("vue").ComputedRef<boolean>;

  5140.             model: import("vue").WritableComputedRef<any>;

  5141.             handleChange: (e: Event) => void;

  5142.             onClickRoot: (e: MouseEvent) => Promise<void>;

  5143.             ns: {

  5144.                 namespace: import("vue").ComputedRef<string>;

  5145.                 b: (blockSuffix?: string) => string;

  5146.                 e: (element?: string | undefined) => string;

  5147.                 m: (modifier?: string | undefined) => string;

  5148.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  5149.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  5150.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  5151.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  5152.                 is: {

  5153.                     (name: string, state: boolean | undefined): string;

  5154.                     (name: string): string;

  5155.                 };

  5156.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  5157.                 cssVarName: (name: string) => string;

  5158.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  5159.                 cssVarBlockName: (name: string) => string;

  5160.             };

  5161.             compKls: import("vue").ComputedRef<string[]>;

  5162.             spanKls: import("vue").ComputedRef<string[]>;

  5163.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  5164.             "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  5165.             change: (val: import("..").CheckboxValueType) => boolean;

  5166.         }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  5167.             modelValue: {

  5168.                 type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  5169.                 default: undefined;

  5170.             };

  5171.             label: {

  5172.                 type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  5173.             };

  5174.             indeterminate: BooleanConstructor;

  5175.             disabled: BooleanConstructor;

  5176.             checked: BooleanConstructor;

  5177.             name: {

  5178.                 type: StringConstructor;

  5179.                 default: undefined;

  5180.             };

  5181.             trueLabel: {

  5182.                 type: (NumberConstructor | StringConstructor)[];

  5183.                 default: undefined;

  5184.             };

  5185.             falseLabel: {

  5186.                 type: (NumberConstructor | StringConstructor)[];

  5187.                 default: undefined;

  5188.             };

  5189.             id: {

  5190.                 type: StringConstructor;

  5191.                 default: undefined;

  5192.             };

  5193.             controls: {

  5194.                 type: StringConstructor;

  5195.                 default: undefined;

  5196.             };

  5197.             border: BooleanConstructor;

  5198.             size: {

  5199.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5200.                 readonly required: false;

  5201.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5202.                 __epPropKey: true;

  5203.             };

  5204.             tabindex: (NumberConstructor | StringConstructor)[];

  5205.             validateEvent: {

  5206.                 type: BooleanConstructor;

  5207.                 default: boolean;

  5208.             };

  5209.         }>> & {

  5210.             onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  5211.             "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  5212.         }, {

  5213.             modelValue: string | number | boolean;

  5214.             id: string;

  5215.             disabled: boolean;

  5216.             name: string;

  5217.             validateEvent: boolean;

  5218.             border: boolean;

  5219.             indeterminate: boolean;

  5220.             checked: boolean;

  5221.             trueLabel: string | number;

  5222.             falseLabel: string | number;

  5223.             controls: string;

  5224.         }>> & {

  5225.             CheckboxButton: import("vue").DefineComponent<{

  5226.                 modelValue: {

  5227.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  5228.                     default: undefined;

  5229.                 };

  5230.                 label: {

  5231.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  5232.                 };

  5233.                 indeterminate: BooleanConstructor;

  5234.                 disabled: BooleanConstructor;

  5235.                 checked: BooleanConstructor;

  5236.                 name: {

  5237.                     type: StringConstructor;

  5238.                     default: undefined;

  5239.                 };

  5240.                 trueLabel: {

  5241.                     type: (NumberConstructor | StringConstructor)[];

  5242.                     default: undefined;

  5243.                 };

  5244.                 falseLabel: {

  5245.                     type: (NumberConstructor | StringConstructor)[];

  5246.                     default: undefined;

  5247.                 };

  5248.                 id: {

  5249.                     type: StringConstructor;

  5250.                     default: undefined;

  5251.                 };

  5252.                 controls: {

  5253.                     type: StringConstructor;

  5254.                     default: undefined;

  5255.                 };

  5256.                 border: BooleanConstructor;

  5257.                 size: {

  5258.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5259.                     readonly required: false;

  5260.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5261.                     __epPropKey: true;

  5262.                 };

  5263.                 tabindex: (NumberConstructor | StringConstructor)[];

  5264.                 validateEvent: {

  5265.                     type: BooleanConstructor;

  5266.                     default: boolean;

  5267.                 };

  5268.             }, {

  5269.                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  5270.                     modelValue: {

  5271.                         type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  5272.                         default: undefined;

  5273.                     };

  5274.                     label: {

  5275.                         type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  5276.                     };

  5277.                     indeterminate: BooleanConstructor;

  5278.                     disabled: BooleanConstructor;

  5279.                     checked: BooleanConstructor;

  5280.                     name: {

  5281.                         type: StringConstructor;

  5282.                         default: undefined;

  5283.                     };

  5284.                     trueLabel: {

  5285.                         type: (NumberConstructor | StringConstructor)[];

  5286.                         default: undefined;

  5287.                     };

  5288.                     falseLabel: {

  5289.                         type: (NumberConstructor | StringConstructor)[];

  5290.                         default: undefined;

  5291.                     };

  5292.                     id: {

  5293.                         type: StringConstructor;

  5294.                         default: undefined;

  5295.                     };

  5296.                     controls: {

  5297.                         type: StringConstructor;

  5298.                         default: undefined;

  5299.                     };

  5300.                     border: BooleanConstructor;

  5301.                     size: {

  5302.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5303.                         readonly required: false;

  5304.                         readonly validator: ((val: unknown) => boolean) | undefined;

  5305.                         __epPropKey: true;

  5306.                     };

  5307.                     tabindex: (NumberConstructor | StringConstructor)[];

  5308.                     validateEvent: {

  5309.                         type: BooleanConstructor;

  5310.                         default: boolean;

  5311.                     };

  5312.                 }>> & {

  5313.                     onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  5314.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  5315.                 }>>;

  5316.                 slots: Readonly<{

  5317.                     [name: string]: import("vue").Slot | undefined;

  5318.                 }>;

  5319.                 isFocused: import("vue").Ref<boolean>;

  5320.                 isChecked: import("vue").ComputedRef<boolean>;

  5321.                 isDisabled: import("vue").ComputedRef<boolean>;

  5322.                 checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  5323.                 model: import("vue").WritableComputedRef<any>;

  5324.                 handleChange: (e: Event) => void;

  5325.                 checkboxGroup: ({

  5326.                     modelValue?: import("vue").WritableComputedRef<any> | undefined;

  5327.                     changeEvent?: ((...args: any) => any) | undefined;

  5328.                 } & import("vue").ToRefs<Pick<import("..").CheckboxGroupProps, "fill" | "size" | "disabled" | "validateEvent" | "max" | "min" | "textColor">>) | undefined;

  5329.                 ns: {

  5330.                     namespace: import("vue").ComputedRef<string>;

  5331.                     b: (blockSuffix?: string) => string;

  5332.                     e: (element?: string | undefined) => string;

  5333.                     m: (modifier?: string | undefined) => string;

  5334.                     be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  5335.                     em: (element?: string | undefined, modifier?: string | undefined) => string;

  5336.                     bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  5337.                     bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  5338.                     is: {

  5339.                         (name: string, state: boolean | undefined): string;

  5340.                         (name: string): string;

  5341.                     };

  5342.                     cssVar: (object: Record<string, string>) => Record<string, string>;

  5343.                     cssVarName: (name: string) => string;

  5344.                     cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  5345.                     cssVarBlockName: (name: string) => string;

  5346.                 };

  5347.                 activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  5348.                 labelKls: import("vue").ComputedRef<string[]>;

  5349.             }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  5350.                 "update:modelValue": (val: import("..").CheckboxValueType) => boolean;

  5351.                 change: (val: import("..").CheckboxValueType) => boolean;

  5352.             }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  5353.                 modelValue: {

  5354.                     type: (NumberConstructor | BooleanConstructor | StringConstructor)[];

  5355.                     default: undefined;

  5356.                 };

  5357.                 label: {

  5358.                     type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];

  5359.                 };

  5360.                 indeterminate: BooleanConstructor;

  5361.                 disabled: BooleanConstructor;

  5362.                 checked: BooleanConstructor;

  5363.                 name: {

  5364.                     type: StringConstructor;

  5365.                     default: undefined;

  5366.                 };

  5367.                 trueLabel: {

  5368.                     type: (NumberConstructor | StringConstructor)[];

  5369.                     default: undefined;

  5370.                 };

  5371.                 falseLabel: {

  5372.                     type: (NumberConstructor | StringConstructor)[];

  5373.                     default: undefined;

  5374.                 };

  5375.                 id: {

  5376.                     type: StringConstructor;

  5377.                     default: undefined;

  5378.                 };

  5379.                 controls: {

  5380.                     type: StringConstructor;

  5381.                     default: undefined;

  5382.                 };

  5383.                 border: BooleanConstructor;

  5384.                 size: {

  5385.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5386.                     readonly required: false;

  5387.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5388.                     __epPropKey: true;

  5389.                 };

  5390.                 tabindex: (NumberConstructor | StringConstructor)[];

  5391.                 validateEvent: {

  5392.                     type: BooleanConstructor;

  5393.                     default: boolean;

  5394.                 };

  5395.             }>> & {

  5396.                 onChange?: ((val: import("..").CheckboxValueType) => any) | undefined;

  5397.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxValueType) => any) | undefined;

  5398.             }, {

  5399.                 modelValue: string | number | boolean;

  5400.                 id: string;

  5401.                 disabled: boolean;

  5402.                 name: string;

  5403.                 validateEvent: boolean;

  5404.                 border: boolean;

  5405.                 indeterminate: boolean;

  5406.                 checked: boolean;

  5407.                 trueLabel: string | number;

  5408.                 falseLabel: string | number;

  5409.                 controls: string;

  5410.             }>;

  5411.             CheckboxGroup: import("vue").DefineComponent<{

  5412.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  5413.                 readonly disabled: BooleanConstructor;

  5414.                 readonly min: NumberConstructor;

  5415.                 readonly max: NumberConstructor;

  5416.                 readonly size: {

  5417.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5418.                     readonly required: false;

  5419.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5420.                     __epPropKey: true;

  5421.                 };

  5422.                 readonly label: StringConstructor;

  5423.                 readonly fill: StringConstructor;

  5424.                 readonly textColor: StringConstructor;

  5425.                 readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  5426.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5427.             }, {

  5428.                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  5429.                     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  5430.                     readonly disabled: BooleanConstructor;

  5431.                     readonly min: NumberConstructor;

  5432.                     readonly max: NumberConstructor;

  5433.                     readonly size: {

  5434.                         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5435.                         readonly required: false;

  5436.                         readonly validator: ((val: unknown) => boolean) | undefined;

  5437.                         __epPropKey: true;

  5438.                     };

  5439.                     readonly label: StringConstructor;

  5440.                     readonly fill: StringConstructor;

  5441.                     readonly textColor: StringConstructor;

  5442.                     readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  5443.                     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5444.                 }>> & {

  5445.                     onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  5446.                     "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  5447.                 }>>;

  5448.                 emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  5449.                 ns: {

  5450.                     namespace: import("vue").ComputedRef<string>;

  5451.                     b: (blockSuffix?: string) => string;

  5452.                     e: (element?: string | undefined) => string;

  5453.                     m: (modifier?: string | undefined) => string;

  5454.                     be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  5455.                     em: (element?: string | undefined, modifier?: string | undefined) => string;

  5456.                     bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  5457.                     bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  5458.                     is: {

  5459.                         (name: string, state: boolean | undefined): string;

  5460.                         (name: string): string;

  5461.                     };

  5462.                     cssVar: (object: Record<string, string>) => Record<string, string>;

  5463.                     cssVarName: (name: string) => string;

  5464.                     cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  5465.                     cssVarBlockName: (name: string) => string;

  5466.                 };

  5467.                 formItem: import("..").FormItemContext | undefined;

  5468.                 groupId: import("vue").Ref<string | undefined>;

  5469.                 isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  5470.                 changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  5471.                 modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

  5472.             }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  5473.                 "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  5474.                 change: (val: import("..").CheckboxValueType[]) => boolean;

  5475.             }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  5476.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  5477.                 readonly disabled: BooleanConstructor;

  5478.                 readonly min: NumberConstructor;

  5479.                 readonly max: NumberConstructor;

  5480.                 readonly size: {

  5481.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5482.                     readonly required: false;

  5483.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5484.                     __epPropKey: true;

  5485.                 };

  5486.                 readonly label: StringConstructor;

  5487.                 readonly fill: StringConstructor;

  5488.                 readonly textColor: StringConstructor;

  5489.                 readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  5490.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5491.             }>> & {

  5492.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  5493.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  5494.             }, {

  5495.                 readonly modelValue: import("..").CheckboxGroupValueType;

  5496.                 readonly disabled: boolean;

  5497.                 readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  5498.                 readonly tag: string;

  5499.             }>;

  5500.         };

  5501.         ElCheckboxGroup: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  5502.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  5503.             readonly disabled: BooleanConstructor;

  5504.             readonly min: NumberConstructor;

  5505.             readonly max: NumberConstructor;

  5506.             readonly size: {

  5507.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5508.                 readonly required: false;

  5509.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5510.                 __epPropKey: true;

  5511.             };

  5512.             readonly label: StringConstructor;

  5513.             readonly fill: StringConstructor;

  5514.             readonly textColor: StringConstructor;

  5515.             readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  5516.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5517.         }, {

  5518.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  5519.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  5520.                 readonly disabled: BooleanConstructor;

  5521.                 readonly min: NumberConstructor;

  5522.                 readonly max: NumberConstructor;

  5523.                 readonly size: {

  5524.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5525.                     readonly required: false;

  5526.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5527.                     __epPropKey: true;

  5528.                 };

  5529.                 readonly label: StringConstructor;

  5530.                 readonly fill: StringConstructor;

  5531.                 readonly textColor: StringConstructor;

  5532.                 readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  5533.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5534.             }>> & {

  5535.                 onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  5536.                 "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  5537.             }>>;

  5538.             emit: ((event: "update:modelValue", val: import("..").CheckboxGroupValueType) => void) & ((event: "change", val: import("..").CheckboxValueType[]) => void);

  5539.             ns: {

  5540.                 namespace: import("vue").ComputedRef<string>;

  5541.                 b: (blockSuffix?: string) => string;

  5542.                 e: (element?: string | undefined) => string;

  5543.                 m: (modifier?: string | undefined) => string;

  5544.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  5545.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  5546.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  5547.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  5548.                 is: {

  5549.                     (name: string, state: boolean | undefined): string;

  5550.                     (name: string): string;

  5551.                 };

  5552.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  5553.                 cssVarName: (name: string) => string;

  5554.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  5555.                 cssVarBlockName: (name: string) => string;

  5556.             };

  5557.             formItem: import("..").FormItemContext | undefined;

  5558.             groupId: import("vue").Ref<string | undefined>;

  5559.             isLabeledByFormItem: import("vue").ComputedRef<boolean>;

  5560.             changeEvent: (value: import("..").CheckboxGroupValueType) => Promise<void>;

  5561.             modelValue: import("vue").WritableComputedRef<import("..").CheckboxGroupValueType>;

  5562.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  5563.             "update:modelValue": (val: import("..").CheckboxGroupValueType) => boolean;

  5564.             change: (val: import("..").CheckboxValueType[]) => boolean;

  5565.         }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  5566.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType) | ((new (...args: any[]) => import("..").CheckboxGroupValueType) | (() => import("..").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;

  5567.             readonly disabled: BooleanConstructor;

  5568.             readonly min: NumberConstructor;

  5569.             readonly max: NumberConstructor;

  5570.             readonly size: {

  5571.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5572.                 readonly required: false;

  5573.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5574.                 __epPropKey: true;

  5575.             };

  5576.             readonly label: StringConstructor;

  5577.             readonly fill: StringConstructor;

  5578.             readonly textColor: StringConstructor;

  5579.             readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  5580.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5581.         }>> & {

  5582.             onChange?: ((val: import("..").CheckboxValueType[]) => any) | undefined;

  5583.             "onUpdate:modelValue"?: ((val: import("..").CheckboxGroupValueType) => any) | undefined;

  5584.         }, {

  5585.             readonly modelValue: import("..").CheckboxGroupValueType;

  5586.             readonly disabled: boolean;

  5587.             readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  5588.             readonly tag: string;

  5589.         }>>;

  5590.         ElInput: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  5591.             readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5592.             readonly size: {

  5593.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5594.                 readonly required: false;

  5595.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5596.                 __epPropKey: true;

  5597.             };

  5598.             readonly disabled: BooleanConstructor;

  5599.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

  5600.             readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;

  5601.             readonly resize: {

  5602.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  5603.                 readonly required: false;

  5604.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5605.                 __epPropKey: true;

  5606.             };

  5607.             readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

  5608.             readonly autocomplete: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;

  5609.             readonly formatter: {

  5610.                 readonly type: import("vue").PropType<Function>;

  5611.                 readonly required: false;

  5612.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5613.                 __epPropKey: true;

  5614.             };

  5615.             readonly parser: {

  5616.                 readonly type: import("vue").PropType<Function>;

  5617.                 readonly required: false;

  5618.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5619.                 __epPropKey: true;

  5620.             };

  5621.             readonly placeholder: {

  5622.                 readonly type: import("vue").PropType<string>;

  5623.                 readonly required: false;

  5624.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5625.                 __epPropKey: true;

  5626.             };

  5627.             readonly form: {

  5628.                 readonly type: import("vue").PropType<string>;

  5629.                 readonly required: false;

  5630.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5631.                 __epPropKey: true;

  5632.             };

  5633.             readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5634.             readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5635.             readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5636.             readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5637.             readonly suffixIcon: {

  5638.                 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>>;

  5639.                 readonly required: false;

  5640.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5641.                 __epPropKey: true;

  5642.             };

  5643.             readonly prefixIcon: {

  5644.                 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>>;

  5645.                 readonly required: false;

  5646.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5647.                 __epPropKey: true;

  5648.             };

  5649.             readonly containerRole: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5650.             readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5651.             readonly tabindex: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;

  5652.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5653.             readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  5654.         }, {

  5655.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  5656.                 readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5657.                 readonly size: {

  5658.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5659.                     readonly required: false;

  5660.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5661.                     __epPropKey: true;

  5662.                 };

  5663.                 readonly disabled: BooleanConstructor;

  5664.                 readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

  5665.                 readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;

  5666.                 readonly resize: {

  5667.                     readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  5668.                     readonly required: false;

  5669.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5670.                     __epPropKey: true;

  5671.                 };

  5672.                 readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

  5673.                 readonly autocomplete: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;

  5674.                 readonly formatter: {

  5675.                     readonly type: import("vue").PropType<Function>;

  5676.                     readonly required: false;

  5677.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5678.                     __epPropKey: true;

  5679.                 };

  5680.                 readonly parser: {

  5681.                     readonly type: import("vue").PropType<Function>;

  5682.                     readonly required: false;

  5683.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5684.                     __epPropKey: true;

  5685.                 };

  5686.                 readonly placeholder: {

  5687.                     readonly type: import("vue").PropType<string>;

  5688.                     readonly required: false;

  5689.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5690.                     __epPropKey: true;

  5691.                 };

  5692.                 readonly form: {

  5693.                     readonly type: import("vue").PropType<string>;

  5694.                     readonly required: false;

  5695.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5696.                     __epPropKey: true;

  5697.                 };

  5698.                 readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5699.                 readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5700.                 readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5701.                 readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5702.                 readonly suffixIcon: {

  5703.                     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>>;

  5704.                     readonly required: false;

  5705.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5706.                     __epPropKey: true;

  5707.                 };

  5708.                 readonly prefixIcon: {

  5709.                     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>>;

  5710.                     readonly required: false;

  5711.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5712.                     __epPropKey: true;

  5713.                 };

  5714.                 readonly containerRole: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5715.                 readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5716.                 readonly tabindex: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;

  5717.                 readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5718.                 readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  5719.             }>> & {

  5720.                 onChange?: ((value: string) => any) | undefined;

  5721.                 "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  5722.                 onInput?: ((value: string) => any) | undefined;

  5723.                 onFocus?: ((evt: FocusEvent) => any) | undefined;

  5724.                 onBlur?: ((evt: FocusEvent) => any) | undefined;

  5725.                 onClear?: (() => any) | undefined;

  5726.                 onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  5727.                 onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  5728.                 onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  5729.                 onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  5730.                 onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  5731.                 onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  5732.             }>>;

  5733.             emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void);

  5734.             rawAttrs: {

  5735.                 [x: string]: unknown;

  5736.             };

  5737.             slots: Readonly<{

  5738.                 [name: string]: import("vue").Slot | undefined;

  5739.             }>;

  5740.             containerAttrs: import("vue").ComputedRef<Record<string, unknown>>;

  5741.             containerKls: import("vue").ComputedRef<unknown[]>;

  5742.             wrapperKls: import("vue").ComputedRef<string[]>;

  5743.             attrs: import("vue").ComputedRef<Record<string, unknown>>;

  5744.             form: import("..").FormContext | undefined;

  5745.             formItem: import("..").FormItemContext | undefined;

  5746.             inputId: import("vue").Ref<string | undefined>;

  5747.             inputSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  5748.             inputDisabled: import("vue").ComputedRef<boolean>;

  5749.             nsInput: {

  5750.                 namespace: import("vue").ComputedRef<string>;

  5751.                 b: (blockSuffix?: string) => string;

  5752.                 e: (element?: string | undefined) => string;

  5753.                 m: (modifier?: string | undefined) => string;

  5754.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  5755.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  5756.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  5757.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  5758.                 is: {

  5759.                     (name: string, state: boolean | undefined): string;

  5760.                     (name: string): string;

  5761.                 };

  5762.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  5763.                 cssVarName: (name: string) => string;

  5764.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  5765.                 cssVarBlockName: (name: string) => string;

  5766.             };

  5767.             nsTextarea: {

  5768.                 namespace: import("vue").ComputedRef<string>;

  5769.                 b: (blockSuffix?: string) => string;

  5770.                 e: (element?: string | undefined) => string;

  5771.                 m: (modifier?: string | undefined) => string;

  5772.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  5773.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  5774.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  5775.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  5776.                 is: {

  5777.                     (name: string, state: boolean | undefined): string;

  5778.                     (name: string): string;

  5779.                 };

  5780.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  5781.                 cssVarName: (name: string) => string;

  5782.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  5783.                 cssVarBlockName: (name: string) => string;

  5784.             };

  5785.             input: import("vue").ShallowRef<HTMLInputElement | undefined>;

  5786.             textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined>;

  5787.             focused: import("vue").Ref<boolean>;

  5788.             hovering: import("vue").Ref<boolean>;

  5789.             isComposing: import("vue").Ref<boolean>;

  5790.             passwordVisible: import("vue").Ref<boolean>;

  5791.             countStyle: import("vue").Ref<import("vue").StyleValue | undefined>;

  5792.             textareaCalcStyle: import("vue").ShallowRef<import("vue").StyleValue>;

  5793.             _ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;

  5794.             needStatusIcon: import("vue").ComputedRef<boolean>;

  5795.             validateState: import("vue").ComputedRef<"" | "success" | "error" | "validating">;

  5796.             validateIcon: import("vue").ComputedRef<"" | 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<{}>>, {}>>;

  5797.             passwordIcon: import("vue").ComputedRef<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<{}>>, {}>>;

  5798.             containerStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  5799.             textareaStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  5800.             nativeInputValue: import("vue").ComputedRef<string>;

  5801.             showClear: import("vue").ComputedRef<boolean>;

  5802.             showPwdVisible: import("vue").ComputedRef<boolean>;

  5803.             isWordLimitVisible: import("vue").ComputedRef<boolean>;

  5804.             textLength: import("vue").ComputedRef<number>;

  5805.             inputExceed: import("vue").ComputedRef<boolean>;

  5806.             suffixVisible: import("vue").ComputedRef<boolean>;

  5807.             recordCursor: () => void;

  5808.             setCursor: () => void;

  5809.             resizeTextarea: () => void;

  5810.             createOnceInitResize: (resizeTextarea: () => void) => () => void;

  5811.             onceInitSizeTextarea: () => void;

  5812.             setNativeInputValue: () => void;

  5813.             handleInput: (event: Event) => Promise<void>;

  5814.             handleChange: (event: Event) => void;

  5815.             handleCompositionStart: (event: CompositionEvent) => void;

  5816.             handleCompositionUpdate: (event: CompositionEvent) => void;

  5817.             handleCompositionEnd: (event: CompositionEvent) => void;

  5818.             handlePasswordVisible: () => void;

  5819.             focus: () => Promise<void>;

  5820.             blur: () => void | undefined;

  5821.             handleFocus: (event: FocusEvent) => void;

  5822.             handleBlur: (event: FocusEvent) => void;

  5823.             handleMouseLeave: (evt: MouseEvent) => void;

  5824.             handleMouseEnter: (evt: MouseEvent) => void;

  5825.             handleKeydown: (evt: KeyboardEvent) => void;

  5826.             select: () => void;

  5827.             clear: () => void;

  5828.             ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  5829.                 readonly size: {

  5830.                     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>>;

  5831.                     readonly required: false;

  5832.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5833.                     __epPropKey: true;

  5834.                 };

  5835.                 readonly color: {

  5836.                     readonly type: import("vue").PropType<string>;

  5837.                     readonly required: false;

  5838.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5839.                     __epPropKey: true;

  5840.                 };

  5841.             }, {

  5842.                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  5843.                     readonly size: {

  5844.                         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>>;

  5845.                         readonly required: false;

  5846.                         readonly validator: ((val: unknown) => boolean) | undefined;

  5847.                         __epPropKey: true;

  5848.                     };

  5849.                     readonly color: {

  5850.                         readonly type: import("vue").PropType<string>;

  5851.                         readonly required: false;

  5852.                         readonly validator: ((val: unknown) => boolean) | undefined;

  5853.                         __epPropKey: true;

  5854.                     };

  5855.                 }>> & {

  5856.                     [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  5857.                 }>>;

  5858.                 ns: {

  5859.                     namespace: import("vue").ComputedRef<string>;

  5860.                     b: (blockSuffix?: string) => string;

  5861.                     e: (element?: string | undefined) => string;

  5862.                     m: (modifier?: string | undefined) => string;

  5863.                     be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  5864.                     em: (element?: string | undefined, modifier?: string | undefined) => string;

  5865.                     bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  5866.                     bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  5867.                     is: {

  5868.                         (name: string, state: boolean | undefined): string;

  5869.                         (name: string): string;

  5870.                     };

  5871.                     cssVar: (object: Record<string, string>) => Record<string, string>;

  5872.                     cssVarName: (name: string) => string;

  5873.                     cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  5874.                     cssVarBlockName: (name: string) => string;

  5875.                 };

  5876.                 style: import("vue").ComputedRef<import("vue").CSSProperties>;

  5877.             }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  5878.                 readonly size: {

  5879.                     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>>;

  5880.                     readonly required: false;

  5881.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5882.                     __epPropKey: true;

  5883.                 };

  5884.                 readonly color: {

  5885.                     readonly type: import("vue").PropType<string>;

  5886.                     readonly required: false;

  5887.                     readonly validator: ((val: unknown) => boolean) | undefined;

  5888.                     __epPropKey: true;

  5889.                 };

  5890.             }>>, {}>> & Record<string, any>;

  5891.             CircleClose: 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<{}>>, {}>;

  5892.             NOOP: () => void;

  5893.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  5894.             "update:modelValue": (value: string) => boolean;

  5895.             input: (value: string) => boolean;

  5896.             change: (value: string) => boolean;

  5897.             focus: (evt: FocusEvent) => boolean;

  5898.             blur: (evt: FocusEvent) => boolean;

  5899.             clear: () => boolean;

  5900.             mouseleave: (evt: MouseEvent) => boolean;

  5901.             mouseenter: (evt: MouseEvent) => boolean;

  5902.             keydown: (evt: Event | KeyboardEvent) => boolean;

  5903.             compositionstart: (evt: CompositionEvent) => boolean;

  5904.             compositionupdate: (evt: CompositionEvent) => boolean;

  5905.             compositionend: (evt: CompositionEvent) => boolean;

  5906.         }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  5907.             readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5908.             readonly size: {

  5909.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  5910.                 readonly required: false;

  5911.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5912.                 __epPropKey: true;

  5913.             };

  5914.             readonly disabled: BooleanConstructor;

  5915.             readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

  5916.             readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;

  5917.             readonly resize: {

  5918.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  5919.                 readonly required: false;

  5920.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5921.                 __epPropKey: true;

  5922.             };

  5923.             readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize) | ((new (...args: any[]) => import("..").InputAutoSize & {}) | (() => import("..").InputAutoSize))[], unknown, unknown, false, boolean>;

  5924.             readonly autocomplete: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;

  5925.             readonly formatter: {

  5926.                 readonly type: import("vue").PropType<Function>;

  5927.                 readonly required: false;

  5928.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5929.                 __epPropKey: true;

  5930.             };

  5931.             readonly parser: {

  5932.                 readonly type: import("vue").PropType<Function>;

  5933.                 readonly required: false;

  5934.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5935.                 __epPropKey: true;

  5936.             };

  5937.             readonly placeholder: {

  5938.                 readonly type: import("vue").PropType<string>;

  5939.                 readonly required: false;

  5940.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5941.                 __epPropKey: true;

  5942.             };

  5943.             readonly form: {

  5944.                 readonly type: import("vue").PropType<string>;

  5945.                 readonly required: false;

  5946.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5947.                 __epPropKey: true;

  5948.             };

  5949.             readonly readonly: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5950.             readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5951.             readonly showPassword: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5952.             readonly showWordLimit: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5953.             readonly suffixIcon: {

  5954.                 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>>;

  5955.                 readonly required: false;

  5956.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5957.                 __epPropKey: true;

  5958.             };

  5959.             readonly prefixIcon: {

  5960.                 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>>;

  5961.                 readonly required: false;

  5962.                 readonly validator: ((val: unknown) => boolean) | undefined;

  5963.                 __epPropKey: true;

  5964.             };

  5965.             readonly containerRole: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5966.             readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  5967.             readonly tabindex: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;

  5968.             readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  5969.             readonly inputStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  5970.         }>> & {

  5971.             onChange?: ((value: string) => any) | undefined;

  5972.             "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  5973.             onInput?: ((value: string) => any) | undefined;

  5974.             onFocus?: ((evt: FocusEvent) => any) | undefined;

  5975.             onBlur?: ((evt: FocusEvent) => any) | undefined;

  5976.             onClear?: (() => any) | undefined;

  5977.             onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  5978.             onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  5979.             onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  5980.             onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  5981.             onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  5982.             onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  5983.         }, {

  5984.             readonly type: string;

  5985.             readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown>;

  5986.             readonly label: string;

  5987.             readonly id: string;

  5988.             readonly disabled: boolean;

  5989.             readonly clearable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  5990.             readonly autosize: import("..").InputAutoSize;

  5991.             readonly autocomplete: string;

  5992.             readonly readonly: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  5993.             readonly showPassword: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  5994.             readonly showWordLimit: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  5995.             readonly containerRole: string;

  5996.             readonly tabindex: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;

  5997.             readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  5998.             readonly inputStyle: import("vue").StyleValue;

  5999.         }>> & Record<string, any>;

  6000.         Search: 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<{}>>, {}>;

  6001.     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  6002.         "checked-change": (value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => boolean;

  6003.     }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  6004.         readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  6005.         readonly optionRender: {

  6006.             readonly type: import("vue").PropType<(option: import("./src/transfer").TransferDataItem) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  6007.                 [key: string]: any;

  6008.             }> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {

  6009.                 [key: string]: any;

  6010.             }>[]>;

  6011.             readonly required: false;

  6012.             readonly validator: ((val: unknown) => boolean) | undefined;

  6013.             __epPropKey: true;

  6014.         };

  6015.         readonly placeholder: StringConstructor;

  6016.         readonly title: StringConstructor;

  6017.         readonly filterable: BooleanConstructor;

  6018.         readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  6019.         readonly filterMethod: {

  6020.             readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  6021.             readonly required: false;

  6022.             readonly validator: ((val: unknown) => boolean) | undefined;

  6023.             __epPropKey: true;

  6024.         };

  6025.         readonly defaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  6026.         readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  6027.             readonly label: "label";

  6028.             readonly key: "key";

  6029.             readonly disabled: "disabled";

  6030.         }>, boolean>;

  6031.     }>> & {

  6032.         "onChecked-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  6033.     }, {

  6034.         readonly props: import("./src/transfer").TransferPropsAlias;

  6035.         readonly data: import("./src/transfer").TransferDataItem[];

  6036.         readonly filterable: boolean;

  6037.         readonly format: import("./src/transfer").TransferFormat;

  6038.         readonly defaultChecked: import("./src/transfer").TransferKey[];

  6039.     }>;

  6040. }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  6041.     change: (value: import("./src/transfer").TransferKey[], direction: import("./src/transfer").TransferDirection, movedKeys: import("./src/transfer").TransferKey[]) => boolean;

  6042.     "update:modelValue": (value: import("./src/transfer").TransferKey[]) => boolean;

  6043.     "left-check-change": (value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => boolean;

  6044.     "right-check-change": (value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => boolean;

  6045. }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  6046.     readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]) | ((new (...args: any[]) => import("./src/transfer").TransferDataItem[]) | (() => import("./src/transfer").TransferDataItem[]))[], unknown, unknown, () => never[], boolean>;

  6047.     readonly titles: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;

  6048.     readonly buttonTexts: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | ((new (...args: any[]) => [string, string]) | (() => [string, string]))[], unknown, unknown, () => never[], boolean>;

  6049.     readonly filterPlaceholder: StringConstructor;

  6050.     readonly filterMethod: {

  6051.         readonly type: import("vue").PropType<(query: string, item: import("./src/transfer").TransferDataItem) => boolean>;

  6052.         readonly required: false;

  6053.         readonly validator: ((val: unknown) => boolean) | undefined;

  6054.         __epPropKey: true;

  6055.     };

  6056.     readonly leftDefaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  6057.     readonly rightDefaultChecked: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  6058.     readonly renderContent: {

  6059.         readonly type: import("vue").PropType<import("./src/transfer").renderContent>;

  6060.         readonly required: false;

  6061.         readonly validator: ((val: unknown) => boolean) | undefined;

  6062.         __epPropKey: true;

  6063.     };

  6064.     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]) | ((new (...args: any[]) => import("./src/transfer").TransferKey[]) | (() => import("./src/transfer").TransferKey[]))[], unknown, unknown, () => never[], boolean>;

  6065.     readonly format: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat) | ((new (...args: any[]) => import("./src/transfer").TransferFormat) | (() => import("./src/transfer").TransferFormat))[], unknown, unknown, () => {}, boolean>;

  6066.     readonly filterable: BooleanConstructor;

  6067.     readonly props: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias) | ((new (...args: any[]) => import("./src/transfer").TransferPropsAlias) | (() => import("./src/transfer").TransferPropsAlias))[], unknown, unknown, () => import("element-plus/es/utils").Mutable<{

  6068.         readonly label: "label";

  6069.         readonly key: "key";

  6070.         readonly disabled: "disabled";

  6071.     }>, boolean>;

  6072.     readonly targetOrder: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "push" | "unshift" | "original", unknown, "original", boolean>;

  6073.     readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  6074. }>> & {

  6075.     onChange?: ((value: import("./src/transfer").TransferKey[], direction: import("./src/transfer").TransferDirection, movedKeys: import("./src/transfer").TransferKey[]) => any) | undefined;

  6076.     "onUpdate:modelValue"?: ((value: import("./src/transfer").TransferKey[]) => any) | undefined;

  6077.     "onLeft-check-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  6078.     "onRight-check-change"?: ((value: import("./src/transfer").TransferKey[], movedKeys?: import("./src/transfer").TransferKey[] | undefined) => any) | undefined;

  6079. }, {

  6080.     readonly props: import("./src/transfer").TransferPropsAlias;

  6081.     readonly modelValue: import("./src/transfer").TransferKey[];

  6082.     readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  6083.     readonly data: import("./src/transfer").TransferDataItem[];

  6084.     readonly titles: [string, string];

  6085.     readonly filterable: boolean;

  6086.     readonly format: import("./src/transfer").TransferFormat;

  6087.     readonly buttonTexts: [string, string];

  6088.     readonly leftDefaultChecked: import("./src/transfer").TransferKey[];

  6089.     readonly rightDefaultChecked: import("./src/transfer").TransferKey[];

  6090.     readonly targetOrder: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "push" | "unshift" | "original", unknown>;

  6091. }>> & Record<string, any>;

  6092. export default ElTransfer;

  6093. export * from './src/transfer';