x-next 0.0.0-alpha.5 → 0.0.0-alpha.51

package/README.md

@@ -1,6 +1,6 @@
 # 简介
 
-X-Next是Ringing Tech的基础UI库。
+X-Next致力打造一套最好看、最好用的Vue3 UI组件库。
 
 # 安装
 
@@ -24,3 +24,28 @@ const app = createApp(App)
 app.use(XNext)
 app.mount('#app')
 ```
+### 目前已完成的组件
+
+```
+    XButton: (typeof import('x-next'))['XButton'];
+    XDialog: (typeof import('x-next'))['XDialog'];
+    XMessage: (typeof import('x-next'))['XMessage'];
+    XMessageBox: (typeof import('x-next'))['XMessageBox'];
+    XNotification: (typeof import('x-next'))['XNotification'];
+    XSpace: (typeof import('x-next'))['XSpace'];
+    XPopconfirm: (typeof import('x-next'))['XPopconfirm'];
+    XTrendChart: (typeof import('x-next'))['XTrendChart'];
+    XTimeline: (typeof import('x-next'))['XTimeline'];
+    XTimelineItem: (typeof import('x-next'))['XTimelineItem'];
+    XPopup: (typeof import('x-next'))['XPopup'];
+    XScrollbar: (typeof import('x-next'))['XScrollbar'];
+    XDrawer: (typeof import('x-next'))['XDrawer'];
+    XTag: (typeof import('x-next'))['XTag'];
+    XTooltip: (typeof import('x-next'))['XTooltip'];
+    XImage: (typeof import('x-next'))['XImage'];
+    XImagePreview: (typeof import('x-next'))['XImagePreview'];
+    XImagePreviewGroup: (typeof import('x-next'))['XImagePreviewGroup'];
+    XImagePreviewAction: (typeof import('x-next'))['XImagePreviewAction'];
+    XTabPane: (typeof import('x-next'))['XTabPane'];
+    XTabs: (typeof import('x-next'))['XTabs'];
+```

package/dist/_container/client-only.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | null | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/parent-scroll-observer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "scroll"[], "scroll", import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onScroll?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/render-function.d.ts

@@ -0,0 +1,14 @@
+import { PropType, VNodeTypes } from 'vue';
+export type RenderFunc = (props: Record<string, unknown>) => VNodeTypes;
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    renderFunc: {
+        type: PropType<RenderFunc>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    renderFunc: {
+        type: PropType<RenderFunc>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/resize-observer-2.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    watchOnUpdated: BooleanConstructor;
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "resize"[], "resize", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    watchOnUpdated: BooleanConstructor;
+}>> & Readonly<{
+    onResize?: ((...args: any[]) => any) | undefined;
+}>, {
+    watchOnUpdated: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/resize-observer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "resize"[], "resize", import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onResize?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_container/utils.d.ts

@@ -0,0 +1,12 @@
+export declare const getProp: (target: any, path: any, defVal?: any) => any;
+export declare const setProp: (target: any, path: any, value: any) => any;
+export declare const deepClone: (obj: any, set?: any) => any;
+export declare const NOOP: () => void;
+export declare const addUnit: (value: string | number | undefined, unit?: string) => string;
+export declare const upperFirstChar: (text: string) => string | undefined;
+export declare const compose: <T>(...fns: ((...v: T[]) => T)[]) => (...v: T[]) => T;
+export declare const pipe: <T>(...fns: ((...v: T[]) => T)[]) => (...v: T[]) => T;
+export declare const findLastIndex: (arr: never[] | undefined, callback: (item: any, i: number, origin: any[]) => boolean) => number;
+export declare const getUniqueId: (size?: number) => string;
+export declare const genMatrix: (list: any[], row: number) => any[];
+export declare const sleep: (delay?: number) => Promise<unknown>;

package/dist/_hooks/_types.d.ts

@@ -0,0 +1,4 @@
+import { VNode } from 'vue';
+export interface SlotChildren {
+    value?: VNode[];
+}

package/dist/_hooks/use-children-components.d.ts

@@ -0,0 +1,5 @@
+import { SlotChildren } from './_types';
+export declare const useChildrenComponents: (name: string) => {
+    children: SlotChildren;
+    components: import('vue').Ref<number[], number[]>;
+};

package/dist/_hooks/use-first-element.d.ts

@@ -0,0 +1,5 @@
+import { SlotChildren } from './_types.ts';
+export declare const useFirstElement: () => {
+    children: SlotChildren;
+    firstElement: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+};

package/dist/_hooks/use-index.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+export declare const useIndex: ({ itemRef, selector, index, parentClassName, }: {
+    itemRef: Ref<HTMLElement | undefined | null>;
+    selector: string;
+    index?: Ref<number | undefined>;
+    parentClassName?: string;
+}) => {
+    innerIndex: import('vue').ComputedRef<number>;
+};

package/dist/_hooks/use-merge-state.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ComputedRef } from 'vue';
+export default function useMergeState<T, E = T | undefined>(defaultValue: T, props: {
+    value: E;
+}): [ComputedRef<T>, (val: E) => void, Ref<T>];

package/dist/_hooks/use-pick-slots.d.ts

@@ -0,0 +1,2 @@
+import { Slots } from 'vue';
+export default function usePickSlots(slots: Slots, slotName: string): import('vue').Ref<import('vue').Slot<any> | undefined, import('vue').Slot<any> | undefined>;

package/dist/_hooks/use-popup-container.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef } from 'vue';
+interface PopupContainerProps {
+    popupContainer: string | HTMLElement | undefined;
+}
+export default function usePopupContainer(defaultPopupContainer: HTMLElement, props: PopupContainerProps): ComputedRef<HTMLElement>;
+export {};

package/dist/_hooks/use-popup-overflow-hidden.d.ts

@@ -0,0 +1,6 @@
+interface PopupOverflowHiddenProps {
+    container: HTMLElement | undefined;
+    hidden: boolean;
+}
+export default function usePopupOverflowHidden(props: PopupOverflowHiddenProps): (() => void)[];
+export {};

package/dist/_hooks/use-resize-observer.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+export declare const useResizeObserver: ({ elementRef, onResize, }: {
+    elementRef: Ref<HTMLElement | undefined>;
+    onResize: (args: ResizeObserverEntry) => void;
+}) => {
+    createResizeObserver: () => void;
+    destroyResizeObserver: () => void;
+};

package/dist/_hooks/use-size.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { Size } from '../_utils/constant';
+export declare const useSize: (size?: Ref<Size | undefined>, { defaultValue }?: {
+    defaultValue?: Size;
+}) => {
+    mergedSize: import('vue').ComputedRef<"mini" | "small" | "medium" | "large">;
+};

package/dist/_hooks/use-state.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useState<T>(defaultValue?: T): [Ref<T>, (newValue: T) => void];

package/dist/_hooks/use-teleport-container.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+export declare const useTeleportContainer: ({ popupContainer, visible, defaultContainer, documentContainer, }: {
+    popupContainer: Ref<string | HTMLElement | undefined>;
+    visible: Ref<boolean>;
+    defaultContainer?: string;
+    documentContainer?: boolean;
+}) => {
+    teleportContainer: Ref<string | HTMLElement | undefined, string | HTMLElement | undefined>;
+    containerRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+};

package/dist/_props/constant.d.ts

@@ -0,0 +1,4 @@
+export declare const TRIGGER_POSITIONS: readonly ["top", "tl", "tr", "bottom", "bl", "br", "left", "lt", "lb", "right", "rt", "rb"];
+export type TriggerPosition = (typeof TRIGGER_POSITIONS)[number];
+export declare const TRIGGER_EVENTS: readonly ["hover", "click", "focus", "contextMenu"];
+export type TriggerEvent = (typeof TRIGGER_EVENTS)[number];

package/dist/_props/types.d.ts

@@ -0,0 +1 @@
+export type ClassName = string | Record<string, boolean> | (string | Record<string, boolean>)[];

package/dist/_utils/click.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @description: 防抖函数
+ * @param callback
+ * @param delay
+ * @param immediate
+ */
+export declare const debounce: (callback: (e: any) => void, delay: number, immediate?: boolean) => any;
+/**
+ * @description: 节流函数
+ * @param callback
+ * @param delay
+ */
+export declare const throttle: (callback: (e: any) => void, delay?: number) => any;

package/dist/_utils/config.d.ts

@@ -1,6 +1,6 @@
 export declare const COMPONENT_INSTALLED_KEY: unique symbol;
 export declare const getClassPrefix: (name?: string) => string;
-export declare const getComponentPrefix: (name: string) => string;
+export declare const getComponentPrefix: (name: string) => `X${string}`;
 export declare const getClassNameMixin: (name: string) => {
     block: string;
     element: (className: string) => string;

package/dist/_utils/constant.d.ts

@@ -0,0 +1,17 @@
+export declare const SIZES: readonly ["mini", "small", "medium", "large"];
+export type Size = typeof SIZES[number];
+export declare const BORDER_SHAPES: readonly ["square", "round", "circle"];
+export type BorderShape = typeof BORDER_SHAPES[number];
+export declare const STATUSES: readonly ["normal", "success", "warning", "danger"];
+export type Status = typeof STATUSES[number];
+export declare const MESSAGE_TYPES: readonly ["info", "success", "warning", "error"];
+export type MessageType = typeof MESSAGE_TYPES[number];
+export declare const TRIGGER_POSITIONS: readonly ["top", "tl", "tr", "bottom", "bl", "br", "left", "lt", "lb", "right", "rt", "rb"];
+export type TriggerPosition = typeof TRIGGER_POSITIONS[number];
+export declare const TRIGGER_EVENTS: readonly ["hover", "click", "focus", "contextMenu"];
+export type TriggerEvent = typeof TRIGGER_EVENTS[number];
+export declare const DIRECTIONS: readonly ["horizontal", "vertical"];
+export type Direction = typeof DIRECTIONS[number];
+export declare const INPUT_EVENTS: string[];
+export declare const TEXT_ALIGNS: readonly ["left", "center", "right"];
+export type TextAlign = typeof TEXT_ALIGNS[number];

package/dist/_utils/dom.d.ts

@@ -3,8 +3,14 @@ export declare const NOOP: () => void;
 export declare const querySelector: (selectors: string, container?: Document | HTMLElement) => HTMLElement | undefined;
 export declare const getScrollBarWidth: (element: HTMLElement) => number;
 export declare const isScroll: (element: HTMLElement) => boolean;
+export declare const isServerRendering: boolean;
 export declare const getStyle: (element: HTMLElement, styleName: keyof CSSProperties) => string;
 export declare const setStyle: (element: HTMLElement, styleName: CSSProperties | keyof CSSProperties, value?: string | number) => void;
 export declare const getElement: (target: string | HTMLElement | undefined, container?: Document | HTMLElement) => HTMLElement | undefined;
 export declare const on: <K extends keyof HTMLElementEventMap>(element: HTMLElement | Window, event: K, handler: (ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => void;
 export declare const off: <K extends keyof HTMLElementEventMap>(element: HTMLElement | Window, type: K, handler: (ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions) => void;
+export interface Size {
+    height: number;
+    width: number;
+}
+export declare const getDocumentSize: () => Size;

package/dist/_utils/is.d.ts

@@ -5,6 +5,8 @@ export declare function isNull(obj: any): obj is null;
 export declare function isBoolean(obj: unknown): obj is boolean;
 export declare function isObject<T>(obj: T): obj is Extract<T, Record<string, any>>;
 export declare const isPromise: <T>(obj: unknown) => obj is Promise<T>;
+export declare const isAsync: (fn: unknown) => boolean;
+export declare const isAsyncOrPromise: (fn: unknown) => boolean;
 export declare function isString(obj: any): obj is string;
 export declare function isNumber(obj: any): obj is number;
 export declare function isRegExp(obj: any): boolean;
@@ -20,3 +22,4 @@ export declare const isArrayChildren: (children: VNodeNormalizedChildren) => chi
 export declare const isQuarter: (fromat: string) => boolean;
 export declare function isDayjs(time: any): time is Dayjs;
 export declare function isClient(): boolean;
+export declare const isFirefox: () => boolean;

package/dist/_utils/omit.d.ts

@@ -0,0 +1,2 @@
+import { Data } from './types';
+export declare const omit: <T extends Data, K extends keyof any>(object: T, path: Array<K>) => Omit<T, K>;

package/dist/_utils/raf.d.ts

@@ -0,0 +1,3 @@
+declare const raf: typeof requestAnimationFrame;
+declare const caf: typeof cancelAnimationFrame;
+export { raf, caf };

package/dist/_utils/throttle-by-raf.d.ts

@@ -0,0 +1,4 @@
+export declare function throttleByRaf(cb: (...args: any[]) => void): {
+    (...args: any[]): void;
+    cancel(): void;
+};

package/dist/_utils/types.d.ts

@@ -0,0 +1 @@
+export type Data = Record<string, any>;

package/dist/_utils/vue-eco.d.ts

@@ -1,5 +1,6 @@
-import { VNodeTypes, VNode, PropType, Component, Slots, Plugin } from 'vue';
+import { VNodeTypes, VNode, PropType, Component, Slots, App, Plugin, DefineComponent } from 'vue';
 export type SFCWithInstall<T> = T & Plugin;
+type ObjectData = Record<string, unknown>;
 /**
  * @description Vue生态操作封装
  */
@@ -22,7 +23,19 @@ export declare const isComponent: (vn: VNode, type?: VNodeTypes) => type is Comp
 export declare const isTextChildren: (child: VNode, children: VNode["children"]) => children is string;
 export declare const isArrayChildren: (vn: VNode, children: VNode["children"]) => children is VNode[];
 export declare const isSlotsChildren: (vn: VNode, children: VNode["children"]) => children is Slots;
+export declare const isEmptyChildren: (children?: VNode[]) => boolean;
 export declare const getAllElements: (children: VNode[] | undefined, includeText?: boolean) => VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
 }>[];
+export declare const getFirstElement: (vn: VNode | VNode[]) => HTMLElement | null;
+export declare const getFirstElementFromVNode: (vn: VNode) => HTMLElement | undefined;
+export declare const getFirstElementFromChildren: (children: VNode[] | undefined) => HTMLElement | undefined;
+export declare const getChildrenArray: (vn: VNode) => VNode[] | undefined;
+export declare const getComponentsFromVNode: (vn: VNode, name: string) => number[];
+export declare const getComponentsFromChildren: (children: VNode[] | undefined, name: string) => number[];
+export declare const mergeFirstChild: (children: VNode[] | undefined, extraProps: ObjectData | ((vn: VNode) => ObjectData)) => boolean;
 export declare const withInstall: <T, E extends Record<string, any>>(main: T, extra?: E) => SFCWithInstall<T> & E;
+export declare const generateComponent: <T extends Component | DefineComponent>(name: string, component: T) => T & {
+    install(app: App): void;
+};
+export {};

package/dist/components/_components/icon-hover.vue.d.ts

@@ -0,0 +1,38 @@
+import { PropType } from 'vue';
+type Size = 'mini' | 'small' | 'medium' | 'large' | 'huge';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    prefix: {
+        type: StringConstructor;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    className: {
+        block: string;
+        element: (className: string) => string;
+        modifier: (className: string) => string;
+        is: (className: string) => string;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    prefix: {
+        type: StringConstructor;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    size: Size;
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/button/Button.d.ts

@@ -0,0 +1,97 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    disabled: BooleanConstructor;
+    block: BooleanConstructor;
+    loading: BooleanConstructor;
+    loadingFill: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    debounce: {
+        type: NumberConstructor;
+        default: number;
+    };
+    shape: {
+        type: import('vue').PropType<import('./props').ButtonShape>;
+        default: undefined;
+    };
+    link: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    type: {
+        type: import('vue').PropType<import('./props').ButtonType>;
+        default: string;
+    };
+    status: {
+        type: import('vue').PropType<import('./props').ButtonStatus>;
+        default: string;
+    };
+    plain: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: import('vue').PropType<import('./props').ButtonSize>;
+        default: string;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "click"[], "click", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    disabled: BooleanConstructor;
+    block: BooleanConstructor;
+    loading: BooleanConstructor;
+    loadingFill: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    debounce: {
+        type: NumberConstructor;
+        default: number;
+    };
+    shape: {
+        type: import('vue').PropType<import('./props').ButtonShape>;
+        default: undefined;
+    };
+    link: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    type: {
+        type: import('vue').PropType<import('./props').ButtonType>;
+        default: string;
+    };
+    status: {
+        type: import('vue').PropType<import('./props').ButtonStatus>;
+        default: string;
+    };
+    plain: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: import('vue').PropType<import('./props').ButtonSize>;
+        default: string;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: import('./props').ButtonSize;
+    type: import('./props').ButtonType;
+    link: boolean;
+    disabled: boolean;
+    block: boolean;
+    loading: boolean;
+    loadingFill: boolean;
+    debounce: number;
+    shape: import('./props').ButtonShape;
+    status: import('./props').ButtonStatus;
+    plain: boolean;
+    border: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/button/index.d.ts

@@ -0,0 +1,181 @@
+export declare const XButton: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        disabled: BooleanConstructor;
+        block: BooleanConstructor;
+        loading: BooleanConstructor;
+        loadingFill: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: number;
+        };
+        shape: {
+            type: import('vue').PropType<import('./props').ButtonShape>;
+            default: undefined;
+        };
+        link: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        type: {
+            type: import('vue').PropType<import('./props').ButtonType>;
+            default: string;
+        };
+        status: {
+            type: import('vue').PropType<import('./props').ButtonStatus>;
+            default: string;
+        };
+        plain: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: import('vue').PropType<import('./props').ButtonSize>;
+            default: string;
+        };
+        border: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+    }>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "click"[], import('vue').PublicProps, {
+        size: import('./props').ButtonSize;
+        type: import('./props').ButtonType;
+        link: boolean;
+        disabled: boolean;
+        block: boolean;
+        loading: boolean;
+        loadingFill: boolean;
+        debounce: number;
+        shape: import('./props').ButtonShape;
+        status: import('./props').ButtonStatus;
+        plain: boolean;
+        border: boolean;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        disabled: BooleanConstructor;
+        block: BooleanConstructor;
+        loading: BooleanConstructor;
+        loadingFill: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: number;
+        };
+        shape: {
+            type: import('vue').PropType<import('./props').ButtonShape>;
+            default: undefined;
+        };
+        link: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        type: {
+            type: import('vue').PropType<import('./props').ButtonType>;
+            default: string;
+        };
+        status: {
+            type: import('vue').PropType<import('./props').ButtonStatus>;
+            default: string;
+        };
+        plain: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: import('vue').PropType<import('./props').ButtonSize>;
+            default: string;
+        };
+        border: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+    }>, () => any, {}, {}, {}, {
+        size: import('./props').ButtonSize;
+        type: import('./props').ButtonType;
+        link: boolean;
+        disabled: boolean;
+        block: boolean;
+        loading: boolean;
+        loadingFill: boolean;
+        debounce: number;
+        shape: import('./props').ButtonShape;
+        status: import('./props').ButtonStatus;
+        plain: boolean;
+        border: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    disabled: BooleanConstructor;
+    block: BooleanConstructor;
+    loading: BooleanConstructor;
+    loadingFill: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    debounce: {
+        type: NumberConstructor;
+        default: number;
+    };
+    shape: {
+        type: import('vue').PropType<import('./props').ButtonShape>;
+        default: undefined;
+    };
+    link: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    type: {
+        type: import('vue').PropType<import('./props').ButtonType>;
+        default: string;
+    };
+    status: {
+        type: import('vue').PropType<import('./props').ButtonStatus>;
+        default: string;
+    };
+    plain: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: import('vue').PropType<import('./props').ButtonSize>;
+        default: string;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "click"[], "click", {
+    size: import('./props').ButtonSize;
+    type: import('./props').ButtonType;
+    link: boolean;
+    disabled: boolean;
+    block: boolean;
+    loading: boolean;
+    loadingFill: boolean;
+    debounce: number;
+    shape: import('./props').ButtonShape;
+    status: import('./props').ButtonStatus;
+    plain: boolean;
+    border: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & {
+    install(app: import('vue').App): void;
+};
+export { XButton as default };