sakana-element 2.1.5 → 2.3.0

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

@@ -0,0 +1,58 @@
+export declare const PxFileInput: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').FileInputProps> & Readonly<{
+        onClear?: (() => 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;
+        change: (value: FileList | null) => any;
+        "update:modelValue": (value: FileList | null) => any;
+    }, import('vue').PublicProps, {
+        placeholder: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        inputRef: HTMLInputElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').FileInputProps> & Readonly<{
+        onClear?: (() => 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;
+    }, {}, {}, {}, {
+        placeholder: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').FileInputProps> & Readonly<{
+    onClear?: (() => 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;
+    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 () => {
+    $slots: {
+        trigger?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export * from './types';

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

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+export interface FileInputProps {
+    modelValue?: FileList | null;
+    id?: string;
+    size?: 'large' | 'small';
+    color?: string;
+    ghost?: boolean;
+    disabled?: boolean;
+    accept?: string;
+    multiple?: boolean;
+    placeholder?: string;
+    clearable?: boolean;
+    form?: string;
+}
+export interface FileInputEmits {
+    (e: 'update:modelValue', value: FileList | null): void;
+    (e: 'change', value: FileList | null): void;
+    (e: 'clear'): void;
+}
+export interface FileInputInstance {
+    ref: Ref<HTMLInputElement | undefined>;
+    open(): void;
+    clear(): void;
+}

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

@@ -1,20 +1,30 @@
-import { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
 import { Ref } from 'vue';
-export interface FormItemRule extends RuleItem {
+import { ZodType } from 'zod';
+export interface FormItemRule {
     trigger?: string | string[];
+    schema?: ZodType;
+    required?: boolean;
+    message?: string;
 }
 export type FormRules = Record<string, FormItemRule[]>;
 export type FormValidateResult = Promise<boolean>;
-export type FormValidateCallback = (isValid: boolean, invalidFields?: ValidateFieldsError) => void;
+export type FormValidateCallback = (isValid: boolean, invalidFields?: FormValidateFailure['fields']) => void;
 export type ValidateStatus = 'success' | 'error' | 'init' | 'validating';
-export interface FormValidateFailuer {
-    errors?: ValidateError[];
-    fields: ValidateFieldsError;
+export interface FormValidateFailure {
+    errors: {
+        field: string;
+        message: string;
+    }[];
+    fields: Record<string, {
+        message: string;
+    }[]>;
 }
 export interface FormProps {
-    model: Record<string, any>;
+    model: Record<string, unknown>;
     rules?: FormRules;
     disabled?: boolean;
+    inline?: boolean;
+    statusIcon?: boolean;
     labelWidth?: number | string;
     labelPosition?: 'left' | 'right' | 'top';
     labelSuffix?: string;

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;
-        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-        onChange?: ((value: string) => any) | undefined;
         onBlur?: ((value: FocusEvent) => any) | undefined;
+        onChange?: ((value: string) => any) | undefined;
         onFocus?: ((value: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => 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;
-        "update:modelValue": (value: string) => any;
-        change: (value: string) => any;
         blur: (value: FocusEvent) => any;
+        change: (value: string) => any;
         focus: (value: FocusEvent) => any;
+        "update:modelValue": (value: string) => 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;
-        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-        onChange?: ((value: string) => any) | undefined;
         onBlur?: ((value: FocusEvent) => any) | undefined;
+        onChange?: ((value: string) => any) | undefined;
         onFocus?: ((value: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => 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;
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    onChange?: ((value: string) => any) | undefined;
     onBlur?: ((value: FocusEvent) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
     onFocus?: ((value: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => 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;
-    "update:modelValue": (value: string) => any;
-    change: (value: string) => any;
     blur: (value: FocusEvent) => any;
+    change: (value: string) => any;
     focus: (value: FocusEvent) => any;
+    "update:modelValue": (value: string) => any;
 }, string, {
     type: string;
     autocomplete: string;

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

@@ -0,0 +1,34 @@
+export declare const PxLink: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').LinkProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        click: (event: MouseEvent) => any;
+    }, import('vue').PublicProps, {
+        underline: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLAnchorElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').LinkProps> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        underline: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').LinkProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (event: MouseEvent) => any;
+}, string, {
+    underline: 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/Link/types.d.ts

@@ -0,0 +1,10 @@
+export type LinkType = 'primary' | 'success' | 'info' | 'warning' | 'danger';
+export interface LinkProps {
+    type?: LinkType;
+    underline?: boolean;
+    disabled?: boolean;
+    href?: string;
+    target?: string;
+    color?: string;
+}
+export type LinkEmits = (e: 'click', event: MouseEvent) => void;

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

@@ -1,6 +1,31 @@
 import { App } from 'vue';
 import { vLoading } from './directive';
 import { Loading } from './service';
+export declare const PxLoadingIndicator: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').LoadingIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: import('packages/core').LoadingSize;
+        type: import('packages/core').LoadingType;
+        variant: import('packages/core').LoadingVariant;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLSpanElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').LoadingIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, {
+        size: import('packages/core').LoadingSize;
+        type: import('packages/core').LoadingType;
+        variant: import('packages/core').LoadingVariant;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').LoadingIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    size: import('packages/core').LoadingSize;
+    type: import('packages/core').LoadingType;
+    variant: import('packages/core').LoadingVariant;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
 export declare const PxLoading: {
     name: string;
     install(app: App): void;

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

@@ -17,3 +17,12 @@ export type LoadingOptions = Partial<Omit<LoadingOptionsResolved, 'parent' | 'ta
     zIndex?: number;
     onAfterLeave(): void;
 }>;
+export type LoadingVariant = 'spinner' | 'dots' | 'bars' | 'ring';
+export type LoadingSize = 'xs' | 'sm' | 'md' | 'lg';
+export type LoadingType = 'primary' | 'success' | 'info' | 'warning' | 'danger';
+export interface LoadingIndicatorProps {
+    variant?: LoadingVariant;
+    size?: LoadingSize;
+    type?: LoadingType;
+    color?: 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;
-    onDestory(): void;
+    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;
@@ -41,4 +47,4 @@ export interface MessageCompInstance {
     close(): void;
     bottomOffset: Ref<number>;
 }
-export type CreateMessageProps = Omit<MessageProps, 'onDestory' | 'id' | 'zIndex'>;
+export type CreateMessageProps = Omit<MessageProps, 'onDestroy' | 'id' | 'zIndex'>;

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';
@@ -11,7 +12,7 @@ export type MessageBoxInputData = {
     value: string;
     action: MessageBoxAction;
 };
-export type MessageBoxData = MessageBoxInputData & MessageBoxAction;
+export type MessageBoxData = MessageBoxInputData | MessageBoxAction;
 export interface MessageBoxOptions {
     title?: string;
     message?: string | VNode | (() => VNode);
@@ -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>;
@@ -49,7 +61,7 @@ export interface MessageBoxProps extends MessageBoxOptions {
 }
 export type MessageBoxShortcutMethod = ((message: MessageBoxOptions['message'], title: MessageBoxOptions['title'], options?: MessageBoxOptions) => Promise<MessageBoxData>) & ((message: MessageBoxOptions['message'], options?: MessageBoxOptions) => Promise<MessageBoxData>);
 export interface IErMessageBox {
-    (options: MessageBoxOptions | string | VNode): Promise<any>;
+    (options: MessageBoxOptions | string | VNode): Promise<MessageBoxData>;
     alert: MessageBoxShortcutMethod;
     confirm: MessageBoxShortcutMethod;
     prompt: MessageBoxShortcutMethod;

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

@@ -1,2 +1,2 @@
-export declare const PxNotification: Notification & import('vue').Plugin;
+export declare const PxNotification: import('packages/core').Notification & import('vue').Plugin;
 export * from './types';

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

@@ -1,13 +1,18 @@
-import { NotificationFn, NotificationProps, NotificationType } from './types';
+import { Notification, NotificationFn, NotificationProps, NotificationType } from './types';
 export declare const notificationDefaults: {
+    readonly title: "";
     readonly type: "info";
     readonly duration: 3000;
     readonly offset: 20;
+    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,9 +15,12 @@ export interface NotificationProps {
     offset?: number;
     transitionName?: string;
     icon?: string;
+    plain?: boolean;
+    ghost?: boolean;
+    showTimer?: boolean;
     onClick?(): void;
     onClose?(): void;
-    onDestory(): void;
+    onDestroy(): void;
 }
 export interface NotificationInstance {
     id: string;
@@ -30,11 +33,13 @@ export interface NotificationCompInstance {
     close(): void;
     bottomOffset: Ref<number>;
 }
-export type CreateNotificationProps = Omit<NotificationProps, 'onDestory' | 'id' | 'zIndex'>;
+export type CreateNotificationProps = Omit<NotificationProps, 'onDestroy' | 'id' | 'zIndex'>;
 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;
+}