sakana-element 2.2.0 → 2.4.0

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;
+                trigger: "hover" | "click" | "contextmenu";
                 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;
+            trigger: "hover" | "click" | "contextmenu";
             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" | "placement" | "trigger" | "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/Filter/constants.d.ts

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

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

@@ -0,0 +1,59 @@
+export declare const PxFilter: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').FilterProps> & Readonly<{
+        onChange?: ((value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any;
+        "update:modelValue": (value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        multiple: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').FilterProps> & Readonly<{
+        onChange?: ((value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        multiple: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').FilterProps> & Readonly<{
+    onChange?: ((value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any;
+    "update:modelValue": (value: import('packages/core').FilterValueType | import('packages/core').FilterValueType[] | undefined) => any;
+}, string, {
+    disabled: boolean;
+    multiple: 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 PxFilterItem: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').FilterItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').FilterItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').FilterItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, 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;
+    };
+}) & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,38 @@
+import { ComputedRef } from 'vue';
+export type FilterValueType = string | number;
+export type FilterType = 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export interface FilterOptionProps {
+    value: FilterValueType;
+    label: string;
+    disabled?: boolean;
+}
+export interface FilterProps {
+    modelValue?: FilterValueType | FilterValueType[];
+    options?: FilterOptionProps[];
+    name?: string;
+    disabled?: boolean;
+    size?: 'small' | 'large';
+    type?: FilterType;
+    color?: string;
+    multiple?: boolean;
+}
+export interface FilterEmits {
+    (e: 'update:modelValue', value: FilterValueType | FilterValueType[] | undefined): void;
+    (e: 'change', value: FilterValueType | FilterValueType[] | undefined): void;
+}
+export interface FilterItemProps {
+    value: FilterValueType;
+    label?: string;
+    disabled?: boolean;
+}
+export interface FilterContext {
+    modelValue: ComputedRef<FilterValueType | FilterValueType[] | undefined>;
+    disabled: ComputedRef<boolean>;
+    size: ComputedRef<'small' | 'large' | undefined>;
+    type: ComputedRef<FilterType | undefined>;
+    color: ComputedRef<string | undefined>;
+    name: ComputedRef<string | undefined>;
+    multiple: ComputedRef<boolean>;
+    hasSelection: ComputedRef<boolean>;
+    changeEvent(value: FilterValueType | undefined): void;
+}

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/Kbd/constants.d.ts

@@ -0,0 +1,3 @@
+import { KbdKey, KbdKeyInfo } from './types';
+export declare const KBD_KEY_MAP: Record<KbdKey, KbdKeyInfo>;
+export declare const ARROW_KEYS: Set<KbdKey>;

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

@@ -0,0 +1,24 @@
+export declare const PxKbd: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').KbdProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: import('packages/core').KbdSize;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLSpanElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').KbdProps> & Readonly<{}>, {}, {}, {}, {}, {
+        size: import('packages/core').KbdSize;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').KbdProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    size: import('packages/core').KbdSize;
+}, {}, 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/Kbd/types.d.ts

@@ -0,0 +1,10 @@
+export type KbdSize = 'small' | 'default' | 'large';
+export type KbdKey = 'command' | 'shift' | 'ctrl' | 'alt' | 'option' | 'enter' | 'delete' | 'escape' | 'tab' | 'capslock' | 'up' | 'down' | 'left' | 'right' | 'space' | 'win' | 'fn' | 'home' | 'end' | 'pageup' | 'pagedown';
+export interface KbdKeyInfo {
+    label: string;
+    icon?: string;
+}
+export interface KbdProps {
+    size?: KbdSize;
+    keys?: KbdKey[];
+}

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;

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";