roui-element 1.0.0

package/dist/types/components/Form/types.d.ts

@@ -0,0 +1,46 @@
+import { InjectionKey } from 'vue';
+import { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
+export interface FormItemProps {
+    label?: string;
+    prop?: string;
+}
+export interface FormItemRule extends RuleItem {
+    trigger?: string;
+}
+export type FormRules = Record<string, FormItemRule[]>;
+export interface FormProps {
+    model: Record<string, any>;
+    rules: FormRules;
+}
+export interface FormContext extends FormProps {
+    addField: (field: FormItemContext) => void;
+    removeField: (field: FormItemContext) => void;
+}
+export interface ValidateStatusProp {
+    state: 'init' | 'success' | 'error';
+    errorMsg: string;
+    loading: boolean;
+}
+export interface FormItemContext {
+    prop: string;
+    validate: (trigger?: string) => Promise<any>;
+    resetField(): void;
+    clearValidate(): void;
+}
+export interface FormValidateFailure {
+    errors: ValidateError[] | null;
+    fields: ValidateFieldsError;
+}
+export interface FormInstance {
+    validate: () => Promise<any>;
+    resetFields: (props?: string[]) => void;
+    clearValidate: (props?: string[]) => void;
+}
+export interface FormItemInstance {
+    validateStatus: ValidateStatusProp;
+    validate: (trigger?: string) => Promise<any>;
+    resetField(): void;
+    clearValidate(): void;
+}
+export declare const formContextKey: InjectionKey<FormContext>;
+export declare const formItemContextKey: InjectionKey<FormItemContext>;

package/dist/types/components/Icon/Icon.vue.d.ts

@@ -0,0 +1,3 @@
+import { IconProps } from './types';
+declare const _default: import('vue').DefineComponent<IconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/components/Icon/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Icon } from './Icon.vue';
+export default Icon;
+export * from './types';

package/dist/types/components/Icon/types.d.ts

@@ -0,0 +1,32 @@
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
+export interface IconProps {
+    border?: boolean;
+    fixedWidth?: boolean;
+    flip?: 'horizontal' | 'vertical' | 'both' | boolean;
+    icon: object | Array<string> | string | IconDefinition;
+    mask?: object | Array<string> | string;
+    maskId?: string;
+    listItem?: boolean;
+    pull?: 'right' | 'left';
+    pulse?: boolean;
+    rotation?: 90 | 180 | 270 | '90' | '180' | '270';
+    rotateBy?: boolean;
+    swapOpacity?: boolean;
+    size?: '2xs' | 'xs' | 'sm' | 'lg' | 'xl' | '2xl' | '1x' | '2x' | '3x' | '4x' | '5x' | '6x' | '7x' | '8x' | '9x' | '10x';
+    spin?: boolean;
+    transform?: object | string;
+    symbol?: boolean | string;
+    title?: string;
+    titleId?: string;
+    inverse?: boolean;
+    bounce?: boolean;
+    shake?: boolean;
+    beat?: boolean;
+    fade?: boolean;
+    beatFade?: boolean;
+    spinPulse?: boolean;
+    spinReverse?: boolean;
+    widthAuto?: boolean;
+    type?: 'primary' | 'success' | 'info' | 'warning' | 'danger' | 'link';
+    color?: string;
+}

package/dist/types/components/Input/Input.vue.d.ts

@@ -0,0 +1,45 @@
+import { Ref } from 'vue';
+import { InputProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prepend?(_: {}): any;
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+        append?(_: {}): any;
+    };
+    refs: {
+        inputRef: HTMLTextAreaElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<InputProps, {
+    ref: Ref<HTMLInputElement, HTMLInputElement>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    input: (value: string) => any;
+    clear: () => any;
+    "update:modelValue": (value: string) => any;
+    change: (value: string) => any;
+    blur: (value: FocusEvent) => any;
+    focus: (value: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<InputProps> & Readonly<{
+    onInput?: (value: string) => any;
+    onClear?: () => any;
+    "onUpdate:modelValue"?: (value: string) => any;
+    onChange?: (value: string) => any;
+    onBlur?: (value: FocusEvent) => any;
+    onFocus?: (value: FocusEvent) => any;
+}>, {
+    type: string;
+    autocomplete: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLTextAreaElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/Input/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Input } from './Input.vue';
+export default Input;
+export * from './types';

package/dist/types/components/Input/types.d.ts

@@ -0,0 +1,24 @@
+export interface InputProps {
+    type?: string;
+    modelValue: string;
+    size?: 'large' | 'small';
+    disabled?: boolean;
+    clearable?: boolean;
+    showPassword?: boolean;
+    placeholder?: string;
+    readonly?: boolean;
+    autocomplete?: string;
+    autofocus?: boolean;
+    form?: string;
+}
+export interface InputEmits {
+    (e: 'update:modelValue', value: string): void;
+    (e: 'input', value: string): void;
+    (e: 'change', value: string): void;
+    (e: 'focus', value: FocusEvent): void;
+    (e: 'blur', value: FocusEvent): void;
+    (e: 'clear'): void;
+}
+export interface InputInstance {
+    ref: HTMLInputElement | HTMLTextAreaElement;
+}

package/dist/types/components/Message/Message.vue.d.ts

@@ -0,0 +1,30 @@
+import { MessageProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        messageRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MessageProps, {
+    bottomOffset: import('vue').ComputedRef<any>;
+    visible: import('vue').Ref<boolean, boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MessageProps> & Readonly<{}>, {
+    type: "success" | "info" | "warning" | "danger";
+    duration: number;
+    offset: number;
+    transitionName: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    messageRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/Message/index.d.ts

@@ -0,0 +1,5 @@
+import { default as Message } from './Message.vue';
+import { createMessage, closeAll } from './method';
+export default Message;
+export { createMessage, closeAll };
+export * from './types';

package/dist/types/components/Message/method.d.ts

@@ -0,0 +1,23 @@
+import { CreateMessageProps, MessageContext } from './types';
+export declare const createMessage: (props: CreateMessageProps) => {
+    id: string;
+    vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+    vm: import('vue').ComponentInternalInstance;
+    props: {
+        id: string;
+        zIndex: number;
+        onDestory: () => void;
+        type?: "success" | "info" | "warning" | "danger";
+        duration?: number;
+        message?: string | import('vue').VNode;
+        showClose?: boolean;
+        offset?: number;
+        transitionName?: string;
+    };
+    destory: () => void;
+};
+export declare const getLastInstance: () => MessageContext;
+export declare const getLastBottomOffset: (id: string) => any;
+export declare const closeAll: () => void;

package/dist/types/components/Message/types.d.ts

@@ -0,0 +1,20 @@
+import { VNode, ComponentInternalInstance } from 'vue';
+export interface MessageProps {
+    message?: string | VNode;
+    duration?: number;
+    showClose?: boolean;
+    type?: 'success' | 'info' | 'warning' | 'danger';
+    onDestory: () => void;
+    id: string;
+    zIndex: number;
+    offset?: number;
+    transitionName?: string;
+}
+export interface MessageContext {
+    id: string;
+    vnode: VNode;
+    vm: ComponentInternalInstance;
+    props: MessageProps;
+    destory: () => void;
+}
+export type CreateMessageProps = Omit<MessageProps, 'onDestory' | 'id' | 'zIndex'>;

package/dist/types/components/Select/Select.vue.d.ts

@@ -0,0 +1,191 @@
+import { Ref } from 'vue';
+import { SelectProps } from './types';
+declare const _default: import('vue').DefineComponent<SelectProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    change: (value: string) => any;
+    "visible-change": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<SelectProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: string) => any;
+    onChange?: (value: string) => any;
+    "onVisible-change"?: (value: boolean) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    selectContainerRef: HTMLDivElement;
+    tooltipRef: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            transition: string;
+            trigger: "hover" | "click";
+            placement: import('@popperjs/core').Placement;
+        }> & Omit<{
+            readonly content?: string;
+            readonly trigger?: "hover" | "click";
+            readonly placement?: import('@popperjs/core').Placement;
+            readonly manual?: boolean;
+            readonly popperOptions?: Partial<import('@popperjs/core').Options>;
+            readonly transition?: string;
+            readonly "onVisible-change"?: (value: boolean) => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "transition" | "trigger" | "placement">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            popperContainerNode: HTMLDivElement;
+            triggerNode: HTMLDivElement;
+            popperNode: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "visible-change", value: boolean) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('../Tooltip').TooltipProps> & Readonly<{
+            "onVisible-change"?: (value: boolean) => any;
+        }>, {
+            show: () => void;
+            hide: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            "visible-change": (value: boolean) => any;
+        }, string, {
+            transition: string;
+            trigger: "hover" | "click";
+            placement: import('@popperjs/core').Placement;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        transition: string;
+        trigger: "hover" | "click";
+        placement: import('@popperjs/core').Placement;
+    }> & Omit<Readonly<import('../Tooltip').TooltipProps> & Readonly<{
+        "onVisible-change"?: (value: boolean) => any;
+    }>, ("transition" | "trigger" | "placement") | "show" | "hide"> & import('vue').ShallowUnwrapRef<{
+        show: () => void;
+        hide: () => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+            content?(_: {}): any;
+        };
+    };
+    inputRef: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly type?: string;
+            readonly modelValue: string;
+            readonly size?: "large" | "small";
+            readonly disabled?: boolean;
+            readonly clearable?: boolean;
+            readonly showPassword?: boolean;
+            readonly placeholder?: string;
+            readonly readonly?: boolean;
+            readonly autocomplete?: string;
+            readonly autofocus?: boolean;
+            readonly form?: string;
+            readonly onInput?: (value: string) => any;
+            readonly onClear?: () => any;
+            readonly "onUpdate:modelValue"?: (value: string) => any;
+            readonly onChange?: (value: string) => any;
+            readonly onBlur?: (value: FocusEvent) => any;
+            readonly onFocus?: (value: FocusEvent) => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            inputRef: HTMLTextAreaElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "input", value: string) => void) & ((event: "clear") => void) & ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "blur", value: FocusEvent) => void) & ((event: "focus", value: FocusEvent) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('../Input').InputProps> & Readonly<{
+            onInput?: (value: string) => any;
+            onClear?: () => any;
+            "onUpdate:modelValue"?: (value: string) => any;
+            onChange?: (value: string) => any;
+            onBlur?: (value: FocusEvent) => any;
+            onFocus?: (value: FocusEvent) => any;
+        }>, {
+            ref: Ref<HTMLInputElement, HTMLInputElement>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            input: (value: string) => any;
+            clear: () => any;
+            "update:modelValue": (value: string) => any;
+            change: (value: string) => any;
+            blur: (value: FocusEvent) => any;
+            focus: (value: FocusEvent) => any;
+        }, string, {
+            type: string;
+            autocomplete: string;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        type: string;
+        autocomplete: string;
+    }> & Omit<Readonly<import('../Input').InputProps> & Readonly<{
+        onInput?: (value: string) => any;
+        onClear?: () => any;
+        "onUpdate:modelValue"?: (value: string) => any;
+        onChange?: (value: string) => any;
+        onBlur?: (value: FocusEvent) => any;
+        onFocus?: (value: FocusEvent) => any;
+    }>, "ref" | ("type" | "autocomplete")> & import('vue').ShallowUnwrapRef<{
+        ref: Ref<HTMLInputElement, HTMLInputElement>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            prepend?(_: {}): any;
+            prefix?(_: {}): any;
+            suffix?(_: {}): any;
+            append?(_: {}): any;
+        };
+    };
+}, HTMLDivElement>;
+export default _default;

package/dist/types/components/Select/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Select } from './Select.vue';
+export default Select;
+export * from './types';

package/dist/types/components/Select/types.d.ts

@@ -0,0 +1,20 @@
+export interface SelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+export interface SelectProps {
+    modelValue: string;
+    options?: SelectOption[];
+    placeholder: string;
+    disabled?: boolean;
+}
+export interface SelectStates {
+    inputValue: string;
+    selectedOption?: null | SelectOption;
+}
+export interface SelectEmits {
+    (e: 'change', value: string): void;
+    (e: 'update:modelValue', value: string): void;
+    (e: 'visible-change', value: boolean): void;
+}

package/dist/types/components/Switch/Switch.vue.d.ts

@@ -0,0 +1,14 @@
+import { SwtichProps } from './types';
+declare const _default: import('vue').DefineComponent<SwtichProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: import('./types').SwitchValueType) => any;
+    change: (value: import('./types').SwitchValueType) => any;
+}, string, import('vue').PublicProps, Readonly<SwtichProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: import('./types').SwitchValueType) => any;
+    onChange?: (value: import('./types').SwitchValueType) => any;
+}>, {
+    activeValue: import('./types').SwitchValueType;
+    inactiveValue: import('./types').SwitchValueType;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    input: HTMLInputElement;
+}, any>;
+export default _default;

package/dist/types/components/Switch/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Switch } from './Switch.vue';
+export default Switch;
+export * from './types';

package/dist/types/components/Switch/types.d.ts

@@ -0,0 +1,16 @@
+export type SwitchValueType = boolean | string | number;
+export interface SwtichProps {
+    modelValue: SwitchValueType;
+    disabled?: boolean;
+    activeText?: string;
+    inactiveText?: string;
+    activeValue?: SwitchValueType;
+    inactiveValue?: SwitchValueType;
+    name?: string;
+    id?: string;
+    size?: 'small' | 'large';
+}
+export interface SwtichEmits {
+    (e: 'update:modelValue', value: SwitchValueType): void;
+    (e: 'change', value: SwitchValueType): void;
+}

package/dist/types/components/Tooltip/Tooltip.vue.d.ts

@@ -0,0 +1,38 @@
+import { TooltipProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        content?(_: {}): any;
+    };
+    refs: {
+        popperContainerNode: HTMLDivElement;
+        triggerNode: HTMLDivElement;
+        popperNode: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TooltipProps, {
+    show: () => void;
+    hide: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "visible-change": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<TooltipProps> & Readonly<{
+    "onVisible-change"?: (value: boolean) => any;
+}>, {
+    transition: string;
+    trigger: "hover" | "click";
+    placement: import('@popperjs/core').Placement;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    popperContainerNode: HTMLDivElement;
+    triggerNode: HTMLDivElement;
+    popperNode: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/Tooltip/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Tooltip } from './Tooltip.vue';
+export default Tooltip;
+export * from './types';

package/dist/types/components/Tooltip/types.d.ts

@@ -0,0 +1,16 @@
+import { Placement, Options } from '@popperjs/core';
+export interface TooltipProps {
+    content?: string;
+    trigger?: 'hover' | 'click';
+    placement?: Placement;
+    manual?: boolean;
+    popperOptions?: Partial<Options>;
+    transition?: string;
+}
+export interface TooltipEmits {
+    (e: 'visible-change', value: boolean): void;
+}
+export interface TooltipInstance {
+    show: () => void;
+    hide: () => void;
+}

package/dist/types/hooks/useClickOutSide.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+declare const useClickOutSide: (elementRef: Ref<HTMLElement | undefined>, callback: (e: MouseEvent) => void) => void;
+export default useClickOutSide;

package/dist/types/hooks/useEventListener.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useEventListener(target: Ref<EventTarget | null> | EventTarget, event: string, handler: (e: Event) => any): void;

package/dist/types/hooks/useZIndex.d.ts

@@ -0,0 +1,6 @@
+declare const useZIndex: (initialValue?: number) => {
+    currentZIndex: import('vue').ComputedRef<number>;
+    nextZIndex: () => number;
+    initialZIndex: import('vue').Ref<number, number>;
+};
+export default useZIndex;

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+import { App } from 'vue';
+import { default as RoButton } from './components/Button';
+import { default as Collapse, CollapseItem } from './components/Collapse';
+import { default as Dropdown } from './components/Dropdown';
+import { default as Form, FormItem } from './components/Form';
+import { default as Icon } from './components/Icon';
+import { default as Message, createMessage, closeAll as closeMessageAll } from './components/Message';
+import { default as Input } from './components/Input';
+import { default as Select } from './components/Select';
+import { default as Switch } from './components/Switch';
+import { default as Tooltip } from './components/Tooltip';
+declare const install: (app: App) => void;
+export { install, RoButton, Collapse, CollapseItem, Dropdown, Form, FormItem, Icon, Message, Input, Select, Switch, Tooltip, createMessage, closeMessageAll, };
+declare const _default: {
+    install: (app: App) => void;
+};
+export default _default;