sakana-element 2.1.5 → 2.3.0

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

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

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

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

@@ -7,4 +7,5 @@ export interface BadgeProps {
     dash?: boolean;
     color?: string;
     round?: boolean;
+    icon?: string;
 }

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

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { BreadcrumbContext } from './types';
+export declare const BREADCRUMB_CTX_KEY: InjectionKey<BreadcrumbContext>;

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

@@ -0,0 +1,45 @@
+export declare const PxBreadcrumb: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').BreadcrumbProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        separator: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').BreadcrumbProps> & Readonly<{}>, {}, {}, {}, {}, {
+        separator: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').BreadcrumbProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    separator: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<{
+        default?(_: {}): any;
+        separator?(_: {}): any;
+    }> & {
+        default?(_: {}): any;
+        separator?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export declare const PxBreadcrumbItem: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').BreadcrumbItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLLIElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('packages/core').BreadcrumbItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').BreadcrumbItemProps> & 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/Breadcrumb/types.d.ts

@@ -0,0 +1,13 @@
+import { Slot } from 'vue';
+export interface BreadcrumbProps {
+    separator?: string;
+}
+export interface BreadcrumbItemProps {
+    to?: string;
+    icon?: string;
+    disabled?: boolean;
+}
+export interface BreadcrumbContext {
+    separator: string;
+    separatorSlot?: Slot;
+}

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

@@ -1,6 +1,12 @@
+export type CardType = 'primary' | 'success' | 'info' | 'warning' | 'danger';
 export type CardShadow = 'always' | 'hover' | 'never';
 export interface CardProps {
+    type?: CardType;
+    color?: string;
     hoverable?: boolean;
     shadow?: boolean | CardShadow;
     size?: 'small' | 'large';
+    outline?: boolean;
+    dash?: boolean;
+    ghost?: boolean;
 }

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

@@ -1,3 +1,6 @@
+import { ColorTemplate } from '@sakana-element/utils';
 import { InjectionKey } from 'vue';
 import { CollapseContext } from './types';
 export declare const COLLAPSE_CTX_KEY: InjectionKey<CollapseContext>;
+export declare const PRESET_COLLAPSE_COLORS: Set<string>;
+export declare const COLLAPSE_COLOR_TEMPLATES: Record<string, ColorTemplate>;

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,36 +13,42 @@ 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;
     };
 }) & import('vue').Plugin;
 export declare const PxCollapseItem: {
-    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').CollapseItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('packages/core').CollapseItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        showArrow: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('packages/core').CollapseItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    }, Readonly<import('packages/core').CollapseItemProps> & Readonly<{}>, {}, {}, {}, {}, {
+        showArrow: boolean;
+    }>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').CollapseItemProps> & 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 () => {
+} & import('vue').ComponentOptionsBase<Readonly<import('packages/core').CollapseItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    showArrow: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
     $slots: {
         title?(_: {}): any;
         default?(_: {}): any;

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

@@ -3,11 +3,19 @@ export type CollapseItemName = string | number;
 export interface CollapseProps {
     modelValue: CollapseItemName[];
     accordion?: boolean;
+    color?: string;
+    ghost?: boolean;
+    trigger?: 'click' | 'focus';
+    iconPlacement?: 'start' | 'end';
 }
 export interface CollapseItemProps {
     name: CollapseItemName;
     title?: string;
     disabled?: boolean;
+    showArrow?: boolean;
+    icon?: string;
+    forceOpen?: boolean;
+    forceClose?: boolean;
 }
 export interface CollapseEmits {
     (e: 'update:modelValue', value: CollapseItemName[]): void;
@@ -16,4 +24,8 @@ export interface CollapseEmits {
 export interface CollapseContext {
     activeNames: Ref<CollapseItemName[]>;
     handleItemClick(name: CollapseItemName): void;
+    color?: string;
+    ghost?: boolean;
+    trigger?: 'click' | 'focus';
+    iconPlacement?: 'start' | 'end';
 }

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

@@ -0,0 +1,3 @@
+import { ColorTemplate } from '@sakana-element/utils';
+export declare const PRESET_FILE_INPUT_COLORS: Set<string>;
+export declare const FILE_INPUT_COLOR_TEMPLATES: Record<string, ColorTemplate>;