/// <reference types="vditor/dist/types" />

import type { AvatarProps } from 'element-plus';
import type { BadgeProps } from 'element-plus';
import type { ButtonProps } from 'element-plus';
import type { ButtonType } from 'element-plus';
import type { ColProps } from 'element-plus';
import type { Component as Component_2 } from 'vue';
import type { CSSProperties } from 'vue';
import type { Directive } from 'vue';
import * as echarts_2 from 'echarts';
import type { FormItemInstance } from 'element-plus';
import type { FormItemProps } from 'element-plus';
import type { FormItemRule } from 'element-plus';
import type { FormMetaProps } from 'element-plus';
import type { FormProps as FormProps_2 } from 'element-plus';
import type { IconifyIcon } from '@iconify/vue';
import type { IconProps } from '@iconify/vue';
import { init } from 'echarts/core';
import type { LinkProps } from 'element-plus';
import type { PaginationProps } from 'element-plus';
import type { PartialOptions } from 'element-plus';
import type { Placement } from 'element-plus';
import type { SetOptionOpts } from 'echarts';
import { setupDirectives } from './directives';
import type { TableColumnCtx } from 'element-plus';
import type { TableProps as TableProps_2 } from 'element-plus';
import type { TabsPaneContext } from 'element-plus';
import type { TabsProps } from 'element-plus';
import type { TagProps } from 'element-plus';
import { default as VpBreadcrumb } from './components/Themes/Breadcrumb.vue';
import { default as VpDarkModeToggle } from './components/Themes/DarkModeToggle.vue';
import { default as VpLoginForm } from './components/Form/LoginForm.vue';
import { default as VpNoticeMessageList } from './components/Notice/NoticeMessageList.vue';
import { default as VpTable } from './components/Table/Table.vue';

declare const $t: any;

declare interface AavatarListProps {
    images: string[] | AvatarImageType[];
    num?: number;
    size?: number;
    direction?: 'vertical' | 'horizontal';
    gutter?: number;
    borderColor?: string;
    borderWidth?: string;
    showMore?: boolean;
    reverse?: boolean;
    inline?: boolean;
}

declare interface AppRouteMenuItem {
    name?: string | Symbol;
    meta?: RouteMeta;
    children?: AppRouteMenuItem[];
    alias?: string;
    path: string;
    component?: Component_2;
    redirect?: string;
}

declare type AudioPlayerEvents = {
    init: [ins: any];
    prev: [];
    next: [];
    mode: [index: number];
};

declare type AudioPlayerMethods = HowlerMethods;

declare type AudioPlayerOptions = HowlerOptions & HowlerGlobalOptions;

declare interface AudioPlayerProps {
    options?: AudioPlayerOptions;
    title?: string;
    controls?: ControlsType[];
}

declare type AutoresizeProp = boolean | {
    throttle?: number;
    onResize?: () => void;
};

declare const availableLocales: string[];

declare interface AvatarImageType {
    src: string;
    [key: string]: any;
}

declare interface AvatarMenuProps extends Omit<DropMenuProps, 'size'>, AvatarProps {
    username: string;
    menuSize: string | 'large' | 'default' | 'small';
    data: DropDownMenuItem[];
}

declare interface ChartsProps {
    options: Object;
    width?: number | string;
    height?: number | string;
    autoresize?: boolean;
}

declare type ComponentType = 'input' | 'button' | 'input-number' | 'select' | 'option' | 'text' | 'link' | 'rate' | 'slider' | 'switch' | 'checkbox' | 'checkbox-group' | 'radio' | 'radio-button' | 'radio-group' | 'cascader' | 'color-picker' | 'time-picker' | 'time-select' | 'date-picker' | 'transfer' | 'avatar' | 'image' | 'progress' | 'tag' | 'timeline' | 'tree' | 'steps' | 'step' | '' | undefined;

declare type ControlsType = 'prev' | 'next' | 'forward' | 'rewind' | 'volume' | 'rate' | 'mode';

declare interface DescriptionItem extends Partial<DescriptionItemProps> {
    labelSlot?: Component_2;
    defaultSlot?: Component_2;
}

declare interface DescriptionItemProps {
    label: string;
    span: number;
    width: string | number;
    minWidth: string | number;
    align: string;
    labelAlign: string;
    className: string;
    labelClassName: string;
    value: string | number;
    tag: TagProps;
    link: LinkProps;
    icon: IconProps;
}

declare interface DescriptionProps {
    border?: boolean;
    column?: number;
    direction?: 'horizontal' | 'vertical';
    size?: '' | 'default' | 'small' | 'large';
    extra?: string;
    title?: string;
    collapse?: boolean;
    data: DescriptionItem[];
}

declare type DropDownMenuItem = string | number | {
    key: string | number | object;
    value: string;
};

declare interface DropDownProps<T> {
    items: T[];
    iconProps?: Partial<IconProps>;
    iconClass?: string;
}

declare interface DropMenuProps {
    trigger?: 'click' | 'hover' | 'contextmenu';
    effect?: string;
    type?: ButtonType;
    placement?: Placement;
    popperOptions?: Partial<PartialOptions>;
    id?: string;
    size?: string;
    splitButton?: boolean;
    hideOnClick?: boolean;
    loop?: boolean;
    showTimeout?: number;
    hideTimeout?: number;
    tabindex?: number | string;
    maxHeight?: number | string;
    popperClass?: string;
    disabled?: boolean;
    role?: string;
    buttonProps?: ButtonProps;
    teleported?: boolean;
}

declare type EditorOptions = IOptions;

declare interface EditorProps {
    options: EditorOptions;
}

declare const epLocaleLoader: (newEPLocalesMap?: any) => void;

declare type FormItemChild = {
    type?: ComponentType;
    label?: string;
    value?: any;
    [key: string]: any;
};

declare interface FormItemProp extends Partial<FormItemProps> {
    prop?: string;
    type?: ComponentType;
    events?: any;
    attrs?: any;
    span?: number;
    colProps?: ColProps;
    value?: any;
    children?: FormItemChild[];
    schema?: FormSchema;
    rules?: FormItemRule[];
    defaultSlot?: Component_2;
    labelSlot?: Component_2;
    errorSlot?: Component_2;
    prefixSlot?: Component_2;
    suffixSlot?: Component_2;
    itemRef?: (ref: FormItemInstance) => void;
    childRef?: (ref: any) => void;
}

declare interface FormProps extends Partial<NewFormProps> {
    schema?: FormSchema;
    rowClass?: string;
    rowStyle?: CSSProperties;
}

declare type FormSchema = FormItemProp[];

declare const globalPlugin: {
    install(app: any): void;
};
export default globalPlugin;
export { globalPlugin }

declare interface HeaderProps extends Partial<AvatarMenuProps> {
    collapse: boolean;
    showCollapse?: boolean;
    locales: LocaleItem[];
    settings?: ThemeSettingsProps;
}

declare type HeaderTabsEvents = {
    tabClick: [pane: TabsPaneContext, ev: Event];
    tabChange: [name: TabPaneName];
    edit: [paneName: TabPaneName | undefined, action: 'remove' | 'add'];
    tabRemove: [name: TabPaneName];
    tabAdd: [];
    tabMenuClick: [action: TabActions];
};

declare interface HeaderTabsProps extends Partial<TabsProps> {
    data: AppRouteMenuItem[];
}

declare interface HowlerGlobalMethods {
    mute: (muted: boolean) => void;
    volume: (volume?: number) => number | void;
    stop: () => void;
    codecs: (ext: string) => boolean;
    unload: () => void;
}

declare interface HowlerGlobalOptions {
    usingWebAudio: boolean;
    noAudio: boolean;
    autoUnlock: boolean;
    html5PoolSize: number;
    autoSuspend: boolean;
    ctx: boolean;
    masterGain: boolean;
}

declare type HowlerGlobalOptionsKeys = keyof HowlerGlobalOptions;

declare type HowlerMethods = {
    play: (spriteOrId?: string | number) => number | void;
    pause: (id?: number) => void;
    stop: (id?: number) => void;
    mute: (muted?: boolean, id?: number) => void;
    volume: (volume?: number, id?: number) => number | void;
    fade: (from: number, to: number, duration: number, id?: number) => void;
    rate: (rate?: number, id?: number) => number | void;
    seek: (seek?: number, id?: number) => number | void;
    loop: (loop?: boolean, id?: number) => boolean | void;
    state: () => 'unloaded' | 'loading' | 'loaded';
    playing: (id?: number) => boolean;
    duration: (id?: number) => number;
    on: (event: string, fn: Function, id?: number) => void;
    once: (event: string, fn: Function, id?: number) => void;
    off: (event: string, fn?: Function, id?: number) => void;
    load: () => void;
    unload: () => void;
};

declare interface HowlerOptions {
    src: string | string[];
    volume: number;
    html5: boolean;
    loop: boolean;
    preload: boolean | 'metadata';
    autoplay: boolean;
    mute: boolean;
    sprite: {
        [key: string]: [number, number, boolean?];
    };
    rate: number;
    pool: number;
    format: string[];
    xhr: {
        method?: string;
        headers?: {
            [key: string]: string;
        };
        withCredentials?: boolean;
    };
    onload: () => void;
    onloaderror: (soundId: number, error: string) => void;
    onplayerror: (soundId: number, error: string) => void;
    onplay: (soundId: number) => void;
    onend: (soundId: number) => void;
    onpause: (soundId: number) => void;
    onstop: (soundId: number) => void;
    onmute: (soundId: number) => void;
    onvolume: (soundId: number) => void;
    onrate: (soundId: number) => void;
    onseek: (soundId: number) => void;
    onfade: (soundId: number) => void;
    onunlock: () => void;
}

declare const i18n: any;

declare namespace I18nModule {
    export {
        setI18nLanguage,
        loadLocaleMessages,
        i18n,
        $t,
        localesMapLoader,
        epLocaleLoader,
        availableLocales,
        i18nPlugin
    }
}
export { I18nModule }

declare const i18nPlugin: {
    install(app: any): void;
};

declare interface IconListProps {
    iconData: string[];
    collection: string;
    itemClass: string;
    iconClass: string;
    activeClass: string;
    showText: boolean;
}

declare interface IconOptions {
    style: CSSProperties;
    class: string;
}

declare interface IconPickerSubmitDataProps {
    icon: string;
    color: string;
    fontSize: number;
}

declare interface IconProps_2 extends /* @vue-ignore */ IconProps {
}

declare type InitOptions = NonNullable<InitParameters[2]>;

declare type InitParameters = Parameters<InitType>;

declare type InitType = typeof init;

declare type LoadingOptions = {
    text?: string;
    textColor?: string;
    fontSize?: number | string;
    fontWeight?: number | string;
    fontStyle?: string;
    fontFamily?: string;
    maskColor?: string;
    showSpinner?: boolean;
    color?: string;
    spinnerRadius?: number;
    lineWidth?: number;
    zlevel?: number;
};

declare function loadLocaleMessages(l: string): Promise<void>;

declare interface LocaleItem {
    text: string;
    icon?: IconifyIcon | string;
    name: string;
}

declare const localesMapLoader: (newLocalesMap: any) => void;

declare interface LoginFormProps {
    position?: 'left' | 'center' | 'right';
    title?: string;
    loginItems?: LoginItem[];
}

declare interface LoginItem {
    icon: IconifyIcon | string;
    url: string;
}

declare type MenuOpenCloseEvent = [index: string, indexPath: string[]];

declare type MenuSelectEvent = [
index: string,
indexPath: string[],
item: any,
routerResult?: Promise<void | any>
];

declare interface MessageListItem {
    avatar?: Partial<AvatarProps>;
    title: string;
    content?: string;
    time?: string;
    tagProps?: Partial<TagProps>;
    tag?: string;
}

declare interface NetIconProps {
    url: string;
    prefix: string;
    fontFamily: string;
    type: string;
}

declare type NewFormProps = FormProps_2 & FormMetaProps;

declare interface NoticeActionsItem extends IconProps {
    title: string;
    click: () => void;
}

declare interface NoticeMessageListOptions {
    title: string;
    contents?: MessageListItem[];
}

declare interface NoticeMessageListProps {
    lists: NoticeMessageListOptions[];
    actions: NoticeActionsItem[];
    wrapClass?: string;
    wrapStyle?: CSSProperties;
}

declare interface NoticeProps extends NoticeMessageListProps, Partial<NotificationProps> {
}

declare interface NotificationProps extends Partial<BadgeProps> {
    icon: string | IconifyIcon;
    iconSize?: number;
    iconColor?: string;
    size: number;
    scale: number;
    color: string;
}

declare type PaginationCallFunc = (value: number) => void;

declare type PaginationEventsType = {
    'page-size-change': [PaginationCallFunc];
    'page-current-change': [PaginationCallFunc];
    'page-prev-click': [PaginationCallFunc];
    'page-next-click': [PaginationCallFunc];
};

declare interface PaginationType extends Partial<PaginationProps> {
    align?: 'center' | 'left' | 'right';
    total: number;
    defaultSlot?: Component_2;
}

declare interface RouteMeta extends Record<string | number | symbol, unknown> {
    title?: string;
    layout?: string;
    order?: number;
    icon?: string | IconifyIcon;
    hideMenu?: boolean;
    disabled?: boolean;
}

declare function setI18nLanguage(locale: string): void;

export { setupDirectives }

declare enum TabActions {
    closeOthers = "closeOthers",
    closeLeft = "closeLeft",
    closeRight = "closeRight",
    closeAll = "closeAll"
}

declare interface TableColumnType extends Omit<Partial<TableColumnCtx<any>>, 'children' | 'id'> {
    id?: string | number;
    defaultSlot?: Component_2;
    headerSlot?: Component_2;
    children?: TableColumnType[];
}

declare type TableEmitsType = TableEventsType & PaginationEventsType & TableExtendEvents;

declare type TableEventsType = {
    select: [selection: any, row: any];
    'select-all': [selection: any];
    'selection-change': [selection: any];
    'cell-mouse-enter': [row: any, column: any, cell: any, event: Event];
    'cell-mouse-leave': [row: any, column: any, cell: any, event: Event];
    'cell-click': [row: any, column: any, cell: any, event: Event];
    'cell-dblclick': [row: any, column: any, cell: any, event: Event];
    'cell-contextmenu': [row: any, column: any, cell: any, event: Event];
    'row-click': [row: any, column: any, event: Event];
    'row-contextmenu': [row: any, column: any, event: Event];
    'row-dblclick': [row: any, column: any, event: Event];
    'header-click': [column: any, event: Event];
    'header-contextmenu': [column: any, event: Event];
    'sort-change': [{
        column: any;
        prop: string;
        order: string;
    }];
    'filter-change': [filters: any];
    'current-change': [currentRow: any, oldCurrentRow: any];
    'header-dragend': [newWidth: number, oldWidth: number, column: any, event: Event];
    'expand-change': [row: any, expandedRows: any];
};

declare type TableExtendEvents = {
    'drag-row-change': [row: any];
    'drag-col-change': [cols: any];
};

declare interface TableProps extends TableProps_2<any> {
    columns: TableColumnType[];
    pagination?: PaginationType;
    adaptive?: boolean | number;
    loading?: boolean;
    elementLoadingText?: string;
    elementLoadingSpinner?: string;
    elementLoadingSvgViewBox?: string;
    elementLoadingBackground?: string;
    elementLoadingSvg?: string;
    draggableCol?: boolean;
    draggableRow?: boolean;
}

declare type TabPaneName = string | number;

declare interface ThemeSettingsProps {
    theme: string;
    backgroundColor: string;
    darkMode: boolean;
    menuWidth?: number;
    showLogo: boolean;
    showTabs: boolean;
    fixedHead: boolean;
    showBreadcrumb: boolean;
    mode: 'siderbar' | 'mix' | 'top' | 'mixbar';
    transition: TransitionNameEnum;
}

declare enum TransitionNameEnum {
    Fade = "Fade",
    Scale = "Scale",
    SlideY = "SlideY",
    ScrollY = "ScrollY",
    SlideYReverse = "SlideYReverse",
    ScrollYReverse = "ScrollYReverse",
    SlideX = "SlideX",
    ScrollX = "ScrollX",
    SlideXReverse = "SlideXReverse",
    ScrollXReverse = "ScrollXReverse",
    ScaleRotate = "ScaleRotate"
}

declare namespace TypesModule0 {
    export {
        DropMenuProps,
        DropDownMenuItem,
        AvatarMenuProps,
        AvatarImageType,
        AavatarListProps
    }
}

declare namespace TypesModule1 {
    export {
        VEchartsProps,
        VueEchartsProps,
        ChartsProps
    }
}

declare namespace TypesModule10 {
    export {
        TableColumnType,
        PaginationType,
        TableProps,
        TableEventsType,
        PaginationEventsType,
        TableEmitsType
    }
}

declare namespace TypesModule11 {
    export {
        LocaleItem,
        ThemeSettingsProps
    }
}

declare namespace TypesModule2 {
    export {
        DescriptionItemProps,
        DescriptionItem,
        DescriptionProps
    }
}

declare namespace TypesModule3 {
    export {
        EditorOptions,
        EditorProps
    }
}

declare namespace TypesModule4 {
    export {
        LoginItem,
        LoginFormProps,
        ComponentType,
        FormItemProp,
        FormSchema,
        FormProps
    }
}

declare namespace TypesModule5 {
    export {
        IconProps_2 as IconProps,
        NetIconProps,
        IconPickerSubmitDataProps,
        IconListProps
    }
}

declare namespace TypesModule6 {
    export {
        HeaderProps,
        HeaderTabsProps,
        TabPaneName,
        HeaderTabsEvents
    }
}

declare namespace TypesModule7 {
    export {
        RouteMeta,
        AppRouteMenuItem,
        IconOptions,
        DropDownProps,
        MenuSelectEvent,
        MenuOpenCloseEvent
    }
}

declare namespace TypesModule8 {
    export {
        NotificationProps,
        MessageListItem,
        NoticeActionsItem,
        NoticeMessageListOptions,
        NoticeMessageListProps,
        NoticeProps
    }
}

declare namespace TypesModule9 {
    export {
        VideoJsOptions,
        VideoPlayerOptions,
        VideoPlayerProps,
        HowlerOptions,
        AudioPlayerOptions,
        HowlerMethods,
        ControlsType,
        AudioPlayerProps,
        AudioPlayerMethods,
        AudioPlayerEvents,
        HowlerGlobalOptions,
        HowlerGlobalOptionsKeys,
        HowlerGlobalMethods
    }
}

declare type UpdateOptions = SetOptionOpts;

export declare function useAudioPlayer(lists: any): {
    current: any;
    mode: any;
    handlePrev: () => void;
    handleNext: () => void;
    handleMode: (index: number) => void;
};

export declare function useDrag(): {
    addId: (flag: boolean, arr: any[]) => any[];
    columnDrop: (elem: any, handle: string, cb: any) => void;
    rowDrop: (elem: any, handle: string, cb: any) => void;
    setColumn: (arr: any) => void;
};

export declare function useForm(schema: FormSchema): {
    model: any;
    rules: any;
    setForm: (arr: any[], level?: number) => {};
    formValue: any;
};

export declare function useMenu(): {
    generateMenuKeys: (menus: AppRouteMenuItem[], level?: string) => {
        name?: string | Symbol;
        meta?: RouteMeta;
        children?: AppRouteMenuItem[];
        alias?: string;
        path: string;
        component?: Component;
        redirect?: string;
    }[];
    getItem: (menus: AppRouteMenuItem[], index: string) => AppRouteMenuItem;
    getParentMenu: (menus: AppRouteMenuItem[]) => AppRouteMenuItem | undefined;
    filterAndOrderMenus: (menus: AppRouteMenuItem[]) => {
        name?: string | Symbol;
        meta?: RouteMeta;
        children?: AppRouteMenuItem[];
        alias?: string;
        path: string;
        component?: Component;
        redirect?: string;
    }[];
    getSubMenus: (menus: AppRouteMenuItem[]) => AppRouteMenuItem[];
    getTopMenus: (menus: AppRouteMenuItem[]) => {
        name?: string | Symbol;
        meta?: RouteMeta;
        children?: AppRouteMenuItem[];
        alias?: string;
        path: string;
        component?: Component;
        redirect?: string;
    }[];
    getIndex: (item: AppRouteMenuItem) => string;
    menuHasChildren: (item: AppRouteMenuItem) => boolean;
};

declare interface VEchartsProps {
    option: echarts_2.EChartsOption;
    initOptions: InitOptions;
    updateOptions: UpdateOptions;
    group: string;
    manualUpdate: boolean;
    autoresize: AutoresizeProp;
    loading: boolean;
    loadingOptions: LoadingOptions;
}

declare interface VideoJsOptions {
    autoplay?: boolean | string;
    controlBar?: {
        remainingTimeDisplay?: {
            displayNegative?: boolean;
        };
    };
    controls?: boolean;
    height?: string | number;
    loop?: boolean;
    muted?: boolean;
    poster?: string;
    preload?: 'auto' | 'metadata' | 'none';
    src?: string;
    width?: string | number;
    aspectRatio?: string;
    audioOnlyMode?: boolean;
    audioPosterMode?: boolean;
    autoSetup?: boolean;
    breakpoints?: {
        tiny?: number;
        xsmall?: number;
        small?: number;
        medium?: number;
        large?: number;
        xlarge?: number;
        huge?: number;
    };
    children?: Array<any> | Object;
    disablePictureInPicture?: boolean;
    enableDocumentPictureInPicture?: boolean;
    experimentalSvgIcons?: boolean;
    fluid?: boolean;
    fullscreen?: {
        options?: {
            navigationUI?: string;
        };
        [key: string]: any;
    };
    id?: string;
    inactivityTimeout?: number;
    language?: string;
    languages?: Object;
    liveui?: boolean;
    liveTracker?: {
        trackingThreshold?: number;
        liveTolerance?: number;
    };
    nativeControlsForTouch?: boolean;
    normalizeAutoplay?: boolean;
    notSupportedMessage?: string;
    noUITitleAttributes?: boolean;
    playbackRates?: Array<number>;
    plugins?: Object;
    preferFullWindow?: boolean;
    responsive?: boolean;
    restoreEl?: boolean | Element;
    skipButtons?: {
        forward?: number;
        backward?: number;
    };
    sources?: Array<{
        src: string;
        type: string;
    }>;
    suppressNotSupportedError?: boolean;
    techCanOverridePoster?: boolean;
    techOrder?: Array<string>;
    userActions?: {
        click?: boolean | Function;
        doubleClick?: boolean | Function;
        hotkeys?: boolean | Function | Object;
    };
    vttjs?: string;
    [key: string]: any;
}

declare type VideoPlayerOptions = VideoJsOptions;

declare interface VideoPlayerProps {
    options?: VideoJsOptions;
    slots?: Component_2;
}

export declare type VpAavatarListProps = TypesModule0.AavatarListProps;

export declare type VpAppRouteMenuItem = TypesModule7.AppRouteMenuItem;

export declare const VpAudioPlayer: any;

export declare type VpAudioPlayerEvents = TypesModule9.AudioPlayerEvents;

export declare type VpAudioPlayerMethods = TypesModule9.AudioPlayerMethods;

export declare type VpAudioPlayerOptions = TypesModule9.AudioPlayerOptions;

export declare type VpAudioPlayerProps = TypesModule9.AudioPlayerProps;

export declare type VpAvatarImageType = TypesModule0.AvatarImageType;

export declare const VpAvatarList: any;

export declare const VpAvatarMenu: any;

export declare type VpAvatarMenuProps = TypesModule0.AvatarMenuProps;

export { VpBreadcrumb }

export declare const VpChangeLocale: any;

export declare const VpCharts: any;

export declare type VpChartsProps = TypesModule1.ChartsProps;

export declare const VpCollapseTransition: any;

export declare type VpComponentType = TypesModule4.ComponentType;

export declare type VpControlsType = TypesModule9.ControlsType;

export { VpDarkModeToggle }

export declare const VpDescription: any;

export declare type VpDescriptionItem = TypesModule2.DescriptionItem;

export declare type VpDescriptionItemProps = TypesModule2.DescriptionItemProps;

export declare type VpDescriptionProps = TypesModule2.DescriptionProps;

export declare const VpDirectiveCopy: Directive;

export declare const VpDirectiveDebounce: Directive;

export declare const VpDirectiveDraggable: Directive;

export declare const VpDirectiveFlash: Directive;

export declare const VpDirectiveLongPress: Directive;

export declare const VpDirectiveScrollText: Directive;

export declare const VpDirectiveThrottle: Directive;

export declare const VpDirectiveWaterMarker: Directive;

export declare const VpDragIcon: any;

export declare const VpDropDown: <T extends {
    icon?: string | IconifyIcon;
}>(__VLS_props: any, __VLS_ctx?: {
    attrs: any;
    slots: {
        header?(_: {}): any;
        item?(_: {
            item: any;
        }): any;
    };
    emit: any;
}, __VLS_expose?: (exposed: any) => void, __VLS_setup?: Promise<{
    props: any;
    expose(exposed: any): void;
    attrs: any;
    slots: {
        header?(_: {}): any;
        item?(_: {
            item: any;
        }): any;
    };
    emit: any;
}>) => any;

export declare type VpDropDownMenuItem = TypesModule0.DropDownMenuItem;

export declare type VpDropDownProps<T> = TypesModule7.DropDownProps<T>;

export declare type VpDropMenuProps = TypesModule0.DropMenuProps;

export declare const VpEditor: any;

export declare type VpEditorOptions = TypesModule3.EditorOptions;

export declare type VpEditorProps = TypesModule3.EditorProps;

export declare const VpForm: any;

export declare const VpFormItem: any;

export declare type VpFormItemProp = TypesModule4.FormItemProp;

export declare const VpFormLayout: any;

export declare type VpFormProps = TypesModule4.FormProps;

export declare type VpFormSchema = TypesModule4.FormSchema;

export declare const VpFullScreen: any;

export declare const VpHeader: any;

export declare type VpHeaderProps = TypesModule6.HeaderProps;

export declare const VpHeaderTabs: any;

export declare type VpHeaderTabsEvents = TypesModule6.HeaderTabsEvents;

export declare type VpHeaderTabsProps = TypesModule6.HeaderTabsProps;

export declare type VpHowlerGlobalMethods = TypesModule9.HowlerGlobalMethods;

export declare type VpHowlerGlobalOptions = TypesModule9.HowlerGlobalOptions;

export declare type VpHowlerGlobalOptionsKeys = TypesModule9.HowlerGlobalOptionsKeys;

export declare type VpHowlerMethods = TypesModule9.HowlerMethods;

export declare type VpHowlerOptions = TypesModule9.HowlerOptions;

export declare const VpIconfontIcon: any;

export declare const VpIconify: any;

export declare const VpIconList: any;

export declare type VpIconListProps = TypesModule5.IconListProps;

export declare type VpIconOptions = TypesModule7.IconOptions;

export declare const VpIconPicker: any;

export declare type VpIconPickerSubmitDataProps = TypesModule5.IconPickerSubmitDataProps;

export declare type VpIconProps = TypesModule5.IconProps;

export declare type VpLocaleItem = TypesModule11.LocaleItem;

export { VpLoginForm }

export declare type VpLoginFormProps = TypesModule4.LoginFormProps;

export declare type VpLoginItem = TypesModule4.LoginItem;

export declare const VpMenu: any;

export declare const VpMenuItem: any;

export declare type VpMenuOpenCloseEvent = TypesModule7.MenuOpenCloseEvent;

export declare type VpMenuSelectEvent = TypesModule7.MenuSelectEvent;

export declare type VpMessageListItem = TypesModule8.MessageListItem;

export declare const VpNetIcon: any;

export declare type VpNetIconProps = TypesModule5.NetIconProps;

export declare const VpNotice: any;

export declare type VpNoticeActionsItem = TypesModule8.NoticeActionsItem;

export { VpNoticeMessageList }

export declare type VpNoticeMessageListOptions = TypesModule8.NoticeMessageListOptions;

export declare type VpNoticeMessageListProps = TypesModule8.NoticeMessageListProps;

export declare type VpNoticeProps = TypesModule8.NoticeProps;

export declare const VpNotification: any;

export declare type VpNotificationProps = TypesModule8.NotificationProps;

export declare type VpPaginationEventsType = TypesModule10.PaginationEventsType;

export declare type VpPaginationType = TypesModule10.PaginationType;

export declare const VpProgressBar: any;

export declare type VpRouteMeta = TypesModule7.RouteMeta;

export declare const VpSubMenu: any;

export declare const VpSvgIcon: any;

export { VpTable }

export declare const VpTableColumn: any;

export declare type VpTableColumnType = TypesModule10.TableColumnType;

export declare type VpTableEmitsType = TypesModule10.TableEmitsType;

export declare type VpTableEventsType = TypesModule10.TableEventsType;

export declare type VpTableProps = TypesModule10.TableProps;

export declare type VpTabPaneName = TypesModule6.TabPaneName;

export declare const VpThemeSettings: any;

export declare type VpThemeSettingsProps = TypesModule11.ThemeSettingsProps;

export declare type VpVEchartsProps = TypesModule1.VEchartsProps;

export declare type VpVideoJsOptions = TypesModule9.VideoJsOptions;

export declare const VpVideoPlayer: any;

export declare type VpVideoPlayerOptions = TypesModule9.VideoPlayerOptions;

export declare type VpVideoPlayerProps = TypesModule9.VideoPlayerProps;

export declare const VpVueEcharts: any;

export declare type VpVueEchartsProps = TypesModule1.VueEchartsProps;

declare interface VueEchartsProps extends Partial<VEchartsProps> {
    theme?: 'dark' | 'default' | string;
    style?: CSSProperties;
    height?: string | number;
    charts?: string;
    components?: string[];
    option: echarts_2.EChartsOption;
}

export { }
