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 { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { JSX } from 'vue/jsx-runtime';
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 type { UnwrapNestedRefs } from 'vue';
import type { ValidatorRule } from '@deot/helper-validator';
import { VNode } from 'vue';
import { 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_2['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;
modelValue: boolean;
placement: string;
}, {}, {}, {}, 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;
};
desc: {
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;
};
desc: {
type: StringConstructor;
default: string;
};
icon: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
type: "error" | "info" | "warning" | "success";
title: string;
desc: string;
icon: string | boolean;
modelValue: boolean;
closable: 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_9;
    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[]>;
    constructor(store: Store);
    buildInitialList(data: any[]): {
        id: any;
        rows: {
            index: number;
            data: any;
        }[];
        rowStart: number;
        expand: boolean;
    }[];
    rebuildMergeList(): void;
    getCells(block: any): any[];
    getCoverAnchors(rowIndex: number): any;
}

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: ({ month, year, lang, monthNames }: RenderMonthProps) => JSX.Element;
};
renderWeek: {
type: PropType<CalendarRender<RenderWeekProps>>;
default: ({ weekNames, lang }: RenderWeekProps) => JSX.Element;
};
lang: {
type: PropType<CalendarLang>;
default: string;
};
firstDayOfWeek: {
type: NumberConstructor;
default: number;
validator: (value: number) => boolean;
};
showAdjacentWeeks: {
type: PropType<CalendarAdjacentWeeks>;
default: () => boolean[];
validator: (value: CalendarAdjacentWeeks) => boolean;
};
monthNames: {
type: PropType<CalendarName[]>;
default: () => CalendarName[];
};
weekNames: {
type: PropType<CalendarName[]>;
default: () => CalendarName[];
};
}>, () => 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: ({ month, year, lang, monthNames }: RenderMonthProps) => JSX.Element;
};
renderWeek: {
type: PropType<CalendarRender<RenderWeekProps>>;
default: ({ weekNames, lang }: RenderWeekProps) => JSX.Element;
};
lang: {
type: PropType<CalendarLang>;
default: string;
};
firstDayOfWeek: {
type: NumberConstructor;
default: number;
validator: (value: number) => boolean;
};
showAdjacentWeeks: {
type: PropType<CalendarAdjacentWeeks>;
default: () => boolean[];
validator: (value: CalendarAdjacentWeeks) => boolean;
};
monthNames: {
type: PropType<CalendarName[]>;
default: () => CalendarName[];
};
weekNames: {
type: PropType<CalendarName[]>;
default: () => CalendarName[];
};
}>> & Readonly<{}>, {
lang: string;
monthNames: CalendarName[];
weekNames: CalendarName[];
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 = 'prev' | 'current' | 'next' | string;

declare type CalendarFirstDayOfWeek = number;

declare interface CalendarHoliday {
    holiday: string;
    festivals?: Array<{
        type: string;
        desc: string;
        value: string;
    }>;
    [key: string]: any;
}

declare type CalendarLang = 'ch' | 'en' | string;

declare interface CalendarName {
    ch: string;
    en: string;
    [key: string]: 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;
gutter: {
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;
gutter: {
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;
}>, {
draggable: boolean;
vertical: boolean;
autoplay: boolean;
loop: boolean;
t: number;
card: boolean;
gutter: number;
initialIndex: number;
trigger: string;
dots: string | boolean;
arrow: 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;
};
gutter: {
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;
};
gutter: {
type: NumberConstructor;
default: number;
};
scale: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
width: string | number;
scale: number;
label: string | number;
gutter: 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;
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;
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;
formatter: Function;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
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;
}>, {
fragment: boolean;
modelValue: unknown[];
}, {}, {}, {}, 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:moodelValue")[], "change" | "update:moodelValue", 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:moodelValue"?: ((...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;
    modelValue: string;
    trigger: string;
    arrow: boolean;
    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;
    modelValue: string;
    trigger: string;
    arrow: boolean;
    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;
modelValue: string;
trigger: string;
arrow: boolean;
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[];
        suppressWatch: boolean;
    };
    constructor(store: Store);
    insert(column: TableColumnNode, index?: number, parent?: TableColumnNode): void;
    remove(column: TableColumnNode, parent?: TableColumnNode): void;
    update(): void;
    cloneVisibleTree(arr: TableColumnNode[]): TableColumnNode[];
    syncToParent(): void;
    applyExternal(v: TableColumnSyncItem[]): void;
}

export declare const Countdown: DefineComponent<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
format: {
type: StringConstructor;
default: string;
};
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: string;
};
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;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
changeOnSelect: boolean;
splitPanels: boolean;
steps: unknown[];
}, {}, {}, {}, 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;
};
}>, () => VNodeChild[], {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "complete"[], "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<{
onComplete?: ((...args: any[]) => any) | undefined;
}>, {
once: boolean;
data: unknown[];
disabled: boolean;
primaryKey: string;
concurrency: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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

export declare const Drawer: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    title: PropType<string | boolean | Props_2["render"]>;
    content: {
    type: PropType<string | Props_2["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;
    };
    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: string;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    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;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change")[], PublicProps, {
    height: number;
    width: number;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    modelValue: boolean;
    maskClosable: boolean;
    placement: string;
    cancelText: string | boolean;
    okText: string | boolean;
    scrollable: 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_2["render"]>;
    content: {
    type: PropType<string | Props_2["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;
    };
    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: string;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    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;
    }>, () => JSX.Element, {}, {}, {}, {
    height: number;
    width: number;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    modelValue: boolean;
    maskClosable: boolean;
    placement: string;
    cancelText: string | boolean;
    okText: string | boolean;
    scrollable: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
title: PropType<string | boolean | Props_2["render"]>;
content: {
type: PropType<string | Props_2["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;
};
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: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change")[], "close" | "update:modelValue" | "visible-change", {
height: number;
width: number;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
modelValue: boolean;
maskClosable: boolean;
placement: string;
cancelText: string | boolean;
okText: string | boolean;
scrollable: 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_2["render"]>;
content: {
type: PropType<string | Props_2["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;
};
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: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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")[], "close" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
title: PropType<string | boolean | Props_2["render"]>;
content: {
type: PropType<string | Props_2["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;
};
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: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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;
}>, {
height: number;
width: number;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
modelValue: boolean;
maskClosable: boolean;
placement: string;
cancelText: string | boolean;
okText: string | boolean;
scrollable: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Dropdown: DefineComponent<ExtractPropTypes<    {
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<    {
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;
}>, {
modelValue: boolean;
placement: string;
trigger: string;
arrow: boolean;
}, {}, {}, {}, 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;
alive: boolean;
modelValue: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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

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_4;
    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;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: StringConstructor;
inherit: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
inherit: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const IconManager: Manager;

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: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    tag: {
    type: StringConstructor;
    default: string;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    tag: string;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    tag: {
    type: StringConstructor;
    default: string;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, {
    tag: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
tag: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    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;
        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;
    };
    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 findDirtyScan;
    refresh(): void;
}

declare class Layout_2 {
    table: any;
    store: Store;
    states: {
        height: null;
        scrollX: boolean;
        scrollY: boolean;
        bodyWidth: any;
        tableHeight: any;
        headerHeight: number;
        appendHeight: number;
        footerHeight: number;
        bodyHeight: any;
    };
    templateColumns: ComputedRef<string>;
    constructor(store: Store);
    updateScrollY(): void;
    setHeight(value: any, prop?: string): any;
    setMaxHeight(value: any): void;
    updateElsHeight(): any;
    updateColumnsWidth(): void;
    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;
    setOriginalData(start: number, items: any[]): void;
    consumePage(): {
        start: number;
        end: number;
        reversed: boolean;
    } | null;
    clearOriginalData(): void;
}

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;
    maskClosable: boolean;
    scrollRegExp: Record<string, any>;
    cancelText: string;
    }, 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;
    maskClosable: boolean;
    scrollRegExp: Record<string, any>;
    cancelText: string;
    }>;
    __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;
maskClosable: boolean;
scrollRegExp: Record<string, any>;
cancelText: string;
}, {}, 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;
modelValue: boolean;
placement: string;
}, {}, {}, {}, 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;
};
desc: {
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;
};
desc: {
type: StringConstructor;
default: string;
};
icon: {
type: (StringConstructor | BooleanConstructor)[];
default: boolean;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{}>, {
type: "error" | "info" | "warning" | "success";
title: string;
desc: string;
icon: string | boolean;
modelValue: boolean;
closable: 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>;
    constructor();
    load(url: string): Promise<void>;
    parser(svgStr: string, url: string): Promise<typeof IconManager['icons']>;
    on(type?: string, fn?: Function): this;
    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: ({ month, year, lang, monthNames }: RenderMonthProps) => JSX.Element;
};
renderWeek: {
type: PropType<CalendarRender<RenderWeekProps>>;
default: ({ weekNames, lang }: RenderWeekProps) => JSX.Element;
};
lang: {
type: PropType<CalendarLang>;
default: string;
};
firstDayOfWeek: {
type: NumberConstructor;
default: number;
validator: (value: number) => boolean;
};
showAdjacentWeeks: {
type: PropType<CalendarAdjacentWeeks>;
default: () => boolean[];
validator: (value: CalendarAdjacentWeeks) => boolean;
};
monthNames: {
type: PropType<CalendarName[]>;
default: () => CalendarName[];
};
weekNames: {
type: PropType<CalendarName[]>;
default: () => CalendarName[];
};
}>, () => 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: ({ month, year, lang, monthNames }: RenderMonthProps) => JSX.Element;
};
renderWeek: {
type: PropType<CalendarRender<RenderWeekProps>>;
default: ({ weekNames, lang }: RenderWeekProps) => JSX.Element;
};
lang: {
type: PropType<CalendarLang>;
default: string;
};
firstDayOfWeek: {
type: NumberConstructor;
default: number;
validator: (value: number) => boolean;
};
showAdjacentWeeks: {
type: PropType<CalendarAdjacentWeeks>;
default: () => boolean[];
validator: (value: CalendarAdjacentWeeks) => boolean;
};
monthNames: {
type: PropType<CalendarName[]>;
default: () => CalendarName[];
};
weekNames: {
type: PropType<CalendarName[]>;
default: () => CalendarName[];
};
}>> & Readonly<{}>, {
lang: string;
monthNames: CalendarName[];
weekNames: CalendarName[];
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;
gutter: {
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;
gutter: {
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;
}>, {
draggable: boolean;
vertical: boolean;
autoplay: boolean;
loop: boolean;
t: number;
card: boolean;
gutter: number;
initialIndex: number;
trigger: string;
dots: string | boolean;
arrow: 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;
};
gutter: {
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;
};
gutter: {
type: NumberConstructor;
default: number;
};
scale: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{}>, {
width: string | number;
scale: number;
label: string | number;
gutter: 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;
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;
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;
formatter: Function;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
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;
}>, {
fragment: boolean;
modelValue: unknown[];
}, {}, {}, {}, 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:moodelValue")[], "change" | "update:moodelValue", 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:moodelValue"?: ((...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;
    modelValue: string;
    trigger: string;
    arrow: boolean;
    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;
    modelValue: string;
    trigger: string;
    arrow: boolean;
    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;
modelValue: string;
trigger: string;
arrow: boolean;
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: string;
};
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: string;
};
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<    {
    extra: {
    type: StringConstructor;
    default: string;
    };
    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;
    };
    cancelText: {
    type: StringConstructor;
    default: string;
    };
    okText: {
    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;
    extra: string;
    cancelText: string;
    arrow: string | boolean;
    nullValue: string | number | Record<string, any>;
    labelWidth: string | number;
    okText: string;
    showToolbar: boolean;
    minDate: Date;
    maxDate: Date;
    startHour: number;
    endHour: number;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    extra: {
    type: StringConstructor;
    default: string;
    };
    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;
    };
    cancelText: {
    type: StringConstructor;
    default: string;
    };
    okText: {
    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;
    extra: string;
    cancelText: string;
    arrow: string | boolean;
    nullValue: string | number | Record<string, any>;
    labelWidth: string | number;
    okText: string;
    showToolbar: boolean;
    minDate: Date;
    maxDate: Date;
    startHour: number;
    endHour: number;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
extra: {
type: StringConstructor;
default: string;
};
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;
};
cancelText: {
type: StringConstructor;
default: string;
};
okText: {
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;
extra: string;
cancelText: string;
arrow: string | boolean;
nullValue: string | number | Record<string, any>;
labelWidth: string | number;
okText: string;
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;
};
}>, () => VNodeChild[], {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "complete"[], "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<{
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_2["render"]>;
    content: {
    type: PropType<string | Props_2["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;
    };
    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: string;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    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;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change")[], PublicProps, {
    height: number;
    width: number;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    modelValue: boolean;
    maskClosable: boolean;
    placement: string;
    cancelText: string | boolean;
    okText: string | boolean;
    scrollable: 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_2["render"]>;
    content: {
    type: PropType<string | Props_2["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;
    };
    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: string;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    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;
    }>, () => JSX.Element, {}, {}, {}, {
    height: number;
    width: number;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    modelValue: boolean;
    maskClosable: boolean;
    placement: string;
    cancelText: string | boolean;
    okText: string | boolean;
    scrollable: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
title: PropType<string | boolean | Props_2["render"]>;
content: {
type: PropType<string | Props_2["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;
};
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: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "update:modelValue" | "visible-change")[], "close" | "update:modelValue" | "visible-change", {
height: number;
width: number;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
modelValue: boolean;
maskClosable: boolean;
placement: string;
cancelText: string | boolean;
okText: string | boolean;
scrollable: 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;
        modelValue: boolean;
        maskClosable: boolean;
        placement: string;
        cancelText: string | boolean;
        okText: string | boolean;
        scrollable: boolean;
        closeWithCancel: boolean;
        okDisabled: boolean;
        cancelDisabled: boolean;
    } & {
        title?: string | boolean | ((props: Record<string, unknown>, context: SetupContext) => any) | undefined;
        onCancel?: Function | undefined;
        wrapperClass?: string | Record<string, any> | undefined;
        wrapperStyle?: string | Record<string, any> | undefined;
        contentStyle?: string | Record<string, any> | undefined;
        contentClass?: string | Record<string, any> | undefined;
        onOk?: Function | undefined;
        maskStyle?: string | Record<string, any> | undefined;
    } & {
        onClose: (...args: any[]) => any;
    }>) => PortalLeaf;
    destroy: () => void;
};

export declare const MDrawerView: DefineComponent<ExtractPropTypes<    {
title: PropType<string | boolean | Props_2["render"]>;
content: {
type: PropType<string | Props_2["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;
};
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: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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")[], "close" | "update:modelValue" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
title: PropType<string | boolean | Props_2["render"]>;
content: {
type: PropType<string | Props_2["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;
};
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: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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;
}>, {
height: number;
width: number;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
modelValue: boolean;
maskClosable: boolean;
placement: string;
cancelText: string | boolean;
okText: string | boolean;
scrollable: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MDropdown: DefineComponent<ExtractPropTypes<    {
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<    {
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;
}>, {
modelValue: boolean;
placement: string;
trigger: string;
arrow: boolean;
}, {}, {}, {}, 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 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_2["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;
    maskClosable: boolean;
    closable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_2["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;
    maskClosable: boolean;
    closable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
content: PropType<string | Props_2["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;
maskClosable: boolean;
closable: 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_2["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_2["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;
maskClosable: boolean;
closable: 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;
alive: boolean;
modelValue: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: StringConstructor;
inherit: {
type: BooleanConstructor;
default: boolean;
};
}>> & 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: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    tag: {
    type: StringConstructor;
    default: string;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    tag: string;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    tag: {
    type: StringConstructor;
    default: string;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, {
    tag: string;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
tag: string;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    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: string;
};
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: string;
};
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 MMessage: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_2["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;
    maskClosable: boolean;
    closable: boolean;
    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_2["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;
    maskClosable: boolean;
    closable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
content: PropType<string | Props_2["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;
maskClosable: boolean;
closable: 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;
        maskClosable: boolean;
        closable: 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;
        maskClosable: boolean;
        closable: 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;
        maskClosable: boolean;
        closable: 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;
        maskClosable: boolean;
        closable: 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;
        maskClosable: boolean;
        closable: 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_2["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_2["render"]>;
    };
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    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";
    modelValue: boolean;
    maskClosable: boolean;
    cancelText: string | boolean;
    okText: string | 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_2["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_2["render"]>;
    };
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    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";
    modelValue: boolean;
    maskClosable: boolean;
    cancelText: string | boolean;
    okText: string | 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_2["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_2["render"]>;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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";
modelValue: boolean;
maskClosable: boolean;
cancelText: string | boolean;
okText: string | 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_2["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_2["render"]>;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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_2["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_2["render"]>;
};
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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";
modelValue: boolean;
maskClosable: boolean;
cancelText: string | boolean;
okText: string | boolean;
closeWithCancel: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MNotice: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    title: PropType<string | Props_2["render"]>;
    content: PropType<string | Props_2["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_2["render"]>;
    content: PropType<string | Props_2["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_2["render"]>;
content: PropType<string | Props_2["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_2["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: NumberConstructor;
    };
    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_2["render"]>;
    };
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    draggable: {
    type: BooleanConstructor;
    default: boolean;
    };
    x: NumberConstructor;
    y: NumberConstructor;
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    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;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...args: any[]) => any) | undefined;
    onOk?: ((...args: any[]) => any) | undefined;
    }>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled" | "visible-change")[], PublicProps, {
    size: "small" | "medium" | "large";
    border: boolean;
    content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
    mask: boolean;
    footer: boolean;
    draggable: boolean;
    modelValue: boolean;
    maskClosable: boolean;
    cancelText: string | boolean;
    closable: boolean;
    okText: string | boolean;
    scrollable: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    escClosable: 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_2["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: NumberConstructor;
    };
    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_2["render"]>;
    };
    scrollable: {
    type: BooleanConstructor;
    default: boolean;
    };
    draggable: {
    type: BooleanConstructor;
    default: boolean;
    };
    x: NumberConstructor;
    y: NumberConstructor;
    okText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    cancelText: {
    type: (StringConstructor | BooleanConstructor)[];
    default: string;
    };
    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;
    "onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
    "onVisible-change"?: ((...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;
    modelValue: boolean;
    maskClosable: boolean;
    cancelText: string | boolean;
    closable: boolean;
    okText: string | boolean;
    scrollable: boolean;
    closeWithCancel: boolean;
    okDisabled: boolean;
    cancelDisabled: boolean;
    escClosable: 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_2["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: NumberConstructor;
};
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_2["render"]>;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
x: NumberConstructor;
y: NumberConstructor;
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
onOk?: ((...args: any[]) => any) | undefined;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled" | "visible-change")[], "cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled" | "visible-change", {
size: "small" | "medium" | "large";
border: boolean;
content: string | ((props: Record<string, unknown>, context: SetupContext) => any);
mask: boolean;
footer: boolean;
draggable: boolean;
modelValue: boolean;
maskClosable: boolean;
cancelText: string | boolean;
closable: boolean;
okText: string | boolean;
scrollable: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
escClosable: 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_2["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: NumberConstructor;
};
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_2["render"]>;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
x: NumberConstructor;
y: NumberConstructor;
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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" | "portal-fulfilled" | "visible-change")[], "cancel" | "close" | "ok" | "update:modelValue" | "portal-fulfilled" | "visible-change", PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
default: boolean;
};
mode: {
type: PropType<"info" | "success" | "error" | "warning">;
validator: (v: string) => boolean;
};
content: {
type: PropType<string | Props_2["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: NumberConstructor;
};
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_2["render"]>;
};
scrollable: {
type: BooleanConstructor;
default: boolean;
};
draggable: {
type: BooleanConstructor;
default: boolean;
};
x: NumberConstructor;
y: NumberConstructor;
okText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
cancelText: {
type: (StringConstructor | BooleanConstructor)[];
default: string;
};
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;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...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;
modelValue: boolean;
maskClosable: boolean;
cancelText: string | boolean;
closable: boolean;
okText: string | boolean;
scrollable: boolean;
closeWithCancel: boolean;
okDisabled: boolean;
cancelDisabled: boolean;
escClosable: 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;
portal: boolean;
placement: string;
current: number;
pageSize: number;
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[];
    };
    cols: {
    type: NumberConstructor;
    default: number;
    };
    itemStyle: PropType<Record<string, any>>;
    cascader: {
    type: BooleanConstructor;
    default: boolean;
    };
    loadData: PropType<() => Promise<any> | any>;
    extra: {
    type: StringConstructor;
    default: string;
    };
    formatter: {
    type: PropType<(label: any[]) => string>;
    default: (v: any[]) => string;
    };
    label: StringConstructor;
    labelWidth: (StringConstructor | NumberConstructor)[];
    title: {
    type: StringConstructor;
    default: string;
    };
    cancelText: {
    type: StringConstructor;
    default: string;
    };
    okText: {
    type: StringConstructor;
    default: string;
    };
    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;
    title: string;
    extra: string;
    separator: string;
    cols: number;
    formatter: (label: any[]) => string;
    modelValue: PickerModelValue;
    cancelText: string;
    numerable: boolean;
    nullValue: PickerModelValue;
    okText: string;
    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[];
    };
    cols: {
    type: NumberConstructor;
    default: number;
    };
    itemStyle: PropType<Record<string, any>>;
    cascader: {
    type: BooleanConstructor;
    default: boolean;
    };
    loadData: PropType<() => Promise<any> | any>;
    extra: {
    type: StringConstructor;
    default: string;
    };
    formatter: {
    type: PropType<(label: any[]) => string>;
    default: (v: any[]) => string;
    };
    label: StringConstructor;
    labelWidth: (StringConstructor | NumberConstructor)[];
    title: {
    type: StringConstructor;
    default: string;
    };
    cancelText: {
    type: StringConstructor;
    default: string;
    };
    okText: {
    type: StringConstructor;
    default: string;
    };
    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;
    title: string;
    extra: string;
    separator: string;
    cols: number;
    formatter: (label: any[]) => string;
    modelValue: PickerModelValue;
    cancelText: string;
    numerable: boolean;
    nullValue: PickerModelValue;
    okText: string;
    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[];
};
cols: {
type: NumberConstructor;
default: number;
};
itemStyle: PropType<Record<string, any>>;
cascader: {
type: BooleanConstructor;
default: boolean;
};
loadData: PropType<() => Promise<any> | any>;
extra: {
type: StringConstructor;
default: string;
};
formatter: {
type: PropType<(label: any[]) => string>;
default: (v: any[]) => string;
};
label: StringConstructor;
labelWidth: (StringConstructor | NumberConstructor)[];
title: {
type: StringConstructor;
default: string;
};
cancelText: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
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;
title: string;
extra: string;
separator: string;
cols: number;
formatter: (label: any[]) => string;
modelValue: PickerModelValue;
cancelText: string;
numerable: boolean;
nullValue: PickerModelValue;
okText: string;
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[];
    };
    cols: {
    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[];
    };
    cols: {
    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;
    separator: string;
    cols: number;
    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: {
    type: StringConstructor;
    default: string;
    };
    okText: {
    type: StringConstructor;
    default: string;
    };
    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: {
    type: StringConstructor;
    default: string;
    };
    okText: {
    type: StringConstructor;
    default: string;
    };
    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;
    cancelText: string;
    okText: string;
    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: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
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: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
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;
cancelText: string;
okText: string;
showToolbar: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MPickerView: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: PropType<PickerModelValue>;
default: () => never[];
};
data: {
type: PropType<PickerSource>;
default: () => never[];
};
cols: {
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[];
};
cols: {
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;
separator: string;
cols: number;
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_2["render"]>;
default: string;
};
content: {
type: PropType<string | Props_2["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
cancelText: {
type: StringConstructor;
default: string;
};
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_2["render"]>;
default: string;
};
content: {
type: PropType<string | Props_2["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
cancelText: {
type: StringConstructor;
default: string;
};
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);
modelValue: boolean;
placement: string;
cancelText: string;
trigger: string;
okText: 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)[];
    portal: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: BooleanConstructor;
    placement: {
    type: StringConstructor;
    default: string;
    validator: (value: string) => boolean;
    };
    theme: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    getPopupContainer: FunctionConstructor;
    autoWidth: {
    type: BooleanConstructor;
    default: boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    portalStyle: (ObjectConstructor | StringConstructor)[];
    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;
    portal: boolean;
    modelValue: boolean;
    placement: string;
    theme: string;
    trigger: string;
    arrow: boolean;
    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)[];
    portal: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: BooleanConstructor;
    placement: {
    type: StringConstructor;
    default: string;
    validator: (value: string) => boolean;
    };
    theme: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    getPopupContainer: FunctionConstructor;
    autoWidth: {
    type: BooleanConstructor;
    default: boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    portalStyle: (ObjectConstructor | StringConstructor)[];
    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;
    portal: boolean;
    modelValue: boolean;
    placement: string;
    theme: string;
    trigger: string;
    arrow: boolean;
    autoWidth: boolean;
    outsideClickable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
always: BooleanConstructor;
animation: StringConstructor;
content: (FunctionConstructor | StringConstructor)[];
portal: {
type: BooleanConstructor;
default: boolean;
};
modelValue: BooleanConstructor;
placement: {
type: StringConstructor;
default: string;
validator: (value: string) => boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
getPopupContainer: FunctionConstructor;
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor)[];
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;
portal: boolean;
modelValue: boolean;
placement: string;
theme: string;
trigger: string;
arrow: boolean;
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" | "portal-fulfilled" | "visible-change")[], "close" | "update:modelValue" | "portal-fulfilled" | "visible-change", 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;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
}>, {
fixed: boolean;
mask: boolean;
modelValue: boolean;
maskClosable: boolean;
placement: string;
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: () => {
normal: 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: () => {
normal: 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;
fragment: boolean;
modelValue: string | number;
}, {}, {}, {}, 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;
};
overscan: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
loadData: {
type: FunctionConstructor;
default: () => boolean;
};
cols: {
type: NumberConstructor;
default: number;
};
gutter: {
type: NumberConstructor;
default: number;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
pullable: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
fill: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<ScrollerProps>;
renderEmpty: Render;
renderComplete: Render;
renderLoading: Render;
renderPlaceholder: Render;
renderRefresh: Render;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("scroll" | "row-resize")[], "scroll" | "row-resize", 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;
};
overscan: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
loadData: {
type: FunctionConstructor;
default: () => boolean;
};
cols: {
type: NumberConstructor;
default: number;
};
gutter: {
type: NumberConstructor;
default: number;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
pullable: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
fill: {
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;
}>, {
fill: boolean;
data: unknown[];
threshold: number;
disabled: boolean;
vertical: boolean;
cols: number;
gutter: number;
loadData: Function;
batchCount: number;
bufferCount: number;
overscan: number;
inverted: boolean;
pullable: 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;
};
barTo: 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;
};
barTo: StringConstructor;
}>> & Readonly<{
onScroll?: ((...args: any[]) => any) | undefined;
}>, {
always: boolean;
native: boolean;
height: string | number;
maxHeight: string | number;
tag: string;
wrapperClass: StyleValue;
wrapperStyle: StyleValue;
contentStyle: StyleValue;
contentClass: StyleValue;
thumbMinSize: number;
autoResize: boolean;
trackOffsetX: number[];
trackOffsetY: number[];
showBar: 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;
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;
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;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
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;
formatter: (value: number) => SliderTipValue;
modelValue: SliderValue;
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 MSteps: 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 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;
};
rowHeight: (StringConstructor | NumberConstructor)[];
fit: {
type: BooleanConstructor;
default: boolean;
};
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)[];
expandRowValue: ArrayConstructor;
defaultExpandAll: BooleanConstructor;
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
lazy: BooleanConstructor;
indent: {
type: NumberConstructor;
default: number;
};
treeMap: {
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: () => {};
};
delay: NumberConstructor;
resizable: {
type: BooleanConstructor;
default: undefined;
};
affix: {
type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
columns: {
type: PropType<TableColumnSyncItem[]>;
default: () => never[];
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("select" | "select-all" | "selection-change" | "update:columns" | "expand-change" | "current-change" | "cell-mouse-enter" | "cell-mouse-leave" | "cell-click" | "row-click" | "header-click" | "header-contextmenu" | "update:sort" | "sort-change" | "header-dragend" | "cell-dblclick" | "cell-contextmenu" | "row-contextmenu" | "row-dblclick")[], "select" | "select-all" | "selection-change" | "update:columns" | "expand-change" | "current-change" | "cell-mouse-enter" | "cell-mouse-leave" | "cell-click" | "row-click" | "header-click" | "header-contextmenu" | "update:sort" | "sort-change" | "header-dragend" | "cell-dblclick" | "cell-contextmenu" | "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;
};
rowHeight: (StringConstructor | NumberConstructor)[];
fit: {
type: BooleanConstructor;
default: boolean;
};
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)[];
expandRowValue: ArrayConstructor;
defaultExpandAll: BooleanConstructor;
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
lazy: BooleanConstructor;
indent: {
type: NumberConstructor;
default: number;
};
treeMap: {
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: () => {};
};
delay: NumberConstructor;
resizable: {
type: BooleanConstructor;
default: undefined;
};
affix: {
type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
columns: {
type: PropType<TableColumnSyncItem[]>;
default: () => never[];
};
}>> & Readonly<{
onSelect?: ((...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-mouse-enter"?: ((...args: any[]) => any) | undefined;
"onCell-mouse-leave"?: ((...args: any[]) => any) | undefined;
"onCell-click"?: ((...args: any[]) => any) | undefined;
"onRow-click"?: ((...args: any[]) => any) | undefined;
"onHeader-click"?: ((...args: any[]) => any) | undefined;
"onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
"onUpdate:sort"?: ((...args: any[]) => any) | undefined;
"onSort-change"?: ((...args: any[]) => any) | undefined;
"onHeader-dragend"?: ((...args: any[]) => any) | undefined;
"onCell-dblclick"?: ((...args: any[]) => any) | undefined;
"onCell-contextmenu"?: ((...args: any[]) => any) | undefined;
"onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
"onRow-dblclick"?: ((...args: any[]) => any) | undefined;
}>, {
sort: Record<string, any>;
resizable: boolean;
data: unknown[];
border: boolean;
columns: TableColumnSyncItem[];
lazy: boolean;
highlight: boolean;
placeholder: string | Function;
indeterminate: boolean;
indent: number;
fit: boolean;
expandSelectable: boolean;
defaultExpandAll: boolean;
showHeader: boolean;
virtualized: boolean;
stripe: boolean;
divider: boolean;
showSummary: boolean;
treeMap: Record<string, any>;
affix: boolean | unknown[] | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MTableColumn: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
line: NumberConstructor;
label: StringConstructor;
labelClass: StringConstructor;
prop: StringConstructor;
width: NumberConstructor;
minWidth: 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;
filters: PropType<unknown[]>;
filterMultiple: {
type: BooleanConstructor;
default: boolean;
};
filterIcon: StringConstructor;
filteredValue: PropType<unknown[]>;
filterPopupClass: StringConstructor;
filter: PropType<(value: unknown) => void>;
tooltip: PropType<TableColumnStates["tooltip"]>;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
line: NumberConstructor;
label: StringConstructor;
labelClass: StringConstructor;
prop: StringConstructor;
width: NumberConstructor;
minWidth: 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;
filters: PropType<unknown[]>;
filterMultiple: {
type: BooleanConstructor;
default: boolean;
};
filterIcon: StringConstructor;
filteredValue: PropType<unknown[]>;
filterPopupClass: StringConstructor;
filter: PropType<(value: unknown) => void>;
tooltip: PropType<TableColumnStates["tooltip"]>;
}>> & Readonly<{}>, {
resizable: boolean;
type: string;
reserveSelection: boolean;
sortable: boolean;
filterMultiple: 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;
theme: string;
closable: boolean;
afloat: boolean;
average: boolean;
animated: 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;
indent: number;
shrink: number | boolean;
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;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
tag: string;
}, {}, {}, {}, 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;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
changeOnSelect: boolean;
splitPanels: boolean;
steps: unknown[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const MToast: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_2["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_2["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_2["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_2["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_2["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 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: string;
};
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: FunctionConstructor;
allowDrop: FunctionConstructor;
lazy: {
type: BooleanConstructor;
default: boolean;
};
highlightCurrent: BooleanConstructor;
loadData: FunctionConstructor;
filterNode: FunctionConstructor;
indent: {
type: NumberConstructor;
default: number;
};
iconClass: StringConstructor;
keyValue: {
type: PropType<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" | "node-expand" | "check-change" | "check" | "node-collapse" | "node-click" | "node-contextmenu" | "node-drag-start" | "node-drag-leave" | "node-drag-enter" | "node-drag-over" | "node-drag-end" | "node-drop")[], "change" | "update:modelValue" | "current-change" | "node-expand" | "check-change" | "check" | "node-collapse" | "node-click" | "node-contextmenu" | "node-drag-start" | "node-drag-leave" | "node-drag-enter" | "node-drag-over" | "node-drag-end" | "node-drop", PublicProps, Readonly<ExtractPropTypes<    {
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
emptyText: {
type: StringConstructor;
default: string;
};
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: FunctionConstructor;
allowDrop: FunctionConstructor;
lazy: {
type: BooleanConstructor;
default: boolean;
};
highlightCurrent: BooleanConstructor;
loadData: FunctionConstructor;
filterNode: FunctionConstructor;
indent: {
type: NumberConstructor;
default: number;
};
iconClass: StringConstructor;
keyValue: {
type: PropType<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;
"onNode-expand"?: ((...args: any[]) => any) | undefined;
"onCheck-change"?: ((...args: any[]) => any) | undefined;
onCheck?: ((...args: any[]) => any) | undefined;
"onNode-collapse"?: ((...args: any[]) => any) | undefined;
"onNode-click"?: ((...args: any[]) => any) | undefined;
"onNode-contextmenu"?: ((...args: any[]) => any) | undefined;
"onNode-drag-start"?: ((...args: any[]) => any) | undefined;
"onNode-drag-leave"?: ((...args: any[]) => any) | undefined;
"onNode-drag-enter"?: ((...args: any[]) => any) | undefined;
"onNode-drag-over"?: ((...args: any[]) => any) | undefined;
"onNode-drag-end"?: ((...args: any[]) => any) | undefined;
"onNode-drop"?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: unknown[];
draggable: boolean;
lazy: boolean;
separator: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
allowDispatch: boolean;
accordion: boolean;
indent: number;
defaultExpandAll: boolean;
emptyText: string;
keyValue: {
children: string;
label: string;
value: string;
disabled: string;
isLeaf: string;
};
expandedValues: (string | number)[];
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;
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;
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;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
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: ObjectConstructor;
    default: () => {};
    };
    headers: {
    type: ObjectConstructor;
    default: () => {};
    };
    mode: {
    type: StringConstructor;
    default: string;
    };
    showTaskManager: {
    type: BooleanConstructor;
    default: boolean;
    };
    directory: {
    type: BooleanConstructor;
    default: boolean;
    };
    enhancer: FunctionConstructor;
    parallel: {
    type: BooleanConstructor;
    default: boolean;
    };
    showMessage: {
    type: BooleanConstructor;
    default: boolean;
    };
    showToast: {
    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, any>;
    directory: boolean;
    disabled: boolean;
    tag: string | Record<string, any>;
    mode: string;
    headers: Record<string, any>;
    showMessage: boolean;
    showLoading: boolean;
    parallel: boolean;
    showTaskManager: boolean;
    showToast: 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: ObjectConstructor;
    default: () => {};
    };
    headers: {
    type: ObjectConstructor;
    default: () => {};
    };
    mode: {
    type: StringConstructor;
    default: string;
    };
    showTaskManager: {
    type: BooleanConstructor;
    default: boolean;
    };
    directory: {
    type: BooleanConstructor;
    default: boolean;
    };
    enhancer: FunctionConstructor;
    parallel: {
    type: BooleanConstructor;
    default: boolean;
    };
    showMessage: {
    type: BooleanConstructor;
    default: boolean;
    };
    showToast: {
    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, any>;
    directory: boolean;
    disabled: boolean;
    tag: string | Record<string, any>;
    mode: string;
    headers: Record<string, any>;
    showMessage: boolean;
    showLoading: boolean;
    parallel: boolean;
    showTaskManager: boolean;
    showToast: 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: ObjectConstructor;
default: () => {};
};
headers: {
type: ObjectConstructor;
default: () => {};
};
mode: {
type: StringConstructor;
default: string;
};
showTaskManager: {
type: BooleanConstructor;
default: boolean;
};
directory: {
type: BooleanConstructor;
default: boolean;
};
enhancer: FunctionConstructor;
parallel: {
type: BooleanConstructor;
default: boolean;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
showToast: {
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, any>;
directory: boolean;
disabled: boolean;
tag: string | Record<string, any>;
mode: string;
headers: Record<string, any>;
showMessage: boolean;
showLoading: boolean;
parallel: boolean;
showTaskManager: boolean;
showToast: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options: any) => PortalLeaf;
};

export declare const MUploadPicker: DefineComponent<ExtractPropTypes<    {
picker: {
type: ArrayConstructor;
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: ObjectConstructor;
default: () => {
label: string;
value: string;
};
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
validator: (v: any) => boolean;
};
max: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
formatter: FunctionConstructor;
boxClass: StringConstructor;
imagePreviewOptions: {
type: ObjectConstructor;
default: () => {};
};
imageClass: StringConstructor;
videoClass: StringConstructor;
audioClass: StringConstructor;
fileClass: StringConstructor;
compressOptions: {
type: ObjectConstructor;
default: () => {
compress: boolean;
width: number;
height: number;
filetype: string;
encoderOptions: number;
};
};
showMessage: BooleanConstructor;
enhancer: (FunctionConstructor | BooleanConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "change" | "complete" | "success" | "update:modelValue" | "file-before" | "file-start" | "file-success" | "file-error" | "remove-before")[], "error" | "change" | "complete" | "success" | "update:modelValue" | "file-before" | "file-start" | "file-success" | "file-error" | "remove-before", PublicProps, Readonly<ExtractPropTypes<    {
picker: {
type: ArrayConstructor;
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: ObjectConstructor;
default: () => {
label: string;
value: string;
};
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
validator: (v: any) => boolean;
};
max: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
formatter: FunctionConstructor;
boxClass: StringConstructor;
imagePreviewOptions: {
type: ObjectConstructor;
default: () => {};
};
imageClass: StringConstructor;
videoClass: StringConstructor;
audioClass: StringConstructor;
fileClass: StringConstructor;
compressOptions: {
type: ObjectConstructor;
default: () => {
compress: boolean;
width: number;
height: number;
filetype: string;
encoderOptions: number;
};
};
showMessage: 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;
onSuccess?: ((...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>;
showMessage: boolean;
picker: unknown[];
uploadOptions: Record<string, any>;
sortable: boolean;
keyValue: Record<string, any>;
imagePreviewOptions: Record<string, any>;
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;
    detach(node: RecycleListItemNodeRaw): void;
    clear(): void;
    get(index: number): RecycleListItemNodeRaw | undefined;
    create(index: number, data?: any): RecycleListItemNodeRaw;
    private revive;
    reuseOrCreate(prevByIndex: Map<number, RecycleListItemNodeRaw>, index: number, data?: any): RecycleListItemNodeRaw;
    setSize(node: RecycleListItemNodeRaw, size: number): void;
    upsert(index: number, data?: any): RecycleListItemNodeRaw;
    build(start: number, end: number, reversed?: boolean): number[];
    allocatePlaceholders(): {
        start: number;
        end: number;
    };
    private prepend;
    trimPlaceholders(): boolean;
    invalidate(): void;
    rebuild(base: number, count: number, dataAt: (index: number) => any): void;
}

export declare const Notice: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    title: PropType<string | Props_2["render"]>;
    content: PropType<string | Props_2["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_2["render"]>;
    content: PropType<string | Props_2["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_2["render"]>;
content: PropType<string | Props_2["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_2["render"]>;
content: PropType<string | Props_2["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_2["render"]>;
content: PropType<string | Props_2["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_2 = Partial<Props_3 & {
    onClose: (...args: any[]) => any;
}>;

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

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

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

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

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

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

declare type Options_9 = Partial<Props_11 & {
    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;
portal: boolean;
placement: string;
current: number;
pageSize: number;
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: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
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: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
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;
cancelText: string;
okText: string;
showToolbar: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare type PickerSource = PickerColumn | PickerColumn[];

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[];
};
cols: {
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[];
};
cols: {
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;
separator: string;
cols: number;
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_2["render"]>;
default: string;
};
content: {
type: PropType<string | Props_2["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
cancelText: {
type: StringConstructor;
default: string;
};
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_2["render"]>;
default: string;
};
content: {
type: PropType<string | Props_2["render"]>;
default: string;
};
modelValue: {
type: BooleanConstructor;
default: boolean;
};
placement: {
type: StringConstructor;
default: string;
};
trigger: {
type: StringConstructor;
default: string;
};
okText: {
type: StringConstructor;
default: string;
};
cancelText: {
type: StringConstructor;
default: string;
};
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);
modelValue: boolean;
placement: string;
cancelText: string;
trigger: string;
okText: 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)[];
    portal: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: BooleanConstructor;
    placement: {
    type: StringConstructor;
    default: string;
    validator: (value: string) => boolean;
    };
    theme: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    getPopupContainer: FunctionConstructor;
    autoWidth: {
    type: BooleanConstructor;
    default: boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    portalStyle: (ObjectConstructor | StringConstructor)[];
    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;
    portal: boolean;
    modelValue: boolean;
    placement: string;
    theme: string;
    trigger: string;
    arrow: boolean;
    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)[];
    portal: {
    type: BooleanConstructor;
    default: boolean;
    };
    modelValue: BooleanConstructor;
    placement: {
    type: StringConstructor;
    default: string;
    validator: (value: string) => boolean;
    };
    theme: {
    type: StringConstructor;
    default: string;
    validator: (v: string) => boolean;
    };
    arrow: {
    type: BooleanConstructor;
    default: boolean;
    };
    getPopupContainer: FunctionConstructor;
    autoWidth: {
    type: BooleanConstructor;
    default: boolean;
    };
    portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
    portalStyle: (ObjectConstructor | StringConstructor)[];
    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;
    portal: boolean;
    modelValue: boolean;
    placement: string;
    theme: string;
    trigger: string;
    arrow: boolean;
    autoWidth: boolean;
    outsideClickable: boolean;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<ExtractPropTypes<    {
always: BooleanConstructor;
animation: StringConstructor;
content: (FunctionConstructor | StringConstructor)[];
portal: {
type: BooleanConstructor;
default: boolean;
};
modelValue: BooleanConstructor;
placement: {
type: StringConstructor;
default: string;
validator: (value: string) => boolean;
};
theme: {
type: StringConstructor;
default: string;
validator: (v: string) => boolean;
};
arrow: {
type: BooleanConstructor;
default: boolean;
};
getPopupContainer: FunctionConstructor;
autoWidth: {
type: BooleanConstructor;
default: boolean;
};
portalClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
portalStyle: (ObjectConstructor | StringConstructor)[];
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;
portal: boolean;
modelValue: boolean;
placement: string;
theme: string;
trigger: string;
arrow: boolean;
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 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" | "portal-fulfilled" | "visible-change")[], "close" | "update:modelValue" | "portal-fulfilled" | "visible-change", 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;
"onPortal-fulfilled"?: ((...args: any[]) => any) | undefined;
"onVisible-change"?: ((...args: any[]) => any) | undefined;
}>, {
fixed: boolean;
mask: boolean;
modelValue: boolean;
maskClosable: boolean;
placement: string;
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>>;
    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;
    el: string | HTMLElement;
    alive: boolean;
    multiple: boolean;
    aliveRegExp: {
        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[], sourceLength: number): void;
    rebuild(): number[][];
    ensure(rawRebuildData: RecycleListItemNodeRaw[], cols: number): 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: () => {
normal: 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: () => {
normal: 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: {
    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;
    };
    barTo: StringConstructor;
};

declare type Props_11 = ExtractPropTypes<typeof props_12>;

declare const props_11: {
    data: {
        type: ArrayConstructor;
        default: () => never[];
    };
    width: (StringConstructor | NumberConstructor)[];
    height: (StringConstructor | NumberConstructor)[];
    maxHeight: (StringConstructor | NumberConstructor)[];
    virtualized: {
        type: BooleanConstructor;
        default: boolean;
    };
    rowHeight: (StringConstructor | NumberConstructor)[];
    fit: {
        type: BooleanConstructor;
        default: boolean;
    };
    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)[];
    expandRowValue: ArrayConstructor;
    defaultExpandAll: BooleanConstructor;
    indeterminate: {
        type: BooleanConstructor;
        default: boolean;
    };
    lazy: BooleanConstructor;
    indent: {
        type: NumberConstructor;
        default: number;
    };
    treeMap: {
        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: () => {};
    };
    delay: NumberConstructor;
    resizable: {
        type: BooleanConstructor;
        default: undefined;
    };
    affix: {
        type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
        default: boolean;
    };
    columns: {
        type: PropType<TableColumnSyncItem[]>;
        default: () => never[];
    };
};

declare const props_12: {
    content: PropType<string | Props_2["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 type Props_2 = ExtractPropTypes<typeof props_2>;

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

declare type Props_3 = ExtractPropTypes<typeof props_3>;

declare const props_3: {
    title: PropType<string | boolean | Props_2["render"]>;
    content: {
        type: PropType<string | Props_2["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;
    };
    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: string;
    };
    cancelText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: string;
    };
    okDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    cancelDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    footer: {
        type: BooleanConstructor;
        default: boolean;
    };
    onOk: {
        type: FunctionConstructor;
    };
    onCancel: {
        type: FunctionConstructor;
    };
};

declare type Props_4 = ExtractPropTypes<typeof props_4>;

declare const props_4: {
    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_5 = ExtractPropTypes<typeof props_5>;

declare const props_5: {
    content: PropType<string | Props_2["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_6 = ExtractPropTypes<typeof props_6>;

declare const props_6: {
    modelValue: {
        type: BooleanConstructor;
        default: boolean;
    };
    mode: {
        type: PropType<"info" | "success" | "error" | "warning">;
        validator: (v: string) => boolean;
    };
    content: {
        type: PropType<string | Props_2["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: NumberConstructor;
    };
    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_2["render"]>;
    };
    scrollable: {
        type: BooleanConstructor;
        default: boolean;
    };
    draggable: {
        type: BooleanConstructor;
        default: boolean;
    };
    x: NumberConstructor;
    y: NumberConstructor;
    okText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: string;
    };
    cancelText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: string;
    };
    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;
    };
};

declare type Props_7 = ExtractPropTypes<typeof props_7>;

declare const props_7: {
    mode: {
        type: PropType<"alert" | "operation">;
        validator: (v: any) => boolean;
        default: string;
    };
    content: {
        type: PropType<boolean | string | Props_2["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_2["render"]>;
    };
    okText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: string;
    };
    cancelText: {
        type: (StringConstructor | BooleanConstructor)[];
        default: string;
    };
    wrapperStyle: {
        type: ObjectConstructor;
    };
    footer: {
        type: BooleanConstructor;
        default: boolean;
    };
    data: ArrayConstructor;
    onOk: {
        type: FunctionConstructor;
    };
    onCancel: {
        type: FunctionConstructor;
    };
};

declare type Props_8 = ExtractPropTypes<typeof props_8>;

declare const props_8: {
    title: PropType<string | Props_2["render"]>;
    content: PropType<string | Props_2["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_9 = ExtractPropTypes<typeof props_9>;

declare const props_9: {
    data: {
        type: ArrayConstructor;
        default: () => never[];
    };
    store: PropType<RecycleListStore>;
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    batchCount: {
        type: NumberConstructor;
        default: number;
    };
    bufferCount: {
        type: NumberConstructor;
        default: number;
    };
    overscan: {
        type: NumberConstructor;
        default: number;
    };
    threshold: {
        type: NumberConstructor;
        default: number;
    };
    loadData: {
        type: FunctionConstructor;
        default: () => boolean;
    };
    cols: {
        type: NumberConstructor;
        default: number;
    };
    gutter: {
        type: NumberConstructor;
        default: number;
    };
    inverted: {
        type: BooleanConstructor;
        default: boolean;
    };
    pullable: {
        type: BooleanConstructor;
        default: boolean;
    };
    vertical: {
        type: BooleanConstructor;
        default: boolean;
    };
    fill: {
        type: BooleanConstructor;
        default: boolean;
    };
    scrollerOptions: PropType<ScrollerProps>;
    renderEmpty: Render;
    renderComplete: Render;
    renderLoading: Render;
    renderPlaceholder: Render;
    renderRefresh: Render;
};

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;
fragment: boolean;
modelValue: string | number;
}, {}, {}, {}, 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>;

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;
};
overscan: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
loadData: {
type: FunctionConstructor;
default: () => boolean;
};
cols: {
type: NumberConstructor;
default: number;
};
gutter: {
type: NumberConstructor;
default: number;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
pullable: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
fill: {
type: BooleanConstructor;
default: boolean;
};
scrollerOptions: PropType<ScrollerProps>;
renderEmpty: Render;
renderComplete: Render;
renderLoading: Render;
renderPlaceholder: Render;
renderRefresh: Render;
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("scroll" | "row-resize")[], "scroll" | "row-resize", 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;
};
overscan: {
type: NumberConstructor;
default: number;
};
threshold: {
type: NumberConstructor;
default: number;
};
loadData: {
type: FunctionConstructor;
default: () => boolean;
};
cols: {
type: NumberConstructor;
default: number;
};
gutter: {
type: NumberConstructor;
default: number;
};
inverted: {
type: BooleanConstructor;
default: boolean;
};
pullable: {
type: BooleanConstructor;
default: boolean;
};
vertical: {
type: BooleanConstructor;
default: boolean;
};
fill: {
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;
}>, {
fill: boolean;
data: unknown[];
threshold: number;
disabled: boolean;
vertical: boolean;
cols: number;
gutter: number;
loadData: Function;
batchCount: number;
bufferCount: number;
overscan: number;
inverted: boolean;
pullable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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

declare type RecycleListItemNodeRaw = Raw<RecycleListItemNode>;

declare type RecycleListStates = {
    rebuildData: RecycleListItemNodeRaw[];
    loadings: string[];
    contentMaxSize: number;
    columnFillSize: number[];
    isEnd: boolean;
    isSilentRefresh: boolean;
    isLoading: boolean;
    columnSize: string | undefined;
    columnOffsetGutter: 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_9;
    constructor(options: Partial<Props_9>);
    setData(data: any[]): boolean;
    fetchPage(onBeforeCommit?: () => void): Promise<{
        current: 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 {
    month: number;
    year: number;
    lang: CalendarLang;
    monthNames: CalendarName[];
}

declare interface RenderWeekProps {
    weekNames: CalendarName[];
    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;
};
barTo: 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;
};
barTo: StringConstructor;
}>> & Readonly<{
onScroll?: ((...args: any[]) => any) | undefined;
}>, {
always: boolean;
native: boolean;
height: string | number;
maxHeight: string | number;
tag: string;
wrapperClass: StyleValue;
wrapperStyle: StyleValue;
contentStyle: StyleValue;
contentClass: StyleValue;
thumbMinSize: number;
autoResize: boolean;
trackOffsetX: number[];
trackOffsetY: number[];
showBar: 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_10>;

export declare const ScrollerWheel: 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;
};
barTo: StringConstructor;
} & {
stopPropagation: {
type: BooleanConstructor;
default: boolean;
};
}>, () => 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;
};
barTo: StringConstructor;
} & {
stopPropagation: {
type: BooleanConstructor;
default: boolean;
};
}>> & Readonly<{
onScroll?: ((...args: any[]) => any) | undefined;
}>, {
always: boolean;
native: boolean;
height: string | number;
maxHeight: string | number;
tag: string;
wrapperClass: StyleValue;
wrapperStyle: StyleValue;
contentStyle: StyleValue;
contentClass: StyleValue;
stopPropagation: boolean;
thumbMinSize: number;
autoResize: boolean;
trackOffsetX: number[];
trackOffsetY: number[];
showBar: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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;
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;
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;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
searchable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class Selection_2 {
    store: Store;
    constructor(store: Store);
    isSelected(row: any): boolean;
    clear(): void;
    clean(): void;
    toggle(row: any, selected?: any, emitChange?: boolean): 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;
formatter: (value: number) => SliderTipValue;
modelValue: SliderValue;
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 Steps: 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>;

declare class Store extends BaseWatcher_2 {
    table: any;
    row: Row;
    expand: Expand_2;
    tree: Tree_2;
    block: Block;
    column: Column;
    layout: Layout_2;
    selection: Selection_2;
    flatData: ComputedRef<any[]>;
    constructor(options: any);
    setData(data: any[]): void;
    updateColumns(): void;
    toggleRowExpansionAdapter(row: any, expanded?: boolean): void;
    checkPrimaryKey(): void;
    setExpandRowValueAdapter(val: any): void;
    updateTableScrollY(): 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;
};
rowHeight: (StringConstructor | NumberConstructor)[];
fit: {
type: BooleanConstructor;
default: boolean;
};
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)[];
expandRowValue: ArrayConstructor;
defaultExpandAll: BooleanConstructor;
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
lazy: BooleanConstructor;
indent: {
type: NumberConstructor;
default: number;
};
treeMap: {
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: () => {};
};
delay: NumberConstructor;
resizable: {
type: BooleanConstructor;
default: undefined;
};
affix: {
type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
columns: {
type: PropType<TableColumnSyncItem[]>;
default: () => never[];
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("select" | "select-all" | "selection-change" | "update:columns" | "expand-change" | "current-change" | "cell-mouse-enter" | "cell-mouse-leave" | "cell-click" | "row-click" | "header-click" | "header-contextmenu" | "update:sort" | "sort-change" | "header-dragend" | "cell-dblclick" | "cell-contextmenu" | "row-contextmenu" | "row-dblclick")[], "select" | "select-all" | "selection-change" | "update:columns" | "expand-change" | "current-change" | "cell-mouse-enter" | "cell-mouse-leave" | "cell-click" | "row-click" | "header-click" | "header-contextmenu" | "update:sort" | "sort-change" | "header-dragend" | "cell-dblclick" | "cell-contextmenu" | "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;
};
rowHeight: (StringConstructor | NumberConstructor)[];
fit: {
type: BooleanConstructor;
default: boolean;
};
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)[];
expandRowValue: ArrayConstructor;
defaultExpandAll: BooleanConstructor;
indeterminate: {
type: BooleanConstructor;
default: boolean;
};
lazy: BooleanConstructor;
indent: {
type: NumberConstructor;
default: number;
};
treeMap: {
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: () => {};
};
delay: NumberConstructor;
resizable: {
type: BooleanConstructor;
default: undefined;
};
affix: {
type: (ObjectConstructor | BooleanConstructor | ArrayConstructor)[];
default: boolean;
};
columns: {
type: PropType<TableColumnSyncItem[]>;
default: () => never[];
};
}>> & Readonly<{
onSelect?: ((...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-mouse-enter"?: ((...args: any[]) => any) | undefined;
"onCell-mouse-leave"?: ((...args: any[]) => any) | undefined;
"onCell-click"?: ((...args: any[]) => any) | undefined;
"onRow-click"?: ((...args: any[]) => any) | undefined;
"onHeader-click"?: ((...args: any[]) => any) | undefined;
"onHeader-contextmenu"?: ((...args: any[]) => any) | undefined;
"onUpdate:sort"?: ((...args: any[]) => any) | undefined;
"onSort-change"?: ((...args: any[]) => any) | undefined;
"onHeader-dragend"?: ((...args: any[]) => any) | undefined;
"onCell-dblclick"?: ((...args: any[]) => any) | undefined;
"onCell-contextmenu"?: ((...args: any[]) => any) | undefined;
"onRow-contextmenu"?: ((...args: any[]) => any) | undefined;
"onRow-dblclick"?: ((...args: any[]) => any) | undefined;
}>, {
sort: Record<string, any>;
resizable: boolean;
data: unknown[];
border: boolean;
columns: TableColumnSyncItem[];
lazy: boolean;
highlight: boolean;
placeholder: string | Function;
indeterminate: boolean;
indent: number;
fit: boolean;
expandSelectable: boolean;
defaultExpandAll: boolean;
showHeader: boolean;
virtualized: boolean;
stripe: boolean;
divider: boolean;
showSummary: boolean;
treeMap: Record<string, any>;
affix: boolean | unknown[] | Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const TableColumn: DefineComponent<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
line: NumberConstructor;
label: StringConstructor;
labelClass: StringConstructor;
prop: StringConstructor;
width: NumberConstructor;
minWidth: 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;
filters: PropType<unknown[]>;
filterMultiple: {
type: BooleanConstructor;
default: boolean;
};
filterIcon: StringConstructor;
filteredValue: PropType<unknown[]>;
filterPopupClass: StringConstructor;
filter: PropType<(value: unknown) => void>;
tooltip: PropType<TableColumnStates["tooltip"]>;
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
type: {
type: StringConstructor;
default: string;
};
line: NumberConstructor;
label: StringConstructor;
labelClass: StringConstructor;
prop: StringConstructor;
width: NumberConstructor;
minWidth: 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;
filters: PropType<unknown[]>;
filterMultiple: {
type: BooleanConstructor;
default: boolean;
};
filterIcon: StringConstructor;
filteredValue: PropType<unknown[]>;
filterPopupClass: StringConstructor;
filter: PropType<(value: unknown) => void>;
tooltip: PropType<TableColumnStates["tooltip"]>;
}>> & Readonly<{}>, {
resizable: boolean;
type: string;
reserveSelection: boolean;
sortable: boolean;
filterMultiple: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare class TableColumnNode {
    states: TableColumnStates;
    childNodes: TableColumnNode[];
    table: TableProvide;
    parentNode: Nullable<TableColumnNode>;
    instance: ComponentInternalInstance;
    constructor(options: Options_8);
    get children(): TableColumnNode[] | undefined;
    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 TableColumnProps = ExtractPropTypes<typeof tableColumnProps>;

declare const tableColumnProps: {
    type: {
        type: StringConstructor;
        default: string;
    };
    line: NumberConstructor;
    label: StringConstructor;
    labelClass: StringConstructor;
    prop: StringConstructor;
    width: NumberConstructor;
    minWidth: 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;
    filters: PropType<unknown[]>;
    filterMultiple: {
        type: BooleanConstructor;
        default: boolean;
    };
    filterIcon: StringConstructor;
    filteredValue: PropType<unknown[]>;
    filterPopupClass: StringConstructor;
    filter: PropType<(value: unknown) => void>;
    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;
    isExpandColumn?: boolean;
    treeNode?: {
        indent?: number;
        expand?: boolean;
        noLazyChildren?: boolean;
        loading?: boolean;
    };
}

declare type TableColumnStates = {
    id: string;
    type: string;
    line?: 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;
    filters?: unknown[];
    filterMultiple?: boolean;
    filterIcon?: string;
    filteredValue?: unknown[];
    filterPopupClass?: string;
    filter?: (value: unknown) => void;
    tooltip?: string | ((data: Pick<TableColumnRenderData, 'column' | 'store'>) => string);
    colspan: number;
    rowspan: number;
    class?: string;
    style?: CSSProperties;
    order?: string;
    realAlign: string | null;
    realHeaderAlign: string | null;
    realWidth?: number;
    hidden?: boolean;
    level?: number;
    stickyOffset?: number;
    stickyStyle?: CSSProperties;
    stickyClass?: string;
    renderHeader?: (data: Pick<TableColumnRenderData, 'column' | 'columnIndex' | 'store'>) => VNodeChild;
    renderCell?: (data: TableColumnRenderData) => VNodeChild;
};

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

declare interface TableProvide {
    tableId: string;
    store: Store;
    props: Props_10;
    emit: (event: string, ...args: unknown[]) => void;
    renderExpand: Ref<Nullable<(data: Pick<TableColumnRenderData, 'row' | 'rowIndex' | 'store'>) => VNodeChild>>;
    hiddenColumns: Ref<Nullable<HTMLElement>>;
    isReady: Ref<boolean>;
    hoverState: Ref<Nullable<{
        cell: HTMLElement;
        column: TableColumnStates;
        row: Record<string, unknown>;
    }>>;
    resizeProxyVisible: Ref<boolean>;
    resizeProxy: Ref<Nullable<HTMLElement>>;
    tableWrapper: Ref<Nullable<HTMLElement>>;
}

declare type TableStates = {
    _data: any[];
    data: 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;
    expandSelectable: any;
    hoverRowIndex: number | null;
    currentRow: any;
    defaultExpandAll: boolean;
    expandRows: any[];
    treeExpandRowValue: any[];
    treeData: Record<string, any>;
    treeLazy: boolean;
    treelazyNodeMap: Record<string, any>;
    treeLazyData: any[];
    treeLazyColumnIdentifier: string;
    treeChildrenColumnName: string;
    isComplex: boolean;
    hasMergeCells: boolean;
    isGroup: boolean;
    columns: TableColumnNodeRaw[];
    leafColumns: TableColumnNodeRaw[];
    leftFixedLeafColumns: TableColumnNodeRaw[];
    rightFixedLeafColumns: TableColumnNodeRaw[];
    leafColumnsLength: number;
    leftFixedLeafColumnsLength: number;
    rightFixedLeafColumnsLength: number;
};

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;
afloat: boolean;
animated: 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;
indent: number;
shrink: number | boolean;
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;
};
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
tag: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
tag: string;
}, {}, {}, {}, 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;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
changeOnSelect: boolean;
splitPanels: boolean;
steps: unknown[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const Toast: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    content: PropType<string | Props_2["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_2["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_2["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_2["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_2["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 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 Tree: DefineComponent<ExtractPropTypes<    {
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
emptyText: {
type: StringConstructor;
default: string;
};
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: FunctionConstructor;
allowDrop: FunctionConstructor;
lazy: {
type: BooleanConstructor;
default: boolean;
};
highlightCurrent: BooleanConstructor;
loadData: FunctionConstructor;
filterNode: FunctionConstructor;
indent: {
type: NumberConstructor;
default: number;
};
iconClass: StringConstructor;
keyValue: {
type: PropType<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" | "node-expand" | "check-change" | "check" | "node-collapse" | "node-click" | "node-contextmenu" | "node-drag-start" | "node-drag-leave" | "node-drag-enter" | "node-drag-over" | "node-drag-end" | "node-drop")[], "change" | "update:modelValue" | "current-change" | "node-expand" | "check-change" | "check" | "node-collapse" | "node-click" | "node-contextmenu" | "node-drag-start" | "node-drag-leave" | "node-drag-enter" | "node-drag-over" | "node-drag-end" | "node-drop", PublicProps, Readonly<ExtractPropTypes<    {
max: {
type: NumberConstructor;
default: number;
validator: (v: any) => boolean;
};
data: {
type: ArrayConstructor;
default: () => never[];
};
emptyText: {
type: StringConstructor;
default: string;
};
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: FunctionConstructor;
allowDrop: FunctionConstructor;
lazy: {
type: BooleanConstructor;
default: boolean;
};
highlightCurrent: BooleanConstructor;
loadData: FunctionConstructor;
filterNode: FunctionConstructor;
indent: {
type: NumberConstructor;
default: number;
};
iconClass: StringConstructor;
keyValue: {
type: PropType<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;
"onNode-expand"?: ((...args: any[]) => any) | undefined;
"onCheck-change"?: ((...args: any[]) => any) | undefined;
onCheck?: ((...args: any[]) => any) | undefined;
"onNode-collapse"?: ((...args: any[]) => any) | undefined;
"onNode-click"?: ((...args: any[]) => any) | undefined;
"onNode-contextmenu"?: ((...args: any[]) => any) | undefined;
"onNode-drag-start"?: ((...args: any[]) => any) | undefined;
"onNode-drag-leave"?: ((...args: any[]) => any) | undefined;
"onNode-drag-enter"?: ((...args: any[]) => any) | undefined;
"onNode-drag-over"?: ((...args: any[]) => any) | undefined;
"onNode-drag-end"?: ((...args: any[]) => any) | undefined;
"onNode-drop"?: ((...args: any[]) => any) | undefined;
}>, {
max: number;
data: unknown[];
draggable: boolean;
lazy: boolean;
separator: string;
numerable: boolean;
nullValue: string | number | Record<string, any>;
allowDispatch: boolean;
accordion: boolean;
indent: number;
defaultExpandAll: boolean;
emptyText: string;
keyValue: {
children: string;
label: string;
value: string;
disabled: string;
isLeaf: string;
};
expandedValues: (string | number)[];
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;
    normalizedData: ComputedRef<    {}>;
    normalizedLazyNode: ComputedRef<    {}>;
    constructor(store: Store);
    normalize(data: any[]): {};
    getMaxLevel(): any;
    update(): void;
    expand(ids: any[]): void;
    toggle(row: any, expanded?: boolean): void;
    loadOrToggle(row: any): void;
    loadData(row: any, key: any, treeNode: any): void;
}

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

declare type TreeLabel = string;

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;
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;
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;
portal: boolean;
placement: string;
trigger: string;
arrow: boolean;
numerable: boolean;
nullValue: string | number | Record<string, any>;
clearable: boolean;
autoWidth: boolean;
searchPlaceholder: string;
searchable: boolean;
cascader: boolean;
checkStrictly: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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: ObjectConstructor;
    default: () => {};
    };
    headers: {
    type: ObjectConstructor;
    default: () => {};
    };
    mode: {
    type: StringConstructor;
    default: string;
    };
    showTaskManager: {
    type: BooleanConstructor;
    default: boolean;
    };
    directory: {
    type: BooleanConstructor;
    default: boolean;
    };
    enhancer: FunctionConstructor;
    parallel: {
    type: BooleanConstructor;
    default: boolean;
    };
    showMessage: {
    type: BooleanConstructor;
    default: boolean;
    };
    showToast: {
    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, any>;
    directory: boolean;
    disabled: boolean;
    tag: string | Record<string, any>;
    mode: string;
    headers: Record<string, any>;
    showMessage: boolean;
    showLoading: boolean;
    parallel: boolean;
    showTaskManager: boolean;
    showToast: 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: ObjectConstructor;
    default: () => {};
    };
    headers: {
    type: ObjectConstructor;
    default: () => {};
    };
    mode: {
    type: StringConstructor;
    default: string;
    };
    showTaskManager: {
    type: BooleanConstructor;
    default: boolean;
    };
    directory: {
    type: BooleanConstructor;
    default: boolean;
    };
    enhancer: FunctionConstructor;
    parallel: {
    type: BooleanConstructor;
    default: boolean;
    };
    showMessage: {
    type: BooleanConstructor;
    default: boolean;
    };
    showToast: {
    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, any>;
    directory: boolean;
    disabled: boolean;
    tag: string | Record<string, any>;
    mode: string;
    headers: Record<string, any>;
    showMessage: boolean;
    showLoading: boolean;
    parallel: boolean;
    showTaskManager: boolean;
    showToast: 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: ObjectConstructor;
default: () => {};
};
headers: {
type: ObjectConstructor;
default: () => {};
};
mode: {
type: StringConstructor;
default: string;
};
showTaskManager: {
type: BooleanConstructor;
default: boolean;
};
directory: {
type: BooleanConstructor;
default: boolean;
};
enhancer: FunctionConstructor;
parallel: {
type: BooleanConstructor;
default: boolean;
};
showMessage: {
type: BooleanConstructor;
default: boolean;
};
showToast: {
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, any>;
directory: boolean;
disabled: boolean;
tag: string | Record<string, any>;
mode: string;
headers: Record<string, any>;
showMessage: boolean;
showLoading: boolean;
parallel: boolean;
showTaskManager: boolean;
showToast: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
    open: (options: any) => PortalLeaf;
};

export declare const UploadPicker: DefineComponent<ExtractPropTypes<    {
picker: {
type: ArrayConstructor;
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: ObjectConstructor;
default: () => {
label: string;
value: string;
};
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
validator: (v: any) => boolean;
};
max: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
formatter: FunctionConstructor;
boxClass: StringConstructor;
imagePreviewOptions: {
type: ObjectConstructor;
default: () => {};
};
imageClass: StringConstructor;
videoClass: StringConstructor;
audioClass: StringConstructor;
fileClass: StringConstructor;
compressOptions: {
type: ObjectConstructor;
default: () => {
compress: boolean;
width: number;
height: number;
filetype: string;
encoderOptions: number;
};
};
showMessage: BooleanConstructor;
enhancer: (FunctionConstructor | BooleanConstructor)[];
}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("error" | "change" | "complete" | "success" | "update:modelValue" | "file-before" | "file-start" | "file-success" | "file-error" | "remove-before")[], "error" | "change" | "complete" | "success" | "update:modelValue" | "file-before" | "file-start" | "file-success" | "file-error" | "remove-before", PublicProps, Readonly<ExtractPropTypes<    {
picker: {
type: ArrayConstructor;
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: ObjectConstructor;
default: () => {
label: string;
value: string;
};
};
output: {
type: (FunctionConstructor | StringConstructor)[];
default: string;
validator: (v: any) => boolean;
};
max: {
type: (ObjectConstructor | NumberConstructor)[];
default: number;
};
disabled: {
type: BooleanConstructor;
default: boolean;
};
formatter: FunctionConstructor;
boxClass: StringConstructor;
imagePreviewOptions: {
type: ObjectConstructor;
default: () => {};
};
imageClass: StringConstructor;
videoClass: StringConstructor;
audioClass: StringConstructor;
fileClass: StringConstructor;
compressOptions: {
type: ObjectConstructor;
default: () => {
compress: boolean;
width: number;
height: number;
filetype: string;
encoderOptions: number;
};
};
showMessage: 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;
onSuccess?: ((...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>;
showMessage: boolean;
picker: unknown[];
uploadOptions: Record<string, any>;
sortable: boolean;
keyValue: Record<string, any>;
imagePreviewOptions: Record<string, any>;
compressOptions: Record<string, any>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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

export declare const VcInstance: Instance;

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

export { }