import { AllowedComponentProps } from 'vue';
import type { App } from 'vue';
import type { Component } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentInternalInstance } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import type { ComponentPublicInstance } from 'vue';
import { ComputedRef } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import type { CSSProperties } from 'vue';
import { DebouncedFunc } from 'lodash-es';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import type { ExtractPublicPropTypes } from 'vue';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { JSX } from 'vue/jsx-runtime';
import type { Language } from '@deot/vc-locale';
import type { MaybeRef } from 'vue';
import type { Nullable } from '@deot/helper-shared';
import type { Plugin as Plugin_2 } from 'vue';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import type { Raw } from 'vue';
import type { Ref } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import { SetupContext } from 'vue';
import type { Slots } from 'vue';
import { StyleValue } from 'vue';
import { TranslatePair } from '@deot/vc-locale';
import type { UnwrapNestedRefs } from 'vue';
import type { ValidatorRule } from '@deot/helper-validator';
import { VNode } from 'vue';
import type { VNodeChild } from 'vue';
import type { VNodeNormalizedChildren } from 'vue';
import { VNodeProps } from 'vue';

export declare type ActionSheetAction = {
    content?: ActionSheetContent;
    subContent?: ActionSheetContent;
    disabled?: boolean;
    class?: any;
    style?: any;
    onClick?: (action: ActionSheetAction) => any;
};

export declare type ActionSheetActionValue = ActionSheetAction;

export declare type ActionSheetContent = string | Props_3['render'];

export declare const Affix: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
zIndex: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
placement: {
type: StringConstructor;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
offset: {
type: NumberConstructor;
default: number;
};
target: {
type: StringConstructor;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | JSX.Element | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
zIndex: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
placement: {
type: StringConstructor;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
offset: {
type: NumberConstructor;
default: number;
};
target: {
type: StringConstructor;
};
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
fixed: boolean;
offset: number;
zIndex: string | number;
disabled: boolean;
placement: string;
modelValue: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Alert: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: PropType<"success" | "info" | "error" | "warning">;
default: string;
};
title: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
icon: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: PropType<"success" | "info" | "error" | "warning">;
default: string;
};
title: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
icon: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
type: "error" | "info" | "warning" | "success";
title: string;
description: string;
icon: string | boolean;
closable: boolean;
modelValue: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const alert_2: (options: Options_5) => PortalLeaf;

export declare const Artboard: DefineComponent<ExtractPropTypes<    {
options: ObjectConstructor;
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
options: ObjectConstructor;
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
height: number;
width: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class BaseWatcher {
    props: Props_11;
    nodes: Nodes;
    states: RecycleListStates;
}

declare class BaseWatcher_2 {
    states: TableStates;
}

declare class Block {
    store: Store;
    _cache: {
        data: any;
        length: number;
        columnsKey: string;
        getSpan: any;
        plan: any;
    };
    _cells: WeakMap<object, any[]>;
    _blocks: WeakMap<object, any>;
    constructor(store: Store);
    buildInitialList(data: any[], levels?: number[]): any[];
    rebuildMergeList(): void;
    getCells(block: any): any[];
    getCoverAnchors(rowIndex: number): any;
    getSpansCovering(columnIndex: number): {
        start: number;
        colspan: number;
    }[];
}

export declare const buildTranslator: (locale: MaybeRef<Language>) => Translator;

export declare const Button: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
type: {
type: PropType<"default" | "primary" | "text" | "success" | "error" | "warning">;
default: string;
};
size: {
type: PropType<"small" | "medium" | "large">;
default: string;
};
wait: {
type: NumberConstructor;
default: number;
};
icon: StringConstructor;
disabled: BooleanConstructor;
circle: BooleanConstructor;
round: BooleanConstructor;
long: BooleanConstructor;
solid: BooleanConstructor;
dashed: BooleanConstructor;
htmlType: {
type: PropType<"button" | "submit" | "reset">;
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
type: {
type: PropType<"default" | "primary" | "text" | "success" | "error" | "warning">;
default: string;
};
size: {
type: PropType<"small" | "medium" | "large">;
default: string;
};
wait: {
type: NumberConstructor;
default: number;
};
icon: StringConstructor;
disabled: BooleanConstructor;
circle: BooleanConstructor;
round: BooleanConstructor;
long: BooleanConstructor;
solid: BooleanConstructor;
dashed: BooleanConstructor;
htmlType: {
type: PropType<"button" | "submit" | "reset">;
default: string;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
long: boolean;
type: "default" | "error" | "text" | "warning" | "success" | "primary";
size: "small" | "medium" | "large";
round: boolean;
circle: boolean;
disabled: boolean;
tag: string;
dashed: boolean;
solid: boolean;
wait: number;
htmlType: "button" | "reset" | "submit";
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const ButtonGroup: DefineComponent<ExtractPropTypes<    {
vertical: {
type: BooleanConstructor;
default: boolean;
};
circle: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: StringConstructor;
default: string;
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | JSX.Element | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
vertical: {
type: BooleanConstructor;
default: boolean;
};
circle: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: StringConstructor;
default: string;
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
size: string;
circle: boolean;
vertical: boolean;
fragment: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Calendar: DefineComponent<ExtractPropTypes<    {
renderDate: {
type: PropType<CalendarRender<RenderDateProps>>;
default: ({ cell, today }: RenderDateProps) => JSX.Element;
};
renderMonth: {
type: PropType<CalendarRender<RenderMonthProps>>;
default: ({ data }: RenderMonthProps) => JSX.Element;
};
renderWeek: {
type: PropType<CalendarRender<RenderWeekProps>>;
default: ({ data }: RenderWeekProps) => JSX.Element;
};
firstDayOfWeek: {
type: NumberConstructor;
default: number;
validator: (value: number) => boolean;
};
showAdjacentWeeks: {
type: PropType<CalendarAdjacentWeeks>;
default: () => boolean[];
validator: (value: CalendarAdjacentWeeks) => boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
renderDate: {
type: PropType<CalendarRender<RenderDateProps>>;
default: ({ cell, today }: RenderDateProps) => JSX.Element;
};
renderMonth: {
type: PropType<CalendarRender<RenderMonthProps>>;
default: ({ data }: RenderMonthProps) => JSX.Element;
};
renderWeek: {
type: PropType<CalendarRender<RenderWeekProps>>;
default: ({ data }: RenderWeekProps) => JSX.Element;
};
firstDayOfWeek: {
type: NumberConstructor;
default: number;
validator: (value: number) => boolean;
};
showAdjacentWeeks: {
type: PropType<CalendarAdjacentWeeks>;
default: () => boolean[];
validator: (value: CalendarAdjacentWeeks) => boolean;
};
}>> & Readonly<{}>, {
renderDate: CalendarRender<RenderDateProps>;
renderMonth: CalendarRender<RenderMonthProps>;
renderWeek: CalendarRender<RenderWeekProps>;
firstDayOfWeek: number;
showAdjacentWeeks: CalendarAdjacentWeeks;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type CalendarAdjacentWeeks = boolean | [boolean, boolean];

declare interface CalendarCell {
    date: number;
    value: string;
    type: CalendarCellType;
}

declare type CalendarCellType = 'previous' | 'current' | 'next' | string;

declare interface CalendarFestival {
    type: CalendarFestivalType;
    description: string;
    value: string;
}

declare type CalendarFestivalType = 'a' | 'c' | 'h' | 'i' | 't';

declare type CalendarFirstDayOfWeek = number;

declare interface CalendarHoliday {
    holiday: string;
    festivals: CalendarFestival[];
    animal?: string;
    ganzhiDate?: string;
    ganzhiMonth?: string;
    ganzhiYear?: string;
    lunarYear?: number;
    lunarMonth?: number;
    lunarDate?: number;
    lunarMonthText?: string;
    lunarDateText?: string;
    solarTerm?: string;
    isBigMonth?: boolean;
    originalDate?: Date;
    weekDay?: number;
    chineseWeekDay?: string;
}

declare type CalendarLang = string;

declare type CalendarRender<T> = (options: T) => VNodeChild;

export declare const Card: DefineComponent<ExtractPropTypes<    {
border: {
type: BooleanConstructor;
default: boolean;
};
shadow: {
type: BooleanConstructor;
default: boolean;
};
padding: {
type: NumberConstructor;
default: number;
};
title: {
type: StringConstructor;
};
icon: {
type: StringConstructor;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
border: {
type: BooleanConstructor;
default: boolean;
};
shadow: {
type: BooleanConstructor;
default: boolean;
};
padding: {
type: NumberConstructor;
default: number;
};
title: {
type: StringConstructor;
};
icon: {
type: StringConstructor;
};
}>> & Readonly<{}>, {
border: boolean;
padding: number;
shadow: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Carousel: DefineComponent<ExtractPropTypes<    {
t: {
type: NumberConstructor;
default: number;
};
card: BooleanConstructor;
gap: {
type: NumberConstructor;
default: number;
};
height: (StringConstructor | NumberConstructor)[];
initialIndex: {
type: NumberConstructor;
default: number;
};
trigger: {
type: StringConstructor;
default: string;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
dots: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
arrow: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
loop: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "change"[], "change", PublicProps, Readonly<ExtractPropTypes<    {
t: {
type: NumberConstructor;
default: number;
};
card: BooleanConstructor;
gap: {
type: NumberConstructor;
default: number;
};
height: (StringConstructor | NumberConstructor)[];
initialIndex: {
type: NumberConstructor;
default: number;
};
trigger: {
type: StringConstructor;
default: string;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
dots: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
arrow: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
loop: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
}>, {
gap: number;
draggable: boolean;
vertical: boolean;
autoplay: boolean;
loop: boolean;
arrow: string | boolean;
t: number;
card: boolean;
initialIndex: number;
trigger: string;
dots: string | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const CarouselItem: DefineComponent<ExtractPropTypes<    {
name: StringConstructor;
label: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
width: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
gap: {
type: NumberConstructor;
default: number;
};
scale: {
type: NumberConstructor;
default: number;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: StringConstructor;
label: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
width: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
gap: {
type: NumberConstructor;
default: number;
};
scale: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
width: string | number;
gap: number;
scale: number;
label: string | number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Cascader: DefineComponent<ExtractPropTypes<    {
data: {
type: PropType<TreeData[]>;
default: () => never[];
};
formatter: {
type: FunctionConstructor;
default: (v: any[]) => string;
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "close" | "ready" | "update:modelValue" | "visible-change")[], "change" | "close" | "ready" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: PropType<TreeData[]>;
default: () => never[];
};
formatter: {
type: FunctionConstructor;
default: (v: any[]) => string;
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: TreeData[];
disabled: boolean;
tag: string;
extra: string;
separator: string;
placement: string;
arrow: boolean;
formatter: Function;
portal: boolean;
trigger: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
maxTagLines: number;
searchable: boolean;
changeOnSelect: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Chart: DefineComponent<ExtractPropTypes<    {
options: ObjectConstructor;
pluginOptions: ObjectConstructor;
theme: (ObjectConstructor | StringConstructor)[];
group: StringConstructor;
resize: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
watchShallow: BooleanConstructor;
manualUpdate: BooleanConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, string[], string, PublicProps, Readonly<ExtractPropTypes<    {
options: ObjectConstructor;
pluginOptions: ObjectConstructor;
theme: (ObjectConstructor | StringConstructor)[];
group: StringConstructor;
resize: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
watchShallow: BooleanConstructor;
manualUpdate: BooleanConstructor;
}>> & Readonly<{
[x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
}>, {
resize: number | boolean;
watchShallow: boolean;
manualUpdate: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Checkbox: DefineComponent<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
name: StringConstructor;
checkedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
uncheckedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
name: StringConstructor;
checkedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
uncheckedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
value: string | number | boolean;
label: string | number | boolean;
disabled: boolean;
indeterminate: boolean;
modelValue: string | number | boolean;
checkedValue: string | number | boolean;
uncheckedValue: string | number | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const CheckboxGroup: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: ArrayConstructor;
default: () => never[];
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | JSX.Element | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: ArrayConstructor;
default: () => never[];
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
modelValue: unknown[];
fragment: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const Clipboard_2: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    value: StringConstructor;
    tag: {
    type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
    default: string;
    };
    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    tag: string | Function | Record<string, any>;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    value: StringConstructor;
    tag: {
    type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
    default: string;
    };
    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, {
    tag: string | Function | Record<string, any>;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
value: StringConstructor;
tag: {
type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
default: string;
};
}>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
tag: string | Function | Record<string, any>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    get: () => Promise<string>;
    set: (value: string) => any;
    clear: () => any;
    clearSelection: () => (() => void) | undefined;
};
export { Clipboard_2 as Clipboard }

export declare const Collapse: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
accordion: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | NumberConstructor | ArrayConstructor)[];
};
alive: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
accordion: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | NumberConstructor | ArrayConstructor)[];
};
alive: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
tag: string;
alive: boolean;
styleless: boolean;
accordion: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const CollapseItem: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: {
type: (StringConstructor | NumberConstructor)[];
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: {
type: (StringConstructor | NumberConstructor)[];
};
}>> & Readonly<{}>, {
tag: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare class Color {
    states: any;
    constructor(options?: ColorOptions);
    setOptions(options?: ColorOptionStates): void;
    set(prop: ColorChannel | Partial<Record<ColorChannel, number>>, value?: number): void;
    get(prop: ColorChannel): any;
    toRgb(): RGB;
    setColor(value?: string): void;
    compare(color: Color): boolean;
    private getOutput;
}

declare type ColorChannel = 'hue' | 'saturation' | 'value' | 'alpha';

declare type ColorFormat = 'hsl' | 'hsv' | 'hex' | 'rgb';

declare interface ColorOptions {
    enableAlpha?: boolean;
    format?: ColorFormat;
    value?: string;
}

declare type ColorOptionStates = Pick<ColorOptions, 'enableAlpha' | 'format'>;

export declare const ColorPicker: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    trigger: {
    type: StringConstructor;
    default: string;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    size: {
    type: PropType<"large" | "medium" | "small">;
    default: string;
    validator: (v: string) => boolean;
    };
    editable: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: {
    type: StringConstructor;
    default: string;
    };
    panel: {
    type: BooleanConstructor;
    default: boolean;
    };
    alpha: {
    type: BooleanConstructor;
    default: boolean;
    };
    hue: {
    type: BooleanConstructor;
    default: boolean;
    };
    recommend: {
    type: BooleanConstructor;
    default: boolean;
    };
    colors: {
    type: PropType<string[]>;
    default: () => never[];
    };
    format: {
    type: PropType<ColorFormat>;
    validator: (v: string) => boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    "onColor-change"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "close" | "ready" | "update:modelValue" | "visible-change" | "color-change")[], PublicProps, {
    alpha: boolean;
    size: "small" | "medium" | "large";
    hue: boolean;
    disabled: boolean;
    arrow: boolean;
    modelValue: string;
    trigger: string;
    panel: boolean;
    recommend: boolean;
    colors: string[];
    editable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    trigger: {
    type: StringConstructor;
    default: string;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    size: {
    type: PropType<"large" | "medium" | "small">;
    default: string;
    validator: (v: string) => boolean;
    };
    editable: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: {
    type: StringConstructor;
    default: string;
    };
    panel: {
    type: BooleanConstructor;
    default: boolean;
    };
    alpha: {
    type: BooleanConstructor;
    default: boolean;
    };
    hue: {
    type: BooleanConstructor;
    default: boolean;
    };
    recommend: {
    type: BooleanConstructor;
    default: boolean;
    };
    colors: {
    type: PropType<string[]>;
    default: () => never[];
    };
    format: {
    type: PropType<ColorFormat>;
    validator: (v: string) => boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    "onColor-change"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    alpha: boolean;
    size: "small" | "medium" | "large";
    hue: boolean;
    disabled: boolean;
    arrow: boolean;
    modelValue: string;
    trigger: string;
    panel: boolean;
    recommend: boolean;
    colors: string[];
    editable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
trigger: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: PropType<"large" | "medium" | "small">;
default: string;
validator: (v: string) => boolean;
};
editable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: StringConstructor;
default: string;
};
panel: {
type: BooleanConstructor;
default: boolean;
};
alpha: {
type: BooleanConstructor;
default: boolean;
};
hue: {
type: BooleanConstructor;
default: boolean;
};
recommend: {
type: BooleanConstructor;
default: boolean;
};
colors: {
type: PropType<string[]>;
default: () => never[];
};
format: {
type: PropType<ColorFormat>;
validator: (v: string) => boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
"onColor-change"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "close" | "ready" | "update:modelValue" | "visible-change" | "color-change")[], "change" | "close" | "ready" | "update:modelValue" | "visible-change" | "color-change", {
alpha: boolean;
size: "small" | "medium" | "large";
hue: boolean;
disabled: boolean;
arrow: boolean;
modelValue: string;
trigger: string;
panel: boolean;
recommend: boolean;
colors: string[];
editable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    View: DefineComponent<ExtractPropTypes<    {
    modelValue: {
    type: StringConstructor;
    default: string;
    };
    panel: {
    type: BooleanConstructor;
    default: boolean;
    };
    alpha: {
    type: BooleanConstructor;
    default: boolean;
    };
    hue: {
    type: BooleanConstructor;
    default: boolean;
    };
    recommend: {
    type: BooleanConstructor;
    default: boolean;
    };
    colors: {
    type: PropType<string[]>;
    default: () => never[];
    };
    format: {
    type: PropType<ColorFormat>;
    validator: (v: string) => boolean;
    };
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
    modelValue: {
    type: StringConstructor;
    default: string;
    };
    panel: {
    type: BooleanConstructor;
    default: boolean;
    };
    alpha: {
    type: BooleanConstructor;
    default: boolean;
    };
    hue: {
    type: BooleanConstructor;
    default: boolean;
    };
    recommend: {
    type: BooleanConstructor;
    default: boolean;
    };
    colors: {
    type: PropType<string[]>;
    default: () => never[];
    };
    format: {
    type: PropType<ColorFormat>;
    validator: (v: string) => boolean;
    };
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
    alpha: boolean;
    hue: boolean;
    modelValue: string;
    panel: boolean;
    recommend: boolean;
    colors: string[];
    }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
    Color: typeof Color;
};

export declare const ColorPickerView: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: StringConstructor;
default: string;
};
panel: {
type: BooleanConstructor;
default: boolean;
};
alpha: {
type: BooleanConstructor;
default: boolean;
};
hue: {
type: BooleanConstructor;
default: boolean;
};
recommend: {
type: BooleanConstructor;
default: boolean;
};
colors: {
type: PropType<string[]>;
default: () => never[];
};
format: {
type: PropType<ColorFormat>;
validator: (v: string) => boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: StringConstructor;
default: string;
};
panel: {
type: BooleanConstructor;
default: boolean;
};
alpha: {
type: BooleanConstructor;
default: boolean;
};
hue: {
type: BooleanConstructor;
default: boolean;
};
recommend: {
type: BooleanConstructor;
default: boolean;
};
colors: {
type: PropType<string[]>;
default: () => never[];
};
format: {
type: PropType<ColorFormat>;
validator: (v: string) => boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
alpha: boolean;
hue: boolean;
modelValue: string;
panel: boolean;
recommend: boolean;
colors: string[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Column {
    store: Store;
    _sync: {
        snapshot: TableColumnSyncItem[];
        order: Nullable<string[]>;
    };
    constructor(store: Store);
    insert(column: TableColumnNode, parent?: TableColumnNode): void;
    remove(column: TableColumnNode, parent?: TableColumnNode): void;
    getSiblings(parent?: Nullable<TableColumnNode>): TableColumnNode[];
    arrange(parent?: Nullable<TableColumnNode>, order?: Nullable<string[]>): TableColumnNode[];
    getLeafOrder(order?: Nullable<string[]>): string[];
    setOrder(order: Nullable<string[]>): void;
    sort(parent?: TableColumnNode): boolean;
    sortTree(): boolean;
    update(): void;
    cloneVisibleTree(arr: TableColumnNode[]): TableColumnNode[];
    move(move: TableColumnMove): TableColumnSyncItem[];
    syncToParent(): void;
    getSyncItems(): TableColumnSyncItem[];
    applyExternal(v: TableColumnSyncItem[]): void;
}

export declare const Countdown: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
format: {
type: StringConstructor;
default: undefined;
};
t: {
type: NumberConstructor;
default: number;
};
targetTime: {
type: (StringConstructor | NumberConstructor | DateConstructor)[];
default: string;
};
serverTime: {
type: (StringConstructor | NumberConstructor | DateConstructor)[];
default: string;
};
render: FunctionConstructor;
trim: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "change" | "complete")[], "error" | "change" | "complete", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
format: {
type: StringConstructor;
default: undefined;
};
t: {
type: NumberConstructor;
default: number;
};
targetTime: {
type: (StringConstructor | NumberConstructor | DateConstructor)[];
default: string;
};
serverTime: {
type: (StringConstructor | NumberConstructor | DateConstructor)[];
default: string;
};
render: FunctionConstructor;
trim: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
}>, {
trim: boolean;
format: string;
tag: string;
t: number;
targetTime: string | number | Date;
serverTime: string | number | Date;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Counter: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: (StringConstructor | NumberConstructor)[];
placeholder: StringConstructor;
precision: {
type: NumberConstructor;
default: number;
};
duration: {
type: NumberConstructor;
default: number;
};
decimal: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerals: {
type: () => string[];
default: () => never[];
};
smartEasingThreshold: {
type: NumberConstructor;
default: number;
};
smartEasingAmount: {
type: NumberConstructor;
default: number;
};
easing: {
type: (FunctionConstructor | BooleanConstructor)[];
default: boolean;
};
zeroless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
render: FunctionConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "complete" | "begin")[], "change" | "complete" | "begin", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: (StringConstructor | NumberConstructor)[];
placeholder: StringConstructor;
precision: {
type: NumberConstructor;
default: number;
};
duration: {
type: NumberConstructor;
default: number;
};
decimal: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerals: {
type: () => string[];
default: () => never[];
};
smartEasingThreshold: {
type: NumberConstructor;
default: number;
};
smartEasingAmount: {
type: NumberConstructor;
default: number;
};
easing: {
type: (FunctionConstructor | BooleanConstructor)[];
default: boolean;
};
zeroless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
render: FunctionConstructor;
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
onBegin?: ((...args: any[]) => any) | undefined;
}>, {
decimal: string;
easing: boolean | Function;
controllable: boolean;
tag: string;
separator: string;
duration: number;
precision: number;
numerals: string[];
smartEasingThreshold: number;
smartEasingAmount: number;
zeroless: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type CrossOrigin = '' | 'anonymous' | 'use-credentials';

export declare const Customer: DefineComponent<ExtractPropTypes<    {
render: {
type: Render;
default: () => null;
};
}>, () => any, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
render: {
type: Render;
default: () => null;
};
}>> & Readonly<{}>, {
render: (props: Record<string, unknown>, context: SetupContext) => any;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const DatePicker: DefineComponent<ExtractPropTypes<    {
type: StringConstructor;
placeholder: StringConstructor;
clearable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: (StringConstructor | DateConstructor | ArrayConstructor)[];
multiple: BooleanConstructor;
open: BooleanConstructor;
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
confirm: {
type: BooleanConstructor;
default: boolean;
};
format: StringConstructor;
separator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
};
splitPanels: {
type: BooleanConstructor;
default: boolean;
};
steps: {
type: ArrayConstructor;
default: () => never[];
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
} & object>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "error" | "clear" | "change" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change")[], "input" | "error" | "clear" | "change" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
type: StringConstructor;
placeholder: StringConstructor;
clearable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: (StringConstructor | DateConstructor | ArrayConstructor)[];
multiple: BooleanConstructor;
open: BooleanConstructor;
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
confirm: {
type: BooleanConstructor;
default: boolean;
};
format: StringConstructor;
separator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
};
splitPanels: {
type: BooleanConstructor;
default: boolean;
};
steps: {
type: ArrayConstructor;
default: () => never[];
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
} & object>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, {
open: boolean;
disabled: boolean;
multiple: boolean;
confirm: boolean;
tag: string;
separator: string;
placement: string;
arrow: boolean;
steps: unknown[];
portal: boolean;
trigger: string;
nullValue: string | number | Record<string, any>;
clearable: boolean;
changeOnSelect: boolean;
splitPanels: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const Debounce: DefineComponent<ExtractPropTypes<    {
wait: {
type: NumberConstructor;
default: number;
};
tag: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
include: {
type: RegExpConstructor;
default: () => RegExp;
};
exclude: RegExpConstructor;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
wait: {
type: NumberConstructor;
default: number;
};
tag: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
include: {
type: RegExpConstructor;
default: () => RegExp;
};
exclude: RegExpConstructor;
}>> & Readonly<{}>, {
include: RegExp;
tag: string | Record<string, any>;
wait: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { Debounce }
export { Debounce as MDebounce }

export declare const Defer: DefineComponent<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: never[];
};
primaryKey: {
type: StringConstructor;
default: string;
};
concurrency: {
type: NumberConstructor;
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
once: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element[], {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("progress" | "complete")[], "progress" | "complete", PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: never[];
};
primaryKey: {
type: StringConstructor;
default: string;
};
concurrency: {
type: NumberConstructor;
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
once: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onProgress?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
}>, {
once: boolean;
data: unknown[];
disabled: boolean;
primaryKey: string;
concurrency: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const defineVcPlugin: (components: Record<string, Component>) => (options?: VcOptions, transfromComponentKey?: (x: string) => string) => {
    install: (app: App) => void;
};

declare const destroy: () => void;

export declare const Divider: DefineComponent<ExtractPropTypes<    {
vertical: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
validator(val: string): boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
vertical: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
validator(val: string): boolean;
};
}>> & Readonly<{}>, {
vertical: boolean;
placement: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Drag {
    store: Store;
    pending: any[] | null;
    draggable: ComputedRef<[boolean, boolean]>;
    rowCursor: ComputedRef<boolean>;
    constructor(store: Store);
    getRows(block: any): any[];
    getPayload(block: any): TableBlockDragPayload;
    getBlockByRowIndex(rowIndex: number): any;
    get disabled(): boolean;
    canDrag(block: any): boolean;
    canDrop(block: any, targetRows: any[], position: TableDropPosition, move: TableMove): boolean;
    indexOf(parent: any, row: any): number;
    canInner(row: any): boolean;
    getTreeMove(block: any, parent: any, index: number): TableMove | null;
    getMove(block: any, target: any, position: TableDropPosition): TableMove | null;
    apply(block: any, move: TableMove): any[];
    consume(data: any[]): boolean;
    getColumnIndex(column: TableColumnNode): number;
    getColumnSide(column: TableColumnNode): "" | "left" | "right";
    getColumnPayload(column: TableColumnNode): TableColumnDragPayload;
    canDragColumn(column: TableColumnNode): boolean;
    isColumnTarget(column: TableColumnNode, target: TableColumnNode): boolean;
    getColumnMove(column: TableColumnNode, target: TableColumnNode, position: TableColumnDropPosition): Nullable<TableColumnMove>;
    getColumnDropPayload(column: TableColumnNode, target: TableColumnNode, position: TableColumnDropPosition, move: TableColumnMove): Omit<TableColumnDropPayload, 'columns'>;
    canDropColumn(column: TableColumnNode, target: TableColumnNode, position: TableColumnDropPosition, move: TableColumnMove): boolean;
}

export declare const Drawer: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    title: PropType<string | boolean | Props_3["render"]>;
    content: {
    type: PropType<string | Props_3["render"]>;
    default: string;
    };
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    width: {
    type: NumberConstructor;
    default: number;
    };
    height: {
    type: NumberConstructor;
    default: number;
    };
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    placement: {
    type: StringConstructor;
    default: string;
    };
    maskStyle: (ObjectConstructor | StringConstructor)[];
    wrapperClass: (ObjectConstructor | StringConstructor)[];
    wrapperStyle: (ObjectConstructor | StringConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    closeWithCancel: {
    type: BooleanConstructor;
    default: boolean;
    };
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    okDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    cancelDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    onOk: {
    type: FunctionConstructor;
    };
    onCancel: {
    type: FunctionConstructor;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], PublicProps, {
    height: number;
    width: number;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    cancelText: string | boolean;
    okText: string | boolean;
    placement: string;
    maskClosable: boolean;
    scrollable: boolean;
    modelValue: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    title: PropType<string | boolean | Props_3["render"]>;
    content: {
    type: PropType<string | Props_3["render"]>;
    default: string;
    };
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    width: {
    type: NumberConstructor;
    default: number;
    };
    height: {
    type: NumberConstructor;
    default: number;
    };
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    placement: {
    type: StringConstructor;
    default: string;
    };
    maskStyle: (ObjectConstructor | StringConstructor)[];
    wrapperClass: (ObjectConstructor | StringConstructor)[];
    wrapperStyle: (ObjectConstructor | StringConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    closeWithCancel: {
    type: BooleanConstructor;
    default: boolean;
    };
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    okDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    cancelDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    onOk: {
    type: FunctionConstructor;
    };
    onCancel: {
    type: FunctionConstructor;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    height: number;
    width: number;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    cancelText: string | boolean;
    okText: string | boolean;
    placement: string;
    maskClosable: boolean;
    scrollable: boolean;
    modelValue: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
title: PropType<string | boolean | Props_3["render"]>;
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
placement: {
type: StringConstructor;
default: string;
};
maskStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], "close" | "update:modelValue" | "visible-change" | "portal-fulfilled", {
height: number;
width: number;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
cancelText: string | boolean;
okText: string | boolean;
placement: string;
maskClosable: boolean;
scrollable: boolean;
modelValue: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options: Options_2) => PortalLeaf;
    destroy: () => void;
};

export declare const DrawerView: DefineComponent<ExtractPropTypes<    {
title: PropType<string | boolean | Props_3["render"]>;
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
placement: {
type: StringConstructor;
default: string;
};
maskStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], "close" | "update:modelValue" | "visible-change" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
title: PropType<string | boolean | Props_3["render"]>;
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
placement: {
type: StringConstructor;
default: string;
};
maskStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, {
height: number;
width: number;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
cancelText: string | boolean;
okText: string | boolean;
placement: string;
maskClosable: boolean;
scrollable: boolean;
modelValue: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Dropdown: DefineComponent<ExtractPropTypes<    {
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
modelValue: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor)[];
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("click" | "close" | "ready" | "update:modelValue" | "visible-change")[], "click" | "close" | "ready" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
modelValue: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor)[];
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
placement: string;
arrow: boolean;
scrollable: boolean;
modelValue: boolean;
trigger: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const DropdownItem: DefineComponent<ExtractPropTypes<    {
value: {
type: (StringConstructor | NumberConstructor)[];
value: undefined;
};
label: {
type: (StringConstructor | NumberConstructor)[];
value: undefined;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
selected: {
type: BooleanConstructor;
default: boolean;
};
divided: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: (StringConstructor | NumberConstructor)[];
value: undefined;
};
label: {
type: (StringConstructor | NumberConstructor)[];
value: undefined;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
selected: {
type: BooleanConstructor;
default: boolean;
};
divided: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
disabled: boolean;
selected: boolean;
closable: boolean;
divided: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const DropdownMenu: DefineComponent<    {}, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Editor: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: StringConstructor;
default: string;
};
options: ObjectConstructor;
disabled: {
type: BooleanConstructor;
default: boolean;
};
uploadOptions: {
type: ObjectConstructor;
default: () => {
file: {};
image: {};
video: {};
};
};
register: FunctionConstructor;
poster: FunctionConstructor;
enhancer: {
type: (FunctionConstructor | BooleanConstructor)[];
default: boolean;
};
previewable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "change" | "blur" | "focus" | "ready" | "update:modelValue")[], "input" | "change" | "blur" | "focus" | "ready" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: StringConstructor;
default: string;
};
options: ObjectConstructor;
disabled: {
type: BooleanConstructor;
default: boolean;
};
uploadOptions: {
type: ObjectConstructor;
default: () => {
file: {};
image: {};
video: {};
};
};
register: FunctionConstructor;
poster: FunctionConstructor;
enhancer: {
type: (FunctionConstructor | BooleanConstructor)[];
default: boolean;
};
previewable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onFocus?: ((...args: any[]) => any) | undefined;
onBlur?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
disabled: boolean;
modelValue: string;
enhancer: boolean | Function;
uploadOptions: Record<string, any>;
previewable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const EditorView: DefineComponent<ExtractPropTypes<    {
value: {
type: StringConstructor;
default: undefined;
};
fontSize: {
type: PropType<string[]>;
default: () => string[];
};
lineHeight: {
type: PropType<string[]>;
default: () => string[];
};
letterSpacing: {
type: PropType<string[]>;
default: () => string[];
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: StringConstructor;
default: undefined;
};
fontSize: {
type: PropType<string[]>;
default: () => string[];
};
lineHeight: {
type: PropType<string[]>;
default: () => string[];
};
letterSpacing: {
type: PropType<string[]>;
default: () => string[];
};
}>> & Readonly<{}>, {
fontSize: string[];
letterSpacing: string[];
lineHeight: string[];
value: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Expand: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
alive: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
alive: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
tag: string;
modelValue: boolean;
alive: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Expand_2 {
    store: Store;
    constructor(store: Store);
    getKey(row: any): any;
    isExpanded(row: any): boolean;
    getRows(): any[];
    toggle(row: any, expanded?: boolean): void;
    reset(values: any[]): void;
    prune(): void;
}

export declare const FilePreview: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    data: {
    type: PropType<FilePreviewData>;
    default: () => never[];
    };
    type: {
    type: PropType<"group" | "mix">;
    default: string;
    validator: (v: string) => boolean;
    };
    size: {
    type: PropType<"small" | "medium" | "large" | "mini">;
    default: string;
    validator: (v: string) => boolean;
    };
    vertical: {
    type: BooleanConstructor;
    default: boolean;
    };
    previewable: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    type: "group" | "mix";
    data: FilePreviewData;
    size: "small" | "medium" | "large" | "mini";
    vertical: boolean;
    previewable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    data: {
    type: PropType<FilePreviewData>;
    default: () => never[];
    };
    type: {
    type: PropType<"group" | "mix">;
    default: string;
    validator: (v: string) => boolean;
    };
    size: {
    type: PropType<"small" | "medium" | "large" | "mini">;
    default: string;
    validator: (v: string) => boolean;
    };
    vertical: {
    type: BooleanConstructor;
    default: boolean;
    };
    previewable: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, {
    type: "group" | "mix";
    data: FilePreviewData;
    size: "small" | "medium" | "large" | "mini";
    vertical: boolean;
    previewable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
data: {
type: PropType<FilePreviewData>;
default: () => never[];
};
type: {
type: PropType<"group" | "mix">;
default: string;
validator: (v: string) => boolean;
};
size: {
type: PropType<"small" | "medium" | "large" | "mini">;
default: string;
validator: (v: string) => boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
previewable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
type: "group" | "mix";
data: FilePreviewData;
size: "small" | "medium" | "large" | "mini";
vertical: boolean;
previewable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options: FilePreviewOpenOptions) => Promise<void>;
};

declare type FilePreviewData = string | FilePreviewItemInput[];

declare interface FilePreviewEnhancerPayload {
    current: number;
    data: FilePreviewItem[];
    instance: ComponentInternalInstance | null;
}

declare type FilePreviewFileType = 'image' | 'video' | 'audio' | 'file';

declare interface FilePreviewItem {
    type: FilePreviewFileType;
    source: string;
    name: string;
    thumbnail?: string;
    [key: string]: any;
}

declare type FilePreviewItemInput = string | (Partial<FilePreviewItem> & {
    source: string;
});

declare interface FilePreviewOpenOptions {
    data: FilePreviewData;
    current?: number;
    instance?: ComponentInternalInstance | null;
}

declare interface FilePreviewOptions {
    getFileType?: (source: string) => FilePreviewFileType | null | undefined | void;
    getFileName?: (source: string) => string | null | undefined | void;
    enhancer?: (payload: FilePreviewEnhancerPayload) => unknown;
}

export declare const Form: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
model: {
type: ObjectConstructor;
};
rules: {
type: PropType<Record<string, FormRule>>;
};
labelWidth: {
type: NumberConstructor;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
inline: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"left" | "right" | "top">;
default: string;
};
autocomplete: {
type: PropType<"on" | "off">;
default: string;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
errorStyle: (ObjectConstructor | StringConstructor)[];
errorClass: (ObjectConstructor | StringConstructor)[];
nestedContentStyle: (ObjectConstructor | StringConstructor)[];
nestedContentClass: (ObjectConstructor | StringConstructor)[];
nestedLabelStyle: (ObjectConstructor | StringConstructor)[];
nestedLabelClass: (ObjectConstructor | StringConstructor)[];
nestedErrorStyle: (ObjectConstructor | StringConstructor)[];
nestedErrorClass: (ObjectConstructor | StringConstructor)[];
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
model: {
type: ObjectConstructor;
};
rules: {
type: PropType<Record<string, FormRule>>;
};
labelWidth: {
type: NumberConstructor;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
inline: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"left" | "right" | "top">;
default: string;
};
autocomplete: {
type: PropType<"on" | "off">;
default: string;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
errorStyle: (ObjectConstructor | StringConstructor)[];
errorClass: (ObjectConstructor | StringConstructor)[];
nestedContentStyle: (ObjectConstructor | StringConstructor)[];
nestedContentClass: (ObjectConstructor | StringConstructor)[];
nestedLabelStyle: (ObjectConstructor | StringConstructor)[];
nestedLabelClass: (ObjectConstructor | StringConstructor)[];
nestedErrorStyle: (ObjectConstructor | StringConstructor)[];
nestedErrorClass: (ObjectConstructor | StringConstructor)[];
}>> & Readonly<{}>, {
inline: boolean;
autocomplete: "off" | "on";
tag: string;
styleless: boolean;
showMessage: boolean;
labelPosition: "left" | "top" | "right";
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const FormItem: DefineComponent<ExtractPropTypes<    {
label: {
type: StringConstructor;
default: string;
};
labelWidth: {
type: NumberConstructor;
};
prop: {
type: StringConstructor;
};
required: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
asterisk: {
type: BooleanConstructor;
default: boolean;
};
error: {
type: StringConstructor;
};
rules: {
type: PropType<FormRule | FormRule[]>;
};
resetByRulesChanged: {
type: BooleanConstructor;
default: boolean;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
labelFor: {
type: StringConstructor;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"left" | "right" | "top">;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
errorStyle: (ObjectConstructor | StringConstructor)[];
errorClass: (ObjectConstructor | StringConstructor)[];
}>, () => JSX.Element | (VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | undefined)[], {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
label: {
type: StringConstructor;
default: string;
};
labelWidth: {
type: NumberConstructor;
};
prop: {
type: StringConstructor;
};
required: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
asterisk: {
type: BooleanConstructor;
default: boolean;
};
error: {
type: StringConstructor;
};
rules: {
type: PropType<FormRule | FormRule[]>;
};
resetByRulesChanged: {
type: BooleanConstructor;
default: boolean;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
labelFor: {
type: StringConstructor;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"left" | "right" | "top">;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
errorStyle: (ObjectConstructor | StringConstructor)[];
errorClass: (ObjectConstructor | StringConstructor)[];
}>> & Readonly<{}>, {
required: string | boolean;
label: string;
styleless: boolean;
showMessage: boolean;
asterisk: boolean;
resetByRulesChanged: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare interface FormItemProvide {
    blur: (...args: any[]) => any;
    change: (...args: any[]) => any;
    add: (item: ComponentInternalInstance) => any;
    remove: (item: ComponentInternalInstance) => any;
    fields: UnwrapNestedRefs<ComponentInternalInstance[]>;
    message: Ref<string>;
}

export declare interface FormProvide {
    props: Props_6;
    add: (item: ComponentInternalInstance) => any;
    remove: (item: ComponentInternalInstance) => any;
}

export declare type FormRule = ValidatorRule & {
    trigger?: string | string[];
};

export declare const Fragment: DefineComponent<    {}, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Icon: DefineComponent<ExtractPropTypes<    {
type: StringConstructor;
inherit: {
type: BooleanConstructor;
default: boolean;
};
color: StringConstructor;
size: PropType<IconSize>;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: StringConstructor;
inherit: {
type: BooleanConstructor;
default: boolean;
};
color: StringConstructor;
size: PropType<IconSize>;
}>> & Readonly<{}>, {
inherit: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const IconManager: Manager;

declare type IconSize = number | [IconSizeItem, IconSizeItem?];

declare type IconSizeItem = number | [number, number?];

declare const Image_2: DefineComponent<ExtractPropTypes<    {
src: StringConstructor;
thumbnail: StringConstructor;
fit: StringConstructor;
lazy: BooleanConstructor;
wrapper: (ObjectConstructor | StringConstructor)[];
previewable: {
type: BooleanConstructor;
default: boolean;
};
formatter: FunctionConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
src: StringConstructor;
thumbnail: StringConstructor;
fit: StringConstructor;
lazy: BooleanConstructor;
wrapper: (ObjectConstructor | StringConstructor)[];
previewable: {
type: BooleanConstructor;
default: boolean;
};
formatter: FunctionConstructor;
}>> & Readonly<{}>, {
lazy: boolean;
previewable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { Image_2 as Image }

export declare const ImageCrop: DefineComponent<ExtractPropTypes<    {
src: PropType<ImageCropSource>;
scale: {
type: NumberConstructor;
default: number;
};
rotate: {
type: NumberConstructor;
default: number;
};
border: {
type: PropType<ImageCropBorder>;
default: number;
};
borderRadius: {
type: NumberConstructor;
default: number;
};
outputSize: {
type: PropType<ImageCropOutputSize>;
default: number;
};
position: PropType<ImageCropPosition>;
maskColor: {
type: PropType<ImageCropMaskColor>;
default: () => number[];
};
crossOrigin: {
type: PropType<ImageCropCrossOrigin>;
default: string;
validator: (value: string) => boolean;
};
droppable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("mousemove" | "mouseup" | "image-load" | "image-error" | "image-change" | "image-drop" | "position-change")[], "mousemove" | "mouseup" | "image-load" | "image-error" | "image-change" | "image-drop" | "position-change", PublicProps, Readonly<ExtractPropTypes<    {
src: PropType<ImageCropSource>;
scale: {
type: NumberConstructor;
default: number;
};
rotate: {
type: NumberConstructor;
default: number;
};
border: {
type: PropType<ImageCropBorder>;
default: number;
};
borderRadius: {
type: NumberConstructor;
default: number;
};
outputSize: {
type: PropType<ImageCropOutputSize>;
default: number;
};
position: PropType<ImageCropPosition>;
maskColor: {
type: PropType<ImageCropMaskColor>;
default: () => number[];
};
crossOrigin: {
type: PropType<ImageCropCrossOrigin>;
default: string;
validator: (value: string) => boolean;
};
droppable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onMousemove?: ((...args: any[]) => any) | undefined;
onMouseup?: ((...args: any[]) => any) | undefined;
"onImage-load"?: ((...args: any[]) => any) | undefined;
"onImage-error"?: ((...args: any[]) => any) | undefined;
"onImage-change"?: ((...args: any[]) => any) | undefined;
"onImage-drop"?: ((...args: any[]) => any) | undefined;
"onPosition-change"?: ((...args: any[]) => any) | undefined;
}>, {
border: ImageCropBorder;
borderRadius: number;
rotate: number;
scale: number;
crossOrigin: ImageCropCrossOrigin;
outputSize: ImageCropOutputSize;
maskColor: ImageCropMaskColor;
droppable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type ImageCropBorder = number | [number, number] | number[];

declare type ImageCropCrossOrigin = '' | 'anonymous' | 'use-credentials';

declare type ImageCropMaskColor = string | number[];

declare type ImageCropOutputSize = number | [number] | [number, number] | number[];

declare interface ImageCropPosition {
    x: number;
    y: number;
}

declare type ImageCropSource = string | Blob | File;

export declare type ImageEnhancer = (imageData: ImageData, options?: ImageProcessorOptions) => ImageData | void | Promise<ImageData | void>;

export declare const ImagePreview: {
    open: (options: {
        [key: string]: any;
        current?: number;
        data: any[];
        onClose?: any;
    }) => Promise<void>;
};

export declare const ImageProcessor: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    src: {
    type: PropType<ImageProcessorSource>;
    default: undefined;
    };
    outputSize: {
    type: PropType<ImageProcessorOutputSize>;
    default: number;
    };
    enhancer: {
    type: PropType<"cutout" | "gray" | ImageEnhancer>;
    default: undefined;
    };
    options: {
    type: PropType<ImageProcessorOptions>;
    default: () => {};
    };
    crossOrigin: {
    type: PropType<"" | "anonymous" | "use-credentials">;
    default: string;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "error"[], PublicProps, {
    src: ImageProcessorSource;
    options: ImageProcessorOptions;
    crossOrigin: "" | "anonymous" | "use-credentials";
    enhancer: "gray" | "cutout" | ImageEnhancer;
    outputSize: ImageProcessorOutputSize;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    src: {
    type: PropType<ImageProcessorSource>;
    default: undefined;
    };
    outputSize: {
    type: PropType<ImageProcessorOutputSize>;
    default: number;
    };
    enhancer: {
    type: PropType<"cutout" | "gray" | ImageEnhancer>;
    default: undefined;
    };
    options: {
    type: PropType<ImageProcessorOptions>;
    default: () => {};
    };
    crossOrigin: {
    type: PropType<"" | "anonymous" | "use-credentials">;
    default: string;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    src: ImageProcessorSource;
    options: ImageProcessorOptions;
    crossOrigin: "" | "anonymous" | "use-credentials";
    enhancer: "gray" | "cutout" | ImageEnhancer;
    outputSize: ImageProcessorOutputSize;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
src: {
type: PropType<ImageProcessorSource>;
default: undefined;
};
outputSize: {
type: PropType<ImageProcessorOutputSize>;
default: number;
};
enhancer: {
type: PropType<"cutout" | "gray" | ImageEnhancer>;
default: undefined;
};
options: {
type: PropType<ImageProcessorOptions>;
default: () => {};
};
crossOrigin: {
type: PropType<"" | "anonymous" | "use-credentials">;
default: string;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "error"[], "error", {
src: ImageProcessorSource;
options: ImageProcessorOptions;
crossOrigin: "" | "anonymous" | "use-credentials";
enhancer: "gray" | "cutout" | ImageEnhancer;
outputSize: ImageProcessorOutputSize;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    Enhancer: {
        gray: ImageEnhancer;
        cutout: ImageEnhancer;
        getImageData: (source: ImageProcessorSource, outputSize?: ImageProcessorOutputSize, crossOrigin?: CrossOrigin) => Promise<ImageData>;
    };
};

export declare type ImageProcessorOptions = Record<string, any>;

export declare type ImageProcessorOutputSize = number | [number] | [number, number];

export declare type ImageProcessorSource = string | Blob | File | ImageData | CanvasImageSource;

export declare const Input: DefineComponent<ExtractPropTypes<    {
indicator: {
type: PropType<boolean | ({
inline: boolean;
inverted: boolean;
})>;
default: boolean;
};
indicateClass: StringConstructor;
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "clear" | "change" | "blur" | "focus" | "keydown" | "keypress" | "keyup" | "paste" | "enter" | "update:modelValue" | "tip")[], "input" | "clear" | "change" | "blur" | "focus" | "keydown" | "keypress" | "keyup" | "paste" | "enter" | "update:modelValue" | "tip", PublicProps, Readonly<ExtractPropTypes<    {
indicator: {
type: PropType<boolean | ({
inline: boolean;
inverted: boolean;
})>;
default: boolean;
};
indicateClass: StringConstructor;
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onEnter?: ((...args: any[]) => any) | undefined;
onPaste?: ((...args: any[]) => any) | undefined;
onFocus?: ((...args: any[]) => any) | undefined;
onBlur?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
onKeydown?: ((...args: any[]) => any) | undefined;
onKeypress?: ((...args: any[]) => any) | undefined;
onKeyup?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onTip?: ((...args: any[]) => any) | undefined;
}>, {
controllable: boolean;
bytes: boolean;
disabled: boolean;
indicator: boolean | {
inline: boolean;
inverted: boolean;
};
focusEnd: boolean;
clearable: boolean;
afloat: boolean;
allowDispatch: boolean;
styleless: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const InputNumber: DefineComponent<ExtractPropTypes<    {
min: {
type: NumberConstructor;
default: number;
};
max: {
type: NumberConstructor;
default: number;
};
step: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
required: {
type: BooleanConstructor;
default: boolean;
};
precision: {
type: NumberConstructor;
default: number;
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
min: {
type: NumberConstructor;
default: number;
};
max: {
type: NumberConstructor;
default: number;
};
step: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
required: {
type: BooleanConstructor;
default: boolean;
};
precision: {
type: NumberConstructor;
default: number;
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
max: number;
required: boolean;
min: number;
controllable: boolean;
bytes: boolean;
output: string | Function;
disabled: boolean;
step: number | boolean;
nullValue: string | number | Record<string, any>;
focusEnd: boolean;
clearable: boolean;
afloat: boolean;
allowDispatch: boolean;
styleless: boolean;
precision: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const InputSearch: DefineComponent<ExtractPropTypes<    {
enterText: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
enterText: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
controllable: boolean;
bytes: boolean;
disabled: boolean;
focusEnd: boolean;
clearable: boolean;
afloat: boolean;
allowDispatch: boolean;
styleless: boolean;
enterText: string | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Instance {
    options: {
        [x: string]: any;
        locale: {
            name: string;
            vc: TranslatePair;
        };
        Theme?: {
            variables: Record<string, string>;
        } | undefined;
        MListItem?: {
            to: (value: any, instance: ComponentInternalInstance) => any;
        } | undefined;
        Image?: {
            formatter?: ((value: any, type: string, instance: ComponentInternalInstance) => string) | undefined;
        } | undefined;
        FilePreview?: {
            getFileType?: ((source: string) => FilePreviewFileType | null | undefined | void) | undefined;
            getFileName?: ((source: string) => string | null | undefined | void) | undefined;
            enhancer?: ((payload: FilePreviewEnhancerPayload) => unknown) | undefined;
        } | undefined;
        Tour?: {
            cache?: boolean | undefined;
            cacheTypes?: TourEndType[] | undefined;
            getCache?: ((context: {
                cacheKey: string;
            }) => any) | undefined;
            setCache?: ((context: {
                cacheKey: string;
                type: TourEndType;
            }) => any) | undefined;
            onOpen?: ((context: {
                cacheKey?: string;
                steps: TourStepOptions[];
            }) => any) | undefined;
        } | undefined;
    };
    globalEvent: MouseEvent;
    constructor();
    configure(options?: VcOptions): this;
}

declare const KEY_VALUE: {
    children: string;
    label: string;
    value: string;
    disabled: string;
    isLeaf: string;
};

declare class Layout {
    private store;
    private checkpoints;
    private laidSizes;
    private laidOffsets;
    private laidLength;
    private laidCols;
    private laidInverted;
    private laidSource;
    constructor(store: RecycleListStore);
    reset(): void;
    private indexAt;
    private resetIfStale;
    private findDirtyScan;
    private restoreCheckpoint;
    private place;
    private resolveInvertedPositions;
    private commit;
    refresh(): void;
}

declare class Layout_2 {
    table: any;
    store: Store;
    states: {
        height: number | null;
        scrollX: boolean;
        scrollY: boolean;
        bodyWidth: any;
        tableHeight: any;
        headerHeight: number;
        appendHeight: number;
        footerHeight: number;
        bodyHeight: any;
    };
    templateColumns: ComputedRef<string>;
    constructor(store: Store);
    setHeight(value: any, prop?: string): any;
    setMaxHeight(value: any): void;
    updateElsHeight(): any;
    updateColumnsWidth(): void;
    getFillColumn(): TableColumnNodeRaw | undefined;
    syncStickyOffsets(): void;
}

declare class Local {
    private store;
    source: any[] | null;
    originalData: any[];
    total: number;
    buildCount: number;
    constructor(store: RecycleListStore);
    get hasMore(): boolean;
    get builtBase(): number;
    get builtRange(): [number, number];
    setData(data: any[]): boolean;
    write(start: number, items: any[]): void;
    private nextBatch;
    consumePage(): {
        start: number;
        end: number;
        reversed: boolean;
    } | null;
    clear(): void;
}

export declare type LocaleKey = `vc.${string}`;

declare const MActionSheet: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    wrapperStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    scrollRegExp: {
    type: ObjectConstructor;
    default: () => {
    className: RegExp;
    };
    };
    title: {
    type: PropType<ActionSheetContent>;
    default: string;
    };
    data: {
    type: PropType<ActionSheetAction[]>;
    default: () => never[];
    };
    cancelText: {
    type: StringConstructor;
    default: string;
    };
    }>> & Readonly<{
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "portal-fulfilled"[], PublicProps, {
    data: ActionSheetAction[];
    mask: boolean;
    title: ActionSheetContent;
    cancelText: string;
    maskClosable: boolean;
    scrollRegExp: Record<string, any>;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    wrapperStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    scrollRegExp: {
    type: ObjectConstructor;
    default: () => {
    className: RegExp;
    };
    };
    title: {
    type: PropType<ActionSheetContent>;
    default: string;
    };
    data: {
    type: PropType<ActionSheetAction[]>;
    default: () => never[];
    };
    cancelText: {
    type: StringConstructor;
    default: string;
    };
    }>> & Readonly<{
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    data: ActionSheetAction[];
    mask: boolean;
    title: ActionSheetContent;
    cancelText: string;
    maskClosable: boolean;
    scrollRegExp: Record<string, any>;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
scrollRegExp: {
type: ObjectConstructor;
default: () => {
className: RegExp;
};
};
title: {
type: PropType<ActionSheetContent>;
default: string;
};
data: {
type: PropType<ActionSheetAction[]>;
default: () => never[];
};
cancelText: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "portal-fulfilled"[], "portal-fulfilled", {
data: ActionSheetAction[];
mask: boolean;
title: ActionSheetContent;
cancelText: string;
maskClosable: boolean;
scrollRegExp: Record<string, any>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options?: Options) => PortalLeaf;
    popup: (options?: Options) => PortalLeaf;
    destroy: () => void;
};
export { MActionSheet as ActionSheet }
export { MActionSheet }

export declare const MAffix: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
zIndex: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
placement: {
type: StringConstructor;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
offset: {
type: NumberConstructor;
default: number;
};
target: {
type: StringConstructor;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | JSX.Element | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
zIndex: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
placement: {
type: StringConstructor;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
offset: {
type: NumberConstructor;
default: number;
};
target: {
type: StringConstructor;
};
}>> & Readonly<{
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
fixed: boolean;
offset: number;
zIndex: string | number;
disabled: boolean;
placement: string;
modelValue: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MAlert: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: PropType<"success" | "info" | "error" | "warning">;
default: string;
};
title: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
icon: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: PropType<"success" | "info" | "error" | "warning">;
default: string;
};
title: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
icon: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
type: "error" | "info" | "warning" | "success";
title: string;
description: string;
icon: string | boolean;
closable: boolean;
modelValue: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Manager {
    icons: {
        [key: string]: {
            viewBox: string;
            path: string[];
        };
    };
    events: {
        [key: string]: Function[];
    };
    sourceStatus: {
        [key: string]: Promise<void>;
    };
    basicStatus?: Promise<void>;
    loading: number;
    constructor();
    load(url: string): Promise<void>;
    parser(svgStr: string, url: string): Promise<typeof IconManager['icons']>;
    on(type?: string, fn?: Function): this;
    private limit;
    off(type?: string, fn?: Function): this;
    private clearResource;
}

export declare const Marquee: DefineComponent<ExtractPropTypes<    {
speed: {
type: NumberConstructor;
default: number;
};
content: (FunctionConstructor | StringConstructor)[];
animated: {
type: BooleanConstructor;
default: boolean;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
speed: {
type: NumberConstructor;
default: number;
};
content: (FunctionConstructor | StringConstructor)[];
animated: {
type: BooleanConstructor;
default: boolean;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
autoplay: boolean;
speed: number;
animated: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MArtboard: DefineComponent<ExtractPropTypes<    {
options: ObjectConstructor;
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
options: ObjectConstructor;
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
height: number;
width: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MButton: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
type: {
type: PropType<"default" | "primary" | "text" | "success" | "error" | "warning">;
default: string;
};
size: {
type: PropType<"small" | "medium" | "large">;
default: string;
};
wait: {
type: NumberConstructor;
default: number;
};
icon: StringConstructor;
disabled: BooleanConstructor;
circle: BooleanConstructor;
round: BooleanConstructor;
long: BooleanConstructor;
solid: BooleanConstructor;
dashed: BooleanConstructor;
htmlType: {
type: PropType<"button" | "submit" | "reset">;
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
type: {
type: PropType<"default" | "primary" | "text" | "success" | "error" | "warning">;
default: string;
};
size: {
type: PropType<"small" | "medium" | "large">;
default: string;
};
wait: {
type: NumberConstructor;
default: number;
};
icon: StringConstructor;
disabled: BooleanConstructor;
circle: BooleanConstructor;
round: BooleanConstructor;
long: BooleanConstructor;
solid: BooleanConstructor;
dashed: BooleanConstructor;
htmlType: {
type: PropType<"button" | "submit" | "reset">;
default: string;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
long: boolean;
type: "default" | "error" | "text" | "warning" | "success" | "primary";
size: "small" | "medium" | "large";
round: boolean;
circle: boolean;
disabled: boolean;
tag: string;
dashed: boolean;
solid: boolean;
wait: number;
htmlType: "button" | "reset" | "submit";
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MButtonGroup: DefineComponent<ExtractPropTypes<    {
vertical: {
type: BooleanConstructor;
default: boolean;
};
circle: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: StringConstructor;
default: string;
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | JSX.Element | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
vertical: {
type: BooleanConstructor;
default: boolean;
};
circle: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: StringConstructor;
default: string;
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
size: string;
circle: boolean;
vertical: boolean;
fragment: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCalendar: DefineComponent<ExtractPropTypes<    {
renderDate: {
type: PropType<CalendarRender<RenderDateProps>>;
default: ({ cell, today }: RenderDateProps) => JSX.Element;
};
renderMonth: {
type: PropType<CalendarRender<RenderMonthProps>>;
default: ({ data }: RenderMonthProps) => JSX.Element;
};
renderWeek: {
type: PropType<CalendarRender<RenderWeekProps>>;
default: ({ data }: RenderWeekProps) => JSX.Element;
};
firstDayOfWeek: {
type: NumberConstructor;
default: number;
validator: (value: number) => boolean;
};
showAdjacentWeeks: {
type: PropType<CalendarAdjacentWeeks>;
default: () => boolean[];
validator: (value: CalendarAdjacentWeeks) => boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
renderDate: {
type: PropType<CalendarRender<RenderDateProps>>;
default: ({ cell, today }: RenderDateProps) => JSX.Element;
};
renderMonth: {
type: PropType<CalendarRender<RenderMonthProps>>;
default: ({ data }: RenderMonthProps) => JSX.Element;
};
renderWeek: {
type: PropType<CalendarRender<RenderWeekProps>>;
default: ({ data }: RenderWeekProps) => JSX.Element;
};
firstDayOfWeek: {
type: NumberConstructor;
default: number;
validator: (value: number) => boolean;
};
showAdjacentWeeks: {
type: PropType<CalendarAdjacentWeeks>;
default: () => boolean[];
validator: (value: CalendarAdjacentWeeks) => boolean;
};
}>> & Readonly<{}>, {
renderDate: CalendarRender<RenderDateProps>;
renderMonth: CalendarRender<RenderMonthProps>;
renderWeek: CalendarRender<RenderWeekProps>;
firstDayOfWeek: number;
showAdjacentWeeks: CalendarAdjacentWeeks;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCard: DefineComponent<ExtractPropTypes<    {
border: {
type: BooleanConstructor;
default: boolean;
};
shadow: {
type: BooleanConstructor;
default: boolean;
};
padding: {
type: NumberConstructor;
default: number;
};
title: {
type: StringConstructor;
};
icon: {
type: StringConstructor;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
border: {
type: BooleanConstructor;
default: boolean;
};
shadow: {
type: BooleanConstructor;
default: boolean;
};
padding: {
type: NumberConstructor;
default: number;
};
title: {
type: StringConstructor;
};
icon: {
type: StringConstructor;
};
}>> & Readonly<{}>, {
border: boolean;
padding: number;
shadow: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCarousel: DefineComponent<ExtractPropTypes<    {
dots: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
indicator: {
type: BooleanConstructor;
default: boolean;
};
t: {
type: NumberConstructor;
default: number;
};
card: BooleanConstructor;
gap: {
type: NumberConstructor;
default: number;
};
height: (StringConstructor | NumberConstructor)[];
initialIndex: {
type: NumberConstructor;
default: number;
};
trigger: {
type: StringConstructor;
default: string;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
arrow: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
loop: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "change"[], "change", PublicProps, Readonly<ExtractPropTypes<    {
dots: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
indicator: {
type: BooleanConstructor;
default: boolean;
};
t: {
type: NumberConstructor;
default: number;
};
card: BooleanConstructor;
gap: {
type: NumberConstructor;
default: number;
};
height: (StringConstructor | NumberConstructor)[];
initialIndex: {
type: NumberConstructor;
default: number;
};
trigger: {
type: StringConstructor;
default: string;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
arrow: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
loop: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
}>, {
gap: number;
draggable: boolean;
vertical: boolean;
autoplay: boolean;
loop: boolean;
arrow: string | boolean;
t: number;
card: boolean;
initialIndex: number;
trigger: string;
dots: string | boolean;
indicator: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCarouselItem: DefineComponent<ExtractPropTypes<    {
name: StringConstructor;
label: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
width: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
gap: {
type: NumberConstructor;
default: number;
};
scale: {
type: NumberConstructor;
default: number;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: StringConstructor;
label: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
width: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
gap: {
type: NumberConstructor;
default: number;
};
scale: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
width: string | number;
gap: number;
scale: number;
label: string | number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCascader: DefineComponent<ExtractPropTypes<    {
data: {
type: PropType<TreeData[]>;
default: () => never[];
};
formatter: {
type: FunctionConstructor;
default: (v: any[]) => string;
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "close" | "ready" | "update:modelValue" | "visible-change")[], "change" | "close" | "ready" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: PropType<TreeData[]>;
default: () => never[];
};
formatter: {
type: FunctionConstructor;
default: (v: any[]) => string;
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: TreeData[];
disabled: boolean;
tag: string;
extra: string;
separator: string;
placement: string;
arrow: boolean;
formatter: Function;
portal: boolean;
trigger: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
maxTagLines: number;
searchable: boolean;
changeOnSelect: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MChart: DefineComponent<ExtractPropTypes<    {
options: ObjectConstructor;
pluginOptions: ObjectConstructor;
theme: (ObjectConstructor | StringConstructor)[];
group: StringConstructor;
resize: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
watchShallow: BooleanConstructor;
manualUpdate: BooleanConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, string[], string, PublicProps, Readonly<ExtractPropTypes<    {
options: ObjectConstructor;
pluginOptions: ObjectConstructor;
theme: (ObjectConstructor | StringConstructor)[];
group: StringConstructor;
resize: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
watchShallow: BooleanConstructor;
manualUpdate: BooleanConstructor;
}>> & Readonly<{
[x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
}>, {
resize: number | boolean;
watchShallow: boolean;
manualUpdate: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCheckbox: DefineComponent<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
name: StringConstructor;
checkedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
uncheckedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
name: StringConstructor;
checkedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
uncheckedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
value: string | number | boolean;
label: string | number | boolean;
disabled: boolean;
indeterminate: boolean;
modelValue: string | number | boolean;
checkedValue: string | number | boolean;
uncheckedValue: string | number | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCheckboxGroup: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: ArrayConstructor;
default: () => never[];
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | JSX.Element | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: ArrayConstructor;
default: () => never[];
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
modelValue: unknown[];
fragment: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MClipboard: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    value: StringConstructor;
    tag: {
    type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
    default: string;
    };
    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    tag: string | Function | Record<string, any>;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    value: StringConstructor;
    tag: {
    type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
    default: string;
    };
    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, {
    tag: string | Function | Record<string, any>;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
value: StringConstructor;
tag: {
type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
default: string;
};
}>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
tag: string | Function | Record<string, any>;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    get: () => Promise<string>;
    set: (value: string) => any;
    clear: () => any;
    clearSelection: () => (() => void) | undefined;
};

export declare const MCollapse: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
accordion: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | NumberConstructor | ArrayConstructor)[];
};
alive: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
accordion: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | NumberConstructor | ArrayConstructor)[];
};
alive: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
tag: string;
alive: boolean;
styleless: boolean;
accordion: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCollapseItem: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: {
type: (StringConstructor | NumberConstructor)[];
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: {
type: (StringConstructor | NumberConstructor)[];
};
}>> & Readonly<{}>, {
tag: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MColorPicker: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    trigger: {
    type: StringConstructor;
    default: string;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    size: {
    type: PropType<"large" | "medium" | "small">;
    default: string;
    validator: (v: string) => boolean;
    };
    editable: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: {
    type: StringConstructor;
    default: string;
    };
    panel: {
    type: BooleanConstructor;
    default: boolean;
    };
    alpha: {
    type: BooleanConstructor;
    default: boolean;
    };
    hue: {
    type: BooleanConstructor;
    default: boolean;
    };
    recommend: {
    type: BooleanConstructor;
    default: boolean;
    };
    colors: {
    type: PropType<string[]>;
    default: () => never[];
    };
    format: {
    type: PropType<ColorFormat>;
    validator: (v: string) => boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    "onColor-change"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "close" | "ready" | "update:modelValue" | "visible-change" | "color-change")[], PublicProps, {
    alpha: boolean;
    size: "small" | "medium" | "large";
    hue: boolean;
    disabled: boolean;
    arrow: boolean;
    modelValue: string;
    trigger: string;
    panel: boolean;
    recommend: boolean;
    colors: string[];
    editable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    trigger: {
    type: StringConstructor;
    default: string;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    size: {
    type: PropType<"large" | "medium" | "small">;
    default: string;
    validator: (v: string) => boolean;
    };
    editable: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: {
    type: StringConstructor;
    default: string;
    };
    panel: {
    type: BooleanConstructor;
    default: boolean;
    };
    alpha: {
    type: BooleanConstructor;
    default: boolean;
    };
    hue: {
    type: BooleanConstructor;
    default: boolean;
    };
    recommend: {
    type: BooleanConstructor;
    default: boolean;
    };
    colors: {
    type: PropType<string[]>;
    default: () => never[];
    };
    format: {
    type: PropType<ColorFormat>;
    validator: (v: string) => boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    "onColor-change"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    alpha: boolean;
    size: "small" | "medium" | "large";
    hue: boolean;
    disabled: boolean;
    arrow: boolean;
    modelValue: string;
    trigger: string;
    panel: boolean;
    recommend: boolean;
    colors: string[];
    editable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
trigger: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: PropType<"large" | "medium" | "small">;
default: string;
validator: (v: string) => boolean;
};
editable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: StringConstructor;
default: string;
};
panel: {
type: BooleanConstructor;
default: boolean;
};
alpha: {
type: BooleanConstructor;
default: boolean;
};
hue: {
type: BooleanConstructor;
default: boolean;
};
recommend: {
type: BooleanConstructor;
default: boolean;
};
colors: {
type: PropType<string[]>;
default: () => never[];
};
format: {
type: PropType<ColorFormat>;
validator: (v: string) => boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
"onColor-change"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "close" | "ready" | "update:modelValue" | "visible-change" | "color-change")[], "change" | "close" | "ready" | "update:modelValue" | "visible-change" | "color-change", {
alpha: boolean;
size: "small" | "medium" | "large";
hue: boolean;
disabled: boolean;
arrow: boolean;
modelValue: string;
trigger: string;
panel: boolean;
recommend: boolean;
colors: string[];
editable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    View: DefineComponent<ExtractPropTypes<    {
    modelValue: {
    type: StringConstructor;
    default: string;
    };
    panel: {
    type: BooleanConstructor;
    default: boolean;
    };
    alpha: {
    type: BooleanConstructor;
    default: boolean;
    };
    hue: {
    type: BooleanConstructor;
    default: boolean;
    };
    recommend: {
    type: BooleanConstructor;
    default: boolean;
    };
    colors: {
    type: PropType<string[]>;
    default: () => never[];
    };
    format: {
    type: PropType<ColorFormat>;
    validator: (v: string) => boolean;
    };
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
    modelValue: {
    type: StringConstructor;
    default: string;
    };
    panel: {
    type: BooleanConstructor;
    default: boolean;
    };
    alpha: {
    type: BooleanConstructor;
    default: boolean;
    };
    hue: {
    type: BooleanConstructor;
    default: boolean;
    };
    recommend: {
    type: BooleanConstructor;
    default: boolean;
    };
    colors: {
    type: PropType<string[]>;
    default: () => never[];
    };
    format: {
    type: PropType<ColorFormat>;
    validator: (v: string) => boolean;
    };
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }>, {
    alpha: boolean;
    hue: boolean;
    modelValue: string;
    panel: boolean;
    recommend: boolean;
    colors: string[];
    }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
    Color: Color;
};

export declare const MColorPickerView: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: StringConstructor;
default: string;
};
panel: {
type: BooleanConstructor;
default: boolean;
};
alpha: {
type: BooleanConstructor;
default: boolean;
};
hue: {
type: BooleanConstructor;
default: boolean;
};
recommend: {
type: BooleanConstructor;
default: boolean;
};
colors: {
type: PropType<string[]>;
default: () => never[];
};
format: {
type: PropType<ColorFormat>;
validator: (v: string) => boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: StringConstructor;
default: string;
};
panel: {
type: BooleanConstructor;
default: boolean;
};
alpha: {
type: BooleanConstructor;
default: boolean;
};
hue: {
type: BooleanConstructor;
default: boolean;
};
recommend: {
type: BooleanConstructor;
default: boolean;
};
colors: {
type: PropType<string[]>;
default: () => never[];
};
format: {
type: PropType<ColorFormat>;
validator: (v: string) => boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
alpha: boolean;
hue: boolean;
modelValue: string;
panel: boolean;
recommend: boolean;
colors: string[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCountdown: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
format: {
type: StringConstructor;
default: undefined;
};
t: {
type: NumberConstructor;
default: number;
};
targetTime: {
type: (StringConstructor | NumberConstructor | DateConstructor)[];
default: string;
};
serverTime: {
type: (StringConstructor | NumberConstructor | DateConstructor)[];
default: string;
};
render: FunctionConstructor;
trim: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "change" | "complete")[], "error" | "change" | "complete", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
format: {
type: StringConstructor;
default: undefined;
};
t: {
type: NumberConstructor;
default: number;
};
targetTime: {
type: (StringConstructor | NumberConstructor | DateConstructor)[];
default: string;
};
serverTime: {
type: (StringConstructor | NumberConstructor | DateConstructor)[];
default: string;
};
render: FunctionConstructor;
trim: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
}>, {
trim: boolean;
format: string;
tag: string;
t: number;
targetTime: string | number | Date;
serverTime: string | number | Date;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCounter: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: (StringConstructor | NumberConstructor)[];
placeholder: StringConstructor;
precision: {
type: NumberConstructor;
default: number;
};
duration: {
type: NumberConstructor;
default: number;
};
decimal: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerals: {
type: () => string[];
default: () => never[];
};
smartEasingThreshold: {
type: NumberConstructor;
default: number;
};
smartEasingAmount: {
type: NumberConstructor;
default: number;
};
easing: {
type: (FunctionConstructor | BooleanConstructor)[];
default: boolean;
};
zeroless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
render: FunctionConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "complete" | "begin")[], "change" | "complete" | "begin", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: (StringConstructor | NumberConstructor)[];
placeholder: StringConstructor;
precision: {
type: NumberConstructor;
default: number;
};
duration: {
type: NumberConstructor;
default: number;
};
decimal: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerals: {
type: () => string[];
default: () => never[];
};
smartEasingThreshold: {
type: NumberConstructor;
default: number;
};
smartEasingAmount: {
type: NumberConstructor;
default: number;
};
easing: {
type: (FunctionConstructor | BooleanConstructor)[];
default: boolean;
};
zeroless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
render: FunctionConstructor;
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
onBegin?: ((...args: any[]) => any) | undefined;
}>, {
decimal: string;
easing: boolean | Function;
controllable: boolean;
tag: string;
separator: string;
duration: number;
precision: number;
numerals: string[];
smartEasingThreshold: number;
smartEasingAmount: number;
zeroless: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MCustomer: DefineComponent<ExtractPropTypes<    {
render: {
type: Render;
default: () => null;
};
}>, () => any, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
render: {
type: Render;
default: () => null;
};
}>> & Readonly<{}>, {
render: (props: Record<string, unknown>, context: SetupContext) => any;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MDatePicker: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    cancelText: StringConstructor;
    okText: StringConstructor;
    extra: StringConstructor;
    formatter: PropType<(value: any, format: string, dates: Date[]) => any>;
    type: {
    type: PropType<MDatePickerType>;
    default: string;
    validator: (value: string) => boolean;
    };
    format: StringConstructor;
    modelValue: PropType<Date | Date[] | string | string[]>;
    nullValue: {
    type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
    default: string;
    };
    minDate: {
    type: DateConstructor;
    default: () => Date;
    };
    maxDate: {
    type: DateConstructor;
    default: () => Date;
    };
    startHour: {
    type: NumberConstructor;
    default: number;
    };
    endHour: {
    type: NumberConstructor;
    default: number;
    };
    title: {
    type: StringConstructor;
    default: string;
    };
    showToolbar: {
    type: BooleanConstructor;
    default: boolean;
    };
    label: StringConstructor;
    arrow: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    labelWidth: {
    type: (StringConstructor | NumberConstructor)[];
    default: string;
    };
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    "onPicker-change"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "change" | "close" | "ok" | "update:modelValue" | "visible-change" | "picker-change")[], PublicProps, {
    type: MDatePickerType;
    title: string;
    arrow: string | boolean;
    nullValue: string | number | Record<string, any>;
    labelWidth: string | number;
    showToolbar: boolean;
    minDate: Date;
    maxDate: Date;
    startHour: number;
    endHour: number;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    cancelText: StringConstructor;
    okText: StringConstructor;
    extra: StringConstructor;
    formatter: PropType<(value: any, format: string, dates: Date[]) => any>;
    type: {
    type: PropType<MDatePickerType>;
    default: string;
    validator: (value: string) => boolean;
    };
    format: StringConstructor;
    modelValue: PropType<Date | Date[] | string | string[]>;
    nullValue: {
    type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
    default: string;
    };
    minDate: {
    type: DateConstructor;
    default: () => Date;
    };
    maxDate: {
    type: DateConstructor;
    default: () => Date;
    };
    startHour: {
    type: NumberConstructor;
    default: number;
    };
    endHour: {
    type: NumberConstructor;
    default: number;
    };
    title: {
    type: StringConstructor;
    default: string;
    };
    showToolbar: {
    type: BooleanConstructor;
    default: boolean;
    };
    label: StringConstructor;
    arrow: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    labelWidth: {
    type: (StringConstructor | NumberConstructor)[];
    default: string;
    };
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    "onPicker-change"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    type: MDatePickerType;
    title: string;
    arrow: string | boolean;
    nullValue: string | number | Record<string, any>;
    labelWidth: string | number;
    showToolbar: boolean;
    minDate: Date;
    maxDate: Date;
    startHour: number;
    endHour: number;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
cancelText: StringConstructor;
okText: StringConstructor;
extra: StringConstructor;
formatter: PropType<(value: any, format: string, dates: Date[]) => any>;
type: {
type: PropType<MDatePickerType>;
default: string;
validator: (value: string) => boolean;
};
format: StringConstructor;
modelValue: PropType<Date | Date[] | string | string[]>;
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
minDate: {
type: DateConstructor;
default: () => Date;
};
maxDate: {
type: DateConstructor;
default: () => Date;
};
startHour: {
type: NumberConstructor;
default: number;
};
endHour: {
type: NumberConstructor;
default: number;
};
title: {
type: StringConstructor;
default: string;
};
showToolbar: {
type: BooleanConstructor;
default: boolean;
};
label: StringConstructor;
arrow: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
labelWidth: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
"onPicker-change"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "change" | "close" | "ok" | "update:modelValue" | "visible-change" | "picker-change")[], "cancel" | "change" | "close" | "ok" | "update:modelValue" | "visible-change" | "picker-change", {
type: MDatePickerType;
title: string;
arrow: string | boolean;
nullValue: string | number | Record<string, any>;
labelWidth: string | number;
showToolbar: boolean;
minDate: Date;
maxDate: Date;
startHour: number;
endHour: number;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options?: Record<string, any>) => PortalLeaf;
    View: DefineComponent<ExtractPropTypes<    {
    modelValue: PropType<Date | Date[] | string | string[]>;
    type: {
    type: PropType<MDatePickerType>;
    default: string;
    validator: (value: string) => boolean;
    };
    format: StringConstructor;
    minDate: {
    type: DateConstructor;
    default: () => Date;
    };
    maxDate: {
    type: DateConstructor;
    default: () => Date;
    };
    startHour: {
    type: NumberConstructor;
    default: number;
    };
    endHour: {
    type: NumberConstructor;
    default: number;
    };
    allowDispatch: {
    type: BooleanConstructor;
    default: boolean;
    };
    nullValue: {
    type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
    default: string;
    };
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "picker-change")[], "change" | "update:modelValue" | "picker-change", PublicProps, Readonly<ExtractPropTypes<    {
    modelValue: PropType<Date | Date[] | string | string[]>;
    type: {
    type: PropType<MDatePickerType>;
    default: string;
    validator: (value: string) => boolean;
    };
    format: StringConstructor;
    minDate: {
    type: DateConstructor;
    default: () => Date;
    };
    maxDate: {
    type: DateConstructor;
    default: () => Date;
    };
    startHour: {
    type: NumberConstructor;
    default: number;
    };
    endHour: {
    type: NumberConstructor;
    default: number;
    };
    allowDispatch: {
    type: BooleanConstructor;
    default: boolean;
    };
    nullValue: {
    type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
    default: string;
    };
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onPicker-change"?: ((...args: any[]) => any) | undefined;
    }>, {
    type: MDatePickerType;
    nullValue: string | number | Record<string, any>;
    allowDispatch: boolean;
    minDate: Date;
    maxDate: Date;
    startHour: number;
    endHour: number;
    }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};

declare type MDatePickerType = 'datetime' | 'date' | 'time' | 'yearmonth' | 'year' | 'month' | 'quarter';

export declare const MDatePickerView: DefineComponent<ExtractPropTypes<    {
modelValue: PropType<Date | Date[] | string | string[]>;
type: {
type: PropType<MDatePickerType>;
default: string;
validator: (value: string) => boolean;
};
format: StringConstructor;
minDate: {
type: DateConstructor;
default: () => Date;
};
maxDate: {
type: DateConstructor;
default: () => Date;
};
startHour: {
type: NumberConstructor;
default: number;
};
endHour: {
type: NumberConstructor;
default: number;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "picker-change")[], "change" | "update:modelValue" | "picker-change", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: PropType<Date | Date[] | string | string[]>;
type: {
type: PropType<MDatePickerType>;
default: string;
validator: (value: string) => boolean;
};
format: StringConstructor;
minDate: {
type: DateConstructor;
default: () => Date;
};
maxDate: {
type: DateConstructor;
default: () => Date;
};
startHour: {
type: NumberConstructor;
default: number;
};
endHour: {
type: NumberConstructor;
default: number;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onPicker-change"?: ((...args: any[]) => any) | undefined;
}>, {
type: MDatePickerType;
nullValue: string | number | Record<string, any>;
allowDispatch: boolean;
minDate: Date;
maxDate: Date;
startHour: number;
endHour: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MDefer: DefineComponent<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: never[];
};
primaryKey: {
type: StringConstructor;
default: string;
};
concurrency: {
type: NumberConstructor;
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
once: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element[], {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("progress" | "complete")[], "progress" | "complete", PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: never[];
};
primaryKey: {
type: StringConstructor;
default: string;
};
concurrency: {
type: NumberConstructor;
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
once: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onProgress?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
}>, {
once: boolean;
data: unknown[];
disabled: boolean;
primaryKey: string;
concurrency: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MDivider: DefineComponent<ExtractPropTypes<    {
vertical: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
validator(val: string): boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
vertical: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
validator(val: string): boolean;
};
}>> & Readonly<{}>, {
vertical: boolean;
placement: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MDrawer: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    title: PropType<string | boolean | Props_3["render"]>;
    content: {
    type: PropType<string | Props_3["render"]>;
    default: string;
    };
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    width: {
    type: NumberConstructor;
    default: number;
    };
    height: {
    type: NumberConstructor;
    default: number;
    };
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    placement: {
    type: StringConstructor;
    default: string;
    };
    maskStyle: (ObjectConstructor | StringConstructor)[];
    wrapperClass: (ObjectConstructor | StringConstructor)[];
    wrapperStyle: (ObjectConstructor | StringConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    closeWithCancel: {
    type: BooleanConstructor;
    default: boolean;
    };
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    okDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    cancelDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    onOk: {
    type: FunctionConstructor;
    };
    onCancel: {
    type: FunctionConstructor;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], PublicProps, {
    height: number;
    width: number;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    cancelText: string | boolean;
    okText: string | boolean;
    placement: string;
    maskClosable: boolean;
    scrollable: boolean;
    modelValue: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    title: PropType<string | boolean | Props_3["render"]>;
    content: {
    type: PropType<string | Props_3["render"]>;
    default: string;
    };
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    width: {
    type: NumberConstructor;
    default: number;
    };
    height: {
    type: NumberConstructor;
    default: number;
    };
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    placement: {
    type: StringConstructor;
    default: string;
    };
    maskStyle: (ObjectConstructor | StringConstructor)[];
    wrapperClass: (ObjectConstructor | StringConstructor)[];
    wrapperStyle: (ObjectConstructor | StringConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    closeWithCancel: {
    type: BooleanConstructor;
    default: boolean;
    };
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    okDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    cancelDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    onOk: {
    type: FunctionConstructor;
    };
    onCancel: {
    type: FunctionConstructor;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    height: number;
    width: number;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    cancelText: string | boolean;
    okText: string | boolean;
    placement: string;
    maskClosable: boolean;
    scrollable: boolean;
    modelValue: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
title: PropType<string | boolean | Props_3["render"]>;
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
placement: {
type: StringConstructor;
default: string;
};
maskStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], "close" | "update:modelValue" | "visible-change" | "portal-fulfilled", {
height: number;
width: number;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
cancelText: string | boolean;
okText: string | boolean;
placement: string;
maskClosable: boolean;
scrollable: boolean;
modelValue: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options: Partial<{
        height: number;
        width: number;
        content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
        mask: boolean;
        footer: boolean;
        placement: string;
        maskClosable: boolean;
        scrollable: boolean;
        modelValue: boolean;
        closeWithCancel: boolean;
        okDisabled: boolean;
        cancelDisabled: boolean;
    } & {
        title?: string | boolean | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        onCancel?: Function | undefined;
        cancelText?: string | boolean | undefined;
        okText?: string | boolean | undefined;
        contentClass?: string | Record<string, any> | undefined;
        contentStyle?: string | Record<string, any> | undefined;
        maskStyle?: string | Record<string, any> | undefined;
        wrapperClass?: string | Record<string, any> | undefined;
        wrapperStyle?: string | Record<string, any> | undefined;
        scrollerOptions?: Partial<ScrollerProps> | undefined;
        onOk?: Function | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>) => PortalLeaf;
    destroy: () => void;
};

export declare const MDrawerView: DefineComponent<ExtractPropTypes<    {
title: PropType<string | boolean | Props_3["render"]>;
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
placement: {
type: StringConstructor;
default: string;
};
maskStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], "close" | "update:modelValue" | "visible-change" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
title: PropType<string | boolean | Props_3["render"]>;
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
placement: {
type: StringConstructor;
default: string;
};
maskStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, {
height: number;
width: number;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
cancelText: string | boolean;
okText: string | boolean;
placement: string;
maskClosable: boolean;
scrollable: boolean;
modelValue: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MDropdown: DefineComponent<ExtractPropTypes<    {
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
modelValue: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor)[];
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("click" | "close" | "ready" | "update:modelValue" | "visible-change")[], "click" | "close" | "ready" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
modelValue: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor)[];
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
placement: string;
arrow: boolean;
scrollable: boolean;
modelValue: boolean;
trigger: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MDropdownItem: DefineComponent<ExtractPropTypes<    {
value: {
type: (StringConstructor | NumberConstructor)[];
value: undefined;
};
label: {
type: (StringConstructor | NumberConstructor)[];
value: undefined;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
selected: {
type: BooleanConstructor;
default: boolean;
};
divided: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: (StringConstructor | NumberConstructor)[];
value: undefined;
};
label: {
type: (StringConstructor | NumberConstructor)[];
value: undefined;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
selected: {
type: BooleanConstructor;
default: boolean;
};
divided: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
disabled: boolean;
selected: boolean;
closable: boolean;
divided: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MDropdownMenu: DefineComponent<    {}, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Measuring: DefineComponent<    {}, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MEditor: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: StringConstructor;
default: string;
};
options: ObjectConstructor;
disabled: {
type: BooleanConstructor;
default: boolean;
};
uploadOptions: {
type: ObjectConstructor;
default: () => {
file: {};
image: {};
video: {};
};
};
register: FunctionConstructor;
poster: FunctionConstructor;
enhancer: {
type: (FunctionConstructor | BooleanConstructor)[];
default: boolean;
};
previewable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "change" | "blur" | "focus" | "ready" | "update:modelValue")[], "input" | "change" | "blur" | "focus" | "ready" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: StringConstructor;
default: string;
};
options: ObjectConstructor;
disabled: {
type: BooleanConstructor;
default: boolean;
};
uploadOptions: {
type: ObjectConstructor;
default: () => {
file: {};
image: {};
video: {};
};
};
register: FunctionConstructor;
poster: FunctionConstructor;
enhancer: {
type: (FunctionConstructor | BooleanConstructor)[];
default: boolean;
};
previewable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onFocus?: ((...args: any[]) => any) | undefined;
onBlur?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
disabled: boolean;
modelValue: string;
enhancer: boolean | Function;
uploadOptions: Record<string, any>;
previewable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MEditorView: DefineComponent<ExtractPropTypes<    {
value: {
type: StringConstructor;
default: undefined;
};
fontSize: {
type: PropType<string[]>;
default: () => string[];
};
lineHeight: {
type: PropType<string[]>;
default: () => string[];
};
letterSpacing: {
type: PropType<string[]>;
default: () => string[];
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: StringConstructor;
default: undefined;
};
fontSize: {
type: PropType<string[]>;
default: () => string[];
};
lineHeight: {
type: PropType<string[]>;
default: () => string[];
};
letterSpacing: {
type: PropType<string[]>;
default: () => string[];
};
}>> & Readonly<{}>, {
fontSize: string[];
letterSpacing: string[];
lineHeight: string[];
value: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Message: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_3["render"]>;
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    fixed: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    top: {
    type: NumberConstructor;
    default: number;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    default: string;
    validator: (v: string) => boolean;
    };
    onBeforeClose: FunctionConstructor;
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onBefore-close"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], PublicProps, {
    fixed: boolean;
    top: number;
    mask: boolean;
    mode: "error" | "info" | "loading" | "warning" | "success";
    duration: number;
    closable: boolean;
    maskClosable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_3["render"]>;
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    fixed: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    top: {
    type: NumberConstructor;
    default: number;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    default: string;
    validator: (v: string) => boolean;
    };
    onBeforeClose: FunctionConstructor;
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onBefore-close"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    fixed: boolean;
    top: number;
    mask: boolean;
    mode: "error" | "info" | "loading" | "warning" | "success";
    duration: number;
    closable: boolean;
    maskClosable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
top: {
type: NumberConstructor;
default: number;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (v: string) => boolean;
};
onBeforeClose: FunctionConstructor;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onBefore-close"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], "close" | "portal-fulfilled" | "before-close", {
fixed: boolean;
top: number;
mask: boolean;
mode: "error" | "info" | "loading" | "warning" | "success";
duration: number;
closable: boolean;
maskClosable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    destroy: () => void;
    info: (...params: Array<Options_3[keyof Options_3] | Options_3>) => PortalLeaf;
    success: (...params: Array<Options_3[keyof Options_3] | Options_3>) => PortalLeaf;
    loading: (...params: Array<Options_3[keyof Options_3] | Options_3>) => PortalLeaf;
    warning: (...params: Array<Options_3[keyof Options_3] | Options_3>) => PortalLeaf;
    error: (...params: Array<Options_3[keyof Options_3] | Options_3>) => PortalLeaf;
};

export declare const MessageView: DefineComponent<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
top: {
type: NumberConstructor;
default: number;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (v: string) => boolean;
};
onBeforeClose: FunctionConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], "close" | "portal-fulfilled" | "before-close", PublicProps, Readonly<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
top: {
type: NumberConstructor;
default: number;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (v: string) => boolean;
};
onBeforeClose: FunctionConstructor;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onBefore-close"?: ((...args: any[]) => any) | undefined;
}>, {
fixed: boolean;
top: number;
mask: boolean;
mode: "error" | "info" | "loading" | "warning" | "success";
duration: number;
closable: boolean;
maskClosable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MExpand: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
alive: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
alive: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
tag: string;
modelValue: boolean;
alive: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MFilePreview: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    data: {
    type: PropType<FilePreviewData>;
    default: () => never[];
    };
    type: {
    type: PropType<"group" | "mix">;
    default: string;
    validator: (v: string) => boolean;
    };
    size: {
    type: PropType<"small" | "medium" | "large" | "mini">;
    default: string;
    validator: (v: string) => boolean;
    };
    vertical: {
    type: BooleanConstructor;
    default: boolean;
    };
    previewable: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    type: "group" | "mix";
    data: FilePreviewData;
    size: "small" | "medium" | "large" | "mini";
    vertical: boolean;
    previewable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    data: {
    type: PropType<FilePreviewData>;
    default: () => never[];
    };
    type: {
    type: PropType<"group" | "mix">;
    default: string;
    validator: (v: string) => boolean;
    };
    size: {
    type: PropType<"small" | "medium" | "large" | "mini">;
    default: string;
    validator: (v: string) => boolean;
    };
    vertical: {
    type: BooleanConstructor;
    default: boolean;
    };
    previewable: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, {
    type: "group" | "mix";
    data: FilePreviewData;
    size: "small" | "medium" | "large" | "mini";
    vertical: boolean;
    previewable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
data: {
type: PropType<FilePreviewData>;
default: () => never[];
};
type: {
type: PropType<"group" | "mix">;
default: string;
validator: (v: string) => boolean;
};
size: {
type: PropType<"small" | "medium" | "large" | "mini">;
default: string;
validator: (v: string) => boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
previewable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
type: "group" | "mix";
data: FilePreviewData;
size: "small" | "medium" | "large" | "mini";
vertical: boolean;
previewable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options: FilePreviewOpenOptions) => Promise<void>;
};

export declare const MForm: DefineComponent<ExtractPropTypes<    {
showToast: {
type: BooleanConstructor;
default: boolean;
};
border: {
type: BooleanConstructor;
default: boolean;
};
tag: {
type: StringConstructor;
default: string;
};
model: {
type: ObjectConstructor;
};
rules: {
type: PropType<Record<string, FormRule>>;
};
labelWidth: {
type: NumberConstructor;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
inline: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"left" | "right" | "top">;
default: string;
};
autocomplete: {
type: PropType<"on" | "off">;
default: string;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
errorStyle: (ObjectConstructor | StringConstructor)[];
errorClass: (ObjectConstructor | StringConstructor)[];
nestedContentStyle: (ObjectConstructor | StringConstructor)[];
nestedContentClass: (ObjectConstructor | StringConstructor)[];
nestedLabelStyle: (ObjectConstructor | StringConstructor)[];
nestedLabelClass: (ObjectConstructor | StringConstructor)[];
nestedErrorStyle: (ObjectConstructor | StringConstructor)[];
nestedErrorClass: (ObjectConstructor | StringConstructor)[];
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
showToast: {
type: BooleanConstructor;
default: boolean;
};
border: {
type: BooleanConstructor;
default: boolean;
};
tag: {
type: StringConstructor;
default: string;
};
model: {
type: ObjectConstructor;
};
rules: {
type: PropType<Record<string, FormRule>>;
};
labelWidth: {
type: NumberConstructor;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
inline: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"left" | "right" | "top">;
default: string;
};
autocomplete: {
type: PropType<"on" | "off">;
default: string;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
errorStyle: (ObjectConstructor | StringConstructor)[];
errorClass: (ObjectConstructor | StringConstructor)[];
nestedContentStyle: (ObjectConstructor | StringConstructor)[];
nestedContentClass: (ObjectConstructor | StringConstructor)[];
nestedLabelStyle: (ObjectConstructor | StringConstructor)[];
nestedLabelClass: (ObjectConstructor | StringConstructor)[];
nestedErrorStyle: (ObjectConstructor | StringConstructor)[];
nestedErrorClass: (ObjectConstructor | StringConstructor)[];
}>> & Readonly<{}>, {
inline: boolean;
border: boolean;
autocomplete: "off" | "on";
tag: string;
styleless: boolean;
showMessage: boolean;
labelPosition: "left" | "top" | "right";
showToast: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MFormItem: DefineComponent<ExtractPropTypes<    {
indent: {
type: NumberConstructor;
default: number;
};
label: {
type: StringConstructor;
default: string;
};
labelWidth: {
type: NumberConstructor;
};
prop: {
type: StringConstructor;
};
required: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
asterisk: {
type: BooleanConstructor;
default: boolean;
};
error: {
type: StringConstructor;
};
rules: {
type: PropType<FormRule | FormRule[]>;
};
resetByRulesChanged: {
type: BooleanConstructor;
default: boolean;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
labelFor: {
type: StringConstructor;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"left" | "right" | "top">;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
errorStyle: (ObjectConstructor | StringConstructor)[];
errorClass: (ObjectConstructor | StringConstructor)[];
}>, () => JSX.Element | (VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | undefined)[], {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
indent: {
type: NumberConstructor;
default: number;
};
label: {
type: StringConstructor;
default: string;
};
labelWidth: {
type: NumberConstructor;
};
prop: {
type: StringConstructor;
};
required: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
asterisk: {
type: BooleanConstructor;
default: boolean;
};
error: {
type: StringConstructor;
};
rules: {
type: PropType<FormRule | FormRule[]>;
};
resetByRulesChanged: {
type: BooleanConstructor;
default: boolean;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
labelFor: {
type: StringConstructor;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"left" | "right" | "top">;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
errorStyle: (ObjectConstructor | StringConstructor)[];
errorClass: (ObjectConstructor | StringConstructor)[];
}>> & Readonly<{}>, {
required: string | boolean;
label: string;
styleless: boolean;
showMessage: boolean;
indent: number;
asterisk: boolean;
resetByRulesChanged: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MFragment: DefineComponent<    {}, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MIcon: DefineComponent<ExtractPropTypes<    {
type: StringConstructor;
inherit: {
type: BooleanConstructor;
default: boolean;
};
color: StringConstructor;
size: PropType<IconSize>;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: StringConstructor;
inherit: {
type: BooleanConstructor;
default: boolean;
};
color: StringConstructor;
size: PropType<IconSize>;
}>> & Readonly<{}>, {
inherit: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MImage: DefineComponent<ExtractPropTypes<    {
src: StringConstructor;
thumbnail: StringConstructor;
fit: StringConstructor;
lazy: BooleanConstructor;
wrapper: (ObjectConstructor | StringConstructor)[];
previewable: {
type: BooleanConstructor;
default: boolean;
};
formatter: FunctionConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
src: StringConstructor;
thumbnail: StringConstructor;
fit: StringConstructor;
lazy: BooleanConstructor;
wrapper: (ObjectConstructor | StringConstructor)[];
previewable: {
type: BooleanConstructor;
default: boolean;
};
formatter: FunctionConstructor;
}>> & Readonly<{}>, {
lazy: boolean;
previewable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MImageCrop: DefineComponent<ExtractPropTypes<    {
src: PropType<ImageCropSource>;
scale: {
type: NumberConstructor;
default: number;
};
rotate: {
type: NumberConstructor;
default: number;
};
border: {
type: PropType<ImageCropBorder>;
default: number;
};
borderRadius: {
type: NumberConstructor;
default: number;
};
outputSize: {
type: PropType<ImageCropOutputSize>;
default: number;
};
position: PropType<ImageCropPosition>;
maskColor: {
type: PropType<ImageCropMaskColor>;
default: () => number[];
};
crossOrigin: {
type: PropType<ImageCropCrossOrigin>;
default: string;
validator: (value: string) => boolean;
};
droppable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("mousemove" | "mouseup" | "image-load" | "image-error" | "image-change" | "image-drop" | "position-change")[], "mousemove" | "mouseup" | "image-load" | "image-error" | "image-change" | "image-drop" | "position-change", PublicProps, Readonly<ExtractPropTypes<    {
src: PropType<ImageCropSource>;
scale: {
type: NumberConstructor;
default: number;
};
rotate: {
type: NumberConstructor;
default: number;
};
border: {
type: PropType<ImageCropBorder>;
default: number;
};
borderRadius: {
type: NumberConstructor;
default: number;
};
outputSize: {
type: PropType<ImageCropOutputSize>;
default: number;
};
position: PropType<ImageCropPosition>;
maskColor: {
type: PropType<ImageCropMaskColor>;
default: () => number[];
};
crossOrigin: {
type: PropType<ImageCropCrossOrigin>;
default: string;
validator: (value: string) => boolean;
};
droppable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onMousemove?: ((...args: any[]) => any) | undefined;
onMouseup?: ((...args: any[]) => any) | undefined;
"onImage-load"?: ((...args: any[]) => any) | undefined;
"onImage-error"?: ((...args: any[]) => any) | undefined;
"onImage-change"?: ((...args: any[]) => any) | undefined;
"onImage-drop"?: ((...args: any[]) => any) | undefined;
"onPosition-change"?: ((...args: any[]) => any) | undefined;
}>, {
border: ImageCropBorder;
borderRadius: number;
rotate: number;
scale: number;
crossOrigin: ImageCropCrossOrigin;
outputSize: ImageCropOutputSize;
maskColor: ImageCropMaskColor;
droppable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MImagePreview: {
    open: (options: {
        [key: string]: any;
        current?: number;
        data: any[];
        onClose?: any;
    }) => Promise<void>;
};

export declare const MImageProcessor: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    src: {
    type: PropType<ImageProcessorSource>;
    default: undefined;
    };
    outputSize: {
    type: PropType<ImageProcessorOutputSize>;
    default: number;
    };
    enhancer: {
    type: PropType<"cutout" | "gray" | ImageEnhancer>;
    default: undefined;
    };
    options: {
    type: PropType<ImageProcessorOptions>;
    default: () => {};
    };
    crossOrigin: {
    type: PropType<"" | "anonymous" | "use-credentials">;
    default: string;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "error"[], PublicProps, {
    src: ImageProcessorSource;
    options: ImageProcessorOptions;
    crossOrigin: "" | "anonymous" | "use-credentials";
    enhancer: "gray" | "cutout" | ImageEnhancer;
    outputSize: ImageProcessorOutputSize;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    src: {
    type: PropType<ImageProcessorSource>;
    default: undefined;
    };
    outputSize: {
    type: PropType<ImageProcessorOutputSize>;
    default: number;
    };
    enhancer: {
    type: PropType<"cutout" | "gray" | ImageEnhancer>;
    default: undefined;
    };
    options: {
    type: PropType<ImageProcessorOptions>;
    default: () => {};
    };
    crossOrigin: {
    type: PropType<"" | "anonymous" | "use-credentials">;
    default: string;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    src: ImageProcessorSource;
    options: ImageProcessorOptions;
    crossOrigin: "" | "anonymous" | "use-credentials";
    enhancer: "gray" | "cutout" | ImageEnhancer;
    outputSize: ImageProcessorOutputSize;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
src: {
type: PropType<ImageProcessorSource>;
default: undefined;
};
outputSize: {
type: PropType<ImageProcessorOutputSize>;
default: number;
};
enhancer: {
type: PropType<"cutout" | "gray" | ImageEnhancer>;
default: undefined;
};
options: {
type: PropType<ImageProcessorOptions>;
default: () => {};
};
crossOrigin: {
type: PropType<"" | "anonymous" | "use-credentials">;
default: string;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "error"[], "error", {
src: ImageProcessorSource;
options: ImageProcessorOptions;
crossOrigin: "" | "anonymous" | "use-credentials";
enhancer: "gray" | "cutout" | ImageEnhancer;
outputSize: ImageProcessorOutputSize;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    Enhancer: {
        gray: ImageEnhancer;
        cutout: ImageEnhancer;
        getImageData: (source: ImageProcessorSource, outputSize?: ImageProcessorOutputSize, crossOrigin?: "" | "anonymous" | "use-credentials") => Promise<ImageData>;
    };
};

export declare const MInput: DefineComponent<ExtractPropTypes<    {
right: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "clear" | "change" | "blur" | "focus" | "keydown" | "keypress" | "keyup" | "paste" | "enter" | "update:modelValue" | "tip")[], "input" | "clear" | "change" | "blur" | "focus" | "keydown" | "keypress" | "keyup" | "paste" | "enter" | "update:modelValue" | "tip", PublicProps, Readonly<ExtractPropTypes<    {
right: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onEnter?: ((...args: any[]) => any) | undefined;
onPaste?: ((...args: any[]) => any) | undefined;
onFocus?: ((...args: any[]) => any) | undefined;
onBlur?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
onKeydown?: ((...args: any[]) => any) | undefined;
onKeypress?: ((...args: any[]) => any) | undefined;
onKeyup?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onTip?: ((...args: any[]) => any) | undefined;
}>, {
controllable: boolean;
bytes: boolean;
right: boolean;
disabled: boolean;
focusEnd: boolean;
clearable: boolean;
afloat: boolean;
allowDispatch: boolean;
styleless: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MInputNumber: DefineComponent<ExtractPropTypes<    {
min: {
type: NumberConstructor;
default: number;
};
max: {
type: NumberConstructor;
default: number;
};
step: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
required: {
type: BooleanConstructor;
default: boolean;
};
precision: {
type: NumberConstructor;
default: number;
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
min: {
type: NumberConstructor;
default: number;
};
max: {
type: NumberConstructor;
default: number;
};
step: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
required: {
type: BooleanConstructor;
default: boolean;
};
precision: {
type: NumberConstructor;
default: number;
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
max: number;
required: boolean;
min: number;
controllable: boolean;
bytes: boolean;
output: string | Function;
disabled: boolean;
step: number | boolean;
nullValue: string | number | Record<string, any>;
focusEnd: boolean;
clearable: boolean;
afloat: boolean;
allowDispatch: boolean;
styleless: boolean;
precision: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MInputSearch: DefineComponent<ExtractPropTypes<    {
cancelText: {
type: StringConstructor;
default: undefined;
};
enterText: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
cancelText: {
type: StringConstructor;
default: undefined;
};
enterText: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
modelValue: PropType<string | number | any[]>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
focusEnd: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
id: {
type: StringConstructor;
};
prepend: {
type: StringConstructor;
};
append: {
type: StringConstructor;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
inputId: {
type: StringConstructor;
};
inputStyle: {
type: PropType<StyleValue>;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
styleless: {
type: BooleanConstructor;
default: boolean;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
controllable: boolean;
bytes: boolean;
disabled: boolean;
cancelText: string;
focusEnd: boolean;
clearable: boolean;
afloat: boolean;
allowDispatch: boolean;
styleless: boolean;
enterText: string | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const MList: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
labelWidth: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
border: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
labelWidth: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
border: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
border: boolean;
tag: string;
labelWidth: string | number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { MList as List }
export { MList }

declare const MListItem: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
label: StringConstructor;
labelWidth: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
extra: StringConstructor;
arrow: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
multiple: {
type: BooleanConstructor;
default: boolean;
};
indent: {
type: NumberConstructor;
default: number;
};
to: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
href: StringConstructor;
alone: BooleanConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "click"[], "click", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
label: StringConstructor;
labelWidth: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
extra: StringConstructor;
arrow: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
multiple: {
type: BooleanConstructor;
default: boolean;
};
indent: {
type: NumberConstructor;
default: number;
};
to: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
href: StringConstructor;
alone: BooleanConstructor;
}>> & Readonly<{
onClick?: ((...args: any[]) => any) | undefined;
}>, {
multiple: boolean;
tag: string;
arrow: string | boolean;
alone: boolean;
labelWidth: string | number;
indent: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { MListItem as ListItem }
export { MListItem }

export declare const MMarquee: DefineComponent<ExtractPropTypes<    {
speed: {
type: NumberConstructor;
default: number;
};
content: (FunctionConstructor | StringConstructor)[];
animated: {
type: BooleanConstructor;
default: boolean;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
speed: {
type: NumberConstructor;
default: number;
};
content: (FunctionConstructor | StringConstructor)[];
animated: {
type: BooleanConstructor;
default: boolean;
};
autoplay: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
autoplay: boolean;
speed: number;
animated: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MMeasuring: DefineComponent<    {}, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MMessage: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_3["render"]>;
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    fixed: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    top: {
    type: NumberConstructor;
    default: number;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    default: string;
    validator: (v: string) => boolean;
    };
    onBeforeClose: FunctionConstructor;
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onBefore-close"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], PublicProps, {
    fixed: boolean;
    top: number;
    mask: boolean;
    mode: "error" | "info" | "loading" | "warning" | "success";
    duration: number;
    closable: boolean;
    maskClosable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_3["render"]>;
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    fixed: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    top: {
    type: NumberConstructor;
    default: number;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    default: string;
    validator: (v: string) => boolean;
    };
    onBeforeClose: FunctionConstructor;
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onBefore-close"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    fixed: boolean;
    top: number;
    mask: boolean;
    mode: "error" | "info" | "loading" | "warning" | "success";
    duration: number;
    closable: boolean;
    maskClosable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
top: {
type: NumberConstructor;
default: number;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (v: string) => boolean;
};
onBeforeClose: FunctionConstructor;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onBefore-close"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], "close" | "portal-fulfilled" | "before-close", {
fixed: boolean;
top: number;
mask: boolean;
mode: "error" | "info" | "loading" | "warning" | "success";
duration: number;
closable: boolean;
maskClosable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    destroy: () => void;
    info: (...params: Array<(string | number | boolean | Function | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        fixed: boolean;
        top: number;
        mask: boolean;
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        closable: boolean;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
    success: (...params: Array<(string | number | boolean | Function | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        fixed: boolean;
        top: number;
        mask: boolean;
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        closable: boolean;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
    loading: (...params: Array<(string | number | boolean | Function | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        fixed: boolean;
        top: number;
        mask: boolean;
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        closable: boolean;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
    warning: (...params: Array<(string | number | boolean | Function | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        fixed: boolean;
        top: number;
        mask: boolean;
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        closable: boolean;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
    error: (...params: Array<(string | number | boolean | Function | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        fixed: boolean;
        top: number;
        mask: boolean;
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        closable: boolean;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
};

declare namespace MModal {
    export {
        destroy,
        alert_2 as alert,
        operation,
        MModal_2 as MModal
    }
}
export { MModal }

declare const MModal_2: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    mode: {
    type: PropType<"alert" | "operation">;
    validator: (v: any) => boolean;
    default: string;
    };
    content: {
    type: PropType<boolean | string | Props_3["render"]>;
    };
    width: {
    type: NumberConstructor;
    default: number;
    };
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    closeWithCancel: {
    type: BooleanConstructor;
    default: boolean;
    };
    title: {
    type: PropType<boolean | string | Props_3["render"]>;
    };
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    wrapperStyle: {
    type: ObjectConstructor;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    data: ArrayConstructor;
    onOk: {
    type: FunctionConstructor;
    };
    onCancel: {
    type: FunctionConstructor;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled")[], PublicProps, {
    width: number;
    mask: boolean;
    footer: boolean;
    mode: "alert" | "operation";
    cancelText: string | boolean;
    okText: string | boolean;
    maskClosable: boolean;
    modelValue: boolean;
    closeWithCancel: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    mode: {
    type: PropType<"alert" | "operation">;
    validator: (v: any) => boolean;
    default: string;
    };
    content: {
    type: PropType<boolean | string | Props_3["render"]>;
    };
    width: {
    type: NumberConstructor;
    default: number;
    };
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    closeWithCancel: {
    type: BooleanConstructor;
    default: boolean;
    };
    title: {
    type: PropType<boolean | string | Props_3["render"]>;
    };
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    wrapperStyle: {
    type: ObjectConstructor;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    data: ArrayConstructor;
    onOk: {
    type: FunctionConstructor;
    };
    onCancel: {
    type: FunctionConstructor;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    width: number;
    mask: boolean;
    footer: boolean;
    mode: "alert" | "operation";
    cancelText: string | boolean;
    okText: string | boolean;
    maskClosable: boolean;
    modelValue: boolean;
    closeWithCancel: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
mode: {
type: PropType<"alert" | "operation">;
validator: (v: any) => boolean;
default: string;
};
content: {
type: PropType<boolean | string | Props_3["render"]>;
};
width: {
type: NumberConstructor;
default: number;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: PropType<boolean | string | Props_3["render"]>;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
wrapperStyle: {
type: ObjectConstructor;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
data: ArrayConstructor;
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled")[], "cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled", {
width: number;
mask: boolean;
footer: boolean;
mode: "alert" | "operation";
cancelText: string | boolean;
okText: string | boolean;
maskClosable: boolean;
modelValue: boolean;
closeWithCancel: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    destroy: () => void;
    alert: (options: Options_5) => PortalLeaf;
    operation: (options: Options_5) => PortalLeaf;
};

export declare const MModalView: DefineComponent<ExtractPropTypes<    {
mode: {
type: PropType<"alert" | "operation">;
validator: (v: any) => boolean;
default: string;
};
content: {
type: PropType<boolean | string | Props_3["render"]>;
};
width: {
type: NumberConstructor;
default: number;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: PropType<boolean | string | Props_3["render"]>;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
wrapperStyle: {
type: ObjectConstructor;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
data: ArrayConstructor;
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled")[], "cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
mode: {
type: PropType<"alert" | "operation">;
validator: (v: any) => boolean;
default: string;
};
content: {
type: PropType<boolean | string | Props_3["render"]>;
};
width: {
type: NumberConstructor;
default: number;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: PropType<boolean | string | Props_3["render"]>;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
wrapperStyle: {
type: ObjectConstructor;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
data: ArrayConstructor;
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, {
width: number;
mask: boolean;
footer: boolean;
mode: "alert" | "operation";
cancelText: string | boolean;
okText: string | boolean;
maskClosable: boolean;
modelValue: boolean;
closeWithCancel: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MNotice: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    title: PropType<string | Props_3["render"]>;
    content: PropType<string | Props_3["render"]>;
    duration: {
    type: NumberConstructor;
    default: number;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    validator: (v: string) => boolean;
    };
    top: {
    type: NumberConstructor;
    default: number;
    };
    fixed: {
    type: BooleanConstructor;
    default: boolean;
    };
    onBeforeClose: FunctionConstructor;
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onBefore-close"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], PublicProps, {
    fixed: boolean;
    top: number;
    duration: number;
    closable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    title: PropType<string | Props_3["render"]>;
    content: PropType<string | Props_3["render"]>;
    duration: {
    type: NumberConstructor;
    default: number;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    validator: (v: string) => boolean;
    };
    top: {
    type: NumberConstructor;
    default: number;
    };
    fixed: {
    type: BooleanConstructor;
    default: boolean;
    };
    onBeforeClose: FunctionConstructor;
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onBefore-close"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    fixed: boolean;
    top: number;
    duration: number;
    closable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
title: PropType<string | Props_3["render"]>;
content: PropType<string | Props_3["render"]>;
duration: {
type: NumberConstructor;
default: number;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
validator: (v: string) => boolean;
};
top: {
type: NumberConstructor;
default: number;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
onBeforeClose: FunctionConstructor;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onBefore-close"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], "close" | "portal-fulfilled" | "before-close", {
fixed: boolean;
top: number;
duration: number;
closable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    destroy: () => void;
    open: (options: Partial<{
        fixed: boolean;
        top: number;
        duration: number;
        closable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        title?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        mode?: "error" | "info" | "loading" | "warning" | "success" | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        insertion: PortalOptions["insertion"];
        onClose: (...args: any[]) => any;
    }>) => PortalLeaf;
    info: (options: Partial<{
        fixed: boolean;
        top: number;
        duration: number;
        closable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        title?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        mode?: "error" | "info" | "loading" | "warning" | "success" | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        insertion: PortalOptions["insertion"];
        onClose: (...args: any[]) => any;
    }>) => PortalLeaf;
    success: (options: Partial<{
        fixed: boolean;
        top: number;
        duration: number;
        closable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        title?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        mode?: "error" | "info" | "loading" | "warning" | "success" | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        insertion: PortalOptions["insertion"];
        onClose: (...args: any[]) => any;
    }>) => PortalLeaf;
    warning: (options: Partial<{
        fixed: boolean;
        top: number;
        duration: number;
        closable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        title?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        mode?: "error" | "info" | "loading" | "warning" | "success" | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        insertion: PortalOptions["insertion"];
        onClose: (...args: any[]) => any;
    }>) => PortalLeaf;
    error: (options: Partial<{
        fixed: boolean;
        top: number;
        duration: number;
        closable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        title?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        mode?: "error" | "info" | "loading" | "warning" | "success" | undefined;
        onBeforeClose?: Function | undefined;
    } & {
        insertion: PortalOptions["insertion"];
        onClose: (...args: any[]) => any;
    }>) => PortalLeaf;
};

export declare const Modal: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "success" | "error" | "warning">;
    validator: (v: string) => boolean;
    };
    content: {
    type: PropType<string | Props_3["render"]>;
    default: string;
    };
    size: {
    type: PropType<"small" | "medium" | "large">;
    validator: (v: string) => boolean;
    default: string;
    };
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    width: {
    type: NumberConstructor;
    };
    height: {
    type: PropType<number | "auto">;
    };
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    escClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    closeWithCancel: {
    type: BooleanConstructor;
    default: boolean;
    };
    title: {
    type: PropType<string | Props_3["render"]>;
    };
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    draggable: {
    type: BooleanConstructor;
    default: boolean;
    };
    x: NumberConstructor;
    y: NumberConstructor;
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    wrapperStyle: (ObjectConstructor | StringConstructor)[];
    wrapperClass: (ObjectConstructor | StringConstructor)[];
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    border: {
    type: BooleanConstructor;
    default: boolean;
    };
    okDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    cancelDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    onOk: {
    type: FunctionConstructor;
    };
    onCancel: {
    type: FunctionConstructor;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], PublicProps, {
    size: "small" | "medium" | "large";
    border: boolean;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    draggable: boolean;
    cancelText: string | boolean;
    okText: string | boolean;
    closable: boolean;
    maskClosable: boolean;
    escClosable: boolean;
    scrollable: boolean;
    modelValue: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "success" | "error" | "warning">;
    validator: (v: string) => boolean;
    };
    content: {
    type: PropType<string | Props_3["render"]>;
    default: string;
    };
    size: {
    type: PropType<"small" | "medium" | "large">;
    validator: (v: string) => boolean;
    default: string;
    };
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    width: {
    type: NumberConstructor;
    };
    height: {
    type: PropType<number | "auto">;
    };
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    escClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    closeWithCancel: {
    type: BooleanConstructor;
    default: boolean;
    };
    title: {
    type: PropType<string | Props_3["render"]>;
    };
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    draggable: {
    type: BooleanConstructor;
    default: boolean;
    };
    x: NumberConstructor;
    y: NumberConstructor;
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    wrapperStyle: (ObjectConstructor | StringConstructor)[];
    wrapperClass: (ObjectConstructor | StringConstructor)[];
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    border: {
    type: BooleanConstructor;
    default: boolean;
    };
    okDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    cancelDisabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    onOk: {
    type: FunctionConstructor;
    };
    onCancel: {
    type: FunctionConstructor;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    size: "small" | "medium" | "large";
    border: boolean;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    draggable: boolean;
    cancelText: string | boolean;
    okText: string | boolean;
    closable: boolean;
    maskClosable: boolean;
    escClosable: boolean;
    scrollable: boolean;
    modelValue: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "success" | "error" | "warning">;
validator: (v: string) => boolean;
};
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
size: {
type: PropType<"small" | "medium" | "large">;
validator: (v: string) => boolean;
default: string;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
width: {
type: NumberConstructor;
};
height: {
type: PropType<number | "auto">;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: PropType<string | Props_3["render"]>;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
draggable: {
type: BooleanConstructor;
default: boolean;
};
x: NumberConstructor;
y: NumberConstructor;
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
wrapperStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
footer: {
type: BooleanConstructor;
default: boolean;
};
border: {
type: BooleanConstructor;
default: boolean;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], "cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "portal-fulfilled", {
size: "small" | "medium" | "large";
border: boolean;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
draggable: boolean;
cancelText: string | boolean;
okText: string | boolean;
closable: boolean;
maskClosable: boolean;
escClosable: boolean;
scrollable: boolean;
modelValue: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    destroy: () => void;
    info: (options: Options_4) => PortalLeaf;
    success: (options: Options_4) => PortalLeaf;
    warning: (options: Options_4) => PortalLeaf;
    error: (options: Options_4) => PortalLeaf;
};

export declare const ModalView: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "success" | "error" | "warning">;
validator: (v: string) => boolean;
};
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
size: {
type: PropType<"small" | "medium" | "large">;
validator: (v: string) => boolean;
default: string;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
width: {
type: NumberConstructor;
};
height: {
type: PropType<number | "auto">;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: PropType<string | Props_3["render"]>;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
draggable: {
type: BooleanConstructor;
default: boolean;
};
x: NumberConstructor;
y: NumberConstructor;
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
wrapperStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
footer: {
type: BooleanConstructor;
default: boolean;
};
border: {
type: BooleanConstructor;
default: boolean;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], "cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "success" | "error" | "warning">;
validator: (v: string) => boolean;
};
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
size: {
type: PropType<"small" | "medium" | "large">;
validator: (v: string) => boolean;
default: string;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
width: {
type: NumberConstructor;
};
height: {
type: PropType<number | "auto">;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
closeWithCancel: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: PropType<string | Props_3["render"]>;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
draggable: {
type: BooleanConstructor;
default: boolean;
};
x: NumberConstructor;
y: NumberConstructor;
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
wrapperStyle: (ObjectConstructor | StringConstructor)[];
wrapperClass: (ObjectConstructor | StringConstructor)[];
footer: {
type: BooleanConstructor;
default: boolean;
};
border: {
type: BooleanConstructor;
default: boolean;
};
okDisabled: {
type: BooleanConstructor;
default: boolean;
};
cancelDisabled: {
type: BooleanConstructor;
default: boolean;
};
onOk: {
type: FunctionConstructor;
};
onCancel: {
type: FunctionConstructor;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, {
size: "small" | "medium" | "large";
border: boolean;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
draggable: boolean;
cancelText: string | boolean;
okText: string | boolean;
closable: boolean;
maskClosable: boolean;
escClosable: boolean;
scrollable: boolean;
modelValue: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MOption: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
tag: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MPagination: DefineComponent<ExtractPropTypes<    {
current: {
type: NumberConstructor;
default: number;
};
count: {
type: NumberConstructor;
default: number;
};
pageSize: {
type: NumberConstructor;
default: number;
};
pageSizeOptions: {
type: ArrayConstructor;
default: () => number[];
};
placement: {
type: StringConstructor;
default: string;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
showCount: {
type: BooleanConstructor;
default: boolean;
};
showElevator: {
type: BooleanConstructor;
default: boolean;
};
showSizer: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:current" | "page-size-change")[], "change" | "update:current" | "page-size-change", PublicProps, Readonly<ExtractPropTypes<    {
current: {
type: NumberConstructor;
default: number;
};
count: {
type: NumberConstructor;
default: number;
};
pageSize: {
type: NumberConstructor;
default: number;
};
pageSizeOptions: {
type: ArrayConstructor;
default: () => number[];
};
placement: {
type: StringConstructor;
default: string;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
showCount: {
type: BooleanConstructor;
default: boolean;
};
showElevator: {
type: BooleanConstructor;
default: boolean;
};
showSizer: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:current"?: ((...args: any[]) => any) | undefined;
"onPage-size-change"?: ((...args: any[]) => any) | undefined;
}>, {
count: number;
pageSize: number;
placement: string;
current: number;
portal: boolean;
pageSizeOptions: unknown[];
showCount: boolean;
showElevator: boolean;
showSizer: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const MPicker: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    modelValue: {
    type: PropType<PickerModelValue>;
    default: () => never[];
    };
    data: {
    type: PropType<PickerSource>;
    default: () => never[];
    };
    columns: {
    type: NumberConstructor;
    default: number;
    };
    itemStyle: PropType<Record<string, any>>;
    cascader: {
    type: BooleanConstructor;
    default: boolean;
    };
    loadData: PropType<() => Promise<any> | any>;
    extra: StringConstructor;
    formatter: {
    type: PropType<(label: any[]) => string>;
    default: (v: any[]) => string;
    };
    label: StringConstructor;
    labelWidth: (StringConstructor | NumberConstructor)[];
    title: {
    type: StringConstructor;
    default: string;
    };
    cancelText: StringConstructor;
    okText: StringConstructor;
    showToolbar: {
    type: BooleanConstructor;
    default: boolean;
    };
    renderLabel: Render;
    separator: {
    type: StringConstructor;
    default: string;
    };
    numerable: {
    type: BooleanConstructor;
    default: boolean;
    };
    nullValue: {
    type: PropType<PickerModelValue>;
    default: undefined;
    };
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    "onPicker-change"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "change" | "close" | "ok" | "update:modelValue" | "visible-change" | "picker-change")[], PublicProps, {
    data: PickerSource;
    columns: number;
    title: string;
    separator: string;
    modelValue: PickerModelValue;
    formatter: (label: any[]) => string;
    numerable: boolean;
    nullValue: PickerModelValue;
    showToolbar: boolean;
    cascader: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    modelValue: {
    type: PropType<PickerModelValue>;
    default: () => never[];
    };
    data: {
    type: PropType<PickerSource>;
    default: () => never[];
    };
    columns: {
    type: NumberConstructor;
    default: number;
    };
    itemStyle: PropType<Record<string, any>>;
    cascader: {
    type: BooleanConstructor;
    default: boolean;
    };
    loadData: PropType<() => Promise<any> | any>;
    extra: StringConstructor;
    formatter: {
    type: PropType<(label: any[]) => string>;
    default: (v: any[]) => string;
    };
    label: StringConstructor;
    labelWidth: (StringConstructor | NumberConstructor)[];
    title: {
    type: StringConstructor;
    default: string;
    };
    cancelText: StringConstructor;
    okText: StringConstructor;
    showToolbar: {
    type: BooleanConstructor;
    default: boolean;
    };
    renderLabel: Render;
    separator: {
    type: StringConstructor;
    default: string;
    };
    numerable: {
    type: BooleanConstructor;
    default: boolean;
    };
    nullValue: {
    type: PropType<PickerModelValue>;
    default: undefined;
    };
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    "onPicker-change"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    data: PickerSource;
    columns: number;
    title: string;
    separator: string;
    modelValue: PickerModelValue;
    formatter: (label: any[]) => string;
    numerable: boolean;
    nullValue: PickerModelValue;
    showToolbar: boolean;
    cascader: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<PickerModelValue>;
default: () => never[];
};
data: {
type: PropType<PickerSource>;
default: () => never[];
};
columns: {
type: NumberConstructor;
default: number;
};
itemStyle: PropType<Record<string, any>>;
cascader: {
type: BooleanConstructor;
default: boolean;
};
loadData: PropType<() => Promise<any> | any>;
extra: StringConstructor;
formatter: {
type: PropType<(label: any[]) => string>;
default: (v: any[]) => string;
};
label: StringConstructor;
labelWidth: (StringConstructor | NumberConstructor)[];
title: {
type: StringConstructor;
default: string;
};
cancelText: StringConstructor;
okText: StringConstructor;
showToolbar: {
type: BooleanConstructor;
default: boolean;
};
renderLabel: Render;
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: PropType<PickerModelValue>;
default: undefined;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
"onPicker-change"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "change" | "close" | "ok" | "update:modelValue" | "visible-change" | "picker-change")[], "cancel" | "change" | "close" | "ok" | "update:modelValue" | "visible-change" | "picker-change", {
data: PickerSource;
columns: number;
title: string;
separator: string;
modelValue: PickerModelValue;
formatter: (label: any[]) => string;
numerable: boolean;
nullValue: PickerModelValue;
showToolbar: boolean;
cascader: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options?: Record<string, any>) => PortalLeaf;
    View: DefineComponent<ExtractPropTypes<    {
    modelValue: {
    type: PropType<PickerModelValue>;
    default: () => never[];
    };
    data: {
    type: PropType<PickerSource>;
    default: () => never[];
    };
    columns: {
    type: NumberConstructor;
    default: number;
    };
    itemStyle: PropType<Record<string, any>>;
    cascader: {
    type: BooleanConstructor;
    default: boolean;
    };
    allowDispatch: {
    type: BooleanConstructor;
    default: boolean;
    };
    renderLabel: Render;
    separator: {
    type: StringConstructor;
    default: string;
    };
    numerable: {
    type: BooleanConstructor;
    default: boolean;
    };
    nullValue: {
    type: PropType<PickerModelValue>;
    default: undefined;
    };
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "picker-change")[], "change" | "update:modelValue" | "picker-change", PublicProps, Readonly<ExtractPropTypes<    {
    modelValue: {
    type: PropType<PickerModelValue>;
    default: () => never[];
    };
    data: {
    type: PropType<PickerSource>;
    default: () => never[];
    };
    columns: {
    type: NumberConstructor;
    default: number;
    };
    itemStyle: PropType<Record<string, any>>;
    cascader: {
    type: BooleanConstructor;
    default: boolean;
    };
    allowDispatch: {
    type: BooleanConstructor;
    default: boolean;
    };
    renderLabel: Render;
    separator: {
    type: StringConstructor;
    default: string;
    };
    numerable: {
    type: BooleanConstructor;
    default: boolean;
    };
    nullValue: {
    type: PropType<PickerModelValue>;
    default: undefined;
    };
    }>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onPicker-change"?: ((...args: any[]) => any) | undefined;
    }>, {
    data: PickerSource;
    columns: number;
    separator: string;
    modelValue: PickerModelValue;
    numerable: boolean;
    nullValue: PickerModelValue;
    allowDispatch: boolean;
    cascader: boolean;
    }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
    Popup: DefineComponent<ExtractPropTypes<    {
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    visible: {
    type: PropType<boolean | undefined>;
    default: undefined;
    };
    title: {
    type: StringConstructor;
    default: string;
    };
    cancelText: StringConstructor;
    okText: StringConstructor;
    showToolbar: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "update:visible")[], "cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "update:visible", PublicProps, Readonly<ExtractPropTypes<    {
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    visible: {
    type: PropType<boolean | undefined>;
    default: undefined;
    };
    title: {
    type: StringConstructor;
    default: string;
    };
    cancelText: StringConstructor;
    okText: StringConstructor;
    showToolbar: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    onCancel?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
    }>, {
    visible: boolean | undefined;
    title: string;
    modelValue: boolean;
    showToolbar: boolean;
    }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
};
export { MPicker }
export { MPicker as Picker }

export declare const MPickerPopup: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: PropType<boolean | undefined>;
default: undefined;
};
title: {
type: StringConstructor;
default: string;
};
cancelText: StringConstructor;
okText: StringConstructor;
showToolbar: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "update:visible")[], "cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "update:visible", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: PropType<boolean | undefined>;
default: undefined;
};
title: {
type: StringConstructor;
default: string;
};
cancelText: StringConstructor;
okText: StringConstructor;
showToolbar: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
"onUpdate:visible"?: ((...args: any[]) => any) | undefined;
}>, {
visible: boolean | undefined;
title: string;
modelValue: boolean;
showToolbar: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MPickerView: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<PickerModelValue>;
default: () => never[];
};
data: {
type: PropType<PickerSource>;
default: () => never[];
};
columns: {
type: NumberConstructor;
default: number;
};
itemStyle: PropType<Record<string, any>>;
cascader: {
type: BooleanConstructor;
default: boolean;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
renderLabel: Render;
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: PropType<PickerModelValue>;
default: undefined;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "picker-change")[], "change" | "update:modelValue" | "picker-change", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<PickerModelValue>;
default: () => never[];
};
data: {
type: PropType<PickerSource>;
default: () => never[];
};
columns: {
type: NumberConstructor;
default: number;
};
itemStyle: PropType<Record<string, any>>;
cascader: {
type: BooleanConstructor;
default: boolean;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
renderLabel: Render;
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: PropType<PickerModelValue>;
default: undefined;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onPicker-change"?: ((...args: any[]) => any) | undefined;
}>, {
data: PickerSource;
columns: number;
separator: string;
modelValue: PickerModelValue;
numerable: boolean;
nullValue: PickerModelValue;
allowDispatch: boolean;
cascader: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MPopconfirm: DefineComponent<ExtractPropTypes<    {
title: {
type: PropType<string | Props_3["render"]>;
default: string;
};
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: undefined;
};
cancelText: {
type: StringConstructor;
default: undefined;
};
okType: {
type: StringConstructor;
default: string;
};
cancelType: {
type: StringConstructor;
default: string;
};
type: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
width: (StringConstructor | NumberConstructor)[];
portalClass: (ObjectConstructor | StringConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change")[], "cancel" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: PropType<string | Props_3["render"]>;
default: string;
};
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: undefined;
};
cancelText: {
type: StringConstructor;
default: undefined;
};
okType: {
type: StringConstructor;
default: string;
};
cancelType: {
type: StringConstructor;
default: string;
};
type: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
width: (StringConstructor | NumberConstructor)[];
portalClass: (ObjectConstructor | StringConstructor)[];
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
title: string | ((props: Record<string, unknown>, context: SetupContext) => any);
cancelText: string;
okText: string;
placement: string;
modelValue: boolean;
trigger: string;
okType: string;
cancelType: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MPopover: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    always: BooleanConstructor;
    animation: StringConstructor;
    content: (FunctionConstructor | StringConstructor)[];
    placement: {
    type: StringConstructor;
    default: string;
    validator: (value: string) => boolean;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    getPopupContainer: FunctionConstructor;
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: BooleanConstructor;
    portal: {
    type: BooleanConstructor;
    default: boolean;
    };
    theme: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    autoWidth: {
    type: BooleanConstructor;
    default: boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    portalStyle: (ObjectConstructor | StringConstructor)[];
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    trigger: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    tag: {
    type: StringConstructor;
    default: string;
    };
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    outsideClickable: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    }>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "ready" | "update:modelValue" | "visible-change")[], PublicProps, {
    always: boolean;
    disabled: boolean;
    tag: string;
    placement: string;
    arrow: boolean;
    scrollable: boolean;
    modelValue: boolean;
    portal: boolean;
    theme: string;
    trigger: string;
    autoWidth: boolean;
    outsideClickable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    always: BooleanConstructor;
    animation: StringConstructor;
    content: (FunctionConstructor | StringConstructor)[];
    placement: {
    type: StringConstructor;
    default: string;
    validator: (value: string) => boolean;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    getPopupContainer: FunctionConstructor;
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: BooleanConstructor;
    portal: {
    type: BooleanConstructor;
    default: boolean;
    };
    theme: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    autoWidth: {
    type: BooleanConstructor;
    default: boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    portalStyle: (ObjectConstructor | StringConstructor)[];
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    trigger: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    tag: {
    type: StringConstructor;
    default: string;
    };
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    outsideClickable: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    }>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, {
    always: boolean;
    disabled: boolean;
    tag: string;
    placement: string;
    arrow: boolean;
    scrollable: boolean;
    modelValue: boolean;
    portal: boolean;
    theme: string;
    trigger: string;
    autoWidth: boolean;
    outsideClickable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
always: BooleanConstructor;
animation: StringConstructor;
content: (FunctionConstructor | StringConstructor)[];
placement: {
type: StringConstructor;
default: string;
validator: (value: string) => boolean;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
getPopupContainer: FunctionConstructor;
scrollable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: BooleanConstructor;
portal: {
type: BooleanConstructor;
default: boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor)[];
scrollerOptions: PropType<Partial<ScrollerProps>>;
trigger: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
tag: {
type: StringConstructor;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
outsideClickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "ready" | "update:modelValue" | "visible-change")[], "close" | "ready" | "update:modelValue" | "visible-change", {
always: boolean;
disabled: boolean;
tag: string;
placement: string;
arrow: boolean;
scrollable: boolean;
modelValue: boolean;
portal: boolean;
theme: string;
trigger: string;
autoWidth: boolean;
outsideClickable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: {
        (): PortalLeaf;
        (options: PortalOptions): PortalLeaf;
        (propsData: Record<string, any>, options: PortalOptions): PortalLeaf;
    };
};

export declare const MPopup: DefineComponent<ExtractPropTypes<    {
fixed: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
validator: (v: any) => boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: any) => boolean;
};
wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
scrollRegExp: {
type: ObjectConstructor;
default: () => {
className: RegExp;
};
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], "close" | "update:modelValue" | "visible-change" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
fixed: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
validator: (v: any) => boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: any) => boolean;
};
wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
scrollRegExp: {
type: ObjectConstructor;
default: () => {
className: RegExp;
};
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, {
fixed: boolean;
mask: boolean;
placement: string;
maskClosable: boolean;
modelValue: boolean;
theme: string;
scrollRegExp: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MPortal: typeof Portal;

export declare const MPrint: DefineComponent<ExtractPropTypes<    {
value: StringConstructor;
tag: {
type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: StringConstructor;
tag: {
type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
default: string;
};
}>> & Readonly<{}>, {
tag: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MProgress: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
validator(val: string): boolean;
default: string;
};
percent: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
status: {
validator(val: string): boolean;
default: string;
};
showText: {
type: BooleanConstructor;
default: boolean;
};
textStyle: {
type: (ObjectConstructor | StringConstructor)[];
};
textClass: {
type: (ObjectConstructor | StringConstructor)[];
};
animated: {
type: BooleanConstructor;
default: boolean;
};
strokeWidth: {
type: NumberConstructor;
default: number;
};
strokeColor: {
type: StringConstructor;
default: string;
};
trackColor: {
type: StringConstructor;
default: string;
};
size: {
type: NumberConstructor;
default: number;
};
color: {
type: (ObjectConstructor | StringConstructor)[];
default: () => {
default: string;
success: string;
error: string;
};
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
validator(val: string): boolean;
default: string;
};
percent: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
status: {
validator(val: string): boolean;
default: string;
};
showText: {
type: BooleanConstructor;
default: boolean;
};
textStyle: {
type: (ObjectConstructor | StringConstructor)[];
};
textClass: {
type: (ObjectConstructor | StringConstructor)[];
};
animated: {
type: BooleanConstructor;
default: boolean;
};
strokeWidth: {
type: NumberConstructor;
default: number;
};
strokeColor: {
type: StringConstructor;
default: string;
};
trackColor: {
type: StringConstructor;
default: string;
};
size: {
type: NumberConstructor;
default: number;
};
color: {
type: (ObjectConstructor | StringConstructor)[];
default: () => {
default: string;
success: string;
error: string;
};
};
}>> & Readonly<{}>, {
percent: string | number;
type: string;
size: number;
color: string | Record<string, any>;
strokeWidth: number;
status: string;
strokeColor: string;
animated: boolean;
showText: boolean;
trackColor: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MRadio: DefineComponent<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
name: {
type: StringConstructor;
};
trueValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
falseValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
name: {
type: StringConstructor;
};
trueValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
falseValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
value: string | number | boolean;
label: string | number | boolean;
disabled: boolean;
modelValue: string | number | boolean;
trueValue: string | number | boolean;
falseValue: string | number | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MRadioButton: DefineComponent<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
name: {
type: StringConstructor;
};
trueValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
falseValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
name: {
type: StringConstructor;
};
trueValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
falseValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
value: string | number | boolean;
label: string | number | boolean;
disabled: boolean;
modelValue: string | number | boolean;
trueValue: string | number | boolean;
falseValue: string | number | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MRadioGroup: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
type: {
type: StringConstructor;
default: string;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
name: {
type: StringConstructor;
default: () => string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | JSX.Element | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
type: {
type: StringConstructor;
default: string;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
name: {
type: StringConstructor;
default: () => string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
name: string;
type: string;
disabled: boolean;
vertical: boolean;
modelValue: string | number;
fragment: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MRate: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
count: {
type: NumberConstructor;
default: number;
};
color: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
character: StringConstructor;
half: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
tooltip: {
type: ArrayConstructor;
default: () => never[];
};
iconStyle: {
type: ObjectConstructor;
default: () => {};
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
count: {
type: NumberConstructor;
default: number;
};
color: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
character: StringConstructor;
half: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
tooltip: {
type: ArrayConstructor;
default: () => never[];
};
iconStyle: {
type: ObjectConstructor;
default: () => {};
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
count: number;
color: string;
disabled: boolean;
icon: string;
tooltip: unknown[];
modelValue: string | number;
clearable: boolean;
iconStyle: Record<string, any>;
half: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MRecycleList: DefineComponent<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: () => never[];
};
store: PropType<RecycleListStore>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
batchCount: {
type: NumberConstructor;
default: number;
};
bufferCount: {
type: NumberConstructor;
default: number;
};
estimateSize: PropType<number | ((data: {
row: any;
index: number;
}) => number | undefined)>;
overscan: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
loadData: {
type: FunctionConstructor;
default: () => boolean;
};
columns: {
type: NumberConstructor;
default: number;
};
gap: {
type: NumberConstructor;
default: number;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
pullable: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
fill: {
type: BooleanConstructor;
default: boolean;
};
lazyTail: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<ScrollerProps>;
renderEmpty: Render;
renderComplete: Render;
renderLoading: Render;
renderPlaceholder: Render;
renderRefresh: Render;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("scroll" | "row-resize" | "load-change")[], "scroll" | "row-resize" | "load-change", PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: () => never[];
};
store: PropType<RecycleListStore>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
batchCount: {
type: NumberConstructor;
default: number;
};
bufferCount: {
type: NumberConstructor;
default: number;
};
estimateSize: PropType<number | ((data: {
row: any;
index: number;
}) => number | undefined)>;
overscan: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
loadData: {
type: FunctionConstructor;
default: () => boolean;
};
columns: {
type: NumberConstructor;
default: number;
};
gap: {
type: NumberConstructor;
default: number;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
pullable: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
fill: {
type: BooleanConstructor;
default: boolean;
};
lazyTail: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<ScrollerProps>;
renderEmpty: Render;
renderComplete: Render;
renderLoading: Render;
renderPlaceholder: Render;
renderRefresh: Render;
}>> & Readonly<{
onScroll?: ((...args: any[]) => any) | undefined;
"onRow-resize"?: ((...args: any[]) => any) | undefined;
"onLoad-change"?: ((...args: any[]) => any) | undefined;
}>, {
fill: boolean;
data: unknown[];
threshold: number;
columns: number;
gap: number;
disabled: boolean;
vertical: boolean;
loadData: Function;
batchCount: number;
bufferCount: number;
inverted: boolean;
overscan: number;
pullable: boolean;
lazyTail: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MResizer: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
fill: {
type: (BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "resize"[], "resize", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
fill: {
type: (BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
}>> & Readonly<{
onResize?: ((...args: any[]) => any) | undefined;
}>, {
fill: boolean | unknown[];
tag: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MScroller: DefineComponent<ExtractPropTypes<    {
always: {
type: BooleanConstructor;
default: boolean;
};
native: {
type: BooleanConstructor;
default: boolean;
};
thumbMinSize: {
type: NumberConstructor;
default: number;
};
thumbStyle: PropType<StyleValue>;
thumbClass: PropType<StyleValue>;
autoResize: {
type: BooleanConstructor;
default: boolean;
};
trackOffsetX: {
type: PropType<number[]>;
default: () => number[];
};
trackOffsetY: {
type: PropType<number[]>;
default: () => number[];
};
trackStyle: PropType<StyleValue>;
trackClass: PropType<StyleValue>;
tag: {
type: StringConstructor;
default: string;
};
height: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
maxHeight: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
wrapperStyle: {
type: PropType<StyleValue>;
default: string;
};
wrapperClass: {
type: PropType<StyleValue>;
default: string;
};
contentStyle: {
type: PropType<StyleValue>;
default: string;
};
contentClass: {
type: PropType<StyleValue>;
default: string;
};
showBar: {
type: BooleanConstructor;
default: boolean;
};
wheel: {
type: BooleanConstructor;
default: boolean;
};
stopPropagation: {
type: BooleanConstructor;
default: boolean;
};
barTo: PropType<string | HTMLElement>;
barTriggerElement: StringConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "scroll"[], "scroll", PublicProps, Readonly<ExtractPropTypes<    {
always: {
type: BooleanConstructor;
default: boolean;
};
native: {
type: BooleanConstructor;
default: boolean;
};
thumbMinSize: {
type: NumberConstructor;
default: number;
};
thumbStyle: PropType<StyleValue>;
thumbClass: PropType<StyleValue>;
autoResize: {
type: BooleanConstructor;
default: boolean;
};
trackOffsetX: {
type: PropType<number[]>;
default: () => number[];
};
trackOffsetY: {
type: PropType<number[]>;
default: () => number[];
};
trackStyle: PropType<StyleValue>;
trackClass: PropType<StyleValue>;
tag: {
type: StringConstructor;
default: string;
};
height: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
maxHeight: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
wrapperStyle: {
type: PropType<StyleValue>;
default: string;
};
wrapperClass: {
type: PropType<StyleValue>;
default: string;
};
contentStyle: {
type: PropType<StyleValue>;
default: string;
};
contentClass: {
type: PropType<StyleValue>;
default: string;
};
showBar: {
type: BooleanConstructor;
default: boolean;
};
wheel: {
type: BooleanConstructor;
default: boolean;
};
stopPropagation: {
type: BooleanConstructor;
default: boolean;
};
barTo: PropType<string | HTMLElement>;
barTriggerElement: StringConstructor;
}>> & Readonly<{
onScroll?: ((...args: any[]) => any) | undefined;
}>, {
always: boolean;
native: boolean;
height: string | number;
maxHeight: string | number;
wheel: boolean;
tag: string;
contentClass: StyleValue;
contentStyle: StyleValue;
wrapperClass: StyleValue;
wrapperStyle: StyleValue;
thumbMinSize: number;
autoResize: boolean;
trackOffsetX: number[];
trackOffsetY: number[];
showBar: boolean;
stopPropagation: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MSelect: DefineComponent<ExtractPropTypes<    {
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
data: {
type: ArrayConstructor;
default: () => never[];
};
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("clear" | "change" | "close" | "ready" | "update:modelValue" | "visible-change")[], "clear" | "change" | "close" | "ready" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
data: {
type: ArrayConstructor;
default: () => never[];
};
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: unknown[];
disabled: boolean;
tag: string;
extra: string;
separator: string;
placement: string;
arrow: boolean;
portal: boolean;
trigger: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
maxTagLines: number;
searchable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MSlider: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<SliderValue>;
default: number;
};
min: {
type: NumberConstructor;
default: number;
};
max: {
type: NumberConstructor;
default: number;
};
step: {
type: NumberConstructor;
default: number;
};
range: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
showStops: {
type: BooleanConstructor;
default: boolean;
};
formatter: {
type: PropType<(value: number) => SliderTipValue>;
default: (value: number) => string;
};
showInput: {
type: BooleanConstructor;
default: boolean;
};
showTip: {
type: PropType<SliderShowTip>;
default: string;
validator: (value: string) => boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "after-change")[], "change" | "update:modelValue" | "after-change", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<SliderValue>;
default: number;
};
min: {
type: NumberConstructor;
default: number;
};
max: {
type: NumberConstructor;
default: number;
};
step: {
type: NumberConstructor;
default: number;
};
range: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
showStops: {
type: BooleanConstructor;
default: boolean;
};
formatter: {
type: PropType<(value: number) => SliderTipValue>;
default: (value: number) => string;
};
showInput: {
type: BooleanConstructor;
default: boolean;
};
showTip: {
type: PropType<SliderShowTip>;
default: string;
validator: (value: string) => boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onAfter-change"?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
min: number;
disabled: boolean;
range: boolean;
step: number;
modelValue: SliderValue;
formatter: (value: number) => SliderTipValue;
clickable: boolean;
showStops: boolean;
showInput: boolean;
showTip: SliderShowTip;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MSnapshot: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
crossOrigin: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
source: FunctionConstructor;
download: FunctionConstructor;
lazy: {
type: BooleanConstructor;
default: boolean;
};
showLoading: {
type: BooleanConstructor;
default: boolean;
};
options: {
type: ObjectConstructor;
default: () => {};
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "ready"[], "ready", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
crossOrigin: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
source: FunctionConstructor;
download: FunctionConstructor;
lazy: {
type: BooleanConstructor;
default: boolean;
};
showLoading: {
type: BooleanConstructor;
default: boolean;
};
options: {
type: ObjectConstructor;
default: () => {};
};
}>> & Readonly<{
onReady?: ((...args: any[]) => any) | undefined;
}>, {
lazy: boolean;
options: Record<string, any>;
tag: string;
crossOrigin: string;
showLoading: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MSortList: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<SortListRow[]>;
default: () => never[];
};
tag: {
type: StringConstructor;
default: string;
};
primaryKey: {
type: PropType<SortListPrimaryKey>;
default: string;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
draggableKey: {
type: PropType<SortListPrimaryKey>;
default: undefined;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<SortListRow[]>;
default: () => never[];
};
tag: {
type: StringConstructor;
default: string;
};
primaryKey: {
type: PropType<SortListPrimaryKey>;
default: string;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
draggableKey: {
type: PropType<SortListPrimaryKey>;
default: undefined;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
mask: boolean;
draggable: boolean;
tag: string;
modelValue: any[];
primaryKey: SortListPrimaryKey;
draggableKey: SortListPrimaryKey;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MSpin: DefineComponent<ExtractPropTypes<    {
size: {
type: NumberConstructor;
default: number;
};
foreground: {
type: StringConstructor;
default: string;
};
background: {
type: StringConstructor;
default: string;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
size: {
type: NumberConstructor;
default: number;
};
foreground: {
type: StringConstructor;
default: string;
};
background: {
type: StringConstructor;
default: string;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
fixed: boolean;
size: number;
background: string;
foreground: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MStep: DefineComponent<ExtractPropTypes<    {
title: {
type: PropType<string | Props_3["render"]>;
default: string;
};
description: {
type: PropType<string | Props_3["render"]>;
default: string;
};
status: {
type: PropType<StepStatus>;
validator(val: StepStatus): boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
index: {
type: NumberConstructor;
default: number;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: PropType<string | Props_3["render"]>;
default: string;
};
description: {
type: PropType<string | Props_3["render"]>;
default: string;
};
status: {
type: PropType<StepStatus>;
validator(val: StepStatus): boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
index: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
index: number;
title: string | ((props: Record<string, unknown>, context: SetupContext) => any);
disabled: boolean;
description: string | ((props: Record<string, unknown>, context: SetupContext) => any);
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MSteps: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
modelValue: {
type: NumberConstructor;
default: number;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"right" | "bottom" | "left" | "top">;
default: string;
validator(val: string): boolean;
};
type: {
type: PropType<"default" | "dot" | "arrow" | "navigation">;
default: string;
validator(val: string): boolean;
};
status: {
type: PropType<StepStatus>;
default: string;
validator(val: StepStatus): boolean;
};
lineless: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
renderDot: PropType<StepsRenderDot>;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
modelValue: {
type: NumberConstructor;
default: number;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"right" | "bottom" | "left" | "top">;
default: string;
validator(val: string): boolean;
};
type: {
type: PropType<"default" | "dot" | "arrow" | "navigation">;
default: string;
validator(val: string): boolean;
};
status: {
type: PropType<StepStatus>;
default: string;
validator(val: StepStatus): boolean;
};
lineless: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
renderDot: PropType<StepsRenderDot>;
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
type: "default" | "navigation" | "dot" | "arrow";
status: "default" | "error" | "pending" | "success";
tag: string;
vertical: boolean;
modelValue: number;
labelPosition: "left" | "top" | "bottom" | "right";
clickable: boolean;
lineless: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MSwitch: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
checkedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
uncheckedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
name: {
type: StringConstructor;
};
checkedText: {
type: StringConstructor;
default: string;
};
uncheckedText: {
type: StringConstructor;
default: string;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
borderWidth: {
type: NumberConstructor;
default: number;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "click" | "update:modelValue")[], "change" | "click" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
checkedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
uncheckedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
name: {
type: StringConstructor;
};
checkedText: {
type: StringConstructor;
default: string;
};
uncheckedText: {
type: StringConstructor;
default: string;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
borderWidth: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClick?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
height: number;
width: number;
borderWidth: number;
disabled: boolean;
modelValue: string | number | boolean;
checkedValue: string | number | boolean;
uncheckedValue: string | number | boolean;
checkedText: string;
uncheckedText: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTable: DefineComponent<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: () => never[];
};
width: (StringConstructor | NumberConstructor)[];
height: (StringConstructor | NumberConstructor)[];
maxHeight: (StringConstructor | NumberConstructor)[];
virtualized: {
type: BooleanConstructor;
default: boolean;
};
lazyTail: {
type: BooleanConstructor;
default: boolean;
};
rowHeight: PropType<TableRowHeight>;
recycleListOptions: PropType<Partial<Omit<Props_11, RECYCLE_LIST_RESERVED_KEYS[number]>>>;
fit: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: PropType<"large" | "medium" | "small" | "mini">;
default: string;
};
stripe: BooleanConstructor;
border: BooleanConstructor;
divider: BooleanConstructor;
primaryKey: (FunctionConstructor | StringConstructor)[];
showHeader: {
type: BooleanConstructor;
default: boolean;
};
showSummary: BooleanConstructor;
sumText: StringConstructor;
getSummary: FunctionConstructor;
rowClass: (FunctionConstructor | StringConstructor)[];
rowStyle: (ObjectConstructor | FunctionConstructor)[];
cellClass: (FunctionConstructor | StringConstructor)[];
cellStyle: (ObjectConstructor | FunctionConstructor)[];
headerRowClass: (FunctionConstructor | StringConstructor)[];
headerRowStyle: (ObjectConstructor | FunctionConstructor)[];
headerCellClass: (FunctionConstructor | StringConstructor)[];
headerCellStyle: (ObjectConstructor | FunctionConstructor)[];
highlight: BooleanConstructor;
currentRowValue: (StringConstructor | NumberConstructor)[];
emptyText: (FunctionConstructor | StringConstructor)[];
expandedValues: ArrayConstructor;
defaultExpandAll: BooleanConstructor;
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
lazyTree: BooleanConstructor;
indent: {
type: NumberConstructor;
default: number;
};
keyValue: {
type: ObjectConstructor;
default: () => {
hasChildren: string;
children: string;
};
};
expandSelectable: {
type: BooleanConstructor;
default: boolean;
};
loadExpand: FunctionConstructor;
getSpan: FunctionConstructor;
placeholder: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
sort: {
type: ObjectConstructor;
default: () => {};
};
resizable: {
type: BooleanConstructor;
default: undefined;
};
affix: {
type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
columns: {
type: PropType<TableColumnSyncItem[]>;
default: () => never[];
};
draggable: {
type: PropType<boolean | [boolean, boolean]>;
default: boolean;
};
allowDrag: PropType<(data: TableAllowDragPayload) => boolean>;
allowDrop: PropType<(data: TableAllowDropPayload) => boolean>;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("select" | "select-all" | "selection-change" | "load-change" | "update:columns" | "expand-change" | "current-change" | "cell-mouseleave" | "cell-mouseenter" | "header-click" | "header-contextmenu" | "column-resize" | "update:sort" | "sort-change" | "block-dragstart" | "update:data" | "block-drop" | "block-dragend" | "cell-click" | "cell-dblclick" | "cell-contextmenu" | "row-click" | "row-contextmenu" | "row-dblclick")[], "select" | "select-all" | "selection-change" | "load-change" | "update:columns" | "expand-change" | "current-change" | "cell-mouseleave" | "cell-mouseenter" | "header-click" | "header-contextmenu" | "column-resize" | "update:sort" | "sort-change" | "block-dragstart" | "update:data" | "block-drop" | "block-dragend" | "cell-click" | "cell-dblclick" | "cell-contextmenu" | "row-click" | "row-contextmenu" | "row-dblclick", PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: () => never[];
};
width: (StringConstructor | NumberConstructor)[];
height: (StringConstructor | NumberConstructor)[];
maxHeight: (StringConstructor | NumberConstructor)[];
virtualized: {
type: BooleanConstructor;
default: boolean;
};
lazyTail: {
type: BooleanConstructor;
default: boolean;
};
rowHeight: PropType<TableRowHeight>;
recycleListOptions: PropType<Partial<Omit<Props_11, RECYCLE_LIST_RESERVED_KEYS[number]>>>;
fit: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: PropType<"large" | "medium" | "small" | "mini">;
default: string;
};
stripe: BooleanConstructor;
border: BooleanConstructor;
divider: BooleanConstructor;
primaryKey: (FunctionConstructor | StringConstructor)[];
showHeader: {
type: BooleanConstructor;
default: boolean;
};
showSummary: BooleanConstructor;
sumText: StringConstructor;
getSummary: FunctionConstructor;
rowClass: (FunctionConstructor | StringConstructor)[];
rowStyle: (ObjectConstructor | FunctionConstructor)[];
cellClass: (FunctionConstructor | StringConstructor)[];
cellStyle: (ObjectConstructor | FunctionConstructor)[];
headerRowClass: (FunctionConstructor | StringConstructor)[];
headerRowStyle: (ObjectConstructor | FunctionConstructor)[];
headerCellClass: (FunctionConstructor | StringConstructor)[];
headerCellStyle: (ObjectConstructor | FunctionConstructor)[];
highlight: BooleanConstructor;
currentRowValue: (StringConstructor | NumberConstructor)[];
emptyText: (FunctionConstructor | StringConstructor)[];
expandedValues: ArrayConstructor;
defaultExpandAll: BooleanConstructor;
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
lazyTree: BooleanConstructor;
indent: {
type: NumberConstructor;
default: number;
};
keyValue: {
type: ObjectConstructor;
default: () => {
hasChildren: string;
children: string;
};
};
expandSelectable: {
type: BooleanConstructor;
default: boolean;
};
loadExpand: FunctionConstructor;
getSpan: FunctionConstructor;
placeholder: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
sort: {
type: ObjectConstructor;
default: () => {};
};
resizable: {
type: BooleanConstructor;
default: undefined;
};
affix: {
type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
columns: {
type: PropType<TableColumnSyncItem[]>;
default: () => never[];
};
draggable: {
type: PropType<boolean | [boolean, boolean]>;
default: boolean;
};
allowDrag: PropType<(data: TableAllowDragPayload) => boolean>;
allowDrop: PropType<(data: TableAllowDropPayload) => boolean>;
}>> & Readonly<{
onSelect?: ((...args: any[]) => any) | undefined;
"onLoad-change"?: ((...args: any[]) => any) | undefined;
"onSelect-all"?: ((...args: any[]) => any) | undefined;
"onSelection-change"?: ((...args: any[]) => any) | undefined;
"onUpdate:columns"?: ((...args: any[]) => any) | undefined;
"onExpand-change"?: ((...args: any[]) => any) | undefined;
"onCurrent-change"?: ((...args: any[]) => any) | undefined;
"onCell-mouseleave"?: ((...args: any[]) => any) | undefined;
"onCell-mouseenter"?: ((...args: any[]) => any) | undefined;
"onHeader-click"?: ((...args: any[]) => any) | undefined;
"onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
"onColumn-resize"?: ((...args: any[]) => any) | undefined;
"onUpdate:sort"?: ((...args: any[]) => any) | undefined;
"onSort-change"?: ((...args: any[]) => any) | undefined;
"onBlock-dragstart"?: ((...args: any[]) => any) | undefined;
"onUpdate:data"?: ((...args: any[]) => any) | undefined;
"onBlock-drop"?: ((...args: any[]) => any) | undefined;
"onBlock-dragend"?: ((...args: any[]) => any) | undefined;
"onCell-click"?: ((...args: any[]) => any) | undefined;
"onCell-dblclick"?: ((...args: any[]) => any) | undefined;
"onCell-contextmenu"?: ((...args: any[]) => any) | undefined;
"onRow-click"?: ((...args: any[]) => any) | undefined;
"onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
"onRow-dblclick"?: ((...args: any[]) => any) | undefined;
}>, {
sort: Record<string, any>;
resizable: boolean;
data: unknown[];
size: "small" | "medium" | "large" | "mini";
border: boolean;
columns: TableColumnSyncItem[];
draggable: boolean | [boolean, boolean];
highlight: boolean;
placeholder: string | Function;
indeterminate: boolean;
fit: boolean;
indent: number;
lazyTail: boolean;
showHeader: boolean;
keyValue: Record<string, any>;
expandSelectable: boolean;
lazyTree: boolean;
virtualized: boolean;
stripe: boolean;
divider: boolean;
showSummary: boolean;
defaultExpandAll: boolean;
affix: boolean | unknown[] | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTableColumn: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
line: NumberConstructor;
headerLine: NumberConstructor;
label: StringConstructor;
labelClass: StringConstructor;
prop: StringConstructor;
width: (StringConstructor | NumberConstructor)[];
minWidth: (StringConstructor | NumberConstructor)[];
renderHeader: PropType<TableColumnStates["renderHeader"]>;
resizable: {
type: BooleanConstructor;
default: boolean;
};
align: StringConstructor;
headerAlign: StringConstructor;
fixed: PropType<boolean | string>;
formatter: PropType<TableColumnStates["formatter"]>;
selectable: PropType<TableColumnStates["selectable"]>;
reserveSelection: BooleanConstructor;
index: PropType<number | ((rowIndex: number) => number)>;
sortable: BooleanConstructor;
filterOptions: PropType<TableFilterOptions>;
tooltip: PropType<TableColumnStates["tooltip"]>;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
line: NumberConstructor;
headerLine: NumberConstructor;
label: StringConstructor;
labelClass: StringConstructor;
prop: StringConstructor;
width: (StringConstructor | NumberConstructor)[];
minWidth: (StringConstructor | NumberConstructor)[];
renderHeader: PropType<TableColumnStates["renderHeader"]>;
resizable: {
type: BooleanConstructor;
default: boolean;
};
align: StringConstructor;
headerAlign: StringConstructor;
fixed: PropType<boolean | string>;
formatter: PropType<TableColumnStates["formatter"]>;
selectable: PropType<TableColumnStates["selectable"]>;
reserveSelection: BooleanConstructor;
index: PropType<number | ((rowIndex: number) => number)>;
sortable: BooleanConstructor;
filterOptions: PropType<TableFilterOptions>;
tooltip: PropType<TableColumnStates["tooltip"]>;
}>> & Readonly<{}>, {
resizable: boolean;
type: string;
reserveSelection: boolean;
sortable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTabs: DefineComponent<ExtractPropTypes<    {
theme: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
barStyle: {
type: (ObjectConstructor | ArrayConstructor)[];
default: () => {};
};
autoAfloatWidth: {
type: BooleanConstructor;
default: boolean;
};
average: {
type: BooleanConstructor;
default: boolean;
};
showWrapper: {
type: BooleanConstructor;
default: boolean;
};
sticky: {
type: BooleanConstructor;
default: boolean;
};
offsetTop: {
type: NumberConstructor;
default: number;
};
showStep: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: StringConstructor;
validator: (v: string) => boolean;
default: string;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
};
animated: {
type: BooleanConstructor;
default: boolean;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
barClass: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
affixable: BooleanConstructor;
affixOptions: ObjectConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "click" | "update:modelValue" | "tab-remove")[], "change" | "click" | "update:modelValue" | "tab-remove", PublicProps, Readonly<ExtractPropTypes<    {
theme: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
barStyle: {
type: (ObjectConstructor | ArrayConstructor)[];
default: () => {};
};
autoAfloatWidth: {
type: BooleanConstructor;
default: boolean;
};
average: {
type: BooleanConstructor;
default: boolean;
};
showWrapper: {
type: BooleanConstructor;
default: boolean;
};
sticky: {
type: BooleanConstructor;
default: boolean;
};
offsetTop: {
type: NumberConstructor;
default: number;
};
showStep: {
type: BooleanConstructor;
default: boolean;
};
type: {
type: StringConstructor;
validator: (v: string) => boolean;
default: string;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
};
animated: {
type: BooleanConstructor;
default: boolean;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
contentStyle: (ObjectConstructor | StringConstructor)[];
barClass: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
affixable: BooleanConstructor;
affixOptions: ObjectConstructor;
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClick?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onTab-remove"?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
offsetTop: number;
sticky: boolean;
closable: boolean;
animated: boolean;
theme: string;
afloat: boolean;
average: boolean;
barStyle: unknown[] | Record<string, any>;
affixable: boolean;
autoAfloatWidth: boolean;
showWrapper: boolean;
showStep: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTabsPane: DefineComponent<ExtractPropTypes<    {
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
anchor: {
type: StringConstructor;
};
lazy: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
anchor: {
type: StringConstructor;
};
lazy: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
value: string | number | boolean;
label: string | Function;
lazy: boolean;
disabled: boolean;
closable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTag: DefineComponent<ExtractPropTypes<    {
closable: {
type: BooleanConstructor;
default: boolean;
};
checkable: {
type: BooleanConstructor;
default: boolean;
};
checked: {
type: BooleanConstructor;
default: boolean;
};
color: {
type: StringConstructor;
default: string;
};
type: {
type: StringConstructor;
validator: (v: any) => boolean;
default: string;
};
value: {
type: (StringConstructor | NumberConstructor)[];
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "close")[], "change" | "close", PublicProps, Readonly<ExtractPropTypes<    {
closable: {
type: BooleanConstructor;
default: boolean;
};
checkable: {
type: BooleanConstructor;
default: boolean;
};
checked: {
type: BooleanConstructor;
default: boolean;
};
color: {
type: StringConstructor;
default: string;
};
type: {
type: StringConstructor;
validator: (v: any) => boolean;
default: string;
};
value: {
type: (StringConstructor | NumberConstructor)[];
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
color: string;
checked: boolean;
closable: boolean;
checkable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MText: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: {
type: StringConstructor;
default: string;
};
line: {
type: NumberConstructor;
default: number;
};
indent: {
type: NumberConstructor;
default: number;
};
resize: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
shrink: {
type: (BooleanConstructor | NumberConstructor)[];
default: undefined;
};
ellipsis: {
type: StringConstructor;
default: string;
};
slice: {
type: NumberConstructor;
default: undefined;
};
placement: {
type: StringConstructor;
default: string;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
renderRow: {
type: FunctionConstructor;
default: (props$: any) => any;
};
theme: {
type: StringConstructor;
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: {
type: StringConstructor;
default: string;
};
line: {
type: NumberConstructor;
default: number;
};
indent: {
type: NumberConstructor;
default: number;
};
resize: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
shrink: {
type: (BooleanConstructor | NumberConstructor)[];
default: undefined;
};
ellipsis: {
type: StringConstructor;
default: string;
};
slice: {
type: NumberConstructor;
default: undefined;
};
placement: {
type: StringConstructor;
default: string;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
renderRow: {
type: FunctionConstructor;
default: (props$: any) => any;
};
theme: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
slice: number;
resize: number | boolean;
value: string;
line: number;
tag: string;
ellipsis: string;
placement: string;
theme: string;
shrink: number | boolean;
indent: number;
renderRow: Function;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTextarea: DefineComponent<ExtractPropTypes<    {
wrap: {
type: StringConstructor;
validator: (v: any) => boolean;
default: string;
};
rows: {
type: NumberConstructor;
default: number;
};
autosize: {
type: (ObjectConstructor | BooleanConstructor)[];
default: boolean;
};
textareaStyle: {
type: (ObjectConstructor | ArrayConstructor)[];
};
id: {
type: StringConstructor;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
modelValue: PropType<string | number | any[]>;
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
} & {
align: {
type: StringConstructor;
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "resize" | "clear" | "cancel" | "change" | "blur" | "focus" | "keydown" | "keypress" | "keyup" | "paste" | "enter" | "update:modelValue")[], "input" | "resize" | "clear" | "cancel" | "change" | "blur" | "focus" | "keydown" | "keypress" | "keyup" | "paste" | "enter" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
wrap: {
type: StringConstructor;
validator: (v: any) => boolean;
default: string;
};
rows: {
type: NumberConstructor;
default: number;
};
autosize: {
type: (ObjectConstructor | BooleanConstructor)[];
default: boolean;
};
textareaStyle: {
type: (ObjectConstructor | ArrayConstructor)[];
};
id: {
type: StringConstructor;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
modelValue: PropType<string | number | any[]>;
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
} & {
align: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{
onEnter?: ((...args: any[]) => any) | undefined;
onPaste?: ((...args: any[]) => any) | undefined;
onFocus?: ((...args: any[]) => any) | undefined;
onBlur?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
onKeydown?: ((...args: any[]) => any) | undefined;
onKeypress?: ((...args: any[]) => any) | undefined;
onKeyup?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
onResize?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
}>, {
controllable: boolean;
bytes: boolean;
disabled: boolean;
wrap: string;
align: string;
autosize: boolean | Record<string, any>;
allowDispatch: boolean;
rows: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTimeline: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
align: {
type: PropType<"start" | "center" | "end">;
default: string;
validator(val: string): boolean;
};
alternate: {
type: BooleanConstructor;
default: boolean;
};
opposite: {
type: BooleanConstructor;
default: boolean;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
showPending: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
align: {
type: PropType<"start" | "center" | "end">;
default: string;
validator(val: string): boolean;
};
alternate: {
type: BooleanConstructor;
default: boolean;
};
opposite: {
type: BooleanConstructor;
default: boolean;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
showPending: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
alternate: boolean;
tag: string;
vertical: boolean;
align: "center" | "end" | "start";
inverted: boolean;
opposite: boolean;
showPending: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTimelineItem: DefineComponent<ExtractPropTypes<    {
label: {
type: PropType<string | Props_3["render"]>;
default: string;
};
dot: {
type: PropType<string | Props_3["render"]>;
};
dotColor: StringConstructor;
dotType: {
type: PropType<"solid" | "hollow">;
default: string;
};
lineColor: StringConstructor;
lineType: {
type: PropType<"solid" | "dashed" | "dotted">;
default: string;
};
opposite: {
type: BooleanConstructor;
default: undefined;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
label: {
type: PropType<string | Props_3["render"]>;
default: string;
};
dot: {
type: PropType<string | Props_3["render"]>;
};
dotColor: StringConstructor;
dotType: {
type: PropType<"solid" | "hollow">;
default: string;
};
lineColor: StringConstructor;
lineType: {
type: PropType<"solid" | "dashed" | "dotted">;
default: string;
};
opposite: {
type: BooleanConstructor;
default: undefined;
};
}>> & Readonly<{}>, {
label: string | ((props: Record<string, unknown>, context: SetupContext) => any);
opposite: boolean;
dotType: "solid" | "hollow";
lineType: "dashed" | "dotted" | "solid";
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTimePicker: DefineComponent<ExtractPropTypes<    {
type: StringConstructor;
placeholder: StringConstructor;
clearable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: (StringConstructor | DateConstructor | ArrayConstructor)[];
multiple: BooleanConstructor;
open: BooleanConstructor;
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
confirm: {
type: BooleanConstructor;
default: boolean;
};
format: StringConstructor;
separator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
};
splitPanels: {
type: BooleanConstructor;
default: boolean;
};
steps: {
type: ArrayConstructor;
default: () => never[];
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
} & object>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "error" | "clear" | "change" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change")[], "input" | "error" | "clear" | "change" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
type: StringConstructor;
placeholder: StringConstructor;
clearable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: (StringConstructor | DateConstructor | ArrayConstructor)[];
multiple: BooleanConstructor;
open: BooleanConstructor;
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
confirm: {
type: BooleanConstructor;
default: boolean;
};
format: StringConstructor;
separator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
};
splitPanels: {
type: BooleanConstructor;
default: boolean;
};
steps: {
type: ArrayConstructor;
default: () => never[];
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
} & object>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, {
open: boolean;
disabled: boolean;
multiple: boolean;
confirm: boolean;
tag: string;
separator: string;
placement: string;
arrow: boolean;
steps: unknown[];
portal: boolean;
trigger: string;
nullValue: string | number | Record<string, any>;
clearable: boolean;
changeOnSelect: boolean;
splitPanels: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MToast: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_3["render"]>;
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    default: string;
    validator: (val: string) => boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled")[], PublicProps, {
    mode: "error" | "info" | "loading" | "warning" | "success";
    duration: number;
    maskClosable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_3["render"]>;
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    default: string;
    validator: (val: string) => boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    mode: "error" | "info" | "loading" | "warning" | "success";
    duration: number;
    maskClosable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (val: string) => boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled")[], "close" | "portal-fulfilled", {
mode: "error" | "info" | "loading" | "warning" | "success";
duration: number;
maskClosable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    destroy: () => void;
    info: (...params: Array<Options_9[keyof Options_9] | Options_9>) => PortalLeaf;
    success: (...params: Array<Options_9[keyof Options_9] | Options_9>) => PortalLeaf;
    loading: (...params: Array<Options_9[keyof Options_9] | Options_9>) => PortalLeaf;
    warning: (...params: Array<Options_9[keyof Options_9] | Options_9>) => PortalLeaf;
    error: (...params: Array<Options_9[keyof Options_9] | Options_9>) => PortalLeaf;
};

export declare const MToastView: DefineComponent<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (val: string) => boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled")[], "close" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (val: string) => boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, {
mode: "error" | "info" | "loading" | "warning" | "success";
duration: number;
maskClosable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTouch: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
flickThreshold: {
type: NumberConstructor;
default: number;
};
prevent: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("rotate" | "move" | "tap" | "long-tap" | "double-tap" | "pinch" | "swipe" | "swipe-left" | "swipe-right" | "swipe-up" | "swipe-down")[], "rotate" | "move" | "tap" | "long-tap" | "double-tap" | "pinch" | "swipe" | "swipe-left" | "swipe-right" | "swipe-up" | "swipe-down", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
flickThreshold: {
type: NumberConstructor;
default: number;
};
prevent: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onRotate?: ((...args: any[]) => any) | undefined;
onMove?: ((...args: any[]) => any) | undefined;
onTap?: ((...args: any[]) => any) | undefined;
"onLong-tap"?: ((...args: any[]) => any) | undefined;
"onDouble-tap"?: ((...args: any[]) => any) | undefined;
onPinch?: ((...args: any[]) => any) | undefined;
onSwipe?: ((...args: any[]) => any) | undefined;
"onSwipe-left"?: ((...args: any[]) => any) | undefined;
"onSwipe-right"?: ((...args: any[]) => any) | undefined;
"onSwipe-up"?: ((...args: any[]) => any) | undefined;
"onSwipe-down"?: ((...args: any[]) => any) | undefined;
}>, {
tag: string;
prevent: boolean;
flickThreshold: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTour: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    placement: {
    type: PropType<TourPlacement>;
    default: string;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    width: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    escClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    stagePadding: {
    type: PropType<number | number[]>;
    default: number;
    };
    stageRadius: {
    type: NumberConstructor;
    default: number;
    };
    disableActiveInteraction: {
    type: BooleanConstructor;
    default: boolean;
    };
    showProgress: {
    type: BooleanConstructor;
    default: boolean;
    };
    progressType: {
    type: PropType<"number" | "dot">;
    default: string;
    };
    progressFormatter: PropType<(context: {
    current: number;
    total: number;
    }) => any>;
    previousText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    nextText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    finishText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    skipText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    previousButtonOptions: PropType<TourButtonOptions>;
    nextButtonOptions: PropType<TourButtonOptions>;
    finishButtonOptions: PropType<TourButtonOptions>;
    skipButtonOptions: PropType<TourButtonOptions>;
    animated: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    keyboard: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollIntoViewOptions: {
    type: PropType<ScrollIntoViewOptions | false>;
    default: () => {
    block: string;
    inline: string;
    };
    };
    advanceOnClick: {
    type: BooleanConstructor;
    default: boolean;
    };
    waitForElement: {
    type: NumberConstructor;
    default: number;
    };
    skipMissingElement: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClickBehavior: {
    type: PropType<"close" | "next" | "none">;
    default: string;
    };
    current: NumberConstructor;
    steps: {
    type: PropType<Record<string, any>[]>;
    default: () => never[];
    };
    getPopupContainer: PropType<() => HTMLElement>;
    zIndex: NumberConstructor;
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    wrapperStyle: PropType<StyleValue>;
    cache: {
    type: (StringConstructor | BooleanConstructor)[];
    default: boolean;
    };
    cacheTypes: PropType<TourEndType[]>;
    onOpen: PropType<(context: {
    cacheKey?: string;
    steps: Record<string, any>[];
    }) => any>;
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    "onUpdate:current"?: ((...args: any[]) => any) | undefined;
    onSkip?: ((...args: any[]) => any) | undefined;
    onFinish?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "finish" | "change" | "close" | "ready" | "skip" | "update:modelValue" | "update:current" | "visible-change")[], PublicProps, {
    width: string | number;
    mask: boolean;
    footer: boolean;
    cache: string | boolean;
    duration: number;
    previousText: string | boolean;
    nextText: string | boolean;
    finishText: string | boolean;
    skipText: string | boolean;
    placement: TourPlacement;
    arrow: boolean;
    closable: boolean;
    maskClosable: boolean;
    escClosable: boolean;
    stagePadding: number | number[];
    stageRadius: number;
    disableActiveInteraction: boolean;
    showProgress: boolean;
    progressType: "number" | "dot";
    animated: boolean;
    keyboard: boolean;
    scrollIntoViewOptions: false | ScrollIntoViewOptions;
    advanceOnClick: boolean;
    waitForElement: number;
    skipMissingElement: boolean;
    maskClickBehavior: "none" | "close" | "next";
    steps: Record<string, any>[];
    scrollable: boolean;
    modelValue: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    placement: {
    type: PropType<TourPlacement>;
    default: string;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    width: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    escClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    stagePadding: {
    type: PropType<number | number[]>;
    default: number;
    };
    stageRadius: {
    type: NumberConstructor;
    default: number;
    };
    disableActiveInteraction: {
    type: BooleanConstructor;
    default: boolean;
    };
    showProgress: {
    type: BooleanConstructor;
    default: boolean;
    };
    progressType: {
    type: PropType<"number" | "dot">;
    default: string;
    };
    progressFormatter: PropType<(context: {
    current: number;
    total: number;
    }) => any>;
    previousText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    nextText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    finishText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    skipText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    previousButtonOptions: PropType<TourButtonOptions>;
    nextButtonOptions: PropType<TourButtonOptions>;
    finishButtonOptions: PropType<TourButtonOptions>;
    skipButtonOptions: PropType<TourButtonOptions>;
    animated: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    keyboard: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollIntoViewOptions: {
    type: PropType<ScrollIntoViewOptions | false>;
    default: () => {
    block: string;
    inline: string;
    };
    };
    advanceOnClick: {
    type: BooleanConstructor;
    default: boolean;
    };
    waitForElement: {
    type: NumberConstructor;
    default: number;
    };
    skipMissingElement: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClickBehavior: {
    type: PropType<"close" | "next" | "none">;
    default: string;
    };
    current: NumberConstructor;
    steps: {
    type: PropType<Record<string, any>[]>;
    default: () => never[];
    };
    getPopupContainer: PropType<() => HTMLElement>;
    zIndex: NumberConstructor;
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    wrapperStyle: PropType<StyleValue>;
    cache: {
    type: (StringConstructor | BooleanConstructor)[];
    default: boolean;
    };
    cacheTypes: PropType<TourEndType[]>;
    onOpen: PropType<(context: {
    cacheKey?: string;
    steps: Record<string, any>[];
    }) => any>;
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    "onUpdate:current"?: ((...args: any[]) => any) | undefined;
    onSkip?: ((...args: any[]) => any) | undefined;
    onFinish?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    width: string | number;
    mask: boolean;
    footer: boolean;
    cache: string | boolean;
    duration: number;
    previousText: string | boolean;
    nextText: string | boolean;
    finishText: string | boolean;
    skipText: string | boolean;
    placement: TourPlacement;
    arrow: boolean;
    closable: boolean;
    maskClosable: boolean;
    escClosable: boolean;
    stagePadding: number | number[];
    stageRadius: number;
    disableActiveInteraction: boolean;
    showProgress: boolean;
    progressType: "number" | "dot";
    animated: boolean;
    keyboard: boolean;
    scrollIntoViewOptions: false | ScrollIntoViewOptions;
    advanceOnClick: boolean;
    waitForElement: number;
    skipMissingElement: boolean;
    maskClickBehavior: "none" | "close" | "next";
    steps: Record<string, any>[];
    scrollable: boolean;
    modelValue: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
placement: {
type: PropType<TourPlacement>;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
width: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
stagePadding: {
type: PropType<number | number[]>;
default: number;
};
stageRadius: {
type: NumberConstructor;
default: number;
};
disableActiveInteraction: {
type: BooleanConstructor;
default: boolean;
};
showProgress: {
type: BooleanConstructor;
default: boolean;
};
progressType: {
type: PropType<"number" | "dot">;
default: string;
};
progressFormatter: PropType<(context: {
current: number;
total: number;
}) => any>;
previousText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
nextText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
finishText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
skipText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
previousButtonOptions: PropType<TourButtonOptions>;
nextButtonOptions: PropType<TourButtonOptions>;
finishButtonOptions: PropType<TourButtonOptions>;
skipButtonOptions: PropType<TourButtonOptions>;
animated: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
keyboard: {
type: BooleanConstructor;
default: boolean;
};
scrollIntoViewOptions: {
type: PropType<ScrollIntoViewOptions | false>;
default: () => {
block: string;
inline: string;
};
};
advanceOnClick: {
type: BooleanConstructor;
default: boolean;
};
waitForElement: {
type: NumberConstructor;
default: number;
};
skipMissingElement: {
type: BooleanConstructor;
default: boolean;
};
maskClickBehavior: {
type: PropType<"close" | "next" | "none">;
default: string;
};
current: NumberConstructor;
steps: {
type: PropType<Record<string, any>[]>;
default: () => never[];
};
getPopupContainer: PropType<() => HTMLElement>;
zIndex: NumberConstructor;
scrollable: {
type: BooleanConstructor;
default: boolean;
};
wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
wrapperStyle: PropType<StyleValue>;
cache: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
cacheTypes: PropType<TourEndType[]>;
onOpen: PropType<(context: {
cacheKey?: string;
steps: Record<string, any>[];
}) => any>;
modelValue: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
"onUpdate:current"?: ((...args: any[]) => any) | undefined;
onSkip?: ((...args: any[]) => any) | undefined;
onFinish?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "finish" | "change" | "close" | "ready" | "skip" | "update:modelValue" | "update:current" | "visible-change")[], "error" | "finish" | "change" | "close" | "ready" | "skip" | "update:modelValue" | "update:current" | "visible-change", {
width: string | number;
mask: boolean;
footer: boolean;
cache: string | boolean;
duration: number;
previousText: string | boolean;
nextText: string | boolean;
finishText: string | boolean;
skipText: string | boolean;
placement: TourPlacement;
arrow: boolean;
closable: boolean;
maskClosable: boolean;
escClosable: boolean;
stagePadding: number | number[];
stageRadius: number;
disableActiveInteraction: boolean;
showProgress: boolean;
progressType: "number" | "dot";
animated: boolean;
keyboard: boolean;
scrollIntoViewOptions: false | ScrollIntoViewOptions;
advanceOnClick: boolean;
waitForElement: number;
skipMissingElement: boolean;
maskClickBehavior: "none" | "close" | "next";
steps: Record<string, any>[];
scrollable: boolean;
modelValue: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: {
        (): PortalLeaf;
        (options: PortalOptions): PortalLeaf;
        (propsData: Record<string, any>, options: PortalOptions): PortalLeaf;
    };
    destroy: (target?: string | PortalLeaf) => void;
};

export declare const MTourStep: DefineComponent<ExtractPropTypes<    {
element: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
title: PropType<string | Props_3["render"]>;
content: PropType<string | Props_3["render"]>;
width: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
placement: {
type: PropType<TourPlacement>;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
stagePadding: {
type: PropType<number | number[]>;
default: number;
};
stageRadius: {
type: NumberConstructor;
default: number;
};
disableActiveInteraction: {
type: BooleanConstructor;
default: boolean;
};
showProgress: {
type: BooleanConstructor;
default: boolean;
};
progressType: {
type: PropType<"number" | "dot">;
default: string;
};
animated: {
type: BooleanConstructor;
default: boolean;
};
keyboard: {
type: BooleanConstructor;
default: boolean;
};
scrollIntoViewOptions: {
type: PropType<ScrollIntoViewOptions | false>;
default: () => {
block: string;
inline: string;
};
};
advanceOnClick: {
type: BooleanConstructor;
default: boolean;
};
waitForElement: {
type: NumberConstructor;
default: number;
};
skipMissingElement: {
type: BooleanConstructor;
default: boolean;
};
maskClickBehavior: {
type: PropType<"close" | "next" | "none">;
default: string;
};
previousText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
nextText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
finishText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
skipText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
progressFormatter: PropType<(context: {
current: number;
total: number;
}) => any>;
previousButtonOptions: PropType<TourButtonOptions>;
nextButtonOptions: PropType<TourButtonOptions>;
finishButtonOptions: PropType<TourButtonOptions>;
skipButtonOptions: PropType<TourButtonOptions>;
}>, () => null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "close"[], "close", PublicProps, Readonly<ExtractPropTypes<    {
element: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
title: PropType<string | Props_3["render"]>;
content: PropType<string | Props_3["render"]>;
width: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
placement: {
type: PropType<TourPlacement>;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
stagePadding: {
type: PropType<number | number[]>;
default: number;
};
stageRadius: {
type: NumberConstructor;
default: number;
};
disableActiveInteraction: {
type: BooleanConstructor;
default: boolean;
};
showProgress: {
type: BooleanConstructor;
default: boolean;
};
progressType: {
type: PropType<"number" | "dot">;
default: string;
};
animated: {
type: BooleanConstructor;
default: boolean;
};
keyboard: {
type: BooleanConstructor;
default: boolean;
};
scrollIntoViewOptions: {
type: PropType<ScrollIntoViewOptions | false>;
default: () => {
block: string;
inline: string;
};
};
advanceOnClick: {
type: BooleanConstructor;
default: boolean;
};
waitForElement: {
type: NumberConstructor;
default: number;
};
skipMissingElement: {
type: BooleanConstructor;
default: boolean;
};
maskClickBehavior: {
type: PropType<"close" | "next" | "none">;
default: string;
};
previousText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
nextText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
finishText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
skipText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
progressFormatter: PropType<(context: {
current: number;
total: number;
}) => any>;
previousButtonOptions: PropType<TourButtonOptions>;
nextButtonOptions: PropType<TourButtonOptions>;
finishButtonOptions: PropType<TourButtonOptions>;
skipButtonOptions: PropType<TourButtonOptions>;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
}>, {
width: string | number;
mask: boolean;
footer: boolean;
duration: number;
previousText: string | boolean;
nextText: string | boolean;
finishText: string | boolean;
skipText: string | boolean;
placement: TourPlacement;
arrow: boolean;
closable: boolean;
maskClosable: boolean;
escClosable: boolean;
stagePadding: number | number[];
stageRadius: number;
disableActiveInteraction: boolean;
showProgress: boolean;
progressType: "number" | "dot";
animated: boolean;
keyboard: boolean;
scrollIntoViewOptions: false | ScrollIntoViewOptions;
advanceOnClick: boolean;
waitForElement: number;
skipMissingElement: boolean;
maskClickBehavior: "none" | "close" | "next";
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTransition: DefineComponent<ExtractPropTypes<    {
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: string;
};
};
prefix: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: string;
};
};
prefix: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTransitionCollapse: DefineComponent<ExtractPropTypes<    {
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: string;
};
};
prefix: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: string;
};
};
prefix: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTransitionFade: DefineComponent<ExtractPropTypes<    {
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTransitionScale: DefineComponent<ExtractPropTypes<    {
mode: {
type: PropType<"x" | "y" | "part" | "both" | "none" | string>;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
mode: {
type: PropType<"x" | "y" | "part" | "both" | "none" | string>;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTransitionSlide: DefineComponent<ExtractPropTypes<    {
mode: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
mode: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTransitionZoom: DefineComponent<ExtractPropTypes<    {
mode: {
type: PropType<"x" | "y" | "center" | "none" | string>;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
mode: {
type: PropType<"x" | "y" | "center" | "none" | string>;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTree: DefineComponent<ExtractPropTypes<    {
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
emptyText: {
type: StringConstructor;
default: undefined;
};
checkStrictly: {
type: BooleanConstructor;
default: boolean;
};
defaultExpandAll: BooleanConstructor;
expandOnClickNode: {
type: BooleanConstructor;
default: boolean;
};
checkOnClickNode: BooleanConstructor;
checkDescendants: {
type: BooleanConstructor;
default: boolean;
};
autoExpandParent: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
expandedValues: {
type: PropType<(string | number)[]>;
default: () => never[];
};
currentNodeValue: (StringConstructor | NumberConstructor)[];
draggable: {
type: BooleanConstructor;
default: boolean;
};
allowDrag: PropType<(data: TreeAllowDragPayload) => boolean>;
allowDrop: PropType<(data: TreeAllowDropPayload) => boolean>;
lazy: {
type: BooleanConstructor;
default: boolean;
};
highlightCurrent: BooleanConstructor;
loadData: FunctionConstructor;
filterNode: FunctionConstructor;
indent: {
type: NumberConstructor;
default: number;
};
iconClass: StringConstructor;
keyValue: {
type: PropType<Partial<KEY_VALUE>>;
default: () => {
children: string;
label: string;
value: string;
disabled: string;
isLeaf: string;
};
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
accordion: {
type: BooleanConstructor;
default: boolean;
};
renderNodeLabel: Render;
renderNodeAfterExpand: {
type: BooleanConstructor;
default: boolean;
};
showCheckbox: {
type: BooleanConstructor;
default: boolean;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "current-change" | "check-change" | "check" | "node-expand-change" | "node-click" | "node-contextmenu" | "node-dragstart" | "node-dragleave" | "node-dragenter" | "node-dragover" | "node-drop" | "node-dragend")[], "change" | "update:modelValue" | "current-change" | "check-change" | "check" | "node-expand-change" | "node-click" | "node-contextmenu" | "node-dragstart" | "node-dragleave" | "node-dragenter" | "node-dragover" | "node-drop" | "node-dragend", PublicProps, Readonly<ExtractPropTypes<    {
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
emptyText: {
type: StringConstructor;
default: undefined;
};
checkStrictly: {
type: BooleanConstructor;
default: boolean;
};
defaultExpandAll: BooleanConstructor;
expandOnClickNode: {
type: BooleanConstructor;
default: boolean;
};
checkOnClickNode: BooleanConstructor;
checkDescendants: {
type: BooleanConstructor;
default: boolean;
};
autoExpandParent: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
expandedValues: {
type: PropType<(string | number)[]>;
default: () => never[];
};
currentNodeValue: (StringConstructor | NumberConstructor)[];
draggable: {
type: BooleanConstructor;
default: boolean;
};
allowDrag: PropType<(data: TreeAllowDragPayload) => boolean>;
allowDrop: PropType<(data: TreeAllowDropPayload) => boolean>;
lazy: {
type: BooleanConstructor;
default: boolean;
};
highlightCurrent: BooleanConstructor;
loadData: FunctionConstructor;
filterNode: FunctionConstructor;
indent: {
type: NumberConstructor;
default: number;
};
iconClass: StringConstructor;
keyValue: {
type: PropType<Partial<KEY_VALUE>>;
default: () => {
children: string;
label: string;
value: string;
disabled: string;
isLeaf: string;
};
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
accordion: {
type: BooleanConstructor;
default: boolean;
};
renderNodeLabel: Render;
renderNodeAfterExpand: {
type: BooleanConstructor;
default: boolean;
};
showCheckbox: {
type: BooleanConstructor;
default: boolean;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onCurrent-change"?: ((...args: any[]) => any) | undefined;
"onCheck-change"?: ((...args: any[]) => any) | undefined;
onCheck?: ((...args: any[]) => any) | undefined;
"onNode-expand-change"?: ((...args: any[]) => any) | undefined;
"onNode-click"?: ((...args: any[]) => any) | undefined;
"onNode-contextmenu"?: ((...args: any[]) => any) | undefined;
"onNode-dragstart"?: ((...args: any[]) => any) | undefined;
"onNode-dragleave"?: ((...args: any[]) => any) | undefined;
"onNode-dragenter"?: ((...args: any[]) => any) | undefined;
"onNode-dragover"?: ((...args: any[]) => any) | undefined;
"onNode-drop"?: ((...args: any[]) => any) | undefined;
"onNode-dragend"?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: unknown[];
draggable: boolean;
lazy: boolean;
separator: string;
emptyText: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
allowDispatch: boolean;
accordion: boolean;
indent: number;
keyValue: Partial<{
children: string;
label: string;
value: string;
disabled: string;
isLeaf: string;
}>;
expandedValues: (string | number)[];
defaultExpandAll: boolean;
checkStrictly: boolean;
autoExpandParent: boolean;
checkDescendants: boolean;
renderNodeAfterExpand: boolean;
showCheckbox: boolean;
expandOnClickNode: boolean;
checkOnClickNode: boolean;
highlightCurrent: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTreeSelect: DefineComponent<ExtractPropTypes<    {
autoWidth: {
type: BooleanConstructor;
default: undefined;
};
cascader: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
checkStrictly: {
type: BooleanConstructor;
default: boolean;
};
renderNodeLabel: Render;
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("clear" | "change" | "close" | "ready" | "update:modelValue" | "visible-change")[], "clear" | "change" | "close" | "ready" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
autoWidth: {
type: BooleanConstructor;
default: undefined;
};
cascader: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
checkStrictly: {
type: BooleanConstructor;
default: boolean;
};
renderNodeLabel: Render;
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: unknown[];
disabled: boolean;
tag: string;
extra: string;
separator: string;
placement: string;
arrow: boolean;
portal: boolean;
trigger: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
maxTagLines: number;
searchable: boolean;
cascader: boolean;
checkStrictly: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MUpload: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    tag: {
    type: (ObjectConstructor | StringConstructor)[];
    default: string;
    };
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    max: {
    type: NumberConstructor;
    default: number;
    };
    accept: StringConstructor;
    size: {
    type: NumberConstructor;
    default: number;
    };
    name: {
    type: StringConstructor;
    default: string;
    };
    url: StringConstructor;
    body: {
    type: PropType<UploadRequestOptions["body"]>;
    default: () => {};
    };
    headers: {
    type: PropType<UploadRequestOptions["headers"]>;
    default: () => {};
    };
    showTask: {
    type: BooleanConstructor;
    default: boolean;
    };
    directory: {
    type: BooleanConstructor;
    default: boolean;
    };
    enhancer: PropType<UploadEnhancer>;
    parallel: {
    type: BooleanConstructor;
    default: boolean;
    };
    showError: {
    type: BooleanConstructor;
    default: boolean;
    };
    showLoading: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onComplete?: ((...args: any[]) => any) | undefined;
    onBegin?: ((...args: any[]) => any) | undefined;
    onMessage?: ((...args: any[]) => any) | undefined;
    onRequest?: ((...args: any[]) => any) | undefined;
    onResponse?: ((...args: any[]) => any) | undefined;
    "onFile-before"?: ((...args: any[]) => any) | undefined;
    "onFile-start"?: ((...args: any[]) => any) | undefined;
    "onFile-progress"?: ((...args: any[]) => any) | undefined;
    "onFile-success"?: ((...args: any[]) => any) | undefined;
    "onFile-error"?: ((...args: any[]) => any) | undefined;
    }>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "message" | "complete" | "begin" | "request" | "response" | "file-before" | "file-start" | "file-progress" | "file-success" | "file-error")[], PublicProps, {
    name: string;
    max: number;
    size: number;
    body: Record<string, unknown>;
    directory: boolean;
    disabled: boolean;
    tag: string | Record<string, any>;
    headers: Record<string, string>;
    showLoading: boolean;
    parallel: boolean;
    showTask: boolean;
    showError: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    tag: {
    type: (ObjectConstructor | StringConstructor)[];
    default: string;
    };
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    max: {
    type: NumberConstructor;
    default: number;
    };
    accept: StringConstructor;
    size: {
    type: NumberConstructor;
    default: number;
    };
    name: {
    type: StringConstructor;
    default: string;
    };
    url: StringConstructor;
    body: {
    type: PropType<UploadRequestOptions["body"]>;
    default: () => {};
    };
    headers: {
    type: PropType<UploadRequestOptions["headers"]>;
    default: () => {};
    };
    showTask: {
    type: BooleanConstructor;
    default: boolean;
    };
    directory: {
    type: BooleanConstructor;
    default: boolean;
    };
    enhancer: PropType<UploadEnhancer>;
    parallel: {
    type: BooleanConstructor;
    default: boolean;
    };
    showError: {
    type: BooleanConstructor;
    default: boolean;
    };
    showLoading: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onComplete?: ((...args: any[]) => any) | undefined;
    onBegin?: ((...args: any[]) => any) | undefined;
    onMessage?: ((...args: any[]) => any) | undefined;
    onRequest?: ((...args: any[]) => any) | undefined;
    onResponse?: ((...args: any[]) => any) | undefined;
    "onFile-before"?: ((...args: any[]) => any) | undefined;
    "onFile-start"?: ((...args: any[]) => any) | undefined;
    "onFile-progress"?: ((...args: any[]) => any) | undefined;
    "onFile-success"?: ((...args: any[]) => any) | undefined;
    "onFile-error"?: ((...args: any[]) => any) | undefined;
    }>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, {
    name: string;
    max: number;
    size: number;
    body: Record<string, unknown>;
    directory: boolean;
    disabled: boolean;
    tag: string | Record<string, any>;
    headers: Record<string, string>;
    showLoading: boolean;
    parallel: boolean;
    showTask: boolean;
    showError: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
tag: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
};
accept: StringConstructor;
size: {
type: NumberConstructor;
default: number;
};
name: {
type: StringConstructor;
default: string;
};
url: StringConstructor;
body: {
type: PropType<UploadRequestOptions["body"]>;
default: () => {};
};
headers: {
type: PropType<UploadRequestOptions["headers"]>;
default: () => {};
};
showTask: {
type: BooleanConstructor;
default: boolean;
};
directory: {
type: BooleanConstructor;
default: boolean;
};
enhancer: PropType<UploadEnhancer>;
parallel: {
type: BooleanConstructor;
default: boolean;
};
showError: {
type: BooleanConstructor;
default: boolean;
};
showLoading: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
onBegin?: ((...args: any[]) => any) | undefined;
onMessage?: ((...args: any[]) => any) | undefined;
onRequest?: ((...args: any[]) => any) | undefined;
onResponse?: ((...args: any[]) => any) | undefined;
"onFile-before"?: ((...args: any[]) => any) | undefined;
"onFile-start"?: ((...args: any[]) => any) | undefined;
"onFile-progress"?: ((...args: any[]) => any) | undefined;
"onFile-success"?: ((...args: any[]) => any) | undefined;
"onFile-error"?: ((...args: any[]) => any) | undefined;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "message" | "complete" | "begin" | "request" | "response" | "file-before" | "file-start" | "file-progress" | "file-success" | "file-error")[], "error" | "message" | "complete" | "begin" | "request" | "response" | "file-before" | "file-start" | "file-progress" | "file-success" | "file-error", {
name: string;
max: number;
size: number;
body: Record<string, unknown>;
directory: boolean;
disabled: boolean;
tag: string | Record<string, any>;
headers: Record<string, string>;
showLoading: boolean;
parallel: boolean;
showTask: boolean;
showError: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options: UploadOpenOptions) => PortalLeaf;
};

export declare const MUploadPicker: DefineComponent<ExtractPropTypes<    {
picker: {
type: PropType<PickerType[]>;
default: () => string[];
};
sortable: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
uploadOptions: {
type: ObjectConstructor;
default(): {};
};
modelValue: {
type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
default: () => never[];
};
keyValue: {
type: PropType<    {
label: string;
value: string;
}>;
default: () => {
label: string;
value: string;
};
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
validator: (v: string | Function) => boolean;
};
max: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
formatter: PropType<(response: any, file: any, type: PickerType) => any>;
boxClass: StringConstructor;
imageClass: StringConstructor;
videoClass: StringConstructor;
audioClass: StringConstructor;
fileClass: StringConstructor;
compressOptions: {
type: ObjectConstructor;
default: () => {
compress: boolean;
width: number;
height: number;
filetype: string;
encoderOptions: number;
};
};
showError: BooleanConstructor;
enhancer: (FunctionConstructor | BooleanConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "change" | "complete" | "update:modelValue" | "file-before" | "file-start" | "file-success" | "file-error" | "remove-before")[], "error" | "change" | "complete" | "update:modelValue" | "file-before" | "file-start" | "file-success" | "file-error" | "remove-before", PublicProps, Readonly<ExtractPropTypes<    {
picker: {
type: PropType<PickerType[]>;
default: () => string[];
};
sortable: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
uploadOptions: {
type: ObjectConstructor;
default(): {};
};
modelValue: {
type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
default: () => never[];
};
keyValue: {
type: PropType<    {
label: string;
value: string;
}>;
default: () => {
label: string;
value: string;
};
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
validator: (v: string | Function) => boolean;
};
max: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
formatter: PropType<(response: any, file: any, type: PickerType) => any>;
boxClass: StringConstructor;
imageClass: StringConstructor;
videoClass: StringConstructor;
audioClass: StringConstructor;
fileClass: StringConstructor;
compressOptions: {
type: ObjectConstructor;
default: () => {
compress: boolean;
width: number;
height: number;
filetype: string;
encoderOptions: number;
};
};
showError: BooleanConstructor;
enhancer: (FunctionConstructor | BooleanConstructor)[];
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
"onFile-before"?: ((...args: any[]) => any) | undefined;
"onFile-start"?: ((...args: any[]) => any) | undefined;
"onFile-success"?: ((...args: any[]) => any) | undefined;
"onFile-error"?: ((...args: any[]) => any) | undefined;
"onRemove-before"?: ((...args: any[]) => any) | undefined;
}>, {
max: number | Record<string, any>;
mask: boolean;
output: string | Function;
disabled: boolean;
modelValue: string | unknown[] | Record<string, any>;
picker: PickerType[];
showError: boolean;
uploadOptions: Record<string, any>;
sortable: boolean;
keyValue: {
label: string;
value: string;
};
compressOptions: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Nodes {
    private store;
    byIndex: Map<number, RecycleListItemNodeRaw>;
    pending: Set<RecycleListItemNodeRaw>;
    real: Set<RecycleListItemNodeRaw>;
    constructor(store: RecycleListStore);
    sync(node: RecycleListItemNodeRaw): void;
    attach(index: number, node: RecycleListItemNodeRaw): RecycleListItemNodeRaw;
    estimate(data: any, index: number): number;
    detach(node: RecycleListItemNodeRaw): void;
    clear(): void;
    get(index: number): RecycleListItemNodeRaw | undefined;
    create(index: number, data?: any): RecycleListItemNodeRaw;
    rebind(node: RecycleListItemNodeRaw, index: number, data?: any): RecycleListItemNodeRaw;
    setSize(node: RecycleListItemNodeRaw, size: number): void;
    reestimate(): boolean;
    upsert(index: number, data?: any): RecycleListItemNodeRaw;
    build(start: number, end: number, options?: {
        reversed?: boolean;
        force?: boolean;
        keep?: Set<RecycleListItemNodeRaw>;
    }): RecycleListItemNodeRaw[];
    allocatePlaceholders(): {
        start: number;
        end: number;
    };
    private prepend;
    trimPlaceholders(): boolean;
    rebuild(base: number, count: number, dataAt: (index: number) => any): void;
}

declare type Normalized = {
    nodes: Record<string, TreeNodeInfo>;
    rows: any[];
    parents: Map<object, any>;
};

export declare const Notice: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    title: PropType<string | Props_3["render"]>;
    content: PropType<string | Props_3["render"]>;
    duration: {
    type: NumberConstructor;
    default: number;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    validator: (v: string) => boolean;
    };
    top: {
    type: NumberConstructor;
    default: number;
    };
    fixed: {
    type: BooleanConstructor;
    default: boolean;
    };
    onBeforeClose: FunctionConstructor;
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onBefore-close"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], PublicProps, {
    fixed: boolean;
    top: number;
    duration: number;
    closable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    title: PropType<string | Props_3["render"]>;
    content: PropType<string | Props_3["render"]>;
    duration: {
    type: NumberConstructor;
    default: number;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    validator: (v: string) => boolean;
    };
    top: {
    type: NumberConstructor;
    default: number;
    };
    fixed: {
    type: BooleanConstructor;
    default: boolean;
    };
    onBeforeClose: FunctionConstructor;
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onBefore-close"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    fixed: boolean;
    top: number;
    duration: number;
    closable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
title: PropType<string | Props_3["render"]>;
content: PropType<string | Props_3["render"]>;
duration: {
type: NumberConstructor;
default: number;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
validator: (v: string) => boolean;
};
top: {
type: NumberConstructor;
default: number;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
onBeforeClose: FunctionConstructor;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onBefore-close"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], "close" | "portal-fulfilled" | "before-close", {
fixed: boolean;
top: number;
duration: number;
closable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    destroy: () => void;
    open: (options: Options_6) => PortalLeaf;
    info: (options: Options_6) => PortalLeaf;
    success: (options: Options_6) => PortalLeaf;
    warning: (options: Options_6) => PortalLeaf;
    error: (options: Options_6) => PortalLeaf;
};

export declare const NoticeView: DefineComponent<ExtractPropTypes<    {
title: PropType<string | Props_3["render"]>;
content: PropType<string | Props_3["render"]>;
duration: {
type: NumberConstructor;
default: number;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
validator: (v: string) => boolean;
};
top: {
type: NumberConstructor;
default: number;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
onBeforeClose: FunctionConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled" | "before-close")[], "close" | "portal-fulfilled" | "before-close", PublicProps, Readonly<ExtractPropTypes<    {
title: PropType<string | Props_3["render"]>;
content: PropType<string | Props_3["render"]>;
duration: {
type: NumberConstructor;
default: number;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
validator: (v: string) => boolean;
};
top: {
type: NumberConstructor;
default: number;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
onBeforeClose: FunctionConstructor;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onBefore-close"?: ((...args: any[]) => any) | undefined;
}>, {
fixed: boolean;
top: number;
duration: number;
closable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const open_2: (options?: Record<string, any>) => PortalLeaf;
export { open_2 as open }

declare const operation: (options: Options_5) => PortalLeaf;

declare const Option_2: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
tag: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { Option_2 as Option }

declare type Options = Partial<Props & {
    onClose: (...args: any[]) => any;
}>;

declare type Options_10 = Omit<Partial<TreeNode_2>, 'states'> & {
    states?: Partial<TreeNode_2['states']>;
};

declare type Options_2 = Partial<Props_5 & {
    onClose: (...args: any[]) => any;
}>;

declare type Options_3 = Partial<Props_7 & {
    onClose: (...args: any[]) => any;
}>;

declare type Options_4 = Partial<Props_8 & {
    onClose: (...args: any[]) => any;
}>;

declare type Options_5 = Partial<Props_9 & {
    onClose: (...args: any[]) => any;
}>;

declare type Options_6 = Partial<Props_10 & {
    insertion: PortalOptions['insertion'];
    onClose: (...args: any[]) => any;
}>;

declare type Options_7 = {
    index: number;
    data?: any;
};

declare type Options_8 = {
    table: TableProvide;
    parentNode?: Nullable<TableColumnNode>;
    instance?: ComponentInternalInstance;
    states?: Partial<TableColumnStates>;
};

declare type Options_9 = Partial<Props_13 & {
    onClose: (...args: any[]) => any;
}>;

export declare const Pagination: DefineComponent<ExtractPropTypes<    {
current: {
type: NumberConstructor;
default: number;
};
count: {
type: NumberConstructor;
default: number;
};
pageSize: {
type: NumberConstructor;
default: number;
};
pageSizeOptions: {
type: ArrayConstructor;
default: () => number[];
};
placement: {
type: StringConstructor;
default: string;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
showCount: {
type: BooleanConstructor;
default: boolean;
};
showElevator: {
type: BooleanConstructor;
default: boolean;
};
showSizer: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:current" | "page-size-change")[], "change" | "update:current" | "page-size-change", PublicProps, Readonly<ExtractPropTypes<    {
current: {
type: NumberConstructor;
default: number;
};
count: {
type: NumberConstructor;
default: number;
};
pageSize: {
type: NumberConstructor;
default: number;
};
pageSizeOptions: {
type: ArrayConstructor;
default: () => number[];
};
placement: {
type: StringConstructor;
default: string;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
showCount: {
type: BooleanConstructor;
default: boolean;
};
showElevator: {
type: BooleanConstructor;
default: boolean;
};
showSizer: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:current"?: ((...args: any[]) => any) | undefined;
"onPage-size-change"?: ((...args: any[]) => any) | undefined;
}>, {
count: number;
pageSize: number;
placement: string;
current: number;
portal: boolean;
pageSizeOptions: unknown[];
showCount: boolean;
showElevator: boolean;
showSizer: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare type PickerColumn = PickerData[];

export declare interface PickerData {
    [key: string]: any;
    value?: PickerValue;
    label?: any;
    children?: PickerData[];
    hasChildren?: boolean;
    loading?: boolean;
}

export declare type PickerModelValue = PickerValue | PickerValue[];

export declare const PickerPopup: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: PropType<boolean | undefined>;
default: undefined;
};
title: {
type: StringConstructor;
default: string;
};
cancelText: StringConstructor;
okText: StringConstructor;
showToolbar: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "update:visible")[], "cancel" | "close" | "ok" | "update:modelValue" | "visible-change" | "update:visible", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
visible: {
type: PropType<boolean | undefined>;
default: undefined;
};
title: {
type: StringConstructor;
default: string;
};
cancelText: StringConstructor;
okText: StringConstructor;
showToolbar: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
"onUpdate:visible"?: ((...args: any[]) => any) | undefined;
}>, {
visible: boolean | undefined;
title: string;
modelValue: boolean;
showToolbar: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare type PickerSource = PickerColumn | PickerColumn[];

declare type PickerType = 'image' | 'video' | 'audio' | 'file';

export declare type PickerValue = string | number | boolean | null | undefined;

export declare const PickerView: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<PickerModelValue>;
default: () => never[];
};
data: {
type: PropType<PickerSource>;
default: () => never[];
};
columns: {
type: NumberConstructor;
default: number;
};
itemStyle: PropType<Record<string, any>>;
cascader: {
type: BooleanConstructor;
default: boolean;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
renderLabel: Render;
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: PropType<PickerModelValue>;
default: undefined;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "picker-change")[], "change" | "update:modelValue" | "picker-change", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<PickerModelValue>;
default: () => never[];
};
data: {
type: PropType<PickerSource>;
default: () => never[];
};
columns: {
type: NumberConstructor;
default: number;
};
itemStyle: PropType<Record<string, any>>;
cascader: {
type: BooleanConstructor;
default: boolean;
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
renderLabel: Render;
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: PropType<PickerModelValue>;
default: undefined;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onPicker-change"?: ((...args: any[]) => any) | undefined;
}>, {
data: PickerSource;
columns: number;
separator: string;
modelValue: PickerModelValue;
numerable: boolean;
nullValue: PickerModelValue;
allowDispatch: boolean;
cascader: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Popconfirm: DefineComponent<ExtractPropTypes<    {
title: {
type: PropType<string | Props_3["render"]>;
default: string;
};
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: undefined;
};
cancelText: {
type: StringConstructor;
default: undefined;
};
okType: {
type: StringConstructor;
default: string;
};
cancelType: {
type: StringConstructor;
default: string;
};
type: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
width: (StringConstructor | NumberConstructor)[];
portalClass: (ObjectConstructor | StringConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change")[], "cancel" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: PropType<string | Props_3["render"]>;
default: string;
};
content: {
type: PropType<string | Props_3["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: undefined;
};
cancelText: {
type: StringConstructor;
default: undefined;
};
okType: {
type: StringConstructor;
default: string;
};
cancelType: {
type: StringConstructor;
default: string;
};
type: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
width: (StringConstructor | NumberConstructor)[];
portalClass: (ObjectConstructor | StringConstructor)[];
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
title: string | ((props: Record<string, unknown>, context: SetupContext) => any);
cancelText: string;
okText: string;
placement: string;
modelValue: boolean;
trigger: string;
okType: string;
cancelType: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Popover: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    always: BooleanConstructor;
    animation: StringConstructor;
    content: (FunctionConstructor | StringConstructor)[];
    placement: {
    type: StringConstructor;
    default: string;
    validator: (value: string) => boolean;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    getPopupContainer: FunctionConstructor;
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: BooleanConstructor;
    portal: {
    type: BooleanConstructor;
    default: boolean;
    };
    theme: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    autoWidth: {
    type: BooleanConstructor;
    default: boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    portalStyle: (ObjectConstructor | StringConstructor)[];
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    trigger: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    tag: {
    type: StringConstructor;
    default: string;
    };
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    outsideClickable: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    }>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "ready" | "update:modelValue" | "visible-change")[], PublicProps, {
    always: boolean;
    disabled: boolean;
    tag: string;
    placement: string;
    arrow: boolean;
    scrollable: boolean;
    modelValue: boolean;
    portal: boolean;
    theme: string;
    trigger: string;
    autoWidth: boolean;
    outsideClickable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    always: BooleanConstructor;
    animation: StringConstructor;
    content: (FunctionConstructor | StringConstructor)[];
    placement: {
    type: StringConstructor;
    default: string;
    validator: (value: string) => boolean;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    getPopupContainer: FunctionConstructor;
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: BooleanConstructor;
    portal: {
    type: BooleanConstructor;
    default: boolean;
    };
    theme: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    autoWidth: {
    type: BooleanConstructor;
    default: boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    portalStyle: (ObjectConstructor | StringConstructor)[];
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    trigger: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    tag: {
    type: StringConstructor;
    default: string;
    };
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    outsideClickable: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    }>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, {
    always: boolean;
    disabled: boolean;
    tag: string;
    placement: string;
    arrow: boolean;
    scrollable: boolean;
    modelValue: boolean;
    portal: boolean;
    theme: string;
    trigger: string;
    autoWidth: boolean;
    outsideClickable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
always: BooleanConstructor;
animation: StringConstructor;
content: (FunctionConstructor | StringConstructor)[];
placement: {
type: StringConstructor;
default: string;
validator: (value: string) => boolean;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
getPopupContainer: FunctionConstructor;
scrollable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: BooleanConstructor;
portal: {
type: BooleanConstructor;
default: boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor)[];
scrollerOptions: PropType<Partial<ScrollerProps>>;
trigger: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
tag: {
type: StringConstructor;
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
outsideClickable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "ready" | "update:modelValue" | "visible-change")[], "close" | "ready" | "update:modelValue" | "visible-change", {
always: boolean;
disabled: boolean;
tag: string;
placement: string;
arrow: boolean;
scrollable: boolean;
modelValue: boolean;
portal: boolean;
theme: string;
trigger: string;
autoWidth: boolean;
outsideClickable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: {
        (): PortalLeaf;
        (options: PortalOptions): PortalLeaf;
        (propsData: Record<string, any>, options: PortalOptions): PortalLeaf;
    };
};

export declare const PopoverView: DefineComponent<ExtractPropTypes<    {
modelValue: BooleanConstructor;
animation: StringConstructor;
placement: {
type: StringConstructor;
default: string;
validator: (value: string) => boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
content: (FunctionConstructor | StringConstructor)[];
getPopupContainer: FunctionConstructor;
portal: {
type: BooleanConstructor;
default: boolean;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
triggerElement: {
type: ObjectConstructor;
required: boolean;
};
onChange: {
type: FunctionConstructor;
default: () => void;
};
onReady: FunctionConstructor;
alone: {
type: BooleanConstructor;
default: boolean;
};
hover: BooleanConstructor;
always: BooleanConstructor;
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor)[];
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled")[], "close" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: BooleanConstructor;
animation: StringConstructor;
placement: {
type: StringConstructor;
default: string;
validator: (value: string) => boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
content: (FunctionConstructor | StringConstructor)[];
getPopupContainer: FunctionConstructor;
portal: {
type: BooleanConstructor;
default: boolean;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
triggerElement: {
type: ObjectConstructor;
required: boolean;
};
onChange: {
type: FunctionConstructor;
default: () => void;
};
onReady: FunctionConstructor;
alone: {
type: BooleanConstructor;
default: boolean;
};
hover: BooleanConstructor;
always: BooleanConstructor;
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor)[];
scrollable: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<Partial<ScrollerProps>>;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, {
always: boolean;
onChange: Function;
placement: string;
arrow: boolean;
scrollable: boolean;
modelValue: boolean;
portal: boolean;
theme: string;
hover: boolean;
autoWidth: boolean;
alone: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Popup: DefineComponent<ExtractPropTypes<    {
fixed: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
validator: (v: any) => boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: any) => boolean;
};
wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
scrollRegExp: {
type: ObjectConstructor;
default: () => {
className: RegExp;
};
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change" | "portal-fulfilled")[], "close" | "update:modelValue" | "visible-change" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
fixed: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
validator: (v: any) => boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: any) => boolean;
};
wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
wrapperStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
scrollRegExp: {
type: ObjectConstructor;
default: () => {
className: RegExp;
};
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, {
fixed: boolean;
mask: boolean;
placement: string;
maskClosable: boolean;
modelValue: boolean;
theme: string;
scrollRegExp: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare class Portal<T extends Component> {
    static clear(name?: string | string[] | boolean): void;
    static clearAll(): void;
    static leafs: Map<string, PortalLeaf>;
    wrapper: T;
    globalOptions: PortalOptions;
    constructor(wrapper: T, options?: PortalOptions);
    popup(): PortalLeaf;
    popup(options: PortalOptions): PortalLeaf;
    popup(propsData: Record<string, any>, options: PortalOptions): PortalLeaf;
    destroy: (target?: string | PortalLeaf) => void;
    private getDefaultOptions;
    private createCallback;
    private render;
}

declare class PortalLeaf {
    app?: App;
    wrapper?: ComponentPublicInstance & Record<string, any>;
    propsData?: Ref<Record<string, any>>;
    container?: HTMLElement & {
        _children?: HTMLElement[];
    };
    destroy: (...args: any[]) => void;
    reject: (...args: any[]) => void;
    resolve: (...args: any[]) => void;
    autoDestroy: boolean;
    target: Promise<any>;
    constructor(target: Promise<any>);
    then(resolve: (...args: any[]) => any, reject?: (...args: any[]) => any): Promise<any>;
    catch(callback?: (...args: any[]) => any): Promise<any>;
    finally(callback?: (...args: any[]) => any): Promise<any>;
}

declare type PortalOptions = Partial<{
    [key: string]: any;
    propsData: {
        [key: string]: any;
    };
    name: string;
    tag: string;
    element: string | HTMLElement;
    alive: boolean;
    multiple: boolean;
    aliveRules: {
        className?: RegExp;
        id?: RegExp;
    };
    aliveVisibleKey: string;
    aliveUpdateKey: string;
    leaveDelay: number;
    autoDestroy: boolean;
    insertion: 'first' | 'last';
    components: Record<string, Component>;
    uses: Record<string, Plugin_2>;
    fragment: boolean;
    slots: VNodeNormalizedChildren;
    parent: object;
    install: (app: App) => any;
    onFulfilled: (...args: any[]) => any;
    onRejected: (...args: any[]) => any;
    onDestroyed: (...args: any[]) => any;
    onBeforeCreate: (propsData?: Record<string, any>) => Promise<Record<string, any>> | Record<string, any>;
}>;

export declare const PortalView: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
tag: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Position {
    private store;
    columns: number[][];
    source: RecycleListItemNodeRaw[] | null;
    sourceLength: number;
    constructor(store: RecycleListStore);
    set(columns: number[][], source: RecycleListItemNodeRaw[]): void;
    rebuild(): number[][];
    truncate(startScan: number, cols: number): number[][];
    updateVisibleRange(headPosition: number, tailPosition: number): void;
}

export declare const Print: DefineComponent<ExtractPropTypes<    {
value: StringConstructor;
tag: {
type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: StringConstructor;
tag: {
type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
default: string;
};
}>> & Readonly<{}>, {
tag: string | Function | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Progress: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
validator(val: string): boolean;
default: string;
};
percent: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
status: {
validator(val: string): boolean;
default: string;
};
showText: {
type: BooleanConstructor;
default: boolean;
};
textStyle: {
type: (ObjectConstructor | StringConstructor)[];
};
textClass: {
type: (ObjectConstructor | StringConstructor)[];
};
animated: {
type: BooleanConstructor;
default: boolean;
};
strokeWidth: {
type: NumberConstructor;
default: number;
};
strokeColor: {
type: StringConstructor;
default: string;
};
trackColor: {
type: StringConstructor;
default: string;
};
size: {
type: NumberConstructor;
default: number;
};
color: {
type: (ObjectConstructor | StringConstructor)[];
default: () => {
default: string;
success: string;
error: string;
};
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
validator(val: string): boolean;
default: string;
};
percent: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
status: {
validator(val: string): boolean;
default: string;
};
showText: {
type: BooleanConstructor;
default: boolean;
};
textStyle: {
type: (ObjectConstructor | StringConstructor)[];
};
textClass: {
type: (ObjectConstructor | StringConstructor)[];
};
animated: {
type: BooleanConstructor;
default: boolean;
};
strokeWidth: {
type: NumberConstructor;
default: number;
};
strokeColor: {
type: StringConstructor;
default: string;
};
trackColor: {
type: StringConstructor;
default: string;
};
size: {
type: NumberConstructor;
default: number;
};
color: {
type: (ObjectConstructor | StringConstructor)[];
default: () => {
default: string;
success: string;
error: string;
};
};
}>> & Readonly<{}>, {
percent: string | number;
type: string;
size: number;
color: string | Record<string, any>;
strokeWidth: number;
status: string;
strokeColor: string;
animated: boolean;
showText: boolean;
trackColor: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare type Props = ExtractPropTypes<typeof props>;

export declare const props: {
    mask: {
        type: BooleanConstructor;
        default: boolean;
    };
    maskClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    wrapperStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    scrollRegExp: {
        type: ObjectConstructor;
        default: () => {
            className: RegExp;
        };
    };
    title: {
        type: PropType<ActionSheetContent>;
        default: string;
    };
    data: {
        type: PropType<ActionSheetAction[]>;
        default: () => never[];
    };
    cancelText: {
        type: StringConstructor;
        default: string;
    };
};

declare type Props_10 = ExtractPropTypes<typeof props_11>;

declare const props_10: {
    mode: {
        type: PropType<"alert" | "operation">;
        validator: (v: any) => boolean;
        default: string;
    };
    content: {
        type: PropType<boolean | string | Props_3["render"]>;
    };
    width: {
        type: NumberConstructor;
        default: number;
    };
    modelValue: {
        type: BooleanConstructor;
        default: boolean;
    };
    mask: {
        type: BooleanConstructor;
        default: boolean;
    };
    maskClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    closeWithCancel: {
        type: BooleanConstructor;
        default: boolean;
    };
    title: {
        type: PropType<boolean | string | Props_3["render"]>;
    };
    okText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    cancelText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    wrapperStyle: {
        type: ObjectConstructor;
    };
    footer: {
        type: BooleanConstructor;
        default: boolean;
    };
    data: ArrayConstructor;
    onOk: {
        type: FunctionConstructor;
    };
    onCancel: {
        type: FunctionConstructor;
    };
};

declare type Props_11 = ExtractPropTypes<typeof props_12>;

declare const props_11: {
    title: PropType<string | Props_3["render"]>;
    content: PropType<string | Props_3["render"]>;
    duration: {
        type: NumberConstructor;
        default: number;
    };
    closable: {
        type: BooleanConstructor;
        default: boolean;
    };
    mode: {
        type: PropType<"info" | "loading" | "success" | "warning" | "error">;
        validator: (v: string) => boolean;
    };
    top: {
        type: NumberConstructor;
        default: number;
    };
    fixed: {
        type: BooleanConstructor;
        default: boolean;
    };
    onBeforeClose: FunctionConstructor;
};

declare type Props_12 = ExtractPropTypes<typeof props_13>;

declare const props_12: {
    data: {
        type: ArrayConstructor;
        default: () => never[];
    };
    store: PropType<RecycleListStore>;
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    batchCount: {
        type: NumberConstructor;
        default: number;
    };
    bufferCount: {
        type: NumberConstructor;
        default: number;
    };
    estimateSize: PropType<number | ((data: {
        row: any;
        index: number;
    }) => number | undefined)>;
    overscan: {
        type: NumberConstructor;
        default: number;
    };
    threshold: {
        type: NumberConstructor;
        default: number;
    };
    loadData: {
        type: FunctionConstructor;
        default: () => boolean;
    };
    columns: {
        type: NumberConstructor;
        default: number;
    };
    gap: {
        type: NumberConstructor;
        default: number;
    };
    inverted: {
        type: BooleanConstructor;
        default: boolean;
    };
    pullable: {
        type: BooleanConstructor;
        default: boolean;
    };
    vertical: {
        type: BooleanConstructor;
        default: boolean;
    };
    fill: {
        type: BooleanConstructor;
        default: boolean;
    };
    lazyTail: {
        type: BooleanConstructor;
        default: boolean;
    };
    scrollerOptions: PropType<ScrollerProps>;
    renderEmpty: Render;
    renderComplete: Render;
    renderLoading: Render;
    renderPlaceholder: Render;
    renderRefresh: Render;
};

declare type Props_13 = ExtractPropTypes<typeof props_14>;

declare const props_13: {
    data: {
        type: ArrayConstructor;
        default: () => never[];
    };
    width: (StringConstructor | NumberConstructor)[];
    height: (StringConstructor | NumberConstructor)[];
    maxHeight: (StringConstructor | NumberConstructor)[];
    virtualized: {
        type: BooleanConstructor;
        default: boolean;
    };
    lazyTail: {
        type: BooleanConstructor;
        default: boolean;
    };
    rowHeight: PropType<TableRowHeight>;
    recycleListOptions: PropType<Partial<Omit<Props_11, (typeof RECYCLE_LIST_RESERVED_KEYS)[number]>>>;
    fit: {
        type: BooleanConstructor;
        default: boolean;
    };
    size: {
        type: PropType<"large" | "medium" | "small" | "mini">;
        default: string;
    };
    stripe: BooleanConstructor;
    border: BooleanConstructor;
    divider: BooleanConstructor;
    primaryKey: (FunctionConstructor | StringConstructor)[];
    showHeader: {
        type: BooleanConstructor;
        default: boolean;
    };
    showSummary: BooleanConstructor;
    sumText: StringConstructor;
    getSummary: FunctionConstructor;
    rowClass: (FunctionConstructor | StringConstructor)[];
    rowStyle: (ObjectConstructor | FunctionConstructor)[];
    cellClass: (FunctionConstructor | StringConstructor)[];
    cellStyle: (ObjectConstructor | FunctionConstructor)[];
    headerRowClass: (FunctionConstructor | StringConstructor)[];
    headerRowStyle: (ObjectConstructor | FunctionConstructor)[];
    headerCellClass: (FunctionConstructor | StringConstructor)[];
    headerCellStyle: (ObjectConstructor | FunctionConstructor)[];
    highlight: BooleanConstructor;
    currentRowValue: (StringConstructor | NumberConstructor)[];
    emptyText: (FunctionConstructor | StringConstructor)[];
    expandedValues: ArrayConstructor;
    defaultExpandAll: BooleanConstructor;
    indeterminate: {
        type: BooleanConstructor;
        default: boolean;
    };
    lazyTree: BooleanConstructor;
    indent: {
        type: NumberConstructor;
        default: number;
    };
    keyValue: {
        type: ObjectConstructor;
        default: () => {
            hasChildren: string;
            children: string;
        };
    };
    expandSelectable: {
        type: BooleanConstructor;
        default: boolean;
    };
    loadExpand: FunctionConstructor;
    getSpan: FunctionConstructor;
    placeholder: {
        type: (FunctionConstructor | StringConstructor)[];
        default: string;
    };
    sort: {
        type: ObjectConstructor;
        default: () => {};
    };
    resizable: {
        type: BooleanConstructor;
        default: undefined;
    };
    affix: {
        type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
        default: boolean;
    };
    columns: {
        type: PropType<TableColumnSyncItem[]>;
        default: () => never[];
    };
    draggable: {
        type: PropType<boolean | [boolean, boolean]>;
        default: boolean;
    };
    allowDrag: PropType<(data: TableAllowDragPayload) => boolean>;
    allowDrop: PropType<(data: TableAllowDropPayload) => boolean>;
};

declare const props_14: {
    content: PropType<string | Props_3["render"]>;
    maskClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    duration: {
        type: NumberConstructor;
        default: number;
    };
    mode: {
        type: PropType<"info" | "loading" | "success" | "warning" | "error">;
        default: string;
        validator: (val: string) => boolean;
    };
};

declare const props_15: {
    tag: {
        type: (ObjectConstructor | StringConstructor)[];
        default: string;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    max: {
        type: NumberConstructor;
        default: number;
    };
    accept: StringConstructor;
    size: {
        type: NumberConstructor;
        default: number;
    };
    name: {
        type: StringConstructor;
        default: string;
    };
    url: StringConstructor;
    body: {
        type: PropType<UploadRequestOptions["body"]>;
        default: () => {};
    };
    headers: {
        type: PropType<UploadRequestOptions["headers"]>;
        default: () => {};
    };
    showTask: {
        type: BooleanConstructor;
        default: boolean;
    };
    directory: {
        type: BooleanConstructor;
        default: boolean;
    };
    enhancer: PropType<UploadEnhancer>;
    parallel: {
        type: BooleanConstructor;
        default: boolean;
    };
    showError: {
        type: BooleanConstructor;
        default: boolean;
    };
    showLoading: {
        type: BooleanConstructor;
        default: boolean;
    };
};

declare type Props_2 = ExtractPropTypes<typeof props_2>;

declare const props_2: {
    element: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
    title: PropType<string | Props_3["render"]>;
    content: PropType<string | Props_3["render"]>;
    width: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    mask: {
        type: BooleanConstructor;
        default: boolean;
    };
    footer: {
        type: BooleanConstructor;
        default: boolean;
    };
    duration: {
        type: NumberConstructor;
        default: number;
    };
    placement: {
        type: PropType<TourPlacement>;
        default: string;
    };
    arrow: {
        type: BooleanConstructor;
        default: boolean;
    };
    closable: {
        type: BooleanConstructor;
        default: boolean;
    };
    maskClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    escClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    stagePadding: {
        type: PropType<number | number[]>;
        default: number;
    };
    stageRadius: {
        type: NumberConstructor;
        default: number;
    };
    disableActiveInteraction: {
        type: BooleanConstructor;
        default: boolean;
    };
    showProgress: {
        type: BooleanConstructor;
        default: boolean;
    };
    progressType: {
        type: PropType<"number" | "dot">;
        default: string;
    };
    animated: {
        type: BooleanConstructor;
        default: boolean;
    };
    keyboard: {
        type: BooleanConstructor;
        default: boolean;
    };
    scrollIntoViewOptions: {
        type: PropType<ScrollIntoViewOptions | false>;
        default: () => {
            block: string;
            inline: string;
        };
    };
    advanceOnClick: {
        type: BooleanConstructor;
        default: boolean;
    };
    waitForElement: {
        type: NumberConstructor;
        default: number;
    };
    skipMissingElement: {
        type: BooleanConstructor;
        default: boolean;
    };
    maskClickBehavior: {
        type: PropType<"close" | "next" | "none">;
        default: string;
    };
    previousText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    nextText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    finishText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    skipText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    progressFormatter: PropType<(context: {
        current: number;
        total: number;
    }) => any>;
    previousButtonOptions: PropType<TourButtonOptions>;
    nextButtonOptions: PropType<TourButtonOptions>;
    finishButtonOptions: PropType<TourButtonOptions>;
    skipButtonOptions: PropType<TourButtonOptions>;
};

declare type Props_3 = ExtractPropTypes<typeof props_3>;

declare const props_3: {
    render: {
        type: Render;
        default: () => null;
    };
};

declare type Props_4 = ExtractPropTypes<typeof props_4>;

declare const props_4: {
    tag: {
        type: StringConstructor;
        default: string;
    };
    type: {
        type: PropType<"default" | "primary" | "text" | "success" | "error" | "warning">;
        default: string;
    };
    size: {
        type: PropType<"small" | "medium" | "large">;
        default: string;
    };
    wait: {
        type: NumberConstructor;
        default: number;
    };
    icon: StringConstructor;
    disabled: BooleanConstructor;
    circle: BooleanConstructor;
    round: BooleanConstructor;
    long: BooleanConstructor;
    solid: BooleanConstructor;
    dashed: BooleanConstructor;
    htmlType: {
        type: PropType<"button" | "submit" | "reset">;
        default: string;
    };
};

declare type Props_5 = ExtractPropTypes<typeof props_6>;

declare const props_5: {
    always: {
        type: BooleanConstructor;
        default: boolean;
    };
    native: {
        type: BooleanConstructor;
        default: boolean;
    };
    thumbMinSize: {
        type: NumberConstructor;
        default: number;
    };
    thumbStyle: PropType<StyleValue>;
    thumbClass: PropType<StyleValue>;
    autoResize: {
        type: BooleanConstructor;
        default: boolean;
    };
    trackOffsetX: {
        type: PropType<number[]>;
        default: () => number[];
    };
    trackOffsetY: {
        type: PropType<number[]>;
        default: () => number[];
    };
    trackStyle: PropType<StyleValue>;
    trackClass: PropType<StyleValue>;
    tag: {
        type: StringConstructor;
        default: string;
    };
    height: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    maxHeight: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    wrapperStyle: {
        type: PropType<StyleValue>;
        default: string;
    };
    wrapperClass: {
        type: PropType<StyleValue>;
        default: string;
    };
    contentStyle: {
        type: PropType<StyleValue>;
        default: string;
    };
    contentClass: {
        type: PropType<StyleValue>;
        default: string;
    };
    showBar: {
        type: BooleanConstructor;
        default: boolean;
    };
    wheel: {
        type: BooleanConstructor;
        default: boolean;
    };
    stopPropagation: {
        type: BooleanConstructor;
        default: boolean;
    };
    barTo: PropType<string | HTMLElement>;
    barTriggerElement: StringConstructor;
};

declare type Props_6 = ExtractPropTypes<typeof props_7>;

declare const props_6: {
    title: PropType<string | boolean | Props_3["render"]>;
    content: {
        type: PropType<string | Props_3["render"]>;
        default: string;
    };
    modelValue: {
        type: BooleanConstructor;
        default: boolean;
    };
    width: {
        type: NumberConstructor;
        default: number;
    };
    height: {
        type: NumberConstructor;
        default: number;
    };
    mask: {
        type: BooleanConstructor;
        default: boolean;
    };
    maskClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    scrollable: {
        type: BooleanConstructor;
        default: boolean;
    };
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    placement: {
        type: StringConstructor;
        default: string;
    };
    maskStyle: (ObjectConstructor | StringConstructor)[];
    wrapperClass: (ObjectConstructor | StringConstructor)[];
    wrapperStyle: (ObjectConstructor | StringConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    closeWithCancel: {
        type: BooleanConstructor;
        default: boolean;
    };
    okText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    cancelText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    okDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    cancelDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    footer: {
        type: BooleanConstructor;
        default: boolean;
    };
    onOk: {
        type: FunctionConstructor;
    };
    onCancel: {
        type: FunctionConstructor;
    };
};

declare type Props_7 = ExtractPropTypes<typeof props_8>;

declare const props_7: {
    tag: {
        type: StringConstructor;
        default: string;
    };
    model: {
        type: ObjectConstructor;
    };
    rules: {
        type: PropType<Record<string, FormRule>>;
    };
    labelWidth: {
        type: NumberConstructor;
    };
    showMessage: {
        type: BooleanConstructor;
        default: boolean;
    };
    inline: {
        type: BooleanConstructor;
        default: boolean;
    };
    labelPosition: {
        type: PropType<"left" | "right" | "top">;
        default: string;
    };
    autocomplete: {
        type: PropType<"on" | "off">;
        default: string;
    };
    styleless: {
        type: BooleanConstructor;
        default: boolean;
    };
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    labelStyle: (ObjectConstructor | StringConstructor)[];
    labelClass: (ObjectConstructor | StringConstructor)[];
    errorStyle: (ObjectConstructor | StringConstructor)[];
    errorClass: (ObjectConstructor | StringConstructor)[];
    nestedContentStyle: (ObjectConstructor | StringConstructor)[];
    nestedContentClass: (ObjectConstructor | StringConstructor)[];
    nestedLabelStyle: (ObjectConstructor | StringConstructor)[];
    nestedLabelClass: (ObjectConstructor | StringConstructor)[];
    nestedErrorStyle: (ObjectConstructor | StringConstructor)[];
    nestedErrorClass: (ObjectConstructor | StringConstructor)[];
};

declare type Props_8 = ExtractPropTypes<typeof props_9>;

declare const props_8: {
    content: PropType<string | Props_3["render"]>;
    mask: {
        type: BooleanConstructor;
        default: boolean;
    };
    maskClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    fixed: {
        type: BooleanConstructor;
        default: boolean;
    };
    duration: {
        type: NumberConstructor;
        default: number;
    };
    top: {
        type: NumberConstructor;
        default: number;
    };
    closable: {
        type: BooleanConstructor;
        default: boolean;
    };
    mode: {
        type: PropType<"info" | "loading" | "success" | "warning" | "error">;
        default: string;
        validator: (v: string) => boolean;
    };
    onBeforeClose: FunctionConstructor;
};

declare type Props_9 = ExtractPropTypes<typeof props_10>;

declare const props_9: {
    modelValue: {
        type: BooleanConstructor;
        default: boolean;
    };
    mode: {
        type: PropType<"info" | "success" | "error" | "warning">;
        validator: (v: string) => boolean;
    };
    content: {
        type: PropType<string | Props_3["render"]>;
        default: string;
    };
    size: {
        type: PropType<"small" | "medium" | "large">;
        validator: (v: string) => boolean;
        default: string;
    };
    contentStyle: (ObjectConstructor | StringConstructor)[];
    contentClass: (ObjectConstructor | StringConstructor)[];
    width: {
        type: NumberConstructor;
    };
    height: {
        type: PropType<number | "auto">;
    };
    mask: {
        type: BooleanConstructor;
        default: boolean;
    };
    closable: {
        type: BooleanConstructor;
        default: boolean;
    };
    maskClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    escClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    closeWithCancel: {
        type: BooleanConstructor;
        default: boolean;
    };
    title: {
        type: PropType<string | Props_3["render"]>;
    };
    scrollable: {
        type: BooleanConstructor;
        default: boolean;
    };
    scrollerOptions: PropType<Partial<ScrollerProps>>;
    draggable: {
        type: BooleanConstructor;
        default: boolean;
    };
    x: NumberConstructor;
    y: NumberConstructor;
    okText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    cancelText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: undefined;
    };
    wrapperStyle: (ObjectConstructor | StringConstructor)[];
    wrapperClass: (ObjectConstructor | StringConstructor)[];
    footer: {
        type: BooleanConstructor;
        default: boolean;
    };
    border: {
        type: BooleanConstructor;
        default: boolean;
    };
    okDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    cancelDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    onOk: {
        type: FunctionConstructor;
    };
    onCancel: {
        type: FunctionConstructor;
    };
};

export declare const Radio: DefineComponent<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
name: {
type: StringConstructor;
};
trueValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
falseValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
name: {
type: StringConstructor;
};
trueValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
falseValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
value: string | number | boolean;
label: string | number | boolean;
disabled: boolean;
modelValue: string | number | boolean;
trueValue: string | number | boolean;
falseValue: string | number | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const RadioButton: DefineComponent<ExtractPropTypes<    {
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
name: {
type: StringConstructor;
};
trueValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
falseValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
labelStyle: (ObjectConstructor | StringConstructor)[];
labelClass: (ObjectConstructor | StringConstructor)[];
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
name: {
type: StringConstructor;
};
trueValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
falseValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
value: string | number | boolean;
label: string | number | boolean;
disabled: boolean;
modelValue: string | number | boolean;
trueValue: string | number | boolean;
falseValue: string | number | boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const RadioGroup: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
type: {
type: StringConstructor;
default: string;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
name: {
type: StringConstructor;
default: () => string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[] | JSX.Element | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
type: {
type: StringConstructor;
default: string;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
name: {
type: StringConstructor;
default: () => string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
fragment: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
name: string;
type: string;
disabled: boolean;
vertical: boolean;
modelValue: string | number;
fragment: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Rate: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
count: {
type: NumberConstructor;
default: number;
};
color: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
character: StringConstructor;
half: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
tooltip: {
type: ArrayConstructor;
default: () => never[];
};
iconStyle: {
type: ObjectConstructor;
default: () => {};
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
count: {
type: NumberConstructor;
default: number;
};
color: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
character: StringConstructor;
half: {
type: BooleanConstructor;
default: boolean;
};
clearable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
tooltip: {
type: ArrayConstructor;
default: () => never[];
};
iconStyle: {
type: ObjectConstructor;
default: () => {};
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
count: number;
color: string;
disabled: boolean;
icon: string;
tooltip: unknown[];
modelValue: string | number;
clearable: boolean;
iconStyle: Record<string, any>;
half: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const RECYCLE_LIST_RESERVED_KEYS: readonly ["data", "store", "disabled", "fill", "vertical", "inverted", "columns", "gap", "pullable", "loadData", "lazyTail", "scrollerOptions", "estimateSize", "style", "class"];

export declare const RecycleList: DefineComponent<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: () => never[];
};
store: PropType<RecycleListStore>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
batchCount: {
type: NumberConstructor;
default: number;
};
bufferCount: {
type: NumberConstructor;
default: number;
};
estimateSize: PropType<number | ((data: {
row: any;
index: number;
}) => number | undefined)>;
overscan: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
loadData: {
type: FunctionConstructor;
default: () => boolean;
};
columns: {
type: NumberConstructor;
default: number;
};
gap: {
type: NumberConstructor;
default: number;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
pullable: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
fill: {
type: BooleanConstructor;
default: boolean;
};
lazyTail: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<ScrollerProps>;
renderEmpty: Render;
renderComplete: Render;
renderLoading: Render;
renderPlaceholder: Render;
renderRefresh: Render;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("scroll" | "row-resize" | "load-change")[], "scroll" | "row-resize" | "load-change", PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: () => never[];
};
store: PropType<RecycleListStore>;
disabled: {
type: BooleanConstructor;
default: boolean;
};
batchCount: {
type: NumberConstructor;
default: number;
};
bufferCount: {
type: NumberConstructor;
default: number;
};
estimateSize: PropType<number | ((data: {
row: any;
index: number;
}) => number | undefined)>;
overscan: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
loadData: {
type: FunctionConstructor;
default: () => boolean;
};
columns: {
type: NumberConstructor;
default: number;
};
gap: {
type: NumberConstructor;
default: number;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
pullable: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
fill: {
type: BooleanConstructor;
default: boolean;
};
lazyTail: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<ScrollerProps>;
renderEmpty: Render;
renderComplete: Render;
renderLoading: Render;
renderPlaceholder: Render;
renderRefresh: Render;
}>> & Readonly<{
onScroll?: ((...args: any[]) => any) | undefined;
"onRow-resize"?: ((...args: any[]) => any) | undefined;
"onLoad-change"?: ((...args: any[]) => any) | undefined;
}>, {
fill: boolean;
data: unknown[];
threshold: number;
columns: number;
gap: number;
disabled: boolean;
vertical: boolean;
loadData: Function;
batchCount: number;
bufferCount: number;
inverted: boolean;
overscan: number;
pullable: boolean;
lazyTail: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class RecycleListItemNode {
    id: string;
    states: {
        index: number;
        data: any;
        size: number;
        position: number;
        column: number;
        isPlaceholder: boolean;
    };
    raw: RecycleListItemNode['states'];
    estimate: number;
    static of(options: Options_7): RecycleListItemNode;
    constructor(options: Options_7);
    setData(data?: any): void;
    reuse(options: Options_7): this;
    rebind(options: Options_7): this;
}

declare type RecycleListItemNodeRaw = Raw<RecycleListItemNode>;

export declare type RecycleListLoadState = {
    isEnd: boolean;
    isLoading: boolean;
    isSilentRefresh: boolean;
    isEmpty: boolean;
    loaded: number;
};

declare type RecycleListStates = {
    rebuildData: RecycleListItemNodeRaw[];
    loadings: string[];
    contentMaxSize: number;
    columnFillSize: number[];
    isEnd: boolean;
    isSilentRefresh: boolean;
    isLoading: boolean;
    isBuilt: boolean;
    loaded: number;
    columnSize: string | undefined;
    columnOffsetGap: number;
    columns: {
        index: number;
        offset: number[];
    }[];
    firstItemIndex: number;
    lastItemIndex: number;
    pendingVersion: number;
    data: RecycleListItemNodeRaw[][];
    preData: RecycleListItemNodeRaw[];
};

export declare class RecycleListStore extends BaseWatcher {
    promiseStack: Promise<any>[];
    layout: Layout;
    position: Position;
    local: Local;
    nodes: Nodes;
    scroll: Scroll;
    props: Props_11;
    constructor(options: Partial<Props_11>);
    setData(data: any[]): boolean;
    syncProps(next: Partial<Props_11>): void;
    fetchPage(onBeforeCommit?: () => void): Promise<{
        page: number;
        response: any;
        start: number;
        end: any;
    }>;
    stop(): void;
    reset(): void;
    clear(): void;
}

export declare type Render = PropType<(props: Record<string, unknown>, context: SetupContext) => any>;

declare interface RenderDateProps {
    cell: CalendarCell;
    today: string;
    holiday: CalendarHoliday;
}

declare interface RenderMonthProps {
    data: {
        month: string;
        year: number;
    };
    month: number;
    year: number;
    lang: CalendarLang;
}

declare interface RenderWeekProps {
    data: string[];
    date: string[];
    lang: CalendarLang;
    firstDayOfWeek: CalendarFirstDayOfWeek;
}

export declare const Resizer: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
fill: {
type: (BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "resize"[], "resize", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
fill: {
type: (BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
}>> & Readonly<{
onResize?: ((...args: any[]) => any) | undefined;
}>, {
fill: boolean | unknown[];
tag: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface RGB {
    r: number;
    g: number;
    b: number;
}

declare class Row {
    store: Store;
    constructor(store: Store);
    setHoverIndex(index: any): void;
    set(row: any): void;
    setById(id?: number | string): void;
    update(): void;
}

declare class Scroll {
    currentLeaf: ScrollLeaf | null;
    leafs: ScrollLeaf[];
    add(leaf: ScrollLeaf | null | undefined): void;
    remove(leaf: ScrollLeaf | null | undefined): void;
    broadcast(e: {
        target: {
            scrollLeft: number;
            scrollTop: number;
        } | EventTarget | null;
    }): void;
}

export declare const Scroller: DefineComponent<ExtractPropTypes<    {
always: {
type: BooleanConstructor;
default: boolean;
};
native: {
type: BooleanConstructor;
default: boolean;
};
thumbMinSize: {
type: NumberConstructor;
default: number;
};
thumbStyle: PropType<StyleValue>;
thumbClass: PropType<StyleValue>;
autoResize: {
type: BooleanConstructor;
default: boolean;
};
trackOffsetX: {
type: PropType<number[]>;
default: () => number[];
};
trackOffsetY: {
type: PropType<number[]>;
default: () => number[];
};
trackStyle: PropType<StyleValue>;
trackClass: PropType<StyleValue>;
tag: {
type: StringConstructor;
default: string;
};
height: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
maxHeight: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
wrapperStyle: {
type: PropType<StyleValue>;
default: string;
};
wrapperClass: {
type: PropType<StyleValue>;
default: string;
};
contentStyle: {
type: PropType<StyleValue>;
default: string;
};
contentClass: {
type: PropType<StyleValue>;
default: string;
};
showBar: {
type: BooleanConstructor;
default: boolean;
};
wheel: {
type: BooleanConstructor;
default: boolean;
};
stopPropagation: {
type: BooleanConstructor;
default: boolean;
};
barTo: PropType<string | HTMLElement>;
barTriggerElement: StringConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "scroll"[], "scroll", PublicProps, Readonly<ExtractPropTypes<    {
always: {
type: BooleanConstructor;
default: boolean;
};
native: {
type: BooleanConstructor;
default: boolean;
};
thumbMinSize: {
type: NumberConstructor;
default: number;
};
thumbStyle: PropType<StyleValue>;
thumbClass: PropType<StyleValue>;
autoResize: {
type: BooleanConstructor;
default: boolean;
};
trackOffsetX: {
type: PropType<number[]>;
default: () => number[];
};
trackOffsetY: {
type: PropType<number[]>;
default: () => number[];
};
trackStyle: PropType<StyleValue>;
trackClass: PropType<StyleValue>;
tag: {
type: StringConstructor;
default: string;
};
height: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
maxHeight: {
type: (StringConstructor | NumberConstructor)[];
default: string;
};
wrapperStyle: {
type: PropType<StyleValue>;
default: string;
};
wrapperClass: {
type: PropType<StyleValue>;
default: string;
};
contentStyle: {
type: PropType<StyleValue>;
default: string;
};
contentClass: {
type: PropType<StyleValue>;
default: string;
};
showBar: {
type: BooleanConstructor;
default: boolean;
};
wheel: {
type: BooleanConstructor;
default: boolean;
};
stopPropagation: {
type: BooleanConstructor;
default: boolean;
};
barTo: PropType<string | HTMLElement>;
barTriggerElement: StringConstructor;
}>> & Readonly<{
onScroll?: ((...args: any[]) => any) | undefined;
}>, {
always: boolean;
native: boolean;
height: string | number;
maxHeight: string | number;
wheel: boolean;
tag: string;
contentClass: StyleValue;
contentStyle: StyleValue;
wrapperClass: StyleValue;
wrapperStyle: StyleValue;
thumbMinSize: number;
autoResize: boolean;
trackOffsetX: number[];
trackOffsetY: number[];
showBar: boolean;
stopPropagation: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare type ScrollerExposed = {
    refresh: () => void;
    setScrollTop: (v: number) => void;
    setScrollLeft: (v: number) => void;
};

export declare type ScrollerProps = ExtractPropTypes<typeof props_5>;

declare type ScrollLeaf = {
    exposed: {
        scrollTo: (opts: {
            x: number;
            y: number;
        }) => void;
    };
};

export declare const Select: DefineComponent<ExtractPropTypes<    {
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
data: {
type: ArrayConstructor;
default: () => never[];
};
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("clear" | "change" | "close" | "ready" | "update:modelValue" | "visible-change")[], "clear" | "change" | "close" | "ready" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
data: {
type: ArrayConstructor;
default: () => never[];
};
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: unknown[];
disabled: boolean;
tag: string;
extra: string;
separator: string;
placement: string;
arrow: boolean;
portal: boolean;
trigger: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
maxTagLines: number;
searchable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Selection_2 {
    store: Store;
    indexMap: ComputedRef<Map<unknown, number>>;
    constructor(store: Store);
    getIndex(row: any): number;
    isSelected(row: any): boolean;
    clear(): void;
    clean(): void;
    toggle(row: any, selected?: any, emitChange?: boolean): void;
    add(rows: any[]): void;
    toggleAll: DebouncedFunc<() => void>;
    updateByRowKey(): void;
    updateAllSelected(): void;
    rowChanged(row: any): void;
}

export declare const Slider: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<SliderValue>;
default: number;
};
min: {
type: NumberConstructor;
default: number;
};
max: {
type: NumberConstructor;
default: number;
};
step: {
type: NumberConstructor;
default: number;
};
range: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
showStops: {
type: BooleanConstructor;
default: boolean;
};
formatter: {
type: PropType<(value: number) => SliderTipValue>;
default: (value: number) => string;
};
showInput: {
type: BooleanConstructor;
default: boolean;
};
showTip: {
type: PropType<SliderShowTip>;
default: string;
validator: (value: string) => boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "after-change")[], "change" | "update:modelValue" | "after-change", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<SliderValue>;
default: number;
};
min: {
type: NumberConstructor;
default: number;
};
max: {
type: NumberConstructor;
default: number;
};
step: {
type: NumberConstructor;
default: number;
};
range: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
showStops: {
type: BooleanConstructor;
default: boolean;
};
formatter: {
type: PropType<(value: number) => SliderTipValue>;
default: (value: number) => string;
};
showInput: {
type: BooleanConstructor;
default: boolean;
};
showTip: {
type: PropType<SliderShowTip>;
default: string;
validator: (value: string) => boolean;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onAfter-change"?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
min: number;
disabled: boolean;
range: boolean;
step: number;
modelValue: SliderValue;
formatter: (value: number) => SliderTipValue;
clickable: boolean;
showStops: boolean;
showInput: boolean;
showTip: SliderShowTip;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type SliderShowTip = 'hover' | 'always' | 'never';

declare type SliderTipValue = string | number | null | undefined;

declare type SliderValue = number | [number, number] | number[];

export declare const Snapshot: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
crossOrigin: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
source: FunctionConstructor;
download: FunctionConstructor;
lazy: {
type: BooleanConstructor;
default: boolean;
};
showLoading: {
type: BooleanConstructor;
default: boolean;
};
options: {
type: ObjectConstructor;
default: () => {};
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "ready"[], "ready", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
crossOrigin: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
source: FunctionConstructor;
download: FunctionConstructor;
lazy: {
type: BooleanConstructor;
default: boolean;
};
showLoading: {
type: BooleanConstructor;
default: boolean;
};
options: {
type: ObjectConstructor;
default: () => {};
};
}>> & Readonly<{
onReady?: ((...args: any[]) => any) | undefined;
}>, {
lazy: boolean;
options: Record<string, any>;
tag: string;
crossOrigin: string;
showLoading: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const SortList: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<SortListRow[]>;
default: () => never[];
};
tag: {
type: StringConstructor;
default: string;
};
primaryKey: {
type: PropType<SortListPrimaryKey>;
default: string;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
draggableKey: {
type: PropType<SortListPrimaryKey>;
default: undefined;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: PropType<SortListRow[]>;
default: () => never[];
};
tag: {
type: StringConstructor;
default: string;
};
primaryKey: {
type: PropType<SortListPrimaryKey>;
default: string;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
draggableKey: {
type: PropType<SortListPrimaryKey>;
default: undefined;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
mask: boolean;
draggable: boolean;
tag: string;
modelValue: any[];
primaryKey: SortListPrimaryKey;
draggableKey: SortListPrimaryKey;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type SortListPrimaryKey = string | number;

declare type SortListRow = any;

export declare const Spin: DefineComponent<ExtractPropTypes<    {
size: {
type: NumberConstructor;
default: number;
};
foreground: {
type: StringConstructor;
default: string;
};
background: {
type: StringConstructor;
default: string;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
size: {
type: NumberConstructor;
default: number;
};
foreground: {
type: StringConstructor;
default: string;
};
background: {
type: StringConstructor;
default: string;
};
fixed: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
fixed: boolean;
size: number;
background: string;
foreground: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Step: DefineComponent<ExtractPropTypes<    {
title: {
type: PropType<string | Props_3["render"]>;
default: string;
};
description: {
type: PropType<string | Props_3["render"]>;
default: string;
};
status: {
type: PropType<StepStatus>;
validator(val: StepStatus): boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
index: {
type: NumberConstructor;
default: number;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: PropType<string | Props_3["render"]>;
default: string;
};
description: {
type: PropType<string | Props_3["render"]>;
default: string;
};
status: {
type: PropType<StepStatus>;
validator(val: StepStatus): boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
index: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
index: number;
title: string | ((props: Record<string, unknown>, context: SetupContext) => any);
disabled: boolean;
description: string | ((props: Record<string, unknown>, context: SetupContext) => any);
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const STEP_STATUSES: readonly ["default", "pending", "success", "error"];

export declare const Steps: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
modelValue: {
type: NumberConstructor;
default: number;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"right" | "bottom" | "left" | "top">;
default: string;
validator(val: string): boolean;
};
type: {
type: PropType<"default" | "dot" | "arrow" | "navigation">;
default: string;
validator(val: string): boolean;
};
status: {
type: PropType<StepStatus>;
default: string;
validator(val: StepStatus): boolean;
};
lineless: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
renderDot: PropType<StepsRenderDot>;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
modelValue: {
type: NumberConstructor;
default: number;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
labelPosition: {
type: PropType<"right" | "bottom" | "left" | "top">;
default: string;
validator(val: string): boolean;
};
type: {
type: PropType<"default" | "dot" | "arrow" | "navigation">;
default: string;
validator(val: string): boolean;
};
status: {
type: PropType<StepStatus>;
default: string;
validator(val: StepStatus): boolean;
};
lineless: {
type: BooleanConstructor;
default: boolean;
};
clickable: {
type: BooleanConstructor;
default: boolean;
};
renderDot: PropType<StepsRenderDot>;
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
type: "default" | "navigation" | "dot" | "arrow";
status: "default" | "error" | "pending" | "success";
tag: string;
vertical: boolean;
modelValue: number;
labelPosition: "left" | "top" | "bottom" | "right";
clickable: boolean;
lineless: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type StepsRenderDot = (options: {
    index: number;
    status: StepStatus;
    title: any;
    description: any;
    dot: VNodeChild;
}) => VNodeChild;

declare type StepStatus = typeof STEP_STATUSES[number];

declare class Store extends BaseWatcher_2 {
    table: any;
    row: Row;
    expand: Expand_2;
    tree: Tree_2;
    block: Block;
    column: Column;
    drag: Drag;
    layout: Layout_2;
    selection: Selection_2;
    flatData: ComputedRef<any[]>;
    constructor(options: any);
    setData(data: any[]): void;
    updateList(): void;
    updateColumns(): void;
    toggleRowExpansion(row: any, expanded?: boolean): void;
    setExpandedValues(values: any[]): void;
    scheduleLayout(needUpdateColumns?: any): void;
}

export declare const Switch: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
checkedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
uncheckedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
name: {
type: StringConstructor;
};
checkedText: {
type: StringConstructor;
default: string;
};
uncheckedText: {
type: StringConstructor;
default: string;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
borderWidth: {
type: NumberConstructor;
default: number;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "click" | "update:modelValue")[], "change" | "click" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
checkedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
uncheckedValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
name: {
type: StringConstructor;
};
checkedText: {
type: StringConstructor;
default: string;
};
uncheckedText: {
type: StringConstructor;
default: string;
};
width: {
type: NumberConstructor;
default: number;
};
height: {
type: NumberConstructor;
default: number;
};
borderWidth: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClick?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
height: number;
width: number;
borderWidth: number;
disabled: boolean;
modelValue: string | number | boolean;
checkedValue: string | number | boolean;
uncheckedValue: string | number | boolean;
checkedText: string;
uncheckedText: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Table: DefineComponent<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: () => never[];
};
width: (StringConstructor | NumberConstructor)[];
height: (StringConstructor | NumberConstructor)[];
maxHeight: (StringConstructor | NumberConstructor)[];
virtualized: {
type: BooleanConstructor;
default: boolean;
};
lazyTail: {
type: BooleanConstructor;
default: boolean;
};
rowHeight: PropType<TableRowHeight>;
recycleListOptions: PropType<Partial<Omit<Props_11, RECYCLE_LIST_RESERVED_KEYS[number]>>>;
fit: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: PropType<"large" | "medium" | "small" | "mini">;
default: string;
};
stripe: BooleanConstructor;
border: BooleanConstructor;
divider: BooleanConstructor;
primaryKey: (FunctionConstructor | StringConstructor)[];
showHeader: {
type: BooleanConstructor;
default: boolean;
};
showSummary: BooleanConstructor;
sumText: StringConstructor;
getSummary: FunctionConstructor;
rowClass: (FunctionConstructor | StringConstructor)[];
rowStyle: (ObjectConstructor | FunctionConstructor)[];
cellClass: (FunctionConstructor | StringConstructor)[];
cellStyle: (ObjectConstructor | FunctionConstructor)[];
headerRowClass: (FunctionConstructor | StringConstructor)[];
headerRowStyle: (ObjectConstructor | FunctionConstructor)[];
headerCellClass: (FunctionConstructor | StringConstructor)[];
headerCellStyle: (ObjectConstructor | FunctionConstructor)[];
highlight: BooleanConstructor;
currentRowValue: (StringConstructor | NumberConstructor)[];
emptyText: (FunctionConstructor | StringConstructor)[];
expandedValues: ArrayConstructor;
defaultExpandAll: BooleanConstructor;
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
lazyTree: BooleanConstructor;
indent: {
type: NumberConstructor;
default: number;
};
keyValue: {
type: ObjectConstructor;
default: () => {
hasChildren: string;
children: string;
};
};
expandSelectable: {
type: BooleanConstructor;
default: boolean;
};
loadExpand: FunctionConstructor;
getSpan: FunctionConstructor;
placeholder: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
sort: {
type: ObjectConstructor;
default: () => {};
};
resizable: {
type: BooleanConstructor;
default: undefined;
};
affix: {
type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
columns: {
type: PropType<TableColumnSyncItem[]>;
default: () => never[];
};
draggable: {
type: PropType<boolean | [boolean, boolean]>;
default: boolean;
};
allowDrag: PropType<(data: TableAllowDragPayload) => boolean>;
allowDrop: PropType<(data: TableAllowDropPayload) => boolean>;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("select" | "select-all" | "selection-change" | "load-change" | "update:columns" | "expand-change" | "current-change" | "cell-mouseleave" | "cell-mouseenter" | "header-click" | "header-contextmenu" | "column-resize" | "update:sort" | "sort-change" | "block-dragstart" | "update:data" | "block-drop" | "block-dragend" | "cell-click" | "cell-dblclick" | "cell-contextmenu" | "row-click" | "row-contextmenu" | "row-dblclick")[], "select" | "select-all" | "selection-change" | "load-change" | "update:columns" | "expand-change" | "current-change" | "cell-mouseleave" | "cell-mouseenter" | "header-click" | "header-contextmenu" | "column-resize" | "update:sort" | "sort-change" | "block-dragstart" | "update:data" | "block-drop" | "block-dragend" | "cell-click" | "cell-dblclick" | "cell-contextmenu" | "row-click" | "row-contextmenu" | "row-dblclick", PublicProps, Readonly<ExtractPropTypes<    {
data: {
type: ArrayConstructor;
default: () => never[];
};
width: (StringConstructor | NumberConstructor)[];
height: (StringConstructor | NumberConstructor)[];
maxHeight: (StringConstructor | NumberConstructor)[];
virtualized: {
type: BooleanConstructor;
default: boolean;
};
lazyTail: {
type: BooleanConstructor;
default: boolean;
};
rowHeight: PropType<TableRowHeight>;
recycleListOptions: PropType<Partial<Omit<Props_11, RECYCLE_LIST_RESERVED_KEYS[number]>>>;
fit: {
type: BooleanConstructor;
default: boolean;
};
size: {
type: PropType<"large" | "medium" | "small" | "mini">;
default: string;
};
stripe: BooleanConstructor;
border: BooleanConstructor;
divider: BooleanConstructor;
primaryKey: (FunctionConstructor | StringConstructor)[];
showHeader: {
type: BooleanConstructor;
default: boolean;
};
showSummary: BooleanConstructor;
sumText: StringConstructor;
getSummary: FunctionConstructor;
rowClass: (FunctionConstructor | StringConstructor)[];
rowStyle: (ObjectConstructor | FunctionConstructor)[];
cellClass: (FunctionConstructor | StringConstructor)[];
cellStyle: (ObjectConstructor | FunctionConstructor)[];
headerRowClass: (FunctionConstructor | StringConstructor)[];
headerRowStyle: (ObjectConstructor | FunctionConstructor)[];
headerCellClass: (FunctionConstructor | StringConstructor)[];
headerCellStyle: (ObjectConstructor | FunctionConstructor)[];
highlight: BooleanConstructor;
currentRowValue: (StringConstructor | NumberConstructor)[];
emptyText: (FunctionConstructor | StringConstructor)[];
expandedValues: ArrayConstructor;
defaultExpandAll: BooleanConstructor;
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
lazyTree: BooleanConstructor;
indent: {
type: NumberConstructor;
default: number;
};
keyValue: {
type: ObjectConstructor;
default: () => {
hasChildren: string;
children: string;
};
};
expandSelectable: {
type: BooleanConstructor;
default: boolean;
};
loadExpand: FunctionConstructor;
getSpan: FunctionConstructor;
placeholder: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
sort: {
type: ObjectConstructor;
default: () => {};
};
resizable: {
type: BooleanConstructor;
default: undefined;
};
affix: {
type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
columns: {
type: PropType<TableColumnSyncItem[]>;
default: () => never[];
};
draggable: {
type: PropType<boolean | [boolean, boolean]>;
default: boolean;
};
allowDrag: PropType<(data: TableAllowDragPayload) => boolean>;
allowDrop: PropType<(data: TableAllowDropPayload) => boolean>;
}>> & Readonly<{
onSelect?: ((...args: any[]) => any) | undefined;
"onLoad-change"?: ((...args: any[]) => any) | undefined;
"onSelect-all"?: ((...args: any[]) => any) | undefined;
"onSelection-change"?: ((...args: any[]) => any) | undefined;
"onUpdate:columns"?: ((...args: any[]) => any) | undefined;
"onExpand-change"?: ((...args: any[]) => any) | undefined;
"onCurrent-change"?: ((...args: any[]) => any) | undefined;
"onCell-mouseleave"?: ((...args: any[]) => any) | undefined;
"onCell-mouseenter"?: ((...args: any[]) => any) | undefined;
"onHeader-click"?: ((...args: any[]) => any) | undefined;
"onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
"onColumn-resize"?: ((...args: any[]) => any) | undefined;
"onUpdate:sort"?: ((...args: any[]) => any) | undefined;
"onSort-change"?: ((...args: any[]) => any) | undefined;
"onBlock-dragstart"?: ((...args: any[]) => any) | undefined;
"onUpdate:data"?: ((...args: any[]) => any) | undefined;
"onBlock-drop"?: ((...args: any[]) => any) | undefined;
"onBlock-dragend"?: ((...args: any[]) => any) | undefined;
"onCell-click"?: ((...args: any[]) => any) | undefined;
"onCell-dblclick"?: ((...args: any[]) => any) | undefined;
"onCell-contextmenu"?: ((...args: any[]) => any) | undefined;
"onRow-click"?: ((...args: any[]) => any) | undefined;
"onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
"onRow-dblclick"?: ((...args: any[]) => any) | undefined;
}>, {
sort: Record<string, any>;
resizable: boolean;
data: unknown[];
size: "small" | "medium" | "large" | "mini";
border: boolean;
columns: TableColumnSyncItem[];
draggable: boolean | [boolean, boolean];
highlight: boolean;
placeholder: string | Function;
indeterminate: boolean;
fit: boolean;
indent: number;
lazyTail: boolean;
showHeader: boolean;
keyValue: Record<string, any>;
expandSelectable: boolean;
lazyTree: boolean;
virtualized: boolean;
stripe: boolean;
divider: boolean;
showSummary: boolean;
defaultExpandAll: boolean;
affix: boolean | unknown[] | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type TableAllowDragPayload = ({
    type: 'block';
} & TableBlockDragPayload) | ({
    type: 'column';
} & TableColumnDragPayload);

declare type TableAllowDropPayload = ({
    type: 'block';
} & Pick<TableBlockDropPayload, 'rows' | 'targetRows' | 'position' | 'from' | 'to'>) | ({
    type: 'column';
} & Omit<TableColumnDropPayload, 'columns'>);

declare interface TableBlockDragPayload {
    rows: any[];
    rowIndex: number;
}

declare interface TableBlockDropPayload {
    rows: any[];
    targetRows: any[];
    position: TableDropPosition;
    from: TableDropPlace;
    to: TableDropPlace;
    rawData: any[];
}

export declare const TableColumn: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
line: NumberConstructor;
headerLine: NumberConstructor;
label: StringConstructor;
labelClass: StringConstructor;
prop: StringConstructor;
width: (StringConstructor | NumberConstructor)[];
minWidth: (StringConstructor | NumberConstructor)[];
renderHeader: PropType<TableColumnStates["renderHeader"]>;
resizable: {
type: BooleanConstructor;
default: boolean;
};
align: StringConstructor;
headerAlign: StringConstructor;
fixed: PropType<boolean | string>;
formatter: PropType<TableColumnStates["formatter"]>;
selectable: PropType<TableColumnStates["selectable"]>;
reserveSelection: BooleanConstructor;
index: PropType<number | ((rowIndex: number) => number)>;
sortable: BooleanConstructor;
filterOptions: PropType<TableFilterOptions>;
tooltip: PropType<TableColumnStates["tooltip"]>;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
line: NumberConstructor;
headerLine: NumberConstructor;
label: StringConstructor;
labelClass: StringConstructor;
prop: StringConstructor;
width: (StringConstructor | NumberConstructor)[];
minWidth: (StringConstructor | NumberConstructor)[];
renderHeader: PropType<TableColumnStates["renderHeader"]>;
resizable: {
type: BooleanConstructor;
default: boolean;
};
align: StringConstructor;
headerAlign: StringConstructor;
fixed: PropType<boolean | string>;
formatter: PropType<TableColumnStates["formatter"]>;
selectable: PropType<TableColumnStates["selectable"]>;
reserveSelection: BooleanConstructor;
index: PropType<number | ((rowIndex: number) => number)>;
sortable: BooleanConstructor;
filterOptions: PropType<TableFilterOptions>;
tooltip: PropType<TableColumnStates["tooltip"]>;
}>> & Readonly<{}>, {
resizable: boolean;
type: string;
reserveSelection: boolean;
sortable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface TableColumnDragPayload {
    column: TableColumnStates;
    columnIndex: number;
}

declare interface TableColumnDropPayload {
    column: TableColumnStates;
    targetColumn: TableColumnStates;
    position: TableColumnDropPosition;
    from: TableColumnDropPlace;
    to: TableColumnDropPlace;
    columns: TableColumnSyncItem[];
}

declare interface TableColumnDropPlace {
    parent: Nullable<TableColumnStates>;
    index: number;
}

declare type TableColumnDropPosition = Exclude<TableDropPosition, 'inner'>;

declare type TableColumnMove = {
    from: TableColumnPlace;
    to: TableColumnPlace;
};

declare class TableColumnNode {
    states: TableColumnStates;
    childNodes: TableColumnNode[];
    table: TableProvide;
    parentNode: Nullable<TableColumnNode>;
    origin: Nullable<TableColumnNode>;
    instance: ComponentInternalInstance;
    constructor(options: Options_8);
    init(props: TableColumnProps, slots: Slots, attrs: SetupContext['attrs']): void;
    private registerWatchers;
    private applyForcedProps;
    private applyWidth;
    private applyRenders;
    cloneNode(childNodes?: TableColumnNode[]): TableColumnNode;
}

declare type TableColumnNodeRaw = Raw<TableColumnNode>;

declare type TableColumnPlace = {
    parent: Nullable<TableColumnNode>;
    index: number;
};

declare type TableColumnProps = ExtractPropTypes<typeof tableColumnProps>;

declare const tableColumnProps: {
    type: {
        type: StringConstructor;
        default: string;
    };
    line: NumberConstructor;
    headerLine: NumberConstructor;
    label: StringConstructor;
    labelClass: StringConstructor;
    prop: StringConstructor;
    width: (StringConstructor | NumberConstructor)[];
    minWidth: (StringConstructor | NumberConstructor)[];
    renderHeader: PropType<TableColumnStates["renderHeader"]>;
    resizable: {
        type: BooleanConstructor;
        default: boolean;
    };
    align: StringConstructor;
    headerAlign: StringConstructor;
    fixed: PropType<boolean | string>;
    formatter: PropType<TableColumnStates["formatter"]>;
    selectable: PropType<TableColumnStates["selectable"]>;
    reserveSelection: BooleanConstructor;
    index: PropType<number | ((rowIndex: number) => number)>;
    sortable: BooleanConstructor;
    filterOptions: PropType<TableFilterOptions>;
    tooltip: PropType<TableColumnStates["tooltip"]>;
};

declare interface TableColumnRenderData {
    row: Record<string, unknown>;
    column: TableColumnStates;
    rowIndex: number;
    columnIndex: number;
    store: Store;
    selected?: boolean;
    level?: number;
    isHead?: boolean;
    isTail?: boolean;
    treeNode?: TreeNode;
}

declare type TableColumnStates = {
    id: string;
    type: string;
    line?: number;
    headerLine?: number;
    label?: string;
    labelClass?: string;
    prop?: string;
    width?: number;
    minWidth?: number;
    resizable?: boolean;
    align?: string;
    headerAlign?: string;
    fixed?: boolean | string;
    formatter?: (data: TableColumnRenderData) => VNodeChild;
    selectable?: (row: Record<string, unknown>, rowIndex: number) => boolean;
    reserveSelection?: boolean;
    index?: number | ((rowIndex: number) => number);
    sortable?: boolean;
    filterOptions?: TableFilterOptions;
    tooltip?: string | ((data: Pick<TableColumnRenderData, 'column' | 'store'>) => string);
    colspan: number;
    rowspan: number;
    class?: string;
    style?: CSSProperties;
    realAlign: string | null;
    realHeaderAlign: string | null;
    realWidth?: number;
    resized?: boolean;
    hidden?: boolean;
    level?: number;
    stickyOffset?: number;
    stickyStyle?: CSSProperties;
    stickyClass?: string;
    renderHeader?: (data: Pick<TableColumnRenderData, 'column' | 'columnIndex' | 'store'>) => VNodeChild;
    renderCell?: (data: TableColumnRenderData) => VNodeChild;
    renderExpand?: (data: Pick<TableColumnRenderData, 'row' | 'rowIndex' | 'store'>) => VNodeChild;
};

declare interface TableColumnSyncItem {
    id: string;
    hidden?: boolean;
    label?: string;
    prop?: string;
    type?: string;
}

declare type TableDropPlace = {
    parent: any;
    index: number;
};

declare type TableDropPosition = 'before' | 'after' | 'inner';

declare type TableFilterOption = {
    label: string | number;
    value: string | number;
    disabled?: boolean;
};

declare type TableFilterOptions = {
    data: TableFilterOption[];
    max?: number;
    icon?: string;
    portalClass?: string | Record<string, unknown>;
    modelValue?: TableFilterValue;
    separator?: string;
    numerable?: boolean;
    onChange?: (value: TableFilterValue | undefined) => void;
} & {
    'onUpdate:modelValue'?: (value: TableFilterValue | undefined) => void;
};

declare type TableFilterValue = (string | number)[] | string | number;

declare type TableMove = {
    from: TableDropPlace;
    to: TableDropPlace;
};

declare interface TableProvide {
    tableId: string;
    store: Store;
    props: Props_12;
    emit: (event: string, ...args: unknown[]) => void;
    hiddenColumns: Ref<Nullable<HTMLElement>>;
    isReady: Ref<boolean>;
    resizeProxyVisible: Ref<boolean>;
    resizeProxy: Ref<Nullable<HTMLElement>>;
    tableWrapper: Ref<Nullable<HTMLElement>>;
    bodyXWrapper: Ref<Nullable<HTMLElement>>;
}

declare type TableRowHeight = string | number | ((data: {
    row: any;
    rowIndex: number;
}) => string | number | undefined);

declare type TableStates = {
    data: any[];
    renderData: any[];
    list: any[];
    headerRows: TableColumnNodeRaw[][];
    _columns: TableColumnNodeRaw[];
    originColumns: TableColumnNodeRaw[];
    notFixedColumns: TableColumnNodeRaw[];
    leftFixedColumns: TableColumnNodeRaw[];
    rightFixedColumns: TableColumnNodeRaw[];
    isAllSelected: boolean;
    selection: any[];
    reserveSelection: boolean;
    selectable: TableColumnStates['selectable'] | null;
    hoverRowIndex: number | null;
    dragging: boolean;
    currentRow: any;
    expandMap: Map<unknown, boolean>;
    treeExpanded: Record<string, boolean>;
    treeLoading: Record<string, boolean>;
    treeLazyChildren: Record<string, any[]>;
    isGroup: boolean;
    expandColumn: TableColumnNodeRaw | null;
    treeColumnIndex: number;
    columns: TableColumnNodeRaw[];
    leafColumns: TableColumnNodeRaw[];
    leftFixedLeafColumns: TableColumnNodeRaw[];
    rightFixedLeafColumns: TableColumnNodeRaw[];
};

export declare const Tabs: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
validator: (v: string) => boolean;
default: string;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
};
animated: {
type: BooleanConstructor;
default: boolean;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
barStyle: (ObjectConstructor | StringConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor)[];
barClass: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
affixable: BooleanConstructor;
affixOptions: ObjectConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "click" | "update:modelValue" | "tab-remove")[], "change" | "click" | "update:modelValue" | "tab-remove", PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
validator: (v: string) => boolean;
default: string;
};
modelValue: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
};
animated: {
type: BooleanConstructor;
default: boolean;
};
afloat: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
barStyle: (ObjectConstructor | StringConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor)[];
barClass: (ObjectConstructor | StringConstructor)[];
contentClass: (ObjectConstructor | StringConstructor)[];
affixable: BooleanConstructor;
affixOptions: ObjectConstructor;
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClick?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onTab-remove"?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
closable: boolean;
animated: boolean;
afloat: boolean;
affixable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TabsPane: DefineComponent<ExtractPropTypes<    {
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
anchor: {
type: StringConstructor;
};
lazy: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
default: undefined;
};
label: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
};
anchor: {
type: StringConstructor;
};
lazy: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
value: string | number | boolean;
label: string | Function;
lazy: boolean;
disabled: boolean;
closable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Tag: DefineComponent<ExtractPropTypes<    {
closable: {
type: BooleanConstructor;
default: boolean;
};
checkable: {
type: BooleanConstructor;
default: boolean;
};
checked: {
type: BooleanConstructor;
default: boolean;
};
color: {
type: StringConstructor;
default: string;
};
type: {
type: StringConstructor;
validator: (v: any) => boolean;
default: string;
};
value: {
type: (StringConstructor | NumberConstructor)[];
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "close")[], "change" | "close", PublicProps, Readonly<ExtractPropTypes<    {
closable: {
type: BooleanConstructor;
default: boolean;
};
checkable: {
type: BooleanConstructor;
default: boolean;
};
checked: {
type: BooleanConstructor;
default: boolean;
};
color: {
type: StringConstructor;
default: string;
};
type: {
type: StringConstructor;
validator: (v: any) => boolean;
default: string;
};
value: {
type: (StringConstructor | NumberConstructor)[];
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
}>, {
type: string;
color: string;
checked: boolean;
closable: boolean;
checkable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const Text_2: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: {
type: StringConstructor;
default: string;
};
line: {
type: NumberConstructor;
default: number;
};
indent: {
type: NumberConstructor;
default: number;
};
resize: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
shrink: {
type: (BooleanConstructor | NumberConstructor)[];
default: undefined;
};
ellipsis: {
type: StringConstructor;
default: string;
};
slice: {
type: NumberConstructor;
default: undefined;
};
placement: {
type: StringConstructor;
default: string;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
renderRow: {
type: FunctionConstructor;
default: (props$: any) => any;
};
theme: {
type: StringConstructor;
default: string;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
value: {
type: StringConstructor;
default: string;
};
line: {
type: NumberConstructor;
default: number;
};
indent: {
type: NumberConstructor;
default: number;
};
resize: {
type: (BooleanConstructor | NumberConstructor)[];
default: number;
};
shrink: {
type: (BooleanConstructor | NumberConstructor)[];
default: undefined;
};
ellipsis: {
type: StringConstructor;
default: string;
};
slice: {
type: NumberConstructor;
default: undefined;
};
placement: {
type: StringConstructor;
default: string;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
renderRow: {
type: FunctionConstructor;
default: (props$: any) => any;
};
theme: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
slice: number;
resize: number | boolean;
value: string;
line: number;
tag: string;
ellipsis: string;
placement: string;
theme: string;
shrink: number | boolean;
indent: number;
renderRow: Function;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { Text_2 as Text }

export declare const Textarea: DefineComponent<ExtractPropTypes<    {
wrap: {
type: StringConstructor;
validator: (v: any) => boolean;
default: string;
};
rows: {
type: NumberConstructor;
default: number;
};
autosize: {
type: (ObjectConstructor | BooleanConstructor)[];
default: boolean;
};
textareaStyle: {
type: (ObjectConstructor | ArrayConstructor)[];
};
id: {
type: StringConstructor;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
modelValue: PropType<string | number | any[]>;
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
} & {
indicator: {
type: (ObjectConstructor | BooleanConstructor)[];
default: boolean;
};
indicateClass: StringConstructor;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "resize" | "clear" | "cancel" | "change" | "blur" | "focus" | "keydown" | "keypress" | "keyup" | "paste" | "enter" | "update:modelValue")[], "input" | "resize" | "clear" | "cancel" | "change" | "blur" | "focus" | "keydown" | "keypress" | "keyup" | "paste" | "enter" | "update:modelValue", PublicProps, Readonly<ExtractPropTypes<    {
wrap: {
type: StringConstructor;
validator: (v: any) => boolean;
default: string;
};
rows: {
type: NumberConstructor;
default: number;
};
autosize: {
type: (ObjectConstructor | BooleanConstructor)[];
default: boolean;
};
textareaStyle: {
type: (ObjectConstructor | ArrayConstructor)[];
};
id: {
type: StringConstructor;
};
controllable: {
type: BooleanConstructor;
default: boolean;
};
bytes: {
type: BooleanConstructor;
default: boolean;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
maxlength: NumberConstructor;
modelValue: PropType<string | number | any[]>;
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
} & {
indicator: {
type: (ObjectConstructor | BooleanConstructor)[];
default: boolean;
};
indicateClass: StringConstructor;
}>> & Readonly<{
onEnter?: ((...args: any[]) => any) | undefined;
onPaste?: ((...args: any[]) => any) | undefined;
onFocus?: ((...args: any[]) => any) | undefined;
onBlur?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
onKeydown?: ((...args: any[]) => any) | undefined;
onKeypress?: ((...args: any[]) => any) | undefined;
onKeyup?: ((...args: any[]) => any) | undefined;
onCancel?: ((...args: any[]) => any) | undefined;
onResize?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
}>, {
controllable: boolean;
bytes: boolean;
disabled: boolean;
wrap: string;
autosize: boolean | Record<string, any>;
indicator: boolean | Record<string, any>;
allowDispatch: boolean;
rows: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Theme: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
color: {
type: StringConstructor;
};
borderColor: {
type: StringConstructor;
};
backgroundColor: {
type: StringConstructor;
};
backgroundSize: {
type: StringConstructor;
default: string;
};
backgroundImage: {
type: StringConstructor;
};
src: {
type: StringConstructor;
};
variables: {
type: ObjectConstructor;
default: () => {};
};
pseudo: {
type: (ObjectConstructor | StringConstructor)[];
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
color: {
type: StringConstructor;
};
borderColor: {
type: StringConstructor;
};
backgroundColor: {
type: StringConstructor;
};
backgroundSize: {
type: StringConstructor;
default: string;
};
backgroundImage: {
type: StringConstructor;
};
src: {
type: StringConstructor;
};
variables: {
type: ObjectConstructor;
default: () => {};
};
pseudo: {
type: (ObjectConstructor | StringConstructor)[];
};
}>> & Readonly<{}>, {
backgroundSize: string;
tag: string;
variables: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const ThemeImage: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
color: {
type: StringConstructor;
};
borderColor: {
type: StringConstructor;
};
backgroundColor: {
type: StringConstructor;
};
backgroundSize: {
type: StringConstructor;
default: string;
};
backgroundImage: {
type: StringConstructor;
};
src: {
type: StringConstructor;
};
variables: {
type: ObjectConstructor;
default: () => {};
};
pseudo: {
type: (ObjectConstructor | StringConstructor)[];
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
color: {
type: StringConstructor;
};
borderColor: {
type: StringConstructor;
};
backgroundColor: {
type: StringConstructor;
};
backgroundSize: {
type: StringConstructor;
default: string;
};
backgroundImage: {
type: StringConstructor;
};
src: {
type: StringConstructor;
};
variables: {
type: ObjectConstructor;
default: () => {};
};
pseudo: {
type: (ObjectConstructor | StringConstructor)[];
};
}>> & Readonly<{}>, {
backgroundSize: string;
tag: string;
variables: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const ThemeText: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
color: {
type: StringConstructor;
};
borderColor: {
type: StringConstructor;
};
backgroundColor: {
type: StringConstructor;
};
backgroundSize: {
type: StringConstructor;
default: string;
};
backgroundImage: {
type: StringConstructor;
};
src: {
type: StringConstructor;
};
variables: {
type: ObjectConstructor;
default: () => {};
};
pseudo: {
type: (ObjectConstructor | StringConstructor)[];
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
color: {
type: StringConstructor;
};
borderColor: {
type: StringConstructor;
};
backgroundColor: {
type: StringConstructor;
};
backgroundSize: {
type: StringConstructor;
default: string;
};
backgroundImage: {
type: StringConstructor;
};
src: {
type: StringConstructor;
};
variables: {
type: ObjectConstructor;
default: () => {};
};
pseudo: {
type: (ObjectConstructor | StringConstructor)[];
};
}>> & Readonly<{}>, {
backgroundSize: string;
tag: string;
variables: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const ThemeView: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
color: {
type: StringConstructor;
};
borderColor: {
type: StringConstructor;
};
backgroundColor: {
type: StringConstructor;
};
backgroundSize: {
type: StringConstructor;
default: string;
};
backgroundImage: {
type: StringConstructor;
};
src: {
type: StringConstructor;
};
variables: {
type: ObjectConstructor;
default: () => {};
};
pseudo: {
type: (ObjectConstructor | StringConstructor)[];
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
color: {
type: StringConstructor;
};
borderColor: {
type: StringConstructor;
};
backgroundColor: {
type: StringConstructor;
};
backgroundSize: {
type: StringConstructor;
default: string;
};
backgroundImage: {
type: StringConstructor;
};
src: {
type: StringConstructor;
};
variables: {
type: ObjectConstructor;
default: () => {};
};
pseudo: {
type: (ObjectConstructor | StringConstructor)[];
};
}>> & Readonly<{}>, {
backgroundSize: string;
tag: string;
variables: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Timeline: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
align: {
type: PropType<"start" | "center" | "end">;
default: string;
validator(val: string): boolean;
};
alternate: {
type: BooleanConstructor;
default: boolean;
};
opposite: {
type: BooleanConstructor;
default: boolean;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
showPending: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
align: {
type: PropType<"start" | "center" | "end">;
default: string;
validator(val: string): boolean;
};
alternate: {
type: BooleanConstructor;
default: boolean;
};
opposite: {
type: BooleanConstructor;
default: boolean;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
showPending: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
alternate: boolean;
tag: string;
vertical: boolean;
align: "center" | "end" | "start";
inverted: boolean;
opposite: boolean;
showPending: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TimelineItem: DefineComponent<ExtractPropTypes<    {
label: {
type: PropType<string | Props_3["render"]>;
default: string;
};
dot: {
type: PropType<string | Props_3["render"]>;
};
dotColor: StringConstructor;
dotType: {
type: PropType<"solid" | "hollow">;
default: string;
};
lineColor: StringConstructor;
lineType: {
type: PropType<"solid" | "dashed" | "dotted">;
default: string;
};
opposite: {
type: BooleanConstructor;
default: undefined;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
label: {
type: PropType<string | Props_3["render"]>;
default: string;
};
dot: {
type: PropType<string | Props_3["render"]>;
};
dotColor: StringConstructor;
dotType: {
type: PropType<"solid" | "hollow">;
default: string;
};
lineColor: StringConstructor;
lineType: {
type: PropType<"solid" | "dashed" | "dotted">;
default: string;
};
opposite: {
type: BooleanConstructor;
default: undefined;
};
}>> & Readonly<{}>, {
label: string | ((props: Record<string, unknown>, context: SetupContext) => any);
opposite: boolean;
dotType: "solid" | "hollow";
lineType: "dashed" | "dotted" | "solid";
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TimePicker: DefineComponent<ExtractPropTypes<    {
type: StringConstructor;
placeholder: StringConstructor;
clearable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: (StringConstructor | DateConstructor | ArrayConstructor)[];
multiple: BooleanConstructor;
open: BooleanConstructor;
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
confirm: {
type: BooleanConstructor;
default: boolean;
};
format: StringConstructor;
separator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
};
splitPanels: {
type: BooleanConstructor;
default: boolean;
};
steps: {
type: ArrayConstructor;
default: () => never[];
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
} & object>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("input" | "error" | "clear" | "change" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change")[], "input" | "error" | "clear" | "change" | "close" | "ready" | "ok" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
type: StringConstructor;
placeholder: StringConstructor;
clearable: {
type: BooleanConstructor;
default: boolean;
};
modelValue: (StringConstructor | DateConstructor | ArrayConstructor)[];
multiple: BooleanConstructor;
open: BooleanConstructor;
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
confirm: {
type: BooleanConstructor;
default: boolean;
};
format: StringConstructor;
separator: {
type: StringConstructor;
default: string;
};
startDate: {
type: DateConstructor;
};
splitPanels: {
type: BooleanConstructor;
default: boolean;
};
steps: {
type: ArrayConstructor;
default: () => never[];
};
changeOnSelect: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: string;
};
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
} & object>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onInput?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, {
open: boolean;
disabled: boolean;
multiple: boolean;
confirm: boolean;
tag: string;
separator: string;
placement: string;
arrow: boolean;
steps: unknown[];
portal: boolean;
trigger: string;
nullValue: string | number | Record<string, any>;
clearable: boolean;
changeOnSelect: boolean;
splitPanels: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Toast: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_3["render"]>;
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    default: string;
    validator: (val: string) => boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled")[], PublicProps, {
    mode: "error" | "info" | "loading" | "warning" | "success";
    duration: number;
    maskClosable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_3["render"]>;
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    mode: {
    type: PropType<"info" | "loading" | "success" | "warning" | "error">;
    default: string;
    validator: (val: string) => boolean;
    };
    }>> & Readonly<{
    onClose?: ((...args: any[]) => any) | undefined;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    mode: "error" | "info" | "loading" | "warning" | "success";
    duration: number;
    maskClosable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (val: string) => boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled")[], "close" | "portal-fulfilled", {
mode: "error" | "info" | "loading" | "warning" | "success";
duration: number;
maskClosable: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    destroy: () => void;
    info: (...params: Array<(string | number | boolean | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
    success: (...params: Array<(string | number | boolean | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
    loading: (...params: Array<(string | number | boolean | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
    warning: (...params: Array<(string | number | boolean | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
    error: (...params: Array<(string | number | boolean | ((props: Record<string, unknown>, context: SetupContext) => any) | ((...args: any[]) => any) | undefined) | Partial<{
        mode: "error" | "info" | "loading" | "warning" | "success";
        duration: number;
        maskClosable: boolean;
    } & {
        content?: string | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>>) => PortalLeaf;
};

export declare const ToastView: DefineComponent<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (val: string) => boolean;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "portal-fulfilled")[], "close" | "portal-fulfilled", PublicProps, Readonly<ExtractPropTypes<    {
content: PropType<string | Props_3["render"]>;
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
mode: {
type: PropType<"info" | "loading" | "success" | "warning" | "error">;
default: string;
validator: (val: string) => boolean;
};
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
}>, {
mode: "error" | "info" | "loading" | "warning" | "success";
duration: number;
maskClosable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const Touch_2: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
flickThreshold: {
type: NumberConstructor;
default: number;
};
prevent: {
type: BooleanConstructor;
default: boolean;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("rotate" | "move" | "tap" | "long-tap" | "double-tap" | "pinch" | "swipe" | "swipe-left" | "swipe-right" | "swipe-up" | "swipe-down")[], "rotate" | "move" | "tap" | "long-tap" | "double-tap" | "pinch" | "swipe" | "swipe-left" | "swipe-right" | "swipe-up" | "swipe-down", PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
flickThreshold: {
type: NumberConstructor;
default: number;
};
prevent: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onRotate?: ((...args: any[]) => any) | undefined;
onMove?: ((...args: any[]) => any) | undefined;
onTap?: ((...args: any[]) => any) | undefined;
"onLong-tap"?: ((...args: any[]) => any) | undefined;
"onDouble-tap"?: ((...args: any[]) => any) | undefined;
onPinch?: ((...args: any[]) => any) | undefined;
onSwipe?: ((...args: any[]) => any) | undefined;
"onSwipe-left"?: ((...args: any[]) => any) | undefined;
"onSwipe-right"?: ((...args: any[]) => any) | undefined;
"onSwipe-up"?: ((...args: any[]) => any) | undefined;
"onSwipe-down"?: ((...args: any[]) => any) | undefined;
}>, {
tag: string;
prevent: boolean;
flickThreshold: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { Touch_2 as Touch }

export declare const Tour: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    placement: {
    type: PropType<TourPlacement>;
    default: string;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    width: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    escClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    stagePadding: {
    type: PropType<number | number[]>;
    default: number;
    };
    stageRadius: {
    type: NumberConstructor;
    default: number;
    };
    disableActiveInteraction: {
    type: BooleanConstructor;
    default: boolean;
    };
    showProgress: {
    type: BooleanConstructor;
    default: boolean;
    };
    progressType: {
    type: PropType<"number" | "dot">;
    default: string;
    };
    progressFormatter: PropType<(context: {
    current: number;
    total: number;
    }) => any>;
    previousText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    nextText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    finishText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    skipText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    previousButtonOptions: PropType<TourButtonOptions>;
    nextButtonOptions: PropType<TourButtonOptions>;
    finishButtonOptions: PropType<TourButtonOptions>;
    skipButtonOptions: PropType<TourButtonOptions>;
    animated: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    keyboard: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollIntoViewOptions: {
    type: PropType<ScrollIntoViewOptions | false>;
    default: () => {
    block: string;
    inline: string;
    };
    };
    advanceOnClick: {
    type: BooleanConstructor;
    default: boolean;
    };
    waitForElement: {
    type: NumberConstructor;
    default: number;
    };
    skipMissingElement: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClickBehavior: {
    type: PropType<"close" | "next" | "none">;
    default: string;
    };
    current: NumberConstructor;
    steps: {
    type: PropType<Record<string, any>[]>;
    default: () => never[];
    };
    getPopupContainer: PropType<() => HTMLElement>;
    zIndex: NumberConstructor;
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    wrapperStyle: PropType<StyleValue>;
    cache: {
    type: (StringConstructor | BooleanConstructor)[];
    default: boolean;
    };
    cacheTypes: PropType<TourEndType[]>;
    onOpen: PropType<(context: {
    cacheKey?: string;
    steps: Record<string, any>[];
    }) => any>;
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    "onUpdate:current"?: ((...args: any[]) => any) | undefined;
    onSkip?: ((...args: any[]) => any) | undefined;
    onFinish?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "finish" | "change" | "close" | "ready" | "skip" | "update:modelValue" | "update:current" | "visible-change")[], PublicProps, {
    width: string | number;
    mask: boolean;
    footer: boolean;
    cache: string | boolean;
    duration: number;
    previousText: string | boolean;
    nextText: string | boolean;
    finishText: string | boolean;
    skipText: string | boolean;
    placement: TourPlacement;
    arrow: boolean;
    closable: boolean;
    maskClosable: boolean;
    escClosable: boolean;
    stagePadding: number | number[];
    stageRadius: number;
    disableActiveInteraction: boolean;
    showProgress: boolean;
    progressType: "number" | "dot";
    animated: boolean;
    keyboard: boolean;
    scrollIntoViewOptions: false | ScrollIntoViewOptions;
    advanceOnClick: boolean;
    waitForElement: number;
    skipMissingElement: boolean;
    maskClickBehavior: "none" | "close" | "next";
    steps: Record<string, any>[];
    scrollable: boolean;
    modelValue: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    placement: {
    type: PropType<TourPlacement>;
    default: string;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    closable: {
    type: BooleanConstructor;
    default: boolean;
    };
    width: {
    type: (StringConstructor | NumberConstructor)[];
    default: number;
    };
    footer: {
    type: BooleanConstructor;
    default: boolean;
    };
    contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    mask: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    escClosable: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    stagePadding: {
    type: PropType<number | number[]>;
    default: number;
    };
    stageRadius: {
    type: NumberConstructor;
    default: number;
    };
    disableActiveInteraction: {
    type: BooleanConstructor;
    default: boolean;
    };
    showProgress: {
    type: BooleanConstructor;
    default: boolean;
    };
    progressType: {
    type: PropType<"number" | "dot">;
    default: string;
    };
    progressFormatter: PropType<(context: {
    current: number;
    total: number;
    }) => any>;
    previousText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    nextText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    finishText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    skipText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: undefined;
    };
    previousButtonOptions: PropType<TourButtonOptions>;
    nextButtonOptions: PropType<TourButtonOptions>;
    finishButtonOptions: PropType<TourButtonOptions>;
    skipButtonOptions: PropType<TourButtonOptions>;
    animated: {
    type: BooleanConstructor;
    default: boolean;
    };
    duration: {
    type: NumberConstructor;
    default: number;
    };
    keyboard: {
    type: BooleanConstructor;
    default: boolean;
    };
    scrollIntoViewOptions: {
    type: PropType<ScrollIntoViewOptions | false>;
    default: () => {
    block: string;
    inline: string;
    };
    };
    advanceOnClick: {
    type: BooleanConstructor;
    default: boolean;
    };
    waitForElement: {
    type: NumberConstructor;
    default: number;
    };
    skipMissingElement: {
    type: BooleanConstructor;
    default: boolean;
    };
    maskClickBehavior: {
    type: PropType<"close" | "next" | "none">;
    default: string;
    };
    current: NumberConstructor;
    steps: {
    type: PropType<Record<string, any>[]>;
    default: () => never[];
    };
    getPopupContainer: PropType<() => HTMLElement>;
    zIndex: NumberConstructor;
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    wrapperStyle: PropType<StyleValue>;
    cache: {
    type: (StringConstructor | BooleanConstructor)[];
    default: boolean;
    };
    cacheTypes: PropType<TourEndType[]>;
    onOpen: PropType<(context: {
    cacheKey?: string;
    steps: Record<string, any>[];
    }) => any>;
    modelValue: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onChange?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onReady?: ((...args: any[]) => any) | undefined;
    "onUpdate:current"?: ((...args: any[]) => any) | undefined;
    onSkip?: ((...args: any[]) => any) | undefined;
    onFinish?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, {
    width: string | number;
    mask: boolean;
    footer: boolean;
    cache: string | boolean;
    duration: number;
    previousText: string | boolean;
    nextText: string | boolean;
    finishText: string | boolean;
    skipText: string | boolean;
    placement: TourPlacement;
    arrow: boolean;
    closable: boolean;
    maskClosable: boolean;
    escClosable: boolean;
    stagePadding: number | number[];
    stageRadius: number;
    disableActiveInteraction: boolean;
    showProgress: boolean;
    progressType: "number" | "dot";
    animated: boolean;
    keyboard: boolean;
    scrollIntoViewOptions: false | ScrollIntoViewOptions;
    advanceOnClick: boolean;
    waitForElement: number;
    skipMissingElement: boolean;
    maskClickBehavior: "none" | "close" | "next";
    steps: Record<string, any>[];
    scrollable: boolean;
    modelValue: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
placement: {
type: PropType<TourPlacement>;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
width: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
mask: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
stagePadding: {
type: PropType<number | number[]>;
default: number;
};
stageRadius: {
type: NumberConstructor;
default: number;
};
disableActiveInteraction: {
type: BooleanConstructor;
default: boolean;
};
showProgress: {
type: BooleanConstructor;
default: boolean;
};
progressType: {
type: PropType<"number" | "dot">;
default: string;
};
progressFormatter: PropType<(context: {
current: number;
total: number;
}) => any>;
previousText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
nextText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
finishText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
skipText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
previousButtonOptions: PropType<TourButtonOptions>;
nextButtonOptions: PropType<TourButtonOptions>;
finishButtonOptions: PropType<TourButtonOptions>;
skipButtonOptions: PropType<TourButtonOptions>;
animated: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
keyboard: {
type: BooleanConstructor;
default: boolean;
};
scrollIntoViewOptions: {
type: PropType<ScrollIntoViewOptions | false>;
default: () => {
block: string;
inline: string;
};
};
advanceOnClick: {
type: BooleanConstructor;
default: boolean;
};
waitForElement: {
type: NumberConstructor;
default: number;
};
skipMissingElement: {
type: BooleanConstructor;
default: boolean;
};
maskClickBehavior: {
type: PropType<"close" | "next" | "none">;
default: string;
};
current: NumberConstructor;
steps: {
type: PropType<Record<string, any>[]>;
default: () => never[];
};
getPopupContainer: PropType<() => HTMLElement>;
zIndex: NumberConstructor;
scrollable: {
type: BooleanConstructor;
default: boolean;
};
wrapperClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
wrapperStyle: PropType<StyleValue>;
cache: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
cacheTypes: PropType<TourEndType[]>;
onOpen: PropType<(context: {
cacheKey?: string;
steps: Record<string, any>[];
}) => any>;
modelValue: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
"onUpdate:current"?: ((...args: any[]) => any) | undefined;
onSkip?: ((...args: any[]) => any) | undefined;
onFinish?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "finish" | "change" | "close" | "ready" | "skip" | "update:modelValue" | "update:current" | "visible-change")[], "error" | "finish" | "change" | "close" | "ready" | "skip" | "update:modelValue" | "update:current" | "visible-change", {
width: string | number;
mask: boolean;
footer: boolean;
cache: string | boolean;
duration: number;
previousText: string | boolean;
nextText: string | boolean;
finishText: string | boolean;
skipText: string | boolean;
placement: TourPlacement;
arrow: boolean;
closable: boolean;
maskClosable: boolean;
escClosable: boolean;
stagePadding: number | number[];
stageRadius: number;
disableActiveInteraction: boolean;
showProgress: boolean;
progressType: "number" | "dot";
animated: boolean;
keyboard: boolean;
scrollIntoViewOptions: false | ScrollIntoViewOptions;
advanceOnClick: boolean;
waitForElement: number;
skipMissingElement: boolean;
maskClickBehavior: "none" | "close" | "next";
steps: Record<string, any>[];
scrollable: boolean;
modelValue: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: {
        (): PortalLeaf;
        (options: PortalOptions): PortalLeaf;
        (propsData: Record<string, any>, options: PortalOptions): PortalLeaf;
    };
    destroy: (target?: string | PortalLeaf) => void;
};

declare interface TourActionContext extends TourContext {
    next: number | null;
    source: TourSource;
}

declare type TourButtonOptions = Partial<Props_4> & {
    onClick?: (event: Event | undefined, context: TourActionContext) => any;
    [key: string]: any;
};

declare interface TourConfig {
    cache?: boolean;
    cacheTypes?: TourEndType[];
    getCache?: (context: {
        cacheKey: string;
    }) => any;
    setCache?: (context: {
        cacheKey: string;
        type: TourEndType;
    }) => any;
    onOpen?: (context: {
        cacheKey?: string;
        steps: TourStepOptions[];
    }) => any;
}

declare interface TourContext {
    current: number;
    total: number;
    step: Record<string, any>;
    element: HTMLElement | null;
}

declare interface TourEndContext extends TourContext {
    type: TourEndType;
    source: TourSource;
}

declare type TourEndType = 'finish' | 'skip' | 'close';

declare type TourPlacement = 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right' | 'left' | 'left-top' | 'left-bottom' | 'right' | 'right-top' | 'right-bottom';

declare type TourSource = 'button' | 'keyboard' | 'element' | 'mask' | 'esc' | 'api' | 'model' | 'replace';

export declare const TourStep: DefineComponent<ExtractPropTypes<    {
element: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
title: PropType<string | Props_3["render"]>;
content: PropType<string | Props_3["render"]>;
width: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
placement: {
type: PropType<TourPlacement>;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
stagePadding: {
type: PropType<number | number[]>;
default: number;
};
stageRadius: {
type: NumberConstructor;
default: number;
};
disableActiveInteraction: {
type: BooleanConstructor;
default: boolean;
};
showProgress: {
type: BooleanConstructor;
default: boolean;
};
progressType: {
type: PropType<"number" | "dot">;
default: string;
};
animated: {
type: BooleanConstructor;
default: boolean;
};
keyboard: {
type: BooleanConstructor;
default: boolean;
};
scrollIntoViewOptions: {
type: PropType<ScrollIntoViewOptions | false>;
default: () => {
block: string;
inline: string;
};
};
advanceOnClick: {
type: BooleanConstructor;
default: boolean;
};
waitForElement: {
type: NumberConstructor;
default: number;
};
skipMissingElement: {
type: BooleanConstructor;
default: boolean;
};
maskClickBehavior: {
type: PropType<"close" | "next" | "none">;
default: string;
};
previousText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
nextText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
finishText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
skipText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
progressFormatter: PropType<(context: {
current: number;
total: number;
}) => any>;
previousButtonOptions: PropType<TourButtonOptions>;
nextButtonOptions: PropType<TourButtonOptions>;
finishButtonOptions: PropType<TourButtonOptions>;
skipButtonOptions: PropType<TourButtonOptions>;
}>, () => null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "close"[], "close", PublicProps, Readonly<ExtractPropTypes<    {
element: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
title: PropType<string | Props_3["render"]>;
content: PropType<string | Props_3["render"]>;
width: {
type: (StringConstructor | NumberConstructor)[];
default: number;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
footer: {
type: BooleanConstructor;
default: boolean;
};
duration: {
type: NumberConstructor;
default: number;
};
placement: {
type: PropType<TourPlacement>;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
maskClosable: {
type: BooleanConstructor;
default: boolean;
};
escClosable: {
type: BooleanConstructor;
default: boolean;
};
stagePadding: {
type: PropType<number | number[]>;
default: number;
};
stageRadius: {
type: NumberConstructor;
default: number;
};
disableActiveInteraction: {
type: BooleanConstructor;
default: boolean;
};
showProgress: {
type: BooleanConstructor;
default: boolean;
};
progressType: {
type: PropType<"number" | "dot">;
default: string;
};
animated: {
type: BooleanConstructor;
default: boolean;
};
keyboard: {
type: BooleanConstructor;
default: boolean;
};
scrollIntoViewOptions: {
type: PropType<ScrollIntoViewOptions | false>;
default: () => {
block: string;
inline: string;
};
};
advanceOnClick: {
type: BooleanConstructor;
default: boolean;
};
waitForElement: {
type: NumberConstructor;
default: number;
};
skipMissingElement: {
type: BooleanConstructor;
default: boolean;
};
maskClickBehavior: {
type: PropType<"close" | "next" | "none">;
default: string;
};
previousText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
nextText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
finishText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
skipText: {
type: (StringConstructor | BooleanConstructor)[];
default: undefined;
};
contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
contentStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
maskStyle: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
progressFormatter: PropType<(context: {
current: number;
total: number;
}) => any>;
previousButtonOptions: PropType<TourButtonOptions>;
nextButtonOptions: PropType<TourButtonOptions>;
finishButtonOptions: PropType<TourButtonOptions>;
skipButtonOptions: PropType<TourButtonOptions>;
}>> & Readonly<{
onClose?: ((...args: any[]) => any) | undefined;
}>, {
width: string | number;
mask: boolean;
footer: boolean;
duration: number;
previousText: string | boolean;
nextText: string | boolean;
finishText: string | boolean;
skipText: string | boolean;
placement: TourPlacement;
arrow: boolean;
closable: boolean;
maskClosable: boolean;
escClosable: boolean;
stagePadding: number | number[];
stageRadius: number;
disableActiveInteraction: boolean;
showProgress: boolean;
progressType: "number" | "dot";
animated: boolean;
keyboard: boolean;
scrollIntoViewOptions: false | ScrollIntoViewOptions;
advanceOnClick: boolean;
waitForElement: number;
skipMissingElement: boolean;
maskClickBehavior: "none" | "close" | "next";
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type TourStepOptions = Partial<Props_2> & {
    slots?: Slots;
    onClose?: (context: TourEndContext) => any;
};

export declare const Transition: DefineComponent<ExtractPropTypes<    {
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: string;
};
};
prefix: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: string;
};
};
prefix: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TransitionCollapse: DefineComponent<ExtractPropTypes<    {
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: string;
};
};
prefix: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: string;
};
};
prefix: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TransitionFade: DefineComponent<ExtractPropTypes<    {
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
mode: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TransitionScale: DefineComponent<ExtractPropTypes<    {
mode: {
type: PropType<"x" | "y" | "part" | "both" | "none" | string>;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
mode: {
type: PropType<"x" | "y" | "part" | "both" | "none" | string>;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TransitionSlide: DefineComponent<ExtractPropTypes<    {
mode: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
mode: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TransitionZoom: DefineComponent<ExtractPropTypes<    {
mode: {
type: PropType<"x" | "y" | "center" | "none" | string>;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
mode: {
type: PropType<"x" | "y" | "center" | "none" | string>;
default: string;
validator: (v: string) => boolean;
};
style: {
type: ObjectConstructor;
default: () => {
animationFillMode: string;
animationTimingFunction: undefined;
};
};
prefix: {
type: StringConstructor;
default: string;
};
duration: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
delay: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
group: BooleanConstructor;
tag: {
type: StringConstructor;
default: undefined;
};
origin: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
origin: string;
style: Record<string, any>;
prefix: string;
tag: string;
group: boolean;
mode: string;
duration: number | Record<string, any>;
delay: number | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const translate: (path: LocaleKey, options: TranslatorOption | undefined, locale: Language) => string;

export declare type Translator = (path: LocaleKey, options?: TranslatorOption) => string;

export declare type TranslatorOption = Record<string, string | number>;

export declare const Tree: DefineComponent<ExtractPropTypes<    {
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
emptyText: {
type: StringConstructor;
default: undefined;
};
checkStrictly: {
type: BooleanConstructor;
default: boolean;
};
defaultExpandAll: BooleanConstructor;
expandOnClickNode: {
type: BooleanConstructor;
default: boolean;
};
checkOnClickNode: BooleanConstructor;
checkDescendants: {
type: BooleanConstructor;
default: boolean;
};
autoExpandParent: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
expandedValues: {
type: PropType<(string | number)[]>;
default: () => never[];
};
currentNodeValue: (StringConstructor | NumberConstructor)[];
draggable: {
type: BooleanConstructor;
default: boolean;
};
allowDrag: PropType<(data: TreeAllowDragPayload) => boolean>;
allowDrop: PropType<(data: TreeAllowDropPayload) => boolean>;
lazy: {
type: BooleanConstructor;
default: boolean;
};
highlightCurrent: BooleanConstructor;
loadData: FunctionConstructor;
filterNode: FunctionConstructor;
indent: {
type: NumberConstructor;
default: number;
};
iconClass: StringConstructor;
keyValue: {
type: PropType<Partial<typeof KEY_VALUE>>;
default: () => {
children: string;
label: string;
value: string;
disabled: string;
isLeaf: string;
};
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
accordion: {
type: BooleanConstructor;
default: boolean;
};
renderNodeLabel: Render;
renderNodeAfterExpand: {
type: BooleanConstructor;
default: boolean;
};
showCheckbox: {
type: BooleanConstructor;
default: boolean;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("change" | "update:modelValue" | "current-change" | "check-change" | "check" | "node-expand-change" | "node-click" | "node-contextmenu" | "node-dragstart" | "node-dragleave" | "node-dragenter" | "node-dragover" | "node-drop" | "node-dragend")[], "change" | "update:modelValue" | "current-change" | "check-change" | "check" | "node-expand-change" | "node-click" | "node-contextmenu" | "node-dragstart" | "node-dragleave" | "node-dragenter" | "node-dragover" | "node-drop" | "node-dragend", PublicProps, Readonly<ExtractPropTypes<    {
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
emptyText: {
type: StringConstructor;
default: undefined;
};
checkStrictly: {
type: BooleanConstructor;
default: boolean;
};
defaultExpandAll: BooleanConstructor;
expandOnClickNode: {
type: BooleanConstructor;
default: boolean;
};
checkOnClickNode: BooleanConstructor;
checkDescendants: {
type: BooleanConstructor;
default: boolean;
};
autoExpandParent: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
expandedValues: {
type: PropType<(string | number)[]>;
default: () => never[];
};
currentNodeValue: (StringConstructor | NumberConstructor)[];
draggable: {
type: BooleanConstructor;
default: boolean;
};
allowDrag: PropType<(data: TreeAllowDragPayload) => boolean>;
allowDrop: PropType<(data: TreeAllowDropPayload) => boolean>;
lazy: {
type: BooleanConstructor;
default: boolean;
};
highlightCurrent: BooleanConstructor;
loadData: FunctionConstructor;
filterNode: FunctionConstructor;
indent: {
type: NumberConstructor;
default: number;
};
iconClass: StringConstructor;
keyValue: {
type: PropType<Partial<typeof KEY_VALUE>>;
default: () => {
children: string;
label: string;
value: string;
disabled: string;
isLeaf: string;
};
};
allowDispatch: {
type: BooleanConstructor;
default: boolean;
};
accordion: {
type: BooleanConstructor;
default: boolean;
};
renderNodeLabel: Render;
renderNodeAfterExpand: {
type: BooleanConstructor;
default: boolean;
};
showCheckbox: {
type: BooleanConstructor;
default: boolean;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onCurrent-change"?: ((...args: any[]) => any) | undefined;
"onCheck-change"?: ((...args: any[]) => any) | undefined;
onCheck?: ((...args: any[]) => any) | undefined;
"onNode-expand-change"?: ((...args: any[]) => any) | undefined;
"onNode-click"?: ((...args: any[]) => any) | undefined;
"onNode-contextmenu"?: ((...args: any[]) => any) | undefined;
"onNode-dragstart"?: ((...args: any[]) => any) | undefined;
"onNode-dragleave"?: ((...args: any[]) => any) | undefined;
"onNode-dragenter"?: ((...args: any[]) => any) | undefined;
"onNode-dragover"?: ((...args: any[]) => any) | undefined;
"onNode-drop"?: ((...args: any[]) => any) | undefined;
"onNode-dragend"?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: unknown[];
draggable: boolean;
lazy: boolean;
separator: string;
emptyText: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
allowDispatch: boolean;
accordion: boolean;
indent: number;
keyValue: Partial<{
children: string;
label: string;
value: string;
disabled: string;
isLeaf: string;
}>;
expandedValues: (string | number)[];
defaultExpandAll: boolean;
checkStrictly: boolean;
autoExpandParent: boolean;
checkDescendants: boolean;
renderNodeAfterExpand: boolean;
showCheckbox: boolean;
expandOnClickNode: boolean;
checkOnClickNode: boolean;
highlightCurrent: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Tree_2 {
    store: Store;
    normalized: ComputedRef<Normalized>;
    built: Normalized | null;
    maxLevel: number;
    constructor(store: Store);
    get nodes(): Record<string, TreeNodeInfo>;
    get rows(): any[];
    get isTree(): boolean;
    get fields(): {
        childrenKey: any;
        hasChildrenKey: any;
    };
    getKey(row: any): any;
    getChildren(row: any, id: any): any[];
    getParent(row: any): any;
    getSiblings(parent: any): any[];
    contains(ancestor: any, row: any): boolean;
    isExpanded(id: any): boolean;
    flatten(): {
        data: any[];
        levels: number[];
    } | null;
    getTreeNode(row: any, level: number): TreeNode;
    toggle(row: any, expanded?: boolean): void;
    reset(values: any[]): void;
    prune(): void;
    load(row: any, id: any, node: TreeNodeInfo): void;
}

declare type TreeAllowDragPayload = TreeNodePayload;

declare interface TreeAllowDropPayload extends TreeNodePayload, TreeMove {
    targetNode: TreeNode_2;
    position: TreeDropPosition;
}

declare interface TreeData {
    [key: string]: any;
    label?: TreeLabel;
    value?: TreeValue;
    children?: TreeData[];
    hasChildren?: boolean;
}

declare type TreeDropPlace = {
    parent: TreeNode_2 | null;
    index: number;
};

declare type TreeDropPosition = 'before' | 'after' | 'inner';

declare type TreeLabel = string;

declare type TreeMove = {
    from: TreeDropPlace;
    to: TreeDropPlace;
};

declare interface TreeNode {
    level: number;
    indent: number;
    expandable: boolean;
    expanded: boolean;
    loading: boolean;
}

declare class TreeNode_2 {
    id: number;
    states: {
        checked: boolean;
        indeterminate: boolean;
        expanded: boolean;
        visible: boolean;
        isCurrent: boolean;
        isLeaf: boolean;
        isLeafByUser: boolean;
        loading: boolean;
        level: number;
        loaded: boolean;
        data: any;
    };
    getter: {
        label: any;
        value: any;
        disabled: any;
    };
    childNodes: TreeNode_2[];
    store: TreeStore;
    parentNode: Nullable<TreeNode_2>;
    constructor(options: Options_10);
    getNextSiblingNode(): TreeNode_2 | null;
    getPreviousSiblingNode(): TreeNode_2 | null;
    setData(data: object): void;
    contains(target: TreeNode_2, deep?: boolean): boolean;
    remove(): void;
    insertChild(states: Partial<TreeNode_2['states']>, index?: number, batch?: any): TreeNode_2;
    insertBefore(states: Partial<TreeNode_2['states']>, ref?: TreeNode_2): TreeNode_2;
    insertAfter(states: Partial<TreeNode_2['states']>, ref?: TreeNode_2): TreeNode_2;
    removeChild(child: TreeNode_2): void;
    removeChildByData(data: object): void;
    expand(expandParent?: boolean): Promise<void>;
    doCreateChildren(array: any[], defaultProps?: {}): void;
    collapse(): void;
    shouldLoadData(): any;
    updateLeafState(): void;
    setChecked(value: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): Promise<void>;
    getChildren(forceInit?: boolean): Nullable<Array<any>>;
    updateChildren(): void;
    loadData(defaultProps?: {}): Promise<any[] | undefined>;
}

declare interface TreeNodeInfo {
    level: number;
    loadable: boolean;
}

declare interface TreeNodePayload {
    node: TreeNode_2;
    data: any;
}

export declare const TreeSelect: DefineComponent<ExtractPropTypes<    {
autoWidth: {
type: BooleanConstructor;
default: undefined;
};
cascader: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
checkStrictly: {
type: BooleanConstructor;
default: boolean;
};
renderNodeLabel: Render;
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("clear" | "change" | "close" | "ready" | "update:modelValue" | "visible-change")[], "clear" | "change" | "close" | "ready" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
autoWidth: {
type: BooleanConstructor;
default: undefined;
};
cascader: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
checkStrictly: {
type: BooleanConstructor;
default: boolean;
};
renderNodeLabel: Render;
renderOption: Render;
renderOptionGroup: Render;
renderLabel: Render;
searchPlaceholder: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
tag: {
type: StringConstructor;
default: string;
};
placement: {
type: StringConstructor;
default: string;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
maxTags: NumberConstructor;
maxTagLines: {
type: NumberConstructor;
default: number;
};
searchable: {
type: BooleanConstructor;
default: boolean;
};
loadData: {
type: FunctionConstructor;
};
extra: {
type: StringConstructor;
default: string;
};
separator: {
type: StringConstructor;
default: string;
};
numerable: {
type: BooleanConstructor;
default: boolean;
};
nullValue: {
type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
default: undefined;
};
label: StringConstructor;
id: {
type: StringConstructor;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
modelValue: PropType<string | number | any[]>;
clearable: {
type: BooleanConstructor;
default: boolean;
};
portal: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
}>> & Readonly<{
onChange?: ((...args: any[]) => any) | undefined;
onClose?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onClear?: ((...args: any[]) => any) | undefined;
onReady?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: unknown[];
disabled: boolean;
tag: string;
extra: string;
separator: string;
placement: string;
arrow: boolean;
portal: boolean;
trigger: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
maxTagLines: number;
searchable: boolean;
cascader: boolean;
checkStrictly: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class TreeStore {
    primaryKey: string;
    keyValue: {
        children: string;
        label: string;
        value: string;
        disabled: string;
        isLeaf: string;
    };
    currentNode: Nullable<TreeNode_2>;
    currentNodeValue?: string | number;
    nodesMap: Record<string | number, TreeNode_2>;
    root: TreeNode_2;
    data: any;
    filterNode: any;
    checkedValues: (string | number)[];
    expandedValues: (string | number)[];
    lazy: boolean;
    checkStrictly: boolean;
    autoExpandParent: boolean;
    checkDescendants: boolean;
    defaultExpandAll: boolean;
    loadData: any;
    constructor(options: Partial<TreeStore>);
    filter(value: any): void;
    setData(newVal: object): void;
    getNode(v: object | string | number | TreeNode_2): Nullable<TreeNode_2>;
    insertBefore(data: object, refData: object): void;
    insertAfter(data: object, refData: object): void;
    remove(data: object): void;
    append(data: object, parentData: object): void;
    _getCascadeCheckedAnchorIds(checkedValues: (string | number)[]): (string | number)[];
    _initDefaultCheckedNodes(): void;
    _initDefaultCheckedNode(node: TreeNode_2): void;
    setCheckedValues(newVal: any): void;
    registerNode(node: TreeNode_2): void;
    deregisterNode(node: TreeNode_2): void;
    getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): TreeNode_2[];
    getCheckedValues(leafOnly?: boolean): any[];
    getHalfCheckedNodes(): TreeNode_2[];
    getHalfCheckedValues(): any[];
    _getAllNodes(): TreeNode_2[];
    updateChildren(key: string, data: any[]): void;
    _setCheckedValues(key: string | number, leafOnly: boolean | undefined, checkedValues: Record<string | number, boolean>): void;
    setCheckedNodes(array: TreeNode_2[], leafOnly?: boolean): void;
    setExpandedValues(values: (string | number)[]): void;
    setChecked(v: any, checked?: boolean, deep?: boolean): void;
    getCurrentNode(): Nullable<TreeNode_2>;
    setCurrentNode(currentNode: TreeNode_2): void;
    setUserCurrentNode(node: TreeNode_2): void;
    setCurrentNodeByData(data?: object): void;
}

declare type TreeValue = string | number | any;

export declare const Upload: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    tag: {
    type: (ObjectConstructor | StringConstructor)[];
    default: string;
    };
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    max: {
    type: NumberConstructor;
    default: number;
    };
    accept: StringConstructor;
    size: {
    type: NumberConstructor;
    default: number;
    };
    name: {
    type: StringConstructor;
    default: string;
    };
    url: StringConstructor;
    body: {
    type: PropType<UploadRequestOptions["body"]>;
    default: () => {};
    };
    headers: {
    type: PropType<UploadRequestOptions["headers"]>;
    default: () => {};
    };
    showTask: {
    type: BooleanConstructor;
    default: boolean;
    };
    directory: {
    type: BooleanConstructor;
    default: boolean;
    };
    enhancer: PropType<UploadEnhancer>;
    parallel: {
    type: BooleanConstructor;
    default: boolean;
    };
    showError: {
    type: BooleanConstructor;
    default: boolean;
    };
    showLoading: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onComplete?: ((...args: any[]) => any) | undefined;
    onBegin?: ((...args: any[]) => any) | undefined;
    onMessage?: ((...args: any[]) => any) | undefined;
    onRequest?: ((...args: any[]) => any) | undefined;
    onResponse?: ((...args: any[]) => any) | undefined;
    "onFile-before"?: ((...args: any[]) => any) | undefined;
    "onFile-start"?: ((...args: any[]) => any) | undefined;
    "onFile-progress"?: ((...args: any[]) => any) | undefined;
    "onFile-success"?: ((...args: any[]) => any) | undefined;
    "onFile-error"?: ((...args: any[]) => any) | undefined;
    }>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "message" | "complete" | "begin" | "request" | "response" | "file-before" | "file-start" | "file-progress" | "file-success" | "file-error")[], PublicProps, {
    name: string;
    max: number;
    size: number;
    body: Record<string, unknown>;
    directory: boolean;
    disabled: boolean;
    tag: string | Record<string, any>;
    headers: Record<string, string>;
    showLoading: boolean;
    parallel: boolean;
    showTask: boolean;
    showError: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    tag: {
    type: (ObjectConstructor | StringConstructor)[];
    default: string;
    };
    disabled: {
    type: BooleanConstructor;
    default: boolean;
    };
    max: {
    type: NumberConstructor;
    default: number;
    };
    accept: StringConstructor;
    size: {
    type: NumberConstructor;
    default: number;
    };
    name: {
    type: StringConstructor;
    default: string;
    };
    url: StringConstructor;
    body: {
    type: PropType<UploadRequestOptions["body"]>;
    default: () => {};
    };
    headers: {
    type: PropType<UploadRequestOptions["headers"]>;
    default: () => {};
    };
    showTask: {
    type: BooleanConstructor;
    default: boolean;
    };
    directory: {
    type: BooleanConstructor;
    default: boolean;
    };
    enhancer: PropType<UploadEnhancer>;
    parallel: {
    type: BooleanConstructor;
    default: boolean;
    };
    showError: {
    type: BooleanConstructor;
    default: boolean;
    };
    showLoading: {
    type: BooleanConstructor;
    default: boolean;
    };
    }>> & Readonly<{
    onError?: ((...args: any[]) => any) | undefined;
    onComplete?: ((...args: any[]) => any) | undefined;
    onBegin?: ((...args: any[]) => any) | undefined;
    onMessage?: ((...args: any[]) => any) | undefined;
    onRequest?: ((...args: any[]) => any) | undefined;
    onResponse?: ((...args: any[]) => any) | undefined;
    "onFile-before"?: ((...args: any[]) => any) | undefined;
    "onFile-start"?: ((...args: any[]) => any) | undefined;
    "onFile-progress"?: ((...args: any[]) => any) | undefined;
    "onFile-success"?: ((...args: any[]) => any) | undefined;
    "onFile-error"?: ((...args: any[]) => any) | undefined;
    }>, () => VNode<RendererNode, RendererElement, {
    [key: string]: any;
    }>, {}, {}, {}, {
    name: string;
    max: number;
    size: number;
    body: Record<string, unknown>;
    directory: boolean;
    disabled: boolean;
    tag: string | Record<string, any>;
    headers: Record<string, string>;
    showLoading: boolean;
    parallel: boolean;
    showTask: boolean;
    showError: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
tag: {
type: (ObjectConstructor | StringConstructor)[];
default: string;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
max: {
type: NumberConstructor;
default: number;
};
accept: StringConstructor;
size: {
type: NumberConstructor;
default: number;
};
name: {
type: StringConstructor;
default: string;
};
url: StringConstructor;
body: {
type: PropType<UploadRequestOptions["body"]>;
default: () => {};
};
headers: {
type: PropType<UploadRequestOptions["headers"]>;
default: () => {};
};
showTask: {
type: BooleanConstructor;
default: boolean;
};
directory: {
type: BooleanConstructor;
default: boolean;
};
enhancer: PropType<UploadEnhancer>;
parallel: {
type: BooleanConstructor;
default: boolean;
};
showError: {
type: BooleanConstructor;
default: boolean;
};
showLoading: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
onBegin?: ((...args: any[]) => any) | undefined;
onMessage?: ((...args: any[]) => any) | undefined;
onRequest?: ((...args: any[]) => any) | undefined;
onResponse?: ((...args: any[]) => any) | undefined;
"onFile-before"?: ((...args: any[]) => any) | undefined;
"onFile-start"?: ((...args: any[]) => any) | undefined;
"onFile-progress"?: ((...args: any[]) => any) | undefined;
"onFile-success"?: ((...args: any[]) => any) | undefined;
"onFile-error"?: ((...args: any[]) => any) | undefined;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "message" | "complete" | "begin" | "request" | "response" | "file-before" | "file-start" | "file-progress" | "file-success" | "file-error")[], "error" | "message" | "complete" | "begin" | "request" | "response" | "file-before" | "file-start" | "file-progress" | "file-success" | "file-error", {
name: string;
max: number;
size: number;
body: Record<string, unknown>;
directory: boolean;
disabled: boolean;
tag: string | Record<string, any>;
headers: Record<string, string>;
showLoading: boolean;
parallel: boolean;
showTask: boolean;
showError: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options: UploadOpenOptions) => PortalLeaf;
};

declare interface UploadCallback {
    onMessage(payload: {
        cause: UploadError;
        message: string;
    }): string | void | Promise<string | void>;
    onError(payload: {
        cause: UploadError;
    }): void;
    onBegin(payload: {
        rawFiles: File[];
        files: UploadFile[];
    }): void;
    onRequest(payload: {
        requestOptions: UploadRequestOptions;
        instance: ComponentInternalInstance;
    }): UploadRequestOptions | void | Promise<UploadRequestOptions | void>;
    onResponse(payload: {
        request: XMLHttpRequest | undefined;
        requestOptions: UploadRequestOptions;
    }): unknown | Promise<unknown>;
    onFileBefore(payload: {
        file: UploadFile;
        rawFiles: File[];
    }): UploadFileBeforeResult | Promise<UploadFileBeforeResult>;
    onFileStart(payload: {
        file: UploadFile;
    }): void;
    onFileProgress(payload: {
        progress: UploadProgress;
        file: UploadFile;
    }): void;
    onFileSuccess(payload: {
        response: unknown;
        file: UploadFile;
        result: UploadCycleResult;
    }): void;
    onFileError(payload: {
        stage: UploadErrorStage;
        cause: unknown;
        message: string;
        file: UploadFile;
        result: UploadCycleResult;
    }): void;
    onComplete(payload: {
        result: UploadCycleResult;
    }): void;
}

declare interface UploadCycleResult {
    total: number;
    completed: number;
    succeeded: number;
    failed: number;
    responses: unknown[];
    queues: Array<() => void>;
}

declare type UploadEnhancer = (instance: ComponentInternalInstance) => boolean | void | Promise<boolean | void>;

declare interface UploadError {
    message?: string;
}

declare type UploadErrorStage = 'preflight' | 'upload';

declare interface UploadFile {
    uploadId: string;
    current: number;
    total: number;
    percent: number;
    size: number;
    name: string;
    target: File;
}

declare type UploadFileBeforeResult = false | void | Blob | (Partial<Omit<UploadFile, 'target'>> & {
    target?: Blob;
});

declare type UploadOpenOptions = Partial<UploadProps & UploadCallback> & {
    silent?: boolean;
};

export declare const UploadPicker: DefineComponent<ExtractPropTypes<    {
picker: {
type: PropType<PickerType[]>;
default: () => string[];
};
sortable: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
uploadOptions: {
type: ObjectConstructor;
default(): {};
};
modelValue: {
type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
default: () => never[];
};
keyValue: {
type: PropType<    {
label: string;
value: string;
}>;
default: () => {
label: string;
value: string;
};
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
validator: (v: string | Function) => boolean;
};
max: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
formatter: PropType<(response: any, file: any, type: PickerType) => any>;
boxClass: StringConstructor;
imageClass: StringConstructor;
videoClass: StringConstructor;
audioClass: StringConstructor;
fileClass: StringConstructor;
compressOptions: {
type: ObjectConstructor;
default: () => {
compress: boolean;
width: number;
height: number;
filetype: string;
encoderOptions: number;
};
};
showError: BooleanConstructor;
enhancer: (FunctionConstructor | BooleanConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "change" | "complete" | "update:modelValue" | "file-before" | "file-start" | "file-success" | "file-error" | "remove-before")[], "error" | "change" | "complete" | "update:modelValue" | "file-before" | "file-start" | "file-success" | "file-error" | "remove-before", PublicProps, Readonly<ExtractPropTypes<    {
picker: {
type: PropType<PickerType[]>;
default: () => string[];
};
sortable: {
type: BooleanConstructor;
default: boolean;
};
mask: {
type: BooleanConstructor;
default: boolean;
};
uploadOptions: {
type: ObjectConstructor;
default(): {};
};
modelValue: {
type: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
default: () => never[];
};
keyValue: {
type: PropType<    {
label: string;
value: string;
}>;
default: () => {
label: string;
value: string;
};
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
validator: (v: string | Function) => boolean;
};
max: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
formatter: PropType<(response: any, file: any, type: PickerType) => any>;
boxClass: StringConstructor;
imageClass: StringConstructor;
videoClass: StringConstructor;
audioClass: StringConstructor;
fileClass: StringConstructor;
compressOptions: {
type: ObjectConstructor;
default: () => {
compress: boolean;
width: number;
height: number;
filetype: string;
encoderOptions: number;
};
};
showError: BooleanConstructor;
enhancer: (FunctionConstructor | BooleanConstructor)[];
}>> & Readonly<{
onError?: ((...args: any[]) => any) | undefined;
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
onComplete?: ((...args: any[]) => any) | undefined;
"onFile-before"?: ((...args: any[]) => any) | undefined;
"onFile-start"?: ((...args: any[]) => any) | undefined;
"onFile-success"?: ((...args: any[]) => any) | undefined;
"onFile-error"?: ((...args: any[]) => any) | undefined;
"onRemove-before"?: ((...args: any[]) => any) | undefined;
}>, {
max: number | Record<string, any>;
mask: boolean;
output: string | Function;
disabled: boolean;
modelValue: string | unknown[] | Record<string, any>;
picker: PickerType[];
showError: boolean;
uploadOptions: Record<string, any>;
sortable: boolean;
keyValue: {
label: string;
value: string;
};
compressOptions: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type UploadPickerBasePayload<Name extends UploadPickerCallbackName> = Name extends 'onFileError' ? Omit<Parameters<UploadCallback[Name]>[0], 'stage'> & {
    stage: 'upload';
} : Parameters<UploadCallback[Name]>[0];

export declare interface UploadPickerCallback {
    onFileBefore(payload: UploadPickerPayload<'onFileBefore'>): ReturnType<UploadCallback['onFileBefore']>;
    onFileStart(payload: UploadPickerPayload<'onFileStart'>): void;
    onFileSuccess(payload: UploadPickerPayload<'onFileSuccess'>): void;
    onFileError(payload: UploadPickerPayload<'onFileError'>): void;
    onError(payload: UploadPickerPayload<'onError'>): void;
    onComplete(payload: UploadPickerPayload<'onComplete'>): void;
}

declare type UploadPickerCallbackName = 'onFileBefore' | 'onFileStart' | 'onFileSuccess' | 'onFileError' | 'onError' | 'onComplete';

declare type UploadPickerPayload<Name extends UploadPickerCallbackName> = UploadPickerBasePayload<Name> & {
    type: PickerType;
};

declare interface UploadProgress extends Pick<UploadFile, 'percent'> {
    progress: number;
    target: ProgressEvent;
}

declare type UploadProps = ExtractPublicPropTypes<typeof props_15>;

declare interface UploadRequestOptions {
    url?: string;
    headers: Record<string, string>;
    body: Record<string, unknown>;
    timeout: number | null;
    file: File;
}

export declare const useLocale: () => {
    locale: ComputedRef<    {
    name: string;
    vc: TranslatePair;
    }>;
    lang: ComputedRef<string>;
    t: Translator;
};

export declare const useMeasuring: () => boolean;

export declare class VcError {
    message?: string;
    constructor(target?: string, message?: any);
}

export declare const VcInstance: Instance;

export declare type VcOptions = Partial<{
    [key: string]: any;
    locale: Language;
    Theme: {
        variables: Record<string, string>;
    };
    MListItem: {
        to: (value: any, instance: ComponentInternalInstance) => any;
    };
    Image: {
        formatter?: (value: any, type: string, instance: ComponentInternalInstance) => string;
    };
    FilePreview: FilePreviewOptions;
    Tour: TourConfig;
}>;

export { }