@haoyulong1112/jh-ui 0.1.0

package/dist/components/infinite-scroll/index.d.ts

@@ -0,0 +1,107 @@
+export declare const JhInfiniteScroll: import("../../utils/src/index").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly height: {
+            readonly type: StringConstructor;
+            readonly default: "240px";
+        };
+        readonly distance: {
+            readonly type: NumberConstructor;
+            readonly default: 0;
+        };
+        readonly delay: {
+            readonly type: NumberConstructor;
+            readonly default: 200;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly loading: BooleanConstructor;
+        readonly immediate: BooleanConstructor;
+    }>> & Readonly<{
+        onLoad?: ((payload: import("./index.js").InfiniteScrollLoadPayload) => any) | undefined;
+    }>, {
+        check: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        load: (payload: import("./index.js").InfiniteScrollLoadPayload) => void;
+    }, import("vue").PublicProps, {
+        readonly loading: boolean;
+        readonly disabled: boolean;
+        readonly immediate: boolean;
+        readonly height: string;
+        readonly distance: number;
+        readonly delay: number;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly height: {
+            readonly type: StringConstructor;
+            readonly default: "240px";
+        };
+        readonly distance: {
+            readonly type: NumberConstructor;
+            readonly default: 0;
+        };
+        readonly delay: {
+            readonly type: NumberConstructor;
+            readonly default: 200;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly loading: BooleanConstructor;
+        readonly immediate: BooleanConstructor;
+    }>> & Readonly<{
+        onLoad?: ((payload: import("./index.js").InfiniteScrollLoadPayload) => any) | undefined;
+    }>, {
+        check: () => void;
+    }, {}, {}, {}, {
+        readonly loading: boolean;
+        readonly disabled: boolean;
+        readonly immediate: boolean;
+        readonly height: string;
+        readonly distance: number;
+        readonly delay: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "240px";
+    };
+    readonly distance: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly delay: {
+        readonly type: NumberConstructor;
+        readonly default: 200;
+    };
+    readonly disabled: BooleanConstructor;
+    readonly loading: BooleanConstructor;
+    readonly immediate: BooleanConstructor;
+}>> & Readonly<{
+    onLoad?: ((payload: import("./index.js").InfiniteScrollLoadPayload) => any) | undefined;
+}>, {
+    check: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    load: (payload: import("./index.js").InfiniteScrollLoadPayload) => void;
+}, string, {
+    readonly loading: boolean;
+    readonly disabled: boolean;
+    readonly immediate: boolean;
+    readonly height: string;
+    readonly distance: number;
+    readonly delay: number;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {}) => any;
+    } & {
+        loading?: (props: {}) => any;
+    };
+})>;
+export default JhInfiniteScroll;
+export * from './src/props';
+export * from './src/types';

package/dist/components/infinite-scroll/src/infinite-scroll.vue.d.ts

@@ -0,0 +1,59 @@
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    loading?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "240px";
+    };
+    readonly distance: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly delay: {
+        readonly type: NumberConstructor;
+        readonly default: 200;
+    };
+    readonly disabled: BooleanConstructor;
+    readonly loading: BooleanConstructor;
+    readonly immediate: BooleanConstructor;
+}>, {
+    check: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    load: (payload: import("./types").InfiniteScrollLoadPayload) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "240px";
+    };
+    readonly distance: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly delay: {
+        readonly type: NumberConstructor;
+        readonly default: 200;
+    };
+    readonly disabled: BooleanConstructor;
+    readonly loading: BooleanConstructor;
+    readonly immediate: BooleanConstructor;
+}>> & Readonly<{
+    onLoad?: ((payload: import("./types").InfiniteScrollLoadPayload) => any) | undefined;
+}>, {
+    readonly loading: boolean;
+    readonly disabled: boolean;
+    readonly immediate: boolean;
+    readonly height: string;
+    readonly distance: number;
+    readonly delay: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/infinite-scroll/src/props.d.ts

@@ -0,0 +1,21 @@
+import type { InfiniteScrollLoadPayload } from './types';
+export declare const infiniteScrollProps: {
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "240px";
+    };
+    readonly distance: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly delay: {
+        readonly type: NumberConstructor;
+        readonly default: 200;
+    };
+    readonly disabled: BooleanConstructor;
+    readonly loading: BooleanConstructor;
+    readonly immediate: BooleanConstructor;
+};
+export declare const infiniteScrollEmits: {
+    load: (payload: InfiniteScrollLoadPayload) => boolean;
+};

package/dist/components/infinite-scroll/src/types.d.ts

@@ -0,0 +1,5 @@
+export interface InfiniteScrollLoadPayload {
+    scrollTop: number;
+    clientHeight: number;
+    scrollHeight: number;
+}

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

@@ -0,0 +1,110 @@
+export declare const JhInput: import("../../utils/src/index").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly modelValue: {
+            readonly type: import("vue").PropType<import("./index.js").InputModelValue>;
+            readonly default: "";
+        };
+        readonly placeholder: StringConstructor;
+        readonly disabled: BooleanConstructor;
+        readonly clearable: BooleanConstructor;
+        readonly password: BooleanConstructor;
+        readonly prefixIcon: import("vue").PropType<import("../index.js").IconName>;
+        readonly suffixIcon: import("vue").PropType<import("../index.js").IconName>;
+        readonly name: StringConstructor;
+        readonly autocomplete: StringConstructor;
+    }>> & Readonly<{
+        onInput?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        input: (_value: import("./index.js").InputModelValue) => void;
+        clear: () => void;
+        blur: (event: FocusEvent) => void;
+        change: (_value: import("./index.js").InputModelValue) => void;
+        focus: (event: FocusEvent) => void;
+        "update:modelValue": (_value: import("./index.js").InputModelValue) => void;
+    }, import("vue").PublicProps, {
+        readonly disabled: boolean;
+        readonly modelValue: import("./index.js").InputModelValue;
+        readonly clearable: boolean;
+        readonly password: boolean;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly modelValue: {
+            readonly type: import("vue").PropType<import("./index.js").InputModelValue>;
+            readonly default: "";
+        };
+        readonly placeholder: StringConstructor;
+        readonly disabled: BooleanConstructor;
+        readonly clearable: BooleanConstructor;
+        readonly password: BooleanConstructor;
+        readonly prefixIcon: import("vue").PropType<import("../index.js").IconName>;
+        readonly suffixIcon: import("vue").PropType<import("../index.js").IconName>;
+        readonly name: StringConstructor;
+        readonly autocomplete: StringConstructor;
+    }>> & Readonly<{
+        onInput?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        readonly disabled: boolean;
+        readonly modelValue: import("./index.js").InputModelValue;
+        readonly clearable: boolean;
+        readonly password: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<import("./index.js").InputModelValue>;
+        readonly default: "";
+    };
+    readonly placeholder: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+    readonly password: BooleanConstructor;
+    readonly prefixIcon: import("vue").PropType<import("../index.js").IconName>;
+    readonly suffixIcon: import("vue").PropType<import("../index.js").IconName>;
+    readonly name: StringConstructor;
+    readonly autocomplete: StringConstructor;
+}>> & Readonly<{
+    onInput?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: import("./index.js").InputModelValue) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    input: (_value: import("./index.js").InputModelValue) => void;
+    clear: () => void;
+    blur: (event: FocusEvent) => void;
+    change: (_value: import("./index.js").InputModelValue) => void;
+    focus: (event: FocusEvent) => void;
+    "update:modelValue": (_value: import("./index.js").InputModelValue) => void;
+}, string, {
+    readonly disabled: boolean;
+    readonly modelValue: import("./index.js").InputModelValue;
+    readonly clearable: boolean;
+    readonly password: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        prefix?: () => unknown;
+        suffix?: () => unknown;
+    };
+})>;
+export default JhInput;
+export * from './src/props';
+export * from './src/types';

package/dist/components/input/src/input.vue.d.ts

@@ -0,0 +1,58 @@
+import type { InputModelValue } from './types';
+type __VLS_Slots = {
+    prefix?: () => unknown;
+    suffix?: () => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<InputModelValue>;
+        readonly default: "";
+    };
+    readonly placeholder: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+    readonly password: BooleanConstructor;
+    readonly prefixIcon: import("vue").PropType<import("../..").IconName>;
+    readonly suffixIcon: import("vue").PropType<import("../..").IconName>;
+    readonly name: StringConstructor;
+    readonly autocomplete: StringConstructor;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    input: (_value: InputModelValue) => void;
+    clear: () => void;
+    blur: (event: FocusEvent) => void;
+    change: (_value: InputModelValue) => void;
+    focus: (event: FocusEvent) => void;
+    "update:modelValue": (_value: InputModelValue) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<InputModelValue>;
+        readonly default: "";
+    };
+    readonly placeholder: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+    readonly password: BooleanConstructor;
+    readonly prefixIcon: import("vue").PropType<import("../..").IconName>;
+    readonly suffixIcon: import("vue").PropType<import("../..").IconName>;
+    readonly name: StringConstructor;
+    readonly autocomplete: StringConstructor;
+}>> & Readonly<{
+    onInput?: ((_value: InputModelValue) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((_value: InputModelValue) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: InputModelValue) => any) | undefined;
+}>, {
+    readonly disabled: boolean;
+    readonly modelValue: InputModelValue;
+    readonly clearable: boolean;
+    readonly password: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/input/src/props.d.ts

@@ -0,0 +1,26 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { IconName } from '../../icon';
+import type { InputModelValue } from './types';
+export declare const inputProps: {
+    readonly modelValue: {
+        readonly type: PropType<InputModelValue>;
+        readonly default: "";
+    };
+    readonly placeholder: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+    readonly password: BooleanConstructor;
+    readonly prefixIcon: PropType<IconName>;
+    readonly suffixIcon: PropType<IconName>;
+    readonly name: StringConstructor;
+    readonly autocomplete: StringConstructor;
+};
+export declare const inputEmits: {
+    'update:modelValue': (_value: InputModelValue) => boolean;
+    input: (_value: InputModelValue) => boolean;
+    change: (_value: InputModelValue) => boolean;
+    clear: () => boolean;
+    focus: (event: FocusEvent) => boolean;
+    blur: (event: FocusEvent) => boolean;
+};
+export type InputProps = ExtractPropTypes<typeof inputProps>;

package/dist/components/input/src/types.d.ts

@@ -0,0 +1 @@
+export type InputModelValue = string | number;

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

@@ -0,0 +1,84 @@
+export declare const JhLink: import("../../utils/src/index").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly type: {
+            readonly type: import("vue").PropType<import("./index.js").LinkType>;
+            readonly default: "default";
+            readonly validator: (value: import("./index.js").LinkType) => boolean;
+        };
+        readonly href: StringConstructor;
+        readonly target: import("vue").PropType<import("./index.js").LinkTarget>;
+        readonly disabled: BooleanConstructor;
+        readonly underline: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly icon: import("vue").PropType<import("../index.js").IconName>;
+    }>> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (event: MouseEvent) => void;
+    }, import("vue").PublicProps, {
+        readonly type: import("./index.js").LinkType;
+        readonly disabled: boolean;
+        readonly underline: boolean;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly type: {
+            readonly type: import("vue").PropType<import("./index.js").LinkType>;
+            readonly default: "default";
+            readonly validator: (value: import("./index.js").LinkType) => boolean;
+        };
+        readonly href: StringConstructor;
+        readonly target: import("vue").PropType<import("./index.js").LinkTarget>;
+        readonly disabled: BooleanConstructor;
+        readonly underline: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly icon: import("vue").PropType<import("../index.js").IconName>;
+    }>> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        readonly type: import("./index.js").LinkType;
+        readonly disabled: boolean;
+        readonly underline: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("./index.js").LinkType>;
+        readonly default: "default";
+        readonly validator: (value: import("./index.js").LinkType) => boolean;
+    };
+    readonly href: StringConstructor;
+    readonly target: import("vue").PropType<import("./index.js").LinkTarget>;
+    readonly disabled: BooleanConstructor;
+    readonly underline: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly icon: import("vue").PropType<import("../index.js").IconName>;
+}>> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => void;
+}, string, {
+    readonly type: import("./index.js").LinkType;
+    readonly disabled: boolean;
+    readonly underline: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {}) => any;
+    };
+})>;
+export default JhLink;
+export * from './src/props';
+export * from './src/types';

package/dist/components/link/src/link.vue.d.ts

@@ -0,0 +1,48 @@
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("./types").LinkType>;
+        readonly default: "default";
+        readonly validator: (value: import("./types").LinkType) => boolean;
+    };
+    readonly href: StringConstructor;
+    readonly target: import("vue").PropType<import("./types").LinkTarget>;
+    readonly disabled: BooleanConstructor;
+    readonly underline: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly icon: import("vue").PropType<import("../..").IconName>;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("./types").LinkType>;
+        readonly default: "default";
+        readonly validator: (value: import("./types").LinkType) => boolean;
+    };
+    readonly href: StringConstructor;
+    readonly target: import("vue").PropType<import("./types").LinkTarget>;
+    readonly disabled: BooleanConstructor;
+    readonly underline: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly icon: import("vue").PropType<import("../..").IconName>;
+}>> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    readonly type: import("./types").LinkType;
+    readonly disabled: boolean;
+    readonly underline: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/link/src/props.d.ts

@@ -0,0 +1,23 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { IconName } from '../../icon';
+import type { LinkTarget, LinkType } from './types';
+export declare const linkTypes: LinkType[];
+export declare const linkProps: {
+    readonly type: {
+        readonly type: PropType<LinkType>;
+        readonly default: "default";
+        readonly validator: (value: LinkType) => boolean;
+    };
+    readonly href: StringConstructor;
+    readonly target: PropType<LinkTarget>;
+    readonly disabled: BooleanConstructor;
+    readonly underline: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly icon: PropType<IconName>;
+};
+export declare const linkEmits: {
+    click: (event: MouseEvent) => boolean;
+};
+export type LinkProps = ExtractPropTypes<typeof linkProps>;

package/dist/components/link/src/types.d.ts

@@ -0,0 +1,2 @@
+export type LinkType = 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export type LinkTarget = '_self' | '_blank' | '_parent' | '_top';

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

@@ -0,0 +1,7 @@
+import Message from './src/message.vue';
+import type { MessageFn } from './src/types';
+export declare const JhMessage: MessageFn;
+export default JhMessage;
+export { Message };
+export * from './src/props';
+export * from './src/types';

package/dist/components/message/src/message.vue.d.ts

@@ -0,0 +1,79 @@
+declare var __VLS_9: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly id: {
+        readonly type: StringConstructor;
+        readonly required: true;
+    };
+    readonly message: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("./types").MessageType>;
+        readonly default: "info";
+        readonly validator: (value: import("./types").MessageType) => boolean;
+    };
+    readonly duration: {
+        readonly type: NumberConstructor;
+        readonly default: 3000;
+    };
+    readonly showClose: BooleanConstructor;
+    readonly offset: {
+        readonly type: NumberConstructor;
+        readonly default: 20;
+    };
+    readonly zIndex: {
+        readonly type: NumberConstructor;
+        readonly default: 3000;
+    };
+    readonly onClose: import("vue").PropType<() => void>;
+    readonly onDestroy: import("vue").PropType<() => void>;
+}>, {
+    close: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly id: {
+        readonly type: StringConstructor;
+        readonly required: true;
+    };
+    readonly message: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("./types").MessageType>;
+        readonly default: "info";
+        readonly validator: (value: import("./types").MessageType) => boolean;
+    };
+    readonly duration: {
+        readonly type: NumberConstructor;
+        readonly default: 3000;
+    };
+    readonly showClose: BooleanConstructor;
+    readonly offset: {
+        readonly type: NumberConstructor;
+        readonly default: 20;
+    };
+    readonly zIndex: {
+        readonly type: NumberConstructor;
+        readonly default: 3000;
+    };
+    readonly onClose: import("vue").PropType<() => void>;
+    readonly onDestroy: import("vue").PropType<() => void>;
+}>> & Readonly<{}>, {
+    readonly type: import("./types").MessageType;
+    readonly duration: number;
+    readonly message: string;
+    readonly showClose: boolean;
+    readonly offset: number;
+    readonly zIndex: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};