@haoyulong1112/jh-ui 0.1.0

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

@@ -0,0 +1,123 @@
+export declare const JhButton: 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").ButtonType>;
+            readonly default: "default";
+            readonly validator: (value: import("./index.js").ButtonType) => boolean;
+        };
+        readonly size: {
+            readonly type: import("vue").PropType<import("./index.js").ButtonSize>;
+            readonly default: "default";
+            readonly validator: (value: import("./index.js").ButtonSize) => boolean;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly loading: BooleanConstructor;
+        readonly plain: BooleanConstructor;
+        readonly round: BooleanConstructor;
+        readonly circle: BooleanConstructor;
+        readonly icon: import("vue").PropType<import("../index.js").IconName>;
+        readonly nativeType: {
+            readonly type: import("vue").PropType<import("./index.js").ButtonNativeType>;
+            readonly default: "button";
+            readonly validator: (value: import("./index.js").ButtonNativeType) => boolean;
+        };
+    }>> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (event: MouseEvent) => void;
+    }, import("vue").PublicProps, {
+        readonly loading: boolean;
+        readonly size: import("./index.js").ButtonSize;
+        readonly type: import("./index.js").ButtonType;
+        readonly circle: boolean;
+        readonly round: boolean;
+        readonly disabled: boolean;
+        readonly plain: boolean;
+        readonly nativeType: import("./index.js").ButtonNativeType;
+    }, 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").ButtonType>;
+            readonly default: "default";
+            readonly validator: (value: import("./index.js").ButtonType) => boolean;
+        };
+        readonly size: {
+            readonly type: import("vue").PropType<import("./index.js").ButtonSize>;
+            readonly default: "default";
+            readonly validator: (value: import("./index.js").ButtonSize) => boolean;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly loading: BooleanConstructor;
+        readonly plain: BooleanConstructor;
+        readonly round: BooleanConstructor;
+        readonly circle: BooleanConstructor;
+        readonly icon: import("vue").PropType<import("../index.js").IconName>;
+        readonly nativeType: {
+            readonly type: import("vue").PropType<import("./index.js").ButtonNativeType>;
+            readonly default: "button";
+            readonly validator: (value: import("./index.js").ButtonNativeType) => boolean;
+        };
+    }>> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        readonly loading: boolean;
+        readonly size: import("./index.js").ButtonSize;
+        readonly type: import("./index.js").ButtonType;
+        readonly circle: boolean;
+        readonly round: boolean;
+        readonly disabled: boolean;
+        readonly plain: boolean;
+        readonly nativeType: import("./index.js").ButtonNativeType;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("./index.js").ButtonType>;
+        readonly default: "default";
+        readonly validator: (value: import("./index.js").ButtonType) => boolean;
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("./index.js").ButtonSize>;
+        readonly default: "default";
+        readonly validator: (value: import("./index.js").ButtonSize) => boolean;
+    };
+    readonly disabled: BooleanConstructor;
+    readonly loading: BooleanConstructor;
+    readonly plain: BooleanConstructor;
+    readonly round: BooleanConstructor;
+    readonly circle: BooleanConstructor;
+    readonly icon: import("vue").PropType<import("../index.js").IconName>;
+    readonly nativeType: {
+        readonly type: import("vue").PropType<import("./index.js").ButtonNativeType>;
+        readonly default: "button";
+        readonly validator: (value: import("./index.js").ButtonNativeType) => boolean;
+    };
+}>> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => void;
+}, string, {
+    readonly loading: boolean;
+    readonly size: import("./index.js").ButtonSize;
+    readonly type: import("./index.js").ButtonType;
+    readonly circle: boolean;
+    readonly round: boolean;
+    readonly disabled: boolean;
+    readonly plain: boolean;
+    readonly nativeType: import("./index.js").ButtonNativeType;
+}, {}, 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 JhButton;
+export * from './src/props';
+export * from './src/types';

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

@@ -0,0 +1,69 @@
+declare var __VLS_9: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("./types").ButtonType>;
+        readonly default: "default";
+        readonly validator: (value: import("./types").ButtonType) => boolean;
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("./types").ButtonSize>;
+        readonly default: "default";
+        readonly validator: (value: import("./types").ButtonSize) => boolean;
+    };
+    readonly disabled: BooleanConstructor;
+    readonly loading: BooleanConstructor;
+    readonly plain: BooleanConstructor;
+    readonly round: BooleanConstructor;
+    readonly circle: BooleanConstructor;
+    readonly icon: import("vue").PropType<import("../..").IconName>;
+    readonly nativeType: {
+        readonly type: import("vue").PropType<import("./types").ButtonNativeType>;
+        readonly default: "button";
+        readonly validator: (value: import("./types").ButtonNativeType) => boolean;
+    };
+}>, {}, {}, {}, {}, 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").ButtonType>;
+        readonly default: "default";
+        readonly validator: (value: import("./types").ButtonType) => boolean;
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("./types").ButtonSize>;
+        readonly default: "default";
+        readonly validator: (value: import("./types").ButtonSize) => boolean;
+    };
+    readonly disabled: BooleanConstructor;
+    readonly loading: BooleanConstructor;
+    readonly plain: BooleanConstructor;
+    readonly round: BooleanConstructor;
+    readonly circle: BooleanConstructor;
+    readonly icon: import("vue").PropType<import("../..").IconName>;
+    readonly nativeType: {
+        readonly type: import("vue").PropType<import("./types").ButtonNativeType>;
+        readonly default: "button";
+        readonly validator: (value: import("./types").ButtonNativeType) => boolean;
+    };
+}>> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    readonly loading: boolean;
+    readonly size: import("./types").ButtonSize;
+    readonly type: import("./types").ButtonType;
+    readonly circle: boolean;
+    readonly round: boolean;
+    readonly disabled: boolean;
+    readonly plain: boolean;
+    readonly nativeType: import("./types").ButtonNativeType;
+}, {}, {}, {}, 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/button/src/props.d.ts

@@ -0,0 +1,33 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { IconName } from '../../icon';
+import type { ButtonNativeType, ButtonSize, ButtonType } from './types';
+export declare const buttonTypes: ButtonType[];
+export declare const buttonSizes: ButtonSize[];
+export declare const buttonNativeTypes: ButtonNativeType[];
+export declare const buttonProps: {
+    readonly type: {
+        readonly type: PropType<ButtonType>;
+        readonly default: "default";
+        readonly validator: (value: ButtonType) => boolean;
+    };
+    readonly size: {
+        readonly type: PropType<ButtonSize>;
+        readonly default: "default";
+        readonly validator: (value: ButtonSize) => boolean;
+    };
+    readonly disabled: BooleanConstructor;
+    readonly loading: BooleanConstructor;
+    readonly plain: BooleanConstructor;
+    readonly round: BooleanConstructor;
+    readonly circle: BooleanConstructor;
+    readonly icon: PropType<IconName>;
+    readonly nativeType: {
+        readonly type: PropType<ButtonNativeType>;
+        readonly default: "button";
+        readonly validator: (value: ButtonNativeType) => boolean;
+    };
+};
+export declare const buttonEmits: {
+    click: (event: MouseEvent) => boolean;
+};
+export type ButtonProps = ExtractPropTypes<typeof buttonProps>;

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

@@ -0,0 +1,3 @@
+export type ButtonType = 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export type ButtonSize = 'small' | 'default' | 'large';
+export type ButtonNativeType = 'button' | 'submit' | 'reset';

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

@@ -0,0 +1,187 @@
+export declare const JhCarousel: import("../../utils/src/index").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly modelValue: {
+            readonly type: NumberConstructor;
+            readonly default: undefined;
+        };
+        readonly height: {
+            readonly type: StringConstructor;
+            readonly default: "200px";
+        };
+        readonly autoplay: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly interval: {
+            readonly type: NumberConstructor;
+            readonly default: 3000;
+        };
+        readonly loop: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly arrow: {
+            readonly type: import("vue").PropType<import("./index.js").CarouselArrow>;
+            readonly default: "hover";
+            readonly validator: (value: import("./index.js").CarouselArrow) => boolean;
+        };
+        readonly indicator: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+    }>> & Readonly<{
+        onChange?: ((current: number, previous: number) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (current: number, previous: number) => void;
+        "update:modelValue": (value: number) => void;
+    }, import("vue").PublicProps, {
+        readonly modelValue: number;
+        readonly height: string;
+        readonly autoplay: boolean;
+        readonly interval: number;
+        readonly loop: boolean;
+        readonly arrow: import("./index.js").CarouselArrow;
+        readonly indicator: 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: NumberConstructor;
+            readonly default: undefined;
+        };
+        readonly height: {
+            readonly type: StringConstructor;
+            readonly default: "200px";
+        };
+        readonly autoplay: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly interval: {
+            readonly type: NumberConstructor;
+            readonly default: 3000;
+        };
+        readonly loop: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly arrow: {
+            readonly type: import("vue").PropType<import("./index.js").CarouselArrow>;
+            readonly default: "hover";
+            readonly validator: (value: import("./index.js").CarouselArrow) => boolean;
+        };
+        readonly indicator: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+    }>> & Readonly<{
+        onChange?: ((current: number, previous: number) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        readonly modelValue: number;
+        readonly height: string;
+        readonly autoplay: boolean;
+        readonly interval: number;
+        readonly loop: boolean;
+        readonly arrow: import("./index.js").CarouselArrow;
+        readonly indicator: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: NumberConstructor;
+        readonly default: undefined;
+    };
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "200px";
+    };
+    readonly autoplay: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly interval: {
+        readonly type: NumberConstructor;
+        readonly default: 3000;
+    };
+    readonly loop: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly arrow: {
+        readonly type: import("vue").PropType<import("./index.js").CarouselArrow>;
+        readonly default: "hover";
+        readonly validator: (value: import("./index.js").CarouselArrow) => boolean;
+    };
+    readonly indicator: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+}>> & Readonly<{
+    onChange?: ((current: number, previous: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (current: number, previous: number) => void;
+    "update:modelValue": (value: number) => void;
+}, string, {
+    readonly modelValue: number;
+    readonly height: string;
+    readonly autoplay: boolean;
+    readonly interval: number;
+    readonly loop: boolean;
+    readonly arrow: import("./index.js").CarouselArrow;
+    readonly indicator: 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 declare const JhCarouselItem: import("../../utils/src/index").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly name: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        readonly name: string;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly name: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        readonly name: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly name: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    readonly name: string;
+}, {}, 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 JhCarousel;
+export * from './src/props';
+export * from './src/types';

package/dist/components/carousel/src/carousel-item.vue.d.ts

@@ -0,0 +1,24 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly name: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly name: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+}>> & Readonly<{}>, {
+    readonly name: string;
+}, {}, {}, {}, 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/carousel/src/carousel.vue.d.ts

@@ -0,0 +1,86 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: NumberConstructor;
+        readonly default: undefined;
+    };
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "200px";
+    };
+    readonly autoplay: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly interval: {
+        readonly type: NumberConstructor;
+        readonly default: 3000;
+    };
+    readonly loop: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly arrow: {
+        readonly type: import("vue").PropType<import("./types").CarouselArrow>;
+        readonly default: "hover";
+        readonly validator: (value: import("./types").CarouselArrow) => boolean;
+    };
+    readonly indicator: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (current: number, previous: number) => void;
+    "update:modelValue": (value: number) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: NumberConstructor;
+        readonly default: undefined;
+    };
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "200px";
+    };
+    readonly autoplay: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly interval: {
+        readonly type: NumberConstructor;
+        readonly default: 3000;
+    };
+    readonly loop: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly arrow: {
+        readonly type: import("vue").PropType<import("./types").CarouselArrow>;
+        readonly default: "hover";
+        readonly validator: (value: import("./types").CarouselArrow) => boolean;
+    };
+    readonly indicator: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+}>> & Readonly<{
+    onChange?: ((current: number, previous: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    readonly modelValue: number;
+    readonly height: string;
+    readonly autoplay: boolean;
+    readonly interval: number;
+    readonly loop: boolean;
+    readonly arrow: import("./types").CarouselArrow;
+    readonly indicator: 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/carousel/src/props.d.ts

@@ -0,0 +1,44 @@
+import type { PropType } from 'vue';
+import type { CarouselArrow } from './types';
+export declare const carouselArrows: CarouselArrow[];
+export declare const carouselProps: {
+    readonly modelValue: {
+        readonly type: NumberConstructor;
+        readonly default: undefined;
+    };
+    readonly height: {
+        readonly type: StringConstructor;
+        readonly default: "200px";
+    };
+    readonly autoplay: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly interval: {
+        readonly type: NumberConstructor;
+        readonly default: 3000;
+    };
+    readonly loop: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly arrow: {
+        readonly type: PropType<CarouselArrow>;
+        readonly default: "hover";
+        readonly validator: (value: CarouselArrow) => boolean;
+    };
+    readonly indicator: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+};
+export declare const carouselEmits: {
+    'update:modelValue': (value: number) => boolean;
+    change: (current: number, previous: number) => boolean;
+};
+export declare const carouselItemProps: {
+    readonly name: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+};

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

@@ -0,0 +1,11 @@
+import type { InjectionKey, Ref } from 'vue';
+export type CarouselArrow = 'always' | 'hover' | 'never';
+export interface CarouselItemContext {
+    uid: symbol;
+}
+export interface CarouselContext {
+    activeUid: Ref<symbol | undefined>;
+    registerItem: (item: CarouselItemContext) => void;
+    unregisterItem: (item: CarouselItemContext) => void;
+}
+export declare const carouselContextKey: InjectionKey<CarouselContext>;

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

@@ -0,0 +1,68 @@
+export declare const JhCascader: import("../../utils/src/index").SFCWithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<import("./index.js").CascaderValue[]>;
+        readonly default: () => never[];
+    };
+    readonly options: {
+        readonly type: import("vue").PropType<import("./index.js").CascaderOption[]>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "Please select";
+    };
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+    readonly separator: {
+        readonly type: StringConstructor;
+        readonly default: " / ";
+    };
+    readonly fieldNames: {
+        readonly type: import("vue").PropType<import("./index.js").CascaderFieldNames>;
+        readonly default: () => {};
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: () => void;
+    change: (_value: import("./index.js").CascaderValue[], _selectedOptions: import("./index.js").CascaderOption[]) => void;
+    "update:modelValue": (_value: import("./index.js").CascaderValue[]) => void;
+    "visible-change": (_visible: boolean) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import("vue").PropType<import("./index.js").CascaderValue[]>;
+        readonly default: () => never[];
+    };
+    readonly options: {
+        readonly type: import("vue").PropType<import("./index.js").CascaderOption[]>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "Please select";
+    };
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+    readonly separator: {
+        readonly type: StringConstructor;
+        readonly default: " / ";
+    };
+    readonly fieldNames: {
+        readonly type: import("vue").PropType<import("./index.js").CascaderFieldNames>;
+        readonly default: () => {};
+    };
+}>> & Readonly<{
+    onClear?: (() => any) | undefined;
+    onChange?: ((_value: import("./index.js").CascaderValue[], _selectedOptions: import("./index.js").CascaderOption[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: import("./index.js").CascaderValue[]) => any) | undefined;
+    "onVisible-change"?: ((_visible: boolean) => any) | undefined;
+}>, {
+    readonly placeholder: string;
+    readonly disabled: boolean;
+    readonly modelValue: import("./index.js").CascaderValue[];
+    readonly options: import("./index.js").CascaderOption[];
+    readonly clearable: boolean;
+    readonly separator: string;
+    readonly fieldNames: import("./index.js").CascaderFieldNames;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export default JhCascader;
+export * from './src/props';
+export * from './src/types';