sakana-element 2.2.0 → 2.3.0

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

@@ -1,10 +1,8 @@
 export type AvatarSize = 'large' | 'default' | 'small';
 export type AvatarShape = 'circle' | 'square';
-export type AvatarStatus = 'online' | 'offline';
 export interface AvatarProps {
     size?: AvatarSize;
     shape?: AvatarShape;
     border?: boolean;
     color?: string;
-    status?: AvatarStatus;
 }

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

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

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

@@ -0,0 +1,94 @@
+export declare const PxCheckbox: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').CheckboxProps> & Readonly<{
+        onChange?: ((value: boolean) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {
+        focus(): void;
+        checked: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: boolean) => any;
+        "update:modelValue": (value: boolean) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        modelValue: boolean;
+        indeterminate: 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').CheckboxProps> & Readonly<{
+        onChange?: ((value: boolean) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {
+        focus(): void;
+        checked: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        modelValue: boolean;
+        indeterminate: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').CheckboxProps> & Readonly<{
+    onChange?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    focus(): void;
+    checked: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: boolean) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, {
+    disabled: boolean;
+    modelValue: boolean;
+    indeterminate: 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 PxCheckboxGroup: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').CheckboxGroupProps> & Readonly<{
+        onChange?: ((value: import('packages/core').CheckboxValueType[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').CheckboxValueType[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('packages/core').CheckboxValueType[]) => any;
+        "update:modelValue": (value: import('packages/core').CheckboxValueType[]) => 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').CheckboxGroupProps> & Readonly<{
+        onChange?: ((value: import('packages/core').CheckboxValueType[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').CheckboxValueType[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').CheckboxGroupProps> & Readonly<{
+    onChange?: ((value: import('packages/core').CheckboxValueType[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('packages/core').CheckboxValueType[]) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('packages/core').CheckboxValueType[]) => any;
+    "update:modelValue": (value: import('packages/core').CheckboxValueType[]) => 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/Checkbox/types.d.ts

@@ -0,0 +1,46 @@
+import { ComputedRef } from 'vue';
+export type CheckboxValueType = string | number | boolean;
+export type CheckboxType = 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export interface CheckboxProps {
+    modelValue?: boolean;
+    value?: CheckboxValueType;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    size?: 'small' | 'large';
+    type?: CheckboxType;
+    color?: string;
+    label?: string;
+    name?: string;
+    id?: string;
+}
+export interface CheckboxEmits {
+    (e: 'update:modelValue', value: boolean): void;
+    (e: 'change', value: boolean): void;
+}
+export interface CheckboxInstance {
+    focus(): void;
+    checked: ComputedRef<boolean>;
+}
+export interface CheckboxGroupProps {
+    modelValue: CheckboxValueType[];
+    disabled?: boolean;
+    size?: 'small' | 'large';
+    type?: CheckboxType;
+    color?: string;
+    min?: number;
+    max?: number;
+}
+export interface CheckboxGroupEmits {
+    (e: 'update:modelValue', value: CheckboxValueType[]): void;
+    (e: 'change', value: CheckboxValueType[]): void;
+}
+export interface CheckboxGroupContext {
+    modelValue: ComputedRef<CheckboxValueType[]>;
+    disabled: ComputedRef<boolean>;
+    size: ComputedRef<'small' | 'large' | undefined>;
+    type: ComputedRef<CheckboxType | undefined>;
+    color: ComputedRef<string | undefined>;
+    min: ComputedRef<number | undefined>;
+    max: ComputedRef<number | undefined>;
+    changeEvent(value: CheckboxValueType[]): void;
+}

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

@@ -1,10 +1,10 @@
 export declare const PxCollapse: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').CollapseProps> & Readonly<{
-        "onUpdate:modelValue"?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
         onChange?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
     }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-        "update:modelValue": (value: import('packages/core').CollapseItemName[]) => any;
         change: (value: import('packages/core').CollapseItemName[]) => any;
+        "update:modelValue": (value: import('packages/core').CollapseItemName[]) => any;
     }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
         P: {};
         B: {};
@@ -13,18 +13,18 @@ export declare const PxCollapse: {
         M: {};
         Defaults: {};
     }, Readonly<import('packages/core').CollapseProps> & Readonly<{
-        "onUpdate:modelValue"?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
         onChange?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
     }>, {}, {}, {}, {}, {}>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
 } & import('vue').ComponentOptionsBase<Readonly<import('packages/core').CollapseProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
     onChange?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('packages/core').CollapseItemName[]) => any) | undefined;
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    "update:modelValue": (value: import('packages/core').CollapseItemName[]) => any;
     change: (value: import('packages/core').CollapseItemName[]) => any;
+    "update:modelValue": (value: import('packages/core').CollapseItemName[]) => any;
 }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
     $slots: {
         default?(_: {}): any;

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

@@ -0,0 +1,30 @@
+export declare const PxDivider: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').DividerProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        direction: "horizontal" | "vertical";
+        contentPosition: "left" | "center" | "right";
+        borderStyle: import('packages/core').DividerBorderStyle;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').DividerProps> & Readonly<{}>, {}, {}, {}, {}, {
+        direction: "horizontal" | "vertical";
+        contentPosition: "left" | "center" | "right";
+        borderStyle: import('packages/core').DividerBorderStyle;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').DividerProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    direction: "horizontal" | "vertical";
+    contentPosition: "left" | "center" | "right";
+    borderStyle: import('packages/core').DividerBorderStyle;
+}, {}, 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/Divider/types.d.ts

@@ -0,0 +1,10 @@
+export type DividerType = 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export type DividerBorderStyle = 'solid' | 'dashed' | 'dotted';
+export interface DividerProps {
+    direction?: 'horizontal' | 'vertical';
+    contentPosition?: 'left' | 'center' | 'right';
+    type?: DividerType;
+    color?: string;
+    borderStyle?: DividerBorderStyle;
+    content?: string;
+}

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

@@ -0,0 +1 @@
+export declare const DRAWER_DEFAULT_SIZE = "300px";

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

@@ -0,0 +1,72 @@
+export declare const PxDrawer: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').DrawerProps> & Readonly<{
+        onClose?: (() => any) | undefined;
+        onOpen?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {
+        open(): void;
+        close(): void;
+        toggle(): void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        close: () => any;
+        open: () => any;
+        "update:modelValue": (value: boolean) => any;
+    }, import('vue').PublicProps, {
+        size: string;
+        placement: "left" | "right";
+        showOverlay: boolean;
+        lockScroll: boolean;
+        closeOnClickOverlay: boolean;
+        closeOnEsc: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').DrawerProps> & Readonly<{
+        onClose?: (() => any) | undefined;
+        onOpen?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {
+        open(): void;
+        close(): void;
+        toggle(): void;
+    }, {}, {}, {}, {
+        size: string;
+        placement: "left" | "right";
+        showOverlay: boolean;
+        lockScroll: boolean;
+        closeOnClickOverlay: boolean;
+        closeOnEsc: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').DrawerProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    open(): void;
+    close(): void;
+    toggle(): void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    close: () => any;
+    open: () => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, {
+    size: string;
+    placement: "left" | "right";
+    showOverlay: boolean;
+    lockScroll: boolean;
+    closeOnClickOverlay: boolean;
+    closeOnEsc: 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;
+        sidebar?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,20 @@
+export interface DrawerProps {
+    modelValue: boolean;
+    placement?: 'left' | 'right';
+    size?: string;
+    showOverlay?: boolean;
+    lockScroll?: boolean;
+    closeOnClickOverlay?: boolean;
+    closeOnEsc?: boolean;
+    title?: string;
+}
+export interface DrawerEmits {
+    (e: 'update:modelValue', value: boolean): void;
+    (e: 'open'): void;
+    (e: 'close'): void;
+}
+export interface DrawerInstance {
+    open(): void;
+    close(): void;
+    toggle(): void;
+}

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

@@ -30,6 +30,11 @@ export declare const PxDropdown: {
                 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;
@@ -62,11 +67,13 @@ export declare const PxDropdown: {
                 "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)[];
@@ -88,15 +95,17 @@ export declare const PxDropdown: {
             $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;
@@ -107,6 +116,7 @@ export declare const PxDropdown: {
                 content?(_: {}): any;
             };
         }) | null;
+        menuRef: HTMLDivElement;
     }, any, import('vue').ComponentProvideOptions, {
         P: {};
         B: {};

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

@@ -7,6 +7,7 @@ export interface DropdownItemProps {
     label: string | VNode;
     disabled?: boolean;
     divided?: boolean;
+    icon?: string;
 }
 export interface DropdownProps extends TooltipProps {
     type?: ButtonType;
@@ -14,6 +15,8 @@ export interface DropdownProps extends TooltipProps {
     items?: DropdownItemProps[];
     hideOnClick?: boolean;
     splitButton?: boolean;
+    maxHeight?: number | string;
+    hoverColor?: string;
 }
 export interface DropdownEmits {
     (e: 'visible-change', value: boolean): void;

package/dist/types/components/Dropdown/useDropdownKeyboard.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+export interface UseDropdownKeyboardOptions {
+    menuRef: Ref<HTMLElement | undefined>;
+    triggerRef: Ref<HTMLElement | undefined>;
+    isOpen: Ref<boolean>;
+    close: () => void;
+}
+export default function useDropdownKeyboard(options: UseDropdownKeyboardOptions): void;

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

@@ -1,16 +1,16 @@
 export declare const PxFileInput: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').FileInputProps> & Readonly<{
         onClear?: (() => any) | undefined;
-        "onUpdate:modelValue"?: ((value: FileList | null) => any) | undefined;
         onChange?: ((value: FileList | null) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: FileList | null) => any) | undefined;
     }>, {
         ref: import('vue').Ref<HTMLInputElement | undefined>;
         open(): void;
         clear(): void;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
         clear: () => any;
-        "update:modelValue": (value: FileList | null) => any;
         change: (value: FileList | null) => any;
+        "update:modelValue": (value: FileList | null) => any;
     }, import('vue').PublicProps, {
         placeholder: string;
     }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
@@ -24,8 +24,8 @@ export declare const PxFileInput: {
         Defaults: {};
     }, Readonly<import('packages/core').FileInputProps> & Readonly<{
         onClear?: (() => any) | undefined;
-        "onUpdate:modelValue"?: ((value: FileList | null) => any) | undefined;
         onChange?: ((value: FileList | null) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: FileList | null) => any) | undefined;
     }>, {
         ref: import('vue').Ref<HTMLInputElement | undefined>;
         open(): void;
@@ -38,16 +38,16 @@ export declare const PxFileInput: {
     __isSuspense?: never;
 } & import('vue').ComponentOptionsBase<Readonly<import('packages/core').FileInputProps> & Readonly<{
     onClear?: (() => any) | undefined;
-    "onUpdate:modelValue"?: ((value: FileList | null) => any) | undefined;
     onChange?: ((value: FileList | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: FileList | null) => any) | undefined;
 }>, {
     ref: import('vue').Ref<HTMLInputElement | undefined>;
     open(): void;
     clear(): void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     clear: () => any;
-    "update:modelValue": (value: FileList | null) => any;
     change: (value: FileList | null) => any;
+    "update:modelValue": (value: FileList | null) => any;
 }, string, {
     placeholder: string;
 }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {

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

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

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

@@ -0,0 +1,28 @@
+export declare const PxIndicator: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').IndicatorProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        type: import('packages/core').IndicatorType;
+        placement: import('packages/core').IndicatorPlacement;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').IndicatorProps> & Readonly<{}>, {}, {}, {}, {}, {
+        type: import('packages/core').IndicatorType;
+        placement: import('packages/core').IndicatorPlacement;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').IndicatorProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    type: import('packages/core').IndicatorType;
+    placement: import('packages/core').IndicatorPlacement;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        indicator?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,10 @@
+export type IndicatorPlacement = 'top-start' | 'top-center' | 'top-end' | 'middle-start' | 'middle-center' | 'middle-end' | 'bottom-start' | 'bottom-center' | 'bottom-end';
+export type IndicatorType = 'primary' | 'success' | 'info' | 'warning' | 'danger';
+export interface IndicatorProps {
+    placement?: IndicatorPlacement;
+    type?: IndicatorType;
+    color?: string;
+    offset?: [number, number];
+    inline?: boolean;
+    processing?: boolean;
+}

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

@@ -2,10 +2,10 @@ export declare const PxInput: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<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>;
@@ -15,10 +15,10 @@ export declare const PxInput: {
     }, {}, {}, {}, 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;
     }, import('vue').PublicProps, {
         type: string;
         autocomplete: string;
@@ -36,10 +36,10 @@ export declare const PxInput: {
     }, 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>;
@@ -56,10 +56,10 @@ export declare const PxInput: {
 } & 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>;
@@ -69,10 +69,10 @@ export declare const PxInput: {
 }, {}, {}, {}, 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;

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

@@ -8,5 +8,7 @@ export declare const messageDefaults: {
 export declare function getLastBottomOffset(this: MessageProps): any;
 export declare const message: MessageFn & Partial<Message>;
 export declare function closeAll(type?: MessageType): void;
+/** Forcefully unmount all message instances, bypassing CSS transitions. */
+export declare function destroyAll(): void;
 declare const _default: Message;
 export default _default;

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

@@ -26,9 +26,15 @@ export interface MessageProps {
     offset?: number;
     zIndex: number;
     transitionName?: string;
+    plain?: boolean;
+    ghost?: boolean;
+    icon?: string;
+    showTimer?: boolean;
     onDestroy(): void;
 }
-export type MessageOptions = Partial<Omit<MessageProps, 'id'>>;
+export type MessageOptions = Partial<Omit<MessageProps, 'id'>> & {
+    max?: number;
+};
 export type MessageParams = string | VNode | MessageOptions;
 export interface MessageInstance {
     id: string;

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

@@ -1,4 +1,5 @@
-import { Ref, VNode } from 'vue';
+import { CSSProperties, Ref, VNode } from 'vue';
+import { ZodType } from 'zod';
 import { ButtonType } from '../Button/types';
 import { MessageType } from '../Message/types';
 export type MessageBoxAction = 'confirm' | 'cancel' | 'close';
@@ -39,7 +40,18 @@ export interface MessageBoxOptions {
     inputValue?: string;
     inputType?: 'text' | 'textarea' | 'password' | 'number';
     buttonSize?: 'default' | 'small' | 'large';
-    beforeClose?: (action: MessageBoxAction, instance: MessageBoxOptions, done: () => void) => void;
+    beforeClose?: (action: MessageBoxAction, instance: MessageBoxOptions, done: () => void) => void | Promise<void>;
+    customClass?: string;
+    customStyle?: CSSProperties;
+    width?: string | number;
+    closeOnPressEscape?: boolean;
+    inputSchema?: ZodType;
+    inputErrorMessage?: string;
+    distinguishCancelAndClose?: boolean;
+    overlayClass?: string | string[] | Record<string, boolean>;
+    closeOnHashChange?: boolean;
+    draggable?: boolean;
+    footer?: VNode | (() => VNode);
 }
 export interface MessageBoxProps extends MessageBoxOptions {
     visible?: Ref<boolean>;

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

@@ -7,9 +7,12 @@ export declare const notificationDefaults: {
     readonly position: "top-right";
     readonly transitionName: "fade";
     readonly showClose: true;
+    readonly showTimer: true;
 };
 export declare const notification: NotificationFn & Partial<Notification>;
 export declare function closeAll(type?: NotificationType): void;
+/** Forcefully unmount all notification instances, bypassing CSS transitions. */
+export declare function destroyAll(): void;
 export declare function getLastBottomOffset(this: NotificationProps): any;
 declare const _default: Notification;
 export default _default;