sakana-element 2.2.0 → 2.3.0

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

@@ -1,5 +1,5 @@
 import { ComponentInternalInstance, Ref, VNode } from 'vue';
-export declare const notificationTypes: readonly ["info", "success", "warning", "danger"];
+export declare const notificationTypes: readonly ["info", "success", "warning", "danger", "error"];
 export type NotificationType = (typeof notificationTypes)[number];
 export declare const notificationPosition: readonly ["top-right", "top-left", "bottom-right", "bottom-left"];
 export type NotificationPosition = (typeof notificationPosition)[number];
@@ -15,6 +15,9 @@ export interface NotificationProps {
     offset?: number;
     transitionName?: string;
     icon?: string;
+    plain?: boolean;
+    ghost?: boolean;
+    showTimer?: boolean;
     onClick?(): void;
     onClose?(): void;
     onDestroy(): void;
@@ -34,7 +37,9 @@ export type CreateNotificationProps = Omit<NotificationProps, 'onDestroy' | 'id'
 export interface NotificationHandler {
     close(): void;
 }
-export type NotificationOptions = Partial<Omit<NotificationProps, 'id'>>;
+export type NotificationOptions = Partial<Omit<NotificationProps, 'id'>> & {
+    max?: number;
+};
 export type NotificationParams = string | VNode | NotificationOptions;
 export type NotificationFn = {
     (props: NotificationParams): NotificationHandler;
@@ -46,4 +51,5 @@ export interface Notification extends NotificationFn {
     warning: NotificationTypeFn;
     info: NotificationTypeFn;
     danger: NotificationTypeFn;
+    error: NotificationTypeFn;
 }

package/dist/types/components/Pixelate/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_PIXEL_SIZE = 8;
+export declare const DEFAULT_BACKGROUND = "#FFFFFF";

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

@@ -0,0 +1,71 @@
+export declare const PxPixelate: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').PixelateProps> & Readonly<{
+        onError?: ((event: Event) => any) | undefined;
+        onRendered?: (() => any) | undefined;
+    }>, {
+        render: () => void;
+        canvasRef: import('vue').Ref<HTMLCanvasElement | undefined, HTMLCanvasElement | undefined>;
+        originRef: import('vue').Ref<HTMLImageElement | undefined, HTMLImageElement | undefined>;
+        getSize: () => {
+            width: number;
+            height: number;
+        };
+        getImageData: () => ImageData | null;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        error: (event: Event) => any;
+        rendered: () => any;
+    }, import('vue').PublicProps, {
+        background: string;
+        pixelSize: number;
+        grayscale: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        canvasRef: HTMLCanvasElement;
+        originRef: HTMLImageElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').PixelateProps> & Readonly<{
+        onError?: ((event: Event) => any) | undefined;
+        onRendered?: (() => any) | undefined;
+    }>, {
+        render: () => void;
+        canvasRef: import('vue').Ref<HTMLCanvasElement | undefined, HTMLCanvasElement | undefined>;
+        originRef: import('vue').Ref<HTMLImageElement | undefined, HTMLImageElement | undefined>;
+        getSize: () => {
+            width: number;
+            height: number;
+        };
+        getImageData: () => ImageData | null;
+    }, {}, {}, {}, {
+        background: string;
+        pixelSize: number;
+        grayscale: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').PixelateProps> & Readonly<{
+    onError?: ((event: Event) => any) | undefined;
+    onRendered?: (() => any) | undefined;
+}>, {
+    render: () => void;
+    canvasRef: import('vue').Ref<HTMLCanvasElement | undefined, HTMLCanvasElement | undefined>;
+    originRef: import('vue').Ref<HTMLImageElement | undefined, HTMLImageElement | undefined>;
+    getSize: () => {
+        width: number;
+        height: number;
+    };
+    getImageData: () => ImageData | null;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    error: (event: Event) => any;
+    rendered: () => any;
+}, string, {
+    background: string;
+    pixelSize: number;
+    grayscale: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,23 @@
+export interface PixelateProps {
+    src: string;
+    pixelSize?: number;
+    width?: number | string;
+    height?: number | string;
+    grayscale?: boolean;
+    palette?: string[] | number[][];
+    background?: string;
+}
+export interface PixelateEmits {
+    (e: 'rendered'): void;
+    (e: 'error', event: Event): void;
+}
+export interface PixelateInstance {
+    render(): void;
+    canvasRef: HTMLCanvasElement;
+    originRef: HTMLImageElement;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    getImageData(): ImageData | null;
+}

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

@@ -1,10 +1,10 @@
 export declare const PxPopconfirm: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').PopconfirmProps> & Readonly<{
-        onConfirm?: ((value: MouseEvent) => any) | undefined;
         onCancel?: ((value: MouseEvent) => any) | undefined;
+        onConfirm?: ((value: MouseEvent) => any) | undefined;
     }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-        confirm: (value: MouseEvent) => any;
         cancel: (value: MouseEvent) => any;
+        confirm: (value: MouseEvent) => any;
     }, import('vue').PublicProps, {
         title: string;
         icon: string;
@@ -28,6 +28,11 @@ export declare const PxPopconfirm: {
                 readonly hideTimeout?: number | undefined;
                 readonly virtualRef?: HTMLElement | undefined;
                 readonly virtualTriggering?: boolean | undefined;
+                readonly effect?: import('packages/core').TooltipEffect | undefined;
+                readonly type?: import('packages/core').TooltipType | undefined;
+                readonly enterable?: boolean | undefined;
+                readonly maxWidth?: string | number | undefined;
+                readonly showArrow?: boolean | undefined;
                 readonly "onVisible-change"?: ((value: boolean) => any) | undefined;
                 readonly "onClick-outside"?: (() => any) | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
@@ -60,11 +65,13 @@ export declare const PxPopconfirm: {
                 "visible-change": (value: boolean) => any;
                 "click-outside": () => any;
             }, string, {
+                effect: import('packages/core').TooltipEffect;
                 transition: string;
                 trigger: "hover" | "click" | "contextmenu";
                 placement: import('@popperjs/core').Placement;
                 showTimeout: number;
                 hideTimeout: number;
+                enterable: boolean;
             }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                 beforeCreate?: (() => void) | (() => void)[];
                 created?: (() => void) | (() => void)[];
@@ -86,15 +93,17 @@ export declare const PxPopconfirm: {
             $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<{
+            effect: import('packages/core').TooltipEffect;
             transition: string;
             trigger: "hover" | "click" | "contextmenu";
             placement: import('@popperjs/core').Placement;
             showTimeout: number;
             hideTimeout: number;
+            enterable: boolean;
         }> & Omit<Readonly<import('packages/core').TooltipProps> & Readonly<{
             "onVisible-change"?: ((value: boolean) => any) | undefined;
             "onClick-outside"?: (() => any) | undefined;
-        }>, "toggle" | "show" | "hide" | ("transition" | "trigger" | "placement" | "showTimeout" | "hideTimeout")> & import('vue').ShallowUnwrapRef<{
+        }>, "toggle" | "show" | "hide" | ("effect" | "transition" | "trigger" | "placement" | "showTimeout" | "hideTimeout" | "enterable")> & import('vue').ShallowUnwrapRef<{
             show(): void;
             hide(): void;
             toggle(): void;
@@ -113,8 +122,8 @@ export declare const PxPopconfirm: {
         M: {};
         Defaults: {};
     }, Readonly<import('packages/core').PopconfirmProps> & Readonly<{
-        onConfirm?: ((value: MouseEvent) => any) | undefined;
         onCancel?: ((value: MouseEvent) => any) | undefined;
+        onConfirm?: ((value: MouseEvent) => any) | undefined;
     }>, {}, {}, {}, {}, {
         title: string;
         icon: string;
@@ -127,11 +136,11 @@ export declare const PxPopconfirm: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import('vue').ComponentOptionsBase<Readonly<import('packages/core').PopconfirmProps> & Readonly<{
-    onConfirm?: ((value: MouseEvent) => any) | undefined;
     onCancel?: ((value: MouseEvent) => any) | undefined;
+    onConfirm?: ((value: MouseEvent) => any) | undefined;
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    confirm: (value: MouseEvent) => any;
     cancel: (value: MouseEvent) => any;
+    confirm: (value: MouseEvent) => any;
 }, string, {
     title: string;
     icon: string;
@@ -141,8 +150,8 @@ export declare const PxPopconfirm: {
     hideAfter: number;
 }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
     $slots: {
-        default?(_: {}): any;
         reference?(_: {}): any;
+        default?(_: {}): any;
     };
 }) & import('vue').Plugin;
 export * from './types';

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

@@ -1,5 +1,6 @@
 import { ButtonType } from '../Button';
-export interface PopconfirmProps {
+import { TooltipProps } from '../Tooltip/types';
+export interface PopconfirmProps extends Pick<TooltipProps, 'disabled' | 'placement' | 'showArrow' | 'effect'> {
     title: string;
     confirmButtonText?: string;
     cancelButtonText?: string;

package/dist/types/components/Progress/constants.d.ts

@@ -0,0 +1,2 @@
+import { ColorTemplate } from '@sakana-element/utils';
+export declare const PROGRESS_COLOR_TEMPLATE: ColorTemplate;

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

@@ -0,0 +1,50 @@
+export declare const PxProgress: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').ProgressProps> & Readonly<{}>, {
+        clampedPercentage: import('vue').ComputedRef<number>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: import('packages/core').ProgressSize;
+        type: import('packages/core').ProgressType;
+        indeterminate: boolean;
+        variant: import('packages/core').ProgressVariant;
+        strokeWidth: number;
+        percentage: number;
+        stripedFlow: boolean;
+        showText: boolean;
+        textInside: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').ProgressProps> & Readonly<{}>, {
+        clampedPercentage: import('vue').ComputedRef<number>;
+    }, {}, {}, {}, {
+        size: import('packages/core').ProgressSize;
+        type: import('packages/core').ProgressType;
+        indeterminate: boolean;
+        variant: import('packages/core').ProgressVariant;
+        strokeWidth: number;
+        percentage: number;
+        stripedFlow: boolean;
+        showText: boolean;
+        textInside: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').ProgressProps> & Readonly<{}>, {
+    clampedPercentage: import('vue').ComputedRef<number>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    size: import('packages/core').ProgressSize;
+    type: import('packages/core').ProgressType;
+    indeterminate: boolean;
+    variant: import('packages/core').ProgressVariant;
+    strokeWidth: number;
+    percentage: number;
+    stripedFlow: boolean;
+    showText: boolean;
+    textInside: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,22 @@
+export type ProgressType = 'primary' | 'success' | 'info' | 'warning' | 'danger';
+export type ProgressStatus = 'success' | 'warning' | 'danger';
+export type ProgressSize = 'large' | 'default' | 'small';
+export type ProgressVariant = 'solid' | 'striped' | 'checkered';
+export interface ProgressProps {
+    percentage?: number;
+    type?: ProgressType;
+    size?: ProgressSize;
+    status?: ProgressStatus;
+    variant?: ProgressVariant;
+    stripedFlow?: boolean;
+    indeterminate?: boolean;
+    strokeWidth?: number;
+    showText?: boolean;
+    textInside?: boolean;
+    color?: string | ((percentage: number) => string);
+    format?: (percentage: number) => string;
+}
+export interface ProgressInstance {
+    /** The clamped percentage value (0-100) */
+    clampedPercentage: number;
+}

package/dist/types/components/Radio/constants.d.ts

@@ -0,0 +1,5 @@
+import { ColorTemplate } from '@sakana-element/utils';
+import { InjectionKey } from 'vue';
+import { RadioGroupContext } from './types';
+export declare const RADIO_GROUP_CTX_KEY: InjectionKey<RadioGroupContext>;
+export declare const RADIO_COLOR_TEMPLATES: Record<string, ColorTemplate>;

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

@@ -0,0 +1,88 @@
+export declare const PxRadio: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').RadioProps> & Readonly<{
+        onChange?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+    }>, {
+        focus(): void;
+        checked: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('packages/core').RadioValueType) => any;
+        "update:modelValue": (value: import('packages/core').RadioValueType) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        inputRef: HTMLInputElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').RadioProps> & Readonly<{
+        onChange?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+    }>, {
+        focus(): void;
+        checked: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, {
+        disabled: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').RadioProps> & Readonly<{
+    onChange?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+}>, {
+    focus(): void;
+    checked: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('packages/core').RadioValueType) => any;
+    "update:modelValue": (value: import('packages/core').RadioValueType) => any;
+}, string, {
+    disabled: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export declare const PxRadioGroup: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').RadioGroupProps> & Readonly<{
+        onChange?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('packages/core').RadioValueType) => any;
+        "update:modelValue": (value: import('packages/core').RadioValueType) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').RadioGroupProps> & Readonly<{
+        onChange?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').RadioGroupProps> & Readonly<{
+    onChange?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('packages/core').RadioValueType) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('packages/core').RadioValueType) => any;
+    "update:modelValue": (value: import('packages/core').RadioValueType) => any;
+}, string, {
+    disabled: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,43 @@
+import { ComputedRef } from 'vue';
+export type RadioValueType = string | number | boolean;
+export type RadioType = 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export interface RadioProps {
+    modelValue?: RadioValueType;
+    value?: RadioValueType;
+    disabled?: boolean;
+    size?: 'small' | 'large';
+    type?: RadioType;
+    color?: string;
+    label?: string;
+    name?: string;
+    id?: string;
+}
+export interface RadioEmits {
+    (e: 'update:modelValue', value: RadioValueType): void;
+    (e: 'change', value: RadioValueType): void;
+}
+export interface RadioInstance {
+    focus(): void;
+    checked: ComputedRef<boolean>;
+}
+export interface RadioGroupProps {
+    modelValue: RadioValueType;
+    disabled?: boolean;
+    size?: 'small' | 'large';
+    type?: RadioType;
+    color?: string;
+    name?: string;
+}
+export interface RadioGroupEmits {
+    (e: 'update:modelValue', value: RadioValueType): void;
+    (e: 'change', value: RadioValueType): void;
+}
+export interface RadioGroupContext {
+    modelValue: ComputedRef<RadioValueType>;
+    disabled: ComputedRef<boolean>;
+    size: ComputedRef<'small' | 'large' | undefined>;
+    type: ComputedRef<RadioType | undefined>;
+    color: ComputedRef<string | undefined>;
+    name: ComputedRef<string | undefined>;
+    changeEvent(value: RadioValueType): void;
+}

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

@@ -1,21 +1,21 @@
 export declare const PxSelect: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').SelectProps> & Readonly<{
         onClear?: (() => any) | undefined;
+        onBlur?: (() => any) | undefined;
+        onChange?: ((value: string) => any) | undefined;
         onFocus?: (() => any) | undefined;
         "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-        onChange?: ((value: string) => any) | undefined;
         "onVisible-change"?: ((value: boolean) => any) | undefined;
-        onBlur?: (() => any) | undefined;
     }>, {
         focus(): void;
         blur(): void;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
         clear: () => any;
+        blur: () => any;
+        change: (value: string) => any;
         focus: () => any;
         "update:modelValue": (value: string) => any;
-        change: (value: string) => any;
         "visible-change": (value: boolean) => any;
-        blur: () => any;
     }, import('vue').PublicProps, {
         options: import('packages/core').SelectOptionProps[];
     }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
@@ -35,6 +35,11 @@ export declare const PxSelect: {
                 readonly hideTimeout?: number | undefined;
                 readonly virtualRef?: HTMLElement | undefined;
                 readonly virtualTriggering?: boolean | undefined;
+                readonly effect?: import('packages/core').TooltipEffect | undefined;
+                readonly type?: import('packages/core').TooltipType | undefined;
+                readonly enterable?: boolean | undefined;
+                readonly maxWidth?: string | number | undefined;
+                readonly showArrow?: boolean | undefined;
                 readonly "onVisible-change"?: ((value: boolean) => any) | undefined;
                 readonly "onClick-outside"?: (() => any) | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
@@ -67,11 +72,13 @@ export declare const PxSelect: {
                 "visible-change": (value: boolean) => any;
                 "click-outside": () => any;
             }, string, {
+                effect: import('packages/core').TooltipEffect;
                 transition: string;
                 trigger: "hover" | "click" | "contextmenu";
                 placement: import('@popperjs/core').Placement;
                 showTimeout: number;
                 hideTimeout: number;
+                enterable: boolean;
             }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                 beforeCreate?: (() => void) | (() => void)[];
                 created?: (() => void) | (() => void)[];
@@ -93,15 +100,17 @@ export declare const PxSelect: {
             $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<{
+            effect: import('packages/core').TooltipEffect;
             transition: string;
             trigger: "hover" | "click" | "contextmenu";
             placement: import('@popperjs/core').Placement;
             showTimeout: number;
             hideTimeout: number;
+            enterable: boolean;
         }> & Omit<Readonly<import('packages/core').TooltipProps> & Readonly<{
             "onVisible-change"?: ((value: boolean) => any) | undefined;
             "onClick-outside"?: (() => any) | undefined;
-        }>, "toggle" | "show" | "hide" | ("transition" | "trigger" | "placement" | "showTimeout" | "hideTimeout")> & import('vue').ShallowUnwrapRef<{
+        }>, "toggle" | "show" | "hide" | ("effect" | "transition" | "trigger" | "placement" | "showTimeout" | "hideTimeout" | "enterable")> & import('vue').ShallowUnwrapRef<{
             show(): void;
             hide(): void;
             toggle(): void;
@@ -133,10 +142,10 @@ export declare const PxSelect: {
                 readonly form?: string | undefined;
                 readonly onInput?: ((value: string) => any) | undefined;
                 readonly onClear?: (() => any) | undefined;
+                readonly onBlur?: ((value: FocusEvent) => any) | undefined;
+                readonly onChange?: ((value: string) => any) | undefined;
                 readonly onFocus?: ((value: FocusEvent) => any) | undefined;
                 readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-                readonly onChange?: ((value: string) => any) | undefined;
-                readonly onBlur?: ((value: FocusEvent) => any) | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
             $attrs: {
                 [x: string]: unknown;
@@ -154,15 +163,15 @@ export declare const PxSelect: {
             $root: import('vue').ComponentPublicInstance | null;
             $parent: import('vue').ComponentPublicInstance | null;
             $host: Element | null;
-            $emit: ((event: "input", value: string) => void) & ((event: "clear") => void) & ((event: "focus", value: FocusEvent) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "blur", value: FocusEvent) => void);
+            $emit: ((event: "input", value: string) => void) & ((event: "clear") => void) & ((event: "blur", value: FocusEvent) => void) & ((event: "change", value: string) => void) & ((event: "focus", value: FocusEvent) => void) & ((event: "update:modelValue", value: string) => void);
             $el: any;
             $options: import('vue').ComponentOptionsBase<Readonly<import('packages/core').InputProps> & Readonly<{
                 onInput?: ((value: string) => any) | undefined;
                 onClear?: (() => any) | undefined;
+                onBlur?: ((value: FocusEvent) => any) | undefined;
+                onChange?: ((value: string) => any) | undefined;
                 onFocus?: ((value: FocusEvent) => any) | undefined;
                 "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-                onChange?: ((value: string) => any) | undefined;
-                onBlur?: ((value: FocusEvent) => any) | undefined;
             }>, {
                 ref: import('vue').Ref<HTMLInputElement | HTMLTextAreaElement | undefined>;
                 focus(): Promise<void>;
@@ -172,10 +181,10 @@ export declare const PxSelect: {
             }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
                 input: (value: string) => any;
                 clear: () => any;
+                blur: (value: FocusEvent) => any;
+                change: (value: string) => any;
                 focus: (value: FocusEvent) => any;
                 "update:modelValue": (value: string) => any;
-                change: (value: string) => any;
-                blur: (value: FocusEvent) => any;
             }, string, {
                 type: string;
                 autocomplete: string;
@@ -205,11 +214,11 @@ export declare const PxSelect: {
         }> & Omit<Readonly<import('packages/core').InputProps> & Readonly<{
             onInput?: ((value: string) => any) | undefined;
             onClear?: (() => any) | undefined;
+            onBlur?: ((value: FocusEvent) => any) | undefined;
+            onChange?: ((value: string) => any) | undefined;
             onFocus?: ((value: FocusEvent) => any) | undefined;
             "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-            onChange?: ((value: string) => any) | undefined;
-            onBlur?: ((value: FocusEvent) => any) | undefined;
-        }>, "select" | "clear" | "ref" | "focus" | "blur" | ("type" | "autocomplete")> & import('vue').ShallowUnwrapRef<{
+        }>, "select" | "clear" | "blur" | "focus" | "ref" | ("type" | "autocomplete")> & import('vue').ShallowUnwrapRef<{
             ref: import('vue').Ref<HTMLInputElement | HTMLTextAreaElement | undefined>;
             focus(): Promise<void>;
             blur(): void;
@@ -232,11 +241,11 @@ export declare const PxSelect: {
         Defaults: {};
     }, Readonly<import('packages/core').SelectProps> & Readonly<{
         onClear?: (() => any) | undefined;
+        onBlur?: (() => any) | undefined;
+        onChange?: ((value: string) => any) | undefined;
         onFocus?: (() => any) | undefined;
         "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-        onChange?: ((value: string) => any) | undefined;
         "onVisible-change"?: ((value: boolean) => any) | undefined;
-        onBlur?: (() => any) | undefined;
     }>, {
         focus(): void;
         blur(): void;
@@ -248,21 +257,21 @@ export declare const PxSelect: {
     __isSuspense?: never;
 } & import('vue').ComponentOptionsBase<Readonly<import('packages/core').SelectProps> & Readonly<{
     onClear?: (() => any) | undefined;
+    onBlur?: (() => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
     onFocus?: (() => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    onChange?: ((value: string) => any) | undefined;
     "onVisible-change"?: ((value: boolean) => any) | undefined;
-    onBlur?: (() => any) | undefined;
 }>, {
     focus(): void;
     blur(): void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     clear: () => any;
+    blur: () => any;
+    change: (value: string) => any;
     focus: () => any;
     "update:modelValue": (value: string) => any;
-    change: (value: string) => any;
     "visible-change": (value: boolean) => any;
-    blur: () => any;
 }, string, {
     options: import('packages/core').SelectOptionProps[];
 }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {