sakana-element 2.2.0 → 2.4.0

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;
+                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)[];
@@ -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;
+            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;
@@ -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 () => {

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

@@ -0,0 +1,36 @@
+export declare const PxSkeleton: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').SkeletonProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        loading: boolean;
+        animation: import('packages/core').SkeletonAnimation;
+        variant: import('packages/core').SkeletonVariant;
+        animated: boolean;
+        rows: number;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').SkeletonProps> & Readonly<{}>, {}, {}, {}, {}, {
+        loading: boolean;
+        animation: import('packages/core').SkeletonAnimation;
+        variant: import('packages/core').SkeletonVariant;
+        animated: boolean;
+        rows: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').SkeletonProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    loading: boolean;
+    animation: import('packages/core').SkeletonAnimation;
+    variant: import('packages/core').SkeletonVariant;
+    animated: boolean;
+    rows: 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;
+    };
+}) & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,12 @@
+export type SkeletonVariant = 'text' | 'circular' | 'rectangular' | 'rounded';
+export type SkeletonAnimation = 'shimmer' | 'pulse' | 'dither';
+export interface SkeletonProps {
+    loading?: boolean;
+    animated?: boolean;
+    animation?: SkeletonAnimation;
+    variant?: SkeletonVariant;
+    width?: string | number;
+    height?: string | number;
+    rows?: number;
+    size?: 'large' | 'default' | 'small';
+}

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

@@ -1,13 +1,13 @@
 export declare const PxSwitch: {
     new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').SwitchProps> & Readonly<{
-        "onUpdate:modelValue"?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
         onChange?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
     }>, {
         focus(): void;
         checked: import('vue').ComputedRef<boolean>;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-        "update:modelValue": (value: import('packages/core').SwitchValueType) => any;
         change: (value: import('packages/core').SwitchValueType) => any;
+        "update:modelValue": (value: import('packages/core').SwitchValueType) => any;
     }, import('vue').PublicProps, {
         activeValue: import('packages/core').SwitchValueType;
         inactiveValue: import('packages/core').SwitchValueType;
@@ -21,8 +21,8 @@ export declare const PxSwitch: {
         M: {};
         Defaults: {};
     }, Readonly<import('packages/core').SwitchProps> & Readonly<{
-        "onUpdate:modelValue"?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
         onChange?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
     }>, {
         focus(): void;
         checked: import('vue').ComputedRef<boolean>;
@@ -34,14 +34,14 @@ export declare const PxSwitch: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import('vue').ComponentOptionsBase<Readonly<import('packages/core').SwitchProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
     onChange?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('packages/core').SwitchValueType) => any) | undefined;
 }>, {
     focus(): void;
     checked: import('vue').ComputedRef<boolean>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    "update:modelValue": (value: import('packages/core').SwitchValueType) => any;
     change: (value: import('packages/core').SwitchValueType) => any;
+    "update:modelValue": (value: import('packages/core').SwitchValueType) => any;
 }, string, {
     activeValue: import('packages/core').SwitchValueType;
     inactiveValue: import('packages/core').SwitchValueType;

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

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

@@ -0,0 +1,20 @@
+export declare const tableSize: readonly ["xs", "sm", "md", "lg", "xl"];
+export type TableSize = (typeof tableSize)[number];
+export type TableType = 'primary' | 'success' | 'info' | 'warning' | 'danger';
+export interface TableProps {
+    type?: TableType;
+    zebra?: boolean;
+    hover?: boolean;
+    border?: boolean;
+    stripe?: boolean;
+    pinRows?: boolean;
+    pinCols?: boolean;
+    size?: TableSize;
+    showHeader?: boolean;
+    outline?: boolean;
+    ghost?: boolean;
+    hoverable?: boolean;
+}
+export interface TableInstance {
+    ref: HTMLDivElement;
+}

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

@@ -10,11 +10,13 @@ export declare const PxTooltip: {
         "visible-change": (value: boolean) => any;
         "click-outside": () => any;
     }, import('vue').PublicProps, {
+        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;
     }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         containerNode: HTMLDivElement;
         _triggerNode: HTMLDivElement;
@@ -34,11 +36,13 @@ export declare const PxTooltip: {
         hide(): void;
         toggle(): void;
     }, {}, {}, {}, {
+        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;
     }>;
     __isFragment?: never;
     __isTeleport?: never;
@@ -54,11 +58,13 @@ export declare const PxTooltip: {
     "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> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
     $slots: {
         default?(_: {}): any;

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

@@ -1,4 +1,6 @@
 import { Options, Placement } from '@popperjs/core';
+export type TooltipEffect = 'dark' | 'light';
+export type TooltipType = 'primary' | 'success' | 'warning' | 'danger' | 'info';
 export interface TooltipProps {
     content?: string;
     trigger?: 'hover' | 'click' | 'contextmenu';
@@ -11,6 +13,11 @@ export interface TooltipProps {
     hideTimeout?: number;
     virtualRef?: HTMLElement | undefined;
     virtualTriggering?: boolean;
+    effect?: TooltipEffect;
+    type?: TooltipType;
+    enterable?: boolean;
+    maxWidth?: string | number;
+    showArrow?: boolean;
 }
 export interface TooltipEmits {
     (e: 'visible-change', value: boolean): void;

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

@@ -0,0 +1,52 @@
+export declare const PxValidator: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').ValidatorProps> & Readonly<{
+        onValidate?: ((isValid: boolean, message: string) => any) | undefined;
+    }>, {
+        validate(trigger?: string): Promise<boolean>;
+        reset(): void;
+        validateStatus: import('vue').Ref<import('packages/core').ValidateStatus>;
+        validateMessage: import('vue').Ref<string>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        validate: (isValid: boolean, message: string) => any;
+    }, import('vue').PublicProps, {
+        rules: import('packages/core').FormItemRule[];
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').ValidatorProps> & Readonly<{
+        onValidate?: ((isValid: boolean, message: string) => any) | undefined;
+    }>, {
+        validate(trigger?: string): Promise<boolean>;
+        reset(): void;
+        validateStatus: import('vue').Ref<import('packages/core').ValidateStatus>;
+        validateMessage: import('vue').Ref<string>;
+    }, {}, {}, {}, {
+        rules: import('packages/core').FormItemRule[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').ValidatorProps> & Readonly<{
+    onValidate?: ((isValid: boolean, message: string) => any) | undefined;
+}>, {
+    validate(trigger?: string): Promise<boolean>;
+    reset(): void;
+    validateStatus: import('vue').Ref<import('packages/core').ValidateStatus>;
+    validateMessage: import('vue').Ref<string>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    validate: (isValid: boolean, message: string) => any;
+}, string, {
+    rules: import('packages/core').FormItemRule[];
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        hint?(_: {
+            message: string;
+        }): any;
+    };
+}) & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { FormItemRule, ValidateStatus } from '../Form/types';
+export interface ValidatorProps {
+    modelValue?: unknown;
+    rules?: FormItemRule[];
+}
+export type ValidatorEmits = (e: 'validate', isValid: boolean, message: string) => void;
+export interface ValidatorInstance {
+    validate(trigger?: string): Promise<boolean>;
+    reset(): void;
+    validateStatus: Ref<ValidateStatus>;
+    validateMessage: Ref<string>;
+}

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

@@ -4,19 +4,34 @@ export * from './Badge';
 export * from './Breadcrumb';
 export * from './Button';
 export * from './Card';
+export * from './ChatBubble';
+export * from './Checkbox';
 export * from './Collapse';
 export * from './ConfigProvider';
+export * from './Diff';
+export * from './Divider';
+export * from './Drawer';
 export * from './Dropdown';
 export * from './FileInput';
+export * from './Filter';
 export * from './Form';
 export * from './Icon';
+export * from './Indicator';
 export * from './Input';
+export * from './Kbd';
 export * from './Link';
 export * from './Loading';
 export * from './Message';
 export * from './MessageBox';
 export * from './Notification';
+export * from './Pixelate';
 export * from './Popconfirm';
+export * from './Progress';
+export * from './Radio';
+export * from './Resizable';
 export * from './Select';
+export * from './Skeleton';
 export * from './Switch';
+export * from './Table';
 export * from './Tooltip';
+export * from './Validator';

package/dist/types/hooks/index.d.ts

@@ -1,11 +1,13 @@
 import { default as useClickOutside } from './useClickOutside';
 import { default as useDisabledStyle } from './useDisabledStyle';
+import { default as useDraggable } from './useDraggable';
 import { default as useEventListener } from './useEventListener';
 import { default as useFocusController } from './useFocusController';
+import { default as useFocusTrap } from './useFocusTrap';
 import { default as useId } from './useId';
 import { default as useLocale } from './useLocale';
 import { default as useOffset } from './useOffset';
 import { default as useZIndex } from './useZIndex';
 export { useSystemTheme } from './useSystemTheme';
 export { type Theme, useTheme } from './useTheme';
-export { useClickOutside, useEventListener, useDisabledStyle, useFocusController, useLocale, useOffset, useZIndex, useId, };
+export { useClickOutside, useDraggable, useEventListener, useDisabledStyle, useFocusController, useFocusTrap, useLocale, useOffset, useZIndex, useId, };

package/dist/types/hooks/useDraggable.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+export interface UseDraggableOptions {
+    constrainToViewport?: boolean;
+}
+export default function useDraggable(targetRef: Ref<HTMLElement | undefined>, handleRef: Ref<HTMLElement | undefined>, options?: UseDraggableOptions): {
+    reset: () => void;
+};

package/dist/types/hooks/useFocusTrap.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+export default function useFocusTrap(containerRef: Ref<HTMLElement | undefined>): {
+    activate: () => void;
+    deactivate: () => void;
+};

package/dist/types/utils/index.d.ts

@@ -15,6 +15,8 @@ export * from './error';
 export * from './icon-map';
 export * from './icon-registry';
 export * from './install';
+export * from './instance-management';
+export * from './pixelate';
 export * from './sanitize-svg';
 export * from './style';
 export * from './test';

package/dist/types/utils/instance-management.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared utilities for imperative component instance management
+ * (used by Message and Notification methods.ts).
+ */
+interface Destroyable {
+    props: {
+        onDestroy(): void;
+    };
+}
+interface Closeable {
+    handler: {
+        close(): void;
+    };
+}
+/**
+ * Forcefully unmount all instances in a flat array, bypassing CSS transitions.
+ */
+export declare function destroyAllInstances(instances: Destroyable[]): void;
+/**
+ * Forcefully unmount all instances across a Map of position-keyed arrays.
+ */
+export declare function destroyAllInstancesMap(instancesMap: Map<string, Destroyable[]>): void;
+/**
+ * Destroy oldest instances that exceed the maximum count.
+ */
+export declare function enforceMaxCount(instances: Destroyable[], max: number): void;
+/**
+ * Create a lazy global Escape key listener that is only active when
+ * at least one instance exists. Call `register()` when an instance is
+ * created and `unregister()` when an instance is destroyed.
+ *
+ * @param getLatestCloseable - returns the instance to close on Escape, or undefined
+ */
+export declare function createLazyEscapeClose(getLatestCloseable: () => Closeable | undefined): {
+    /** Call when an instance is created. */
+    register(): void;
+    /** Call when an instance is destroyed. */
+    unregister(): void;
+};
+export {};

package/dist/types/utils/pixelate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared pixelation utilities used by PxPixelate and PxDiff.
+ */
+export interface PixelateCanvasOptions {
+    pixelSize: number;
+    grayscale?: boolean;
+    palette?: string[] | number[][];
+    background?: string;
+}
+export declare function pixelateCanvas(canvas: HTMLCanvasElement, img: HTMLImageElement, options: PixelateCanvasOptions): void;

package/dist/types/utils/style.d.ts

@@ -1 +1,2 @@
 export declare function addUnit(val?: string | number, defaultUnit?: string): string | undefined;
+export declare function clamp(value: number, min: number, max: number): number;