@polyv/vue-components 1.1.2 → 1.2.1

package/vue3/src/components/swiper/hooks/use-swiper-slide.d.ts

@@ -0,0 +1 @@
+export declare const useSwiperSlide: () => void;

package/vue3/src/components/swiper/hooks/use-swiper-wrapper.d.ts

@@ -0,0 +1,22 @@
+import { VueEmit, VueProps } from '../../../vue-utils';
+import { ComputedRef } from 'vue';
+import { swiperEmits, swiperProps } from './swiper-props';
+export interface SwiperInjectData {
+    /** 是否初始化 swiper 成功 */
+    swiperInited: ComputedRef<boolean>;
+    /** 当前激活的幻灯片索引 */
+    activeIndex: ComputedRef<number>;
+    /** 总幻灯片数量 */
+    total: ComputedRef<number>;
+    /** 更新 swiper */
+    updateSwiper: () => void;
+}
+export declare const useSwiperWrapper: (options: {
+    props: VueProps<typeof swiperProps>;
+    emit: VueEmit<typeof swiperEmits>;
+}) => {
+    wrapperRef: import('vue').Ref<HTMLDivElement | undefined>;
+    navigationOptions: ComputedRef<false | import('swiper/types').NavigationOptions>;
+    paginationOptions: ComputedRef<false | import('swiper/types').PaginationOptions>;
+};
+export declare const useSwiperInject: () => SwiperInjectData;

package/vue3/src/components/swiper/index.d.ts

@@ -0,0 +1,4 @@
+export { default as PwcSwiper } from './swiper.vue';
+export { default as PwcSwiperSlide } from './swiper-slide.vue';
+export * from './hooks/swiper-props';
+export type { SwiperOptions } from 'swiper/types/swiper-options';

package/vue3/src/components/swiper/modules/use-navigation-module.d.ts

@@ -0,0 +1,21 @@
+import { NavigationOptions } from 'swiper/types/modules/navigation';
+import { UseSwiperOptionsReturn } from '../hooks/use-swiper-options';
+export declare const swiperNavigationProps: () => {
+    /**
+     * 是否显示导航箭头
+     * @default true
+     */
+    showNavigationArrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * swiper 导航配置，详细可见 [官方文档](https://swiperjs.com/swiper-api#navigation)
+     * @default false
+     */
+    navigation: import('vue-types').VueTypeDef<boolean | NavigationOptions> & {
+        default: boolean | (() => NavigationOptions);
+    };
+};
+export declare const useNavigationModule: (swiperOptionsHook: UseSwiperOptionsReturn) => {
+    navigationOptions: import('vue').ComputedRef<false | NavigationOptions>;
+};

package/vue3/src/components/swiper/modules/use-pagination-module.d.ts

@@ -0,0 +1,14 @@
+import { PaginationOptions } from 'swiper/types/modules/pagination';
+import { UseSwiperOptionsReturn } from '../hooks/use-swiper-options';
+export declare const swiperPaginationProps: () => {
+    /**
+     * swiper 指示器配置，详细可见 [官方文档](https://swiperjs.com/swiper-api#pagination)
+     * @default false
+     */
+    pagination: import('vue-types').VueTypeDef<boolean | PaginationOptions> & {
+        default: boolean | (() => PaginationOptions);
+    };
+};
+export declare const usePaginationModule: (swiperOptionsHook: UseSwiperOptionsReturn) => {
+    paginationOptions: import('vue').ComputedRef<false | PaginationOptions>;
+};

package/vue3/src/components/swiper/swiper-slide.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{}>>, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/vue3/src/components/swiper/swiper.vue.d.ts

@@ -0,0 +1,73 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        'navigation-prev'?(_: {}): any;
+        'navigation-next'?(_: {}): any;
+        pagination?(_: {}): any;
+        'wrapper-suffix'?(_: {}): any;
+    };
+    refs: {
+        wrapperRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    pagination: import('vue-types').VueTypeDef<boolean | import('swiper/types').PaginationOptions> & {
+        default: boolean | (() => import('swiper/types').PaginationOptions);
+    };
+    showNavigationArrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    navigation: import('vue-types').VueTypeDef<boolean | import('swiper/types').NavigationOptions> & {
+        default: boolean | (() => import('swiper/types').NavigationOptions);
+    };
+    initialSlide: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    direction: import('vue-types').VueTypeDef<"horizontal" | "vertical"> & {
+        default: "horizontal" | "vertical";
+    };
+    swiperOptions: import('vue-types').VueTypeValidableDef<import('swiper/types').SwiperOptions, import('vue-types/dist/types').ValidatorFunction<import('swiper/types').SwiperOptions>> & {
+        default: () => import('swiper/types').SwiperOptions;
+    };
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    init: (arg: import('swiper').default) => void;
+    "slide-change": (arg: import('swiper').default) => void;
+    "slide-change-transition-start": (arg: import('swiper').default) => void;
+    "slide-change-transition-end": (arg: import('swiper').default) => void;
+}, string, Readonly<import('vue').ExtractPropTypes<{
+    pagination: import('vue-types').VueTypeDef<boolean | import('swiper/types').PaginationOptions> & {
+        default: boolean | (() => import('swiper/types').PaginationOptions);
+    };
+    showNavigationArrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    navigation: import('vue-types').VueTypeDef<boolean | import('swiper/types').NavigationOptions> & {
+        default: boolean | (() => import('swiper/types').NavigationOptions);
+    };
+    initialSlide: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    direction: import('vue-types').VueTypeDef<"horizontal" | "vertical"> & {
+        default: "horizontal" | "vertical";
+    };
+    swiperOptions: import('vue-types').VueTypeValidableDef<import('swiper/types').SwiperOptions, import('vue-types/dist/types').ValidatorFunction<import('swiper/types').SwiperOptions>> & {
+        default: () => import('swiper/types').SwiperOptions;
+    };
+}>>, {
+    direction: "horizontal" | "vertical";
+    pagination: boolean | import('swiper/types').PaginationOptions;
+    showNavigationArrow: boolean;
+    navigation: boolean | import('swiper/types').NavigationOptions;
+    initialSlide: number;
+    swiperOptions: import('swiper/types').SwiperOptions;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/vue3/src/components/switch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PwcSwitch } from './switch.vue';
+export * from './use-switch';

package/vue3/src/components/switch/switch.vue.d.ts

@@ -0,0 +1,51 @@
+declare const _default: import('vue').DefineComponent<{
+    "v-model-key": import('vue-types').VueTypeDef<import('./use-switch').SwitchValue>;
+    disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    activeValue: import('vue-types').VueTypeDef<import('./use-switch').SwitchValue> & {
+        default: import('./use-switch').SwitchValue;
+    };
+    inactiveValue: import('vue-types').VueTypeDef<import('./use-switch').SwitchValue> & {
+        default: import('./use-switch').SwitchValue;
+    };
+    activeColor: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    inactiveColor: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    size: import('vue-types').VueTypeDef<"default" | "mini" | "medium"> & {
+        default: "default" | "mini" | "medium";
+    };
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (arg: import('./use-switch').SwitchValue) => void;
+}, string, Readonly<import('vue').ExtractPropTypes<{
+    "v-model-key": import('vue-types').VueTypeDef<import('./use-switch').SwitchValue>;
+    disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    activeValue: import('vue-types').VueTypeDef<import('./use-switch').SwitchValue> & {
+        default: import('./use-switch').SwitchValue;
+    };
+    inactiveValue: import('vue-types').VueTypeDef<import('./use-switch').SwitchValue> & {
+        default: import('./use-switch').SwitchValue;
+    };
+    activeColor: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    inactiveColor: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    size: import('vue-types').VueTypeDef<"default" | "mini" | "medium"> & {
+        default: "default" | "mini" | "medium";
+    };
+}>>, {
+    size: "default" | "mini" | "medium";
+    disabled: boolean;
+    activeValue: import('./use-switch').SwitchValue;
+    inactiveValue: import('./use-switch').SwitchValue;
+    activeColor: string;
+    inactiveColor: string;
+}>;
+export default _default;

package/vue3/src/components/switch/use-switch.d.ts

@@ -0,0 +1,69 @@
+import { VueEmit, VueProps } from '../../vue-utils';
+export type SwitchValue = boolean | number | string;
+declare const switchSizes: readonly ["default", "medium", "mini"];
+export type SwitchSize = (typeof switchSizes)[number];
+export declare const switchProps: () => {
+    /**
+     * 是否选中，支持 v-model
+     */
+    "v-model-key": import('vue-types').VueTypeDef<SwitchValue>;
+    /**
+     * 是否禁用
+     * @default false
+     */
+    disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * 激活值
+     * @default true
+     */
+    activeValue: import('vue-types').VueTypeDef<SwitchValue> & {
+        default: SwitchValue;
+    };
+    /**
+     * 非激活值
+     * @default false
+     */
+    inactiveValue: import('vue-types').VueTypeDef<SwitchValue> & {
+        default: SwitchValue;
+    };
+    /**
+     * 激活颜色
+     */
+    activeColor: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    /**
+     * 非激活颜色
+     */
+    inactiveColor: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    /**
+     * 大小
+     * @default 'default'
+     */
+    size: import('vue-types').VueTypeDef<"default" | "mini" | "medium"> & {
+        default: "default" | "mini" | "medium";
+    };
+};
+export declare const switchEmits: () => {
+    /**
+     * 开关切换
+     * @cbName 开关值
+     * @cbType SwitchValue
+     */
+    change: import('../../vue-utils').EmitFuncType<SwitchValue>;
+};
+export declare const useSwitch: (options: {
+    props: VueProps<typeof switchProps>;
+    emit: VueEmit<typeof switchEmits>;
+}) => {
+    isOpened: import('vue').ComputedRef<boolean>;
+    switchStyle: import('vue').ComputedRef<{
+        backgroundColor: string;
+    }>;
+    toggleSwitch: () => void;
+};
+export {};

package/vue3/src/components/toast/_component/toast-element.vue.d.ts

@@ -0,0 +1,61 @@
+import { ToastType } from '../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: Element;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    "v-model-key": import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    message: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    type: import('vue-types').VueTypeValidableDef<ToastType, import('vue-types/dist/types').ValidatorFunction<ToastType>> & {
+        default: ToastType;
+    };
+    duration: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    showIcon: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}, {
+    openToast: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "after-enter": (arg?: void | undefined) => void;
+    "after-leave": (arg?: void | undefined) => void;
+}, string, Readonly<import('vue').ExtractPropTypes<{
+    "v-model-key": import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    message: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    type: import('vue-types').VueTypeValidableDef<ToastType, import('vue-types/dist/types').ValidatorFunction<ToastType>> & {
+        default: ToastType;
+    };
+    duration: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    showIcon: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}>>, {
+    "v-model-key": boolean;
+    type: ToastType;
+    message: string;
+    duration: number;
+    showIcon: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/vue3/src/components/toast/_component/use-toast-element.d.ts

@@ -0,0 +1,63 @@
+import { FormatEmit, FormatProps, VueEmit, VueProps } from '../../../vue-utils';
+import { ToastType } from '../types';
+export declare const toastProps: () => {
+    /**
+     * 是否显示绑定值
+     */
+    "v-model-key": import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    /**
+     * 提示内容
+     * @default '提示'
+     */
+    message: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    /**
+     * 提示类型
+     * @default ToastType.Info
+     */
+    type: import('vue-types').VueTypeValidableDef<ToastType, import('vue-types/dist/types').ValidatorFunction<ToastType>> & {
+        default: ToastType;
+    };
+    /**
+     * 关闭时间
+     * @default 3000
+     */
+    duration: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    /**
+     * 显示图标
+     * @default false
+     */
+    showIcon: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+};
+export declare const toastEmits: () => {
+    /**
+     * 提示动画进入之后
+     */
+    'after-enter': import('../../../vue-utils').EmitFuncType<void>;
+    /**
+     * 提示动画离开之后
+     */
+    'after-leave': import('../../../vue-utils').EmitFuncType<void>;
+};
+export type ToastPropsType = FormatProps<typeof toastProps>;
+export type ToastEmitsType = FormatEmit<typeof toastEmits>;
+/**
+ * Toast 组件 hook
+ */
+export declare const useToastElement: (options: {
+    props: VueProps<typeof toastProps>;
+    emit: VueEmit<typeof toastEmits>;
+}) => {
+    toastVisible: import('vue').Ref<boolean>;
+    openToast: () => void;
+    closeToast: () => void;
+    onAfterLeave: () => void;
+    onAfterEnter: () => void;
+};

package/vue3/src/components/toast/hook.d.ts

@@ -0,0 +1,11 @@
+import { ToastOptions } from './types';
+export * from './types';
+export declare const useToast: (options?: ToastOptions) => {
+    toast: {
+        info: (message: string, opts?: ToastOptions) => void;
+        success: (message: string, opts?: ToastOptions) => void;
+        warning: (message: string, opts?: ToastOptions) => void;
+        error: (message: string, opts?: ToastOptions) => void;
+        loading: (message: string, opts?: ToastOptions) => void;
+    };
+};

package/vue3/src/components/toast/index.d.ts

@@ -0,0 +1,4 @@
+export * from './hook';
+export * from './types';
+export { default as PwcToast } from './_component/toast-element.vue';
+export { toastProps, toastEmits } from './_component/use-toast-element';

package/vue3/src/components/toast/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 提示类型
+ */
+export declare enum ToastType {
+    /** 信息类提示 */
+    Info = "info",
+    /** 成功类提示 */
+    Success = "success",
+    /** 警告类提示 */
+    Warning = "warning",
+    /** 异常类提示 */
+    Error = "error",
+    /** 加载中提示 */
+    Loading = "loading"
+}
+export interface ToastOptions {
+    /**
+     * 关闭时间
+     * @default 3000
+     */
+    duration?: number;
+    /**
+     * 显示图标
+     * @default false
+     */
+    showIcon?: boolean;
+}

package/vue3/src/components/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PwcTooltip } from './tooltip.vue';
+export * from './use-tooltip';

package/vue3/src/components/tooltip/tooltip.vue.d.ts

@@ -0,0 +1,139 @@
+import { BeforeShowPopper } from '../../hooks/components/use-popper';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        content?(_: {}): any;
+    };
+    refs: {
+        popperRef: (import('vue/types/v3-component-public-instance').Vue3Instance<{}, Readonly<import('vue').ExtractPropTypes<{
+            trigger: import('vue-types').VueTypeDef<"click" | "hover" | "focus" | "long-press" | "custom"> & {
+                default: "click" | "hover" | "focus" | "long-press" | "custom";
+            };
+            placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+                default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            };
+            arrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            offset: import('vue-types').VueTypeDef<import('../../hooks/components/use-popper').PopperOffset>;
+            disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            beforeShowPopper: import('vue-types').VueTypeValidableDef<BeforeShowPopper, import('vue-types/dist/types').ValidatorFunction<BeforeShowPopper>>;
+        }>>, Readonly<import('vue').ExtractPropTypes<{
+            trigger: import('vue-types').VueTypeDef<"click" | "hover" | "focus" | "long-press" | "custom"> & {
+                default: "click" | "hover" | "focus" | "long-press" | "custom";
+            };
+            placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+                default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            };
+            arrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            offset: import('vue-types').VueTypeDef<import('../../hooks/components/use-popper').PopperOffset>;
+            disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            beforeShowPopper: import('vue-types').VueTypeValidableDef<BeforeShowPopper, import('vue-types/dist/types').ValidatorFunction<BeforeShowPopper>>;
+        }>>, {}, {
+            trigger: "click" | "hover" | "focus" | "long-press" | "custom";
+            placement: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            arrow: boolean;
+            disabled: boolean;
+        }, true, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any>> & Readonly<Readonly<import('vue').ExtractPropTypes<{
+            trigger: import('vue-types').VueTypeDef<"click" | "hover" | "focus" | "long-press" | "custom"> & {
+                default: "click" | "hover" | "focus" | "long-press" | "custom";
+            };
+            placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+                default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            };
+            arrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            offset: import('vue-types').VueTypeDef<import('../../hooks/components/use-popper').PopperOffset>;
+            disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            beforeShowPopper: import('vue-types').VueTypeValidableDef<BeforeShowPopper, import('vue-types/dist/types').ValidatorFunction<BeforeShowPopper>>;
+        }>>> & import('vue').ShallowUnwrapRef<{
+            referenceRef: import('vue').Ref<any>;
+            popperRef: import('vue').Ref<any>;
+            popperVisible: import('vue').Ref<boolean>;
+        }> & import('vue/types/v3-component-options').ExtractComputedReturns<{}> & import('vue').ComponentCustomProperties & Readonly<import('vue').ExtractPropTypes<{
+            trigger: import('vue-types').VueTypeDef<"click" | "hover" | "focus" | "long-press" | "custom"> & {
+                default: "click" | "hover" | "focus" | "long-press" | "custom";
+            };
+            placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+                default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+            };
+            arrow: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            offset: import('vue-types').VueTypeDef<import('../../hooks/components/use-popper').PopperOffset>;
+            disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+                default: boolean;
+            };
+            beforeShowPopper: import('vue-types').VueTypeValidableDef<BeforeShowPopper, import('vue-types/dist/types').ValidatorFunction<BeforeShowPopper>>;
+        }>> & {
+            $scopedSlots: {
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: Element;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    content: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+        default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+    };
+    effect: import('vue-types').VueTypeDef<"light" | "dark" | "auto"> & {
+        default: "light" | "dark" | "auto";
+    };
+    disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    tooltipClass: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    onlyTextEllipsis: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, Readonly<import('vue').ExtractPropTypes<{
+    content: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    placement: import('vue-types').VueTypeDef<"bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end"> & {
+        default: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+    };
+    effect: import('vue-types').VueTypeDef<"light" | "dark" | "auto"> & {
+        default: "light" | "dark" | "auto";
+    };
+    disabled: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    tooltipClass: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    onlyTextEllipsis: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}>>, {
+    placement: "bottom" | "left" | "right" | "top" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end";
+    effect: "light" | "dark" | "auto";
+    content: string;
+    disabled: boolean;
+    tooltipClass: string;
+    onlyTextEllipsis: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};