@sdata/web-vue 4.5.1 → 4.5.2

package/es/_components/{icon-hover.vue.d.ts → icon-hover.vue.d.vue.ts}

@@ -33,7 +33,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
 }>> & Readonly<{
     onClick?: ((_e: MouseEvent) => any) | undefined;
 }>, {
-    size: "small" | "medium" | "large" | "mini";
+    size: "large" | "medium" | "mini" | "small";
     disabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/es/_components/input-label/{input-label.vue.d.ts → input-label.vue.d.vue.ts}

@@ -25,29 +25,31 @@ type __VLS_Slots = {
     prefix?: () => VNode[];
     suffix?: () => VNode[];
 };
+declare const focus: () => void | undefined;
+declare const blur: () => void | undefined;
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     inputRef: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
-    focus: () => void | undefined;
-    blur: () => void | undefined;
+    focus: typeof focus;
+    blur: typeof blur;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    focus: (event: FocusEvent) => any;
     blur: (event: FocusEvent) => any;
-    "update:inputValue": (value: string) => any;
+    focus: (event: FocusEvent) => any;
     inputValueChange: (value: string, event: Event) => any;
+    "update:inputValue": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onFocus?: ((event: FocusEvent) => any) | undefined;
     onBlur?: ((event: FocusEvent) => any) | undefined;
-    "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
     onInputValueChange?: ((value: string, event: Event) => any) | undefined;
+    "onUpdate:inputValue"?: ((value: string) => any) | undefined;
 }>, {
+    inputValue: string;
+    enabledInput: boolean;
+    retainInputValue: boolean;
     disabled: boolean;
     error: boolean;
+    uninjectFormItemContext: boolean;
     fitWidth: boolean;
     maxWFull: boolean;
-    inputValue: string;
-    uninjectFormItemContext: boolean;
-    retainInputValue: boolean;
-    enabledInput: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/es/_components/picker/{input-range.vue.d.ts → input-range.vue.d.vue.ts}

@@ -12,7 +12,7 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     size: {
-        type: PropType<"mini" | "small" | "medium" | "large">;
+        type: PropType<'mini' | 'small' | 'medium' | 'large'>;
     };
     focused: {
         type: BooleanConstructor;
@@ -28,7 +28,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: boolean;
     };
     readonly: {
-        type: (StringConstructor | BooleanConstructor)[];
+        type: (BooleanConstructor | StringConstructor)[];
     };
     allowClear: {
         type: BooleanConstructor;
@@ -62,14 +62,14 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     focus: typeof focus;
     blur: typeof blur;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    clear: (_e: Event) => any;
     change: (_e: Event) => any;
-    "press-enter": () => any;
+    clear: (_e: Event) => any;
     "focused-index-change": (_index: number) => any;
+    "press-enter": () => any;
     "update:focusedIndex": (_index: number) => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     size: {
-        type: PropType<"mini" | "small" | "medium" | "large">;
+        type: PropType<'mini' | 'small' | 'medium' | 'large'>;
     };
     focused: {
         type: BooleanConstructor;
@@ -85,7 +85,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: boolean;
     };
     readonly: {
-        type: (StringConstructor | BooleanConstructor)[];
+        type: (BooleanConstructor | StringConstructor)[];
     };
     allowClear: {
         type: BooleanConstructor;
@@ -116,21 +116,21 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
 }>> & Readonly<{
-    onClear?: ((_e: Event) => any) | undefined;
     onChange?: ((_e: Event) => any) | undefined;
-    "onPress-enter"?: (() => any) | undefined;
+    onClear?: ((_e: Event) => any) | undefined;
     "onFocused-index-change"?: ((_index: number) => any) | undefined;
+    "onPress-enter"?: (() => any) | undefined;
     "onUpdate:focusedIndex"?: ((_index: number) => any) | undefined;
 }>, {
-    value: (Dayjs | undefined)[];
-    disabled: boolean | boolean[];
+    focused: boolean;
     error: boolean;
-    placeholder: string[];
+    disabled: boolean | boolean[];
     allowClear: boolean;
+    placeholder: string[];
     fitWidth: boolean;
     maxWFull: boolean;
     fitWidthFallback: string;
-    focused: boolean;
+    value: (Dayjs | undefined)[];
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/es/_components/picker/{input.vue.d.ts → input.vue.d.vue.ts}

@@ -10,7 +10,7 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     size: {
-        type: PropType<"mini" | "small" | "medium" | "large">;
+        type: PropType<'mini' | 'small' | 'medium' | 'large'>;
     };
     focused: {
         type: BooleanConstructor;
@@ -19,7 +19,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: BooleanConstructor;
     };
     readonly: {
-        type: (StringConstructor | BooleanConstructor)[];
+        type: (BooleanConstructor | StringConstructor)[];
     };
     error: {
         type: BooleanConstructor;
@@ -54,13 +54,13 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     focus: typeof focus;
     blur: typeof blur;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    clear: (_e: Event) => any;
     blur: (_e: Event) => any;
     change: (_e: Event) => any;
+    clear: (_e: Event) => any;
     "press-enter": () => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     size: {
-        type: PropType<"mini" | "small" | "medium" | "large">;
+        type: PropType<'mini' | 'small' | 'medium' | 'large'>;
     };
     focused: {
         type: BooleanConstructor;
@@ -69,7 +69,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: BooleanConstructor;
     };
     readonly: {
-        type: (StringConstructor | BooleanConstructor)[];
+        type: (BooleanConstructor | StringConstructor)[];
     };
     error: {
         type: BooleanConstructor;
@@ -101,18 +101,18 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
 }>> & Readonly<{
-    onClear?: ((_e: Event) => any) | undefined;
     onBlur?: ((_e: Event) => any) | undefined;
     onChange?: ((_e: Event) => any) | undefined;
+    onClear?: ((_e: Event) => any) | undefined;
     "onPress-enter"?: (() => any) | undefined;
 }>, {
+    focused: boolean;
     disabled: boolean;
     error: boolean;
     allowClear: boolean;
     fitWidth: boolean;
     maxWFull: boolean;
     fitWidthFallback: string;
-    focused: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/es/_components/{resize-trigger.vue.d.ts → resize-trigger.vue.d.vue.ts}

@@ -11,7 +11,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     direction: {
-        type: PropType<"horizontal" | "vertical">;
+        type: PropType<'horizontal' | 'vertical'>;
         default: string;
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
@@ -22,7 +22,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     direction: {
-        type: PropType<"horizontal" | "vertical">;
+        type: PropType<'horizontal' | 'vertical'>;
         default: string;
     };
 }>> & Readonly<{

package/es/_components/select-view/{select-view.vue.d.ts → select-view.vue.d.vue.ts}

@@ -35,36 +35,38 @@ type __VLS_Slots = {
     'search-icon'?: () => VNode[];
     'arrow-icon'?: () => VNode[];
 };
+declare const focus: () => void | undefined;
+declare const blur: () => void | undefined;
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     inputRef: import("vue").ComputedRef<HTMLInputElement | undefined>;
-    focus: () => void | undefined;
-    blur: () => void | undefined;
+    focus: typeof focus;
+    blur: typeof blur;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
     clear: (event: MouseEvent) => any;
     focus: (event: FocusEvent) => any;
-    blur: (event: FocusEvent) => any;
     remove: (tag: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
     onClear?: ((event: MouseEvent) => any) | undefined;
     onFocus?: ((event: FocusEvent) => any) | undefined;
-    onBlur?: ((event: FocusEvent) => any) | undefined;
     onRemove?: ((tag: string) => any) | undefined;
 }>, {
-    multiple: boolean;
     disabled: boolean;
     error: boolean;
     loading: boolean;
-    showArrow: boolean;
-    allowClear: boolean;
-    fitWidth: boolean;
-    maxWFull: boolean;
-    bordered: boolean;
-    maxTagCount: number | "responsive";
-    retainInputValue: boolean;
-    tagNowrap: boolean;
     opened: boolean;
+    bordered: boolean;
+    multiple: boolean;
+    allowClear: boolean;
     allowCreate: boolean;
+    showArrow: boolean;
     allowSearch: boolean;
+    maxTagCount: number | 'responsive';
+    tagNowrap: boolean;
+    retainInputValue: boolean;
+    fitWidth: boolean;
+    maxWFull: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/es/_components/virtual-list/{virtual-list.vue.d.ts → virtual-list.vue.d.vue.ts}

@@ -2,6 +2,18 @@ import type { CacheSnapshot } from 'virtua';
 import { type CSSProperties, type PropType } from 'vue';
 import type { ScrollbarProps } from '../../scrollbar';
 import type { ClassValue, ItemSizeValue, ScrollOptions, ScrollToOptions, VirtualItemKey } from './interface';
+declare const scrollToItem: (index: number, options?: ScrollToOptions) => void;
+declare const scrollToPosition: (position: number, options?: ScrollToOptions) => void;
+declare const findItemIndex: (offset: number) => number;
+declare const getItemOffset: (index: number) => number;
+declare const getItemSize: (index: number) => number;
+declare const cacheSnapshot: () => CacheSnapshot | undefined;
+declare const restoreCache: () => boolean;
+declare const updateVisibleItems: () => void;
+declare const scrollToBottom: () => void;
+declare const forceUpdate: () => void;
+declare const getDynamicItemSize: (_item: unknown, index?: number) => number;
+declare const scrollTo: (options: ScrollOptions) => void;
 declare var __VLS_1: {}, __VLS_15: {
     item: any;
     index: number;
@@ -38,7 +50,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: string;
     };
     direction: {
-        type: PropType<"vertical" | "horizontal">;
+        type: PropType<'vertical' | 'horizontal'>;
         default: string;
     };
     listTag: {
@@ -114,7 +126,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: undefined;
     };
     paddingPosition: {
-        type: PropType<"content" | "list">;
+        type: PropType<'content' | 'list'>;
         default: string;
     };
     scrollbar: {
@@ -122,27 +134,27 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: boolean;
     };
 }>, {
-    scrollToItem: (index: number, options?: ScrollToOptions) => void;
-    scrollToPosition: (position: number, options?: ScrollToOptions) => void;
-    findItemIndex: (offset: number) => number;
-    getItemOffset: (index: number) => number;
-    getItemSize: (index: number) => number;
-    cacheSnapshot: () => CacheSnapshot | undefined;
-    restoreCache: () => boolean;
-    updateVisibleItems: () => void;
-    scrollToBottom: () => void;
-    forceUpdate: () => void;
-    getDynamicItemSize: (_item: unknown, index?: number) => number;
-    scrollTo: (options: ScrollOptions) => void;
+    scrollToItem: typeof scrollToItem;
+    scrollToPosition: typeof scrollToPosition;
+    findItemIndex: typeof findItemIndex;
+    getItemOffset: typeof getItemOffset;
+    getItemSize: typeof getItemSize;
+    cacheSnapshot: typeof cacheSnapshot;
+    restoreCache: typeof restoreCache;
+    updateVisibleItems: typeof updateVisibleItems;
+    scrollToBottom: typeof scrollToBottom;
+    forceUpdate: typeof forceUpdate;
+    getDynamicItemSize: typeof getDynamicItemSize;
+    scrollTo: typeof scrollTo;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
-    scroll: (_ev: Event) => any;
     hidden: () => any;
-    visible: () => any;
-    resize: () => any;
     reachBottom: (_ev: Event) => any;
-    scrollStart: () => any;
+    resize: () => any;
+    scroll: (_ev: Event) => any;
     scrollEnd: () => any;
+    scrollStart: () => any;
+    update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any;
+    visible: () => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     items: {
         type: PropType<unknown[]>;
@@ -157,7 +169,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: string;
     };
     direction: {
-        type: PropType<"vertical" | "horizontal">;
+        type: PropType<'vertical' | 'horizontal'>;
         default: string;
     };
     listTag: {
@@ -233,7 +245,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: undefined;
     };
     paddingPosition: {
-        type: PropType<"content" | "list">;
+        type: PropType<'content' | 'list'>;
         default: string;
     };
     scrollbar: {
@@ -241,22 +253,15 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: boolean;
     };
 }>> & Readonly<{
-    onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
-    onScroll?: ((_ev: Event) => any) | undefined;
     onHidden?: (() => any) | undefined;
-    onVisible?: (() => any) | undefined;
-    onResize?: (() => any) | undefined;
     onReachBottom?: ((_ev: Event) => any) | undefined;
-    onScrollStart?: (() => any) | undefined;
+    onResize?: (() => any) | undefined;
+    onScroll?: ((_ev: Event) => any) | undefined;
     onScrollEnd?: (() => any) | undefined;
+    onScrollStart?: (() => any) | undefined;
+    onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+    onVisible?: (() => any) | undefined;
 }>, {
-    shift: boolean;
-    scrollbar: boolean | ScrollbarProps;
-    enabled: boolean;
-    emitUpdate: boolean;
-    disableTransform: boolean;
-    flowMode: boolean;
-    skipHover: boolean;
     items: unknown[];
     height: string | number;
     keyField: string | ((item: unknown, index: number) => VirtualItemKey);
@@ -265,6 +270,12 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     itemTag: string;
     itemSize: ItemSizeValue;
     minItemSize: string | number | null;
+    shift: boolean;
+    emitUpdate: boolean;
+    disableTransform: boolean;
+    flowMode: boolean;
+    skipHover: boolean;
+    enabled: boolean;
     threshold: number;
     fixedSize: boolean;
     estimatedSize: number;
@@ -274,6 +285,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     contentAttrs: Record<string, unknown> | undefined;
     listStyle: CSSProperties | undefined;
     paddingPosition: "content" | "list";
+    scrollbar: boolean | ScrollbarProps;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/es/_hooks/use-form-item.d.ts

@@ -8,7 +8,7 @@ export declare const useFormItem: ({ size, disabled, error, uninject, }?: {
     uninject?: boolean;
 }) => {
     formItemCtx: FormItemContext;
-    mergedSize: import("vue").ComputedRef<"small" | "medium" | "large" | "mini" | undefined>;
+    mergedSize: import("vue").ComputedRef<"large" | "medium" | "mini" | "small" | undefined>;
     mergedDisabled: import("vue").ComputedRef<boolean>;
     mergedError: import("vue").ComputedRef<boolean>;
     feedback: Ref<string | undefined, string | undefined>;

package/es/_hooks/use-size.d.ts

@@ -3,5 +3,5 @@ import { Size } from '../_utils/constant';
 export declare const useSize: (size?: Ref<Size | undefined>, { defaultValue }?: {
     defaultValue?: Size;
 }) => {
-    mergedSize: import("vue").ComputedRef<"small" | "medium" | "large" | "mini">;
+    mergedSize: import("vue").ComputedRef<"large" | "medium" | "mini" | "small">;
 };

package/es/_hooks/use-trigger.d.ts

@@ -4,7 +4,7 @@ export declare const useTrigger: ({ popupVisible, defaultPopupVisible, show, def
     defaultPopupVisible?: Ref<boolean | undefined>;
     show?: Ref<boolean | undefined>;
     defaultShow?: Ref<boolean | undefined>;
-    emit: (event: "update:popupVisible" | "popupVisibleChange" | "update:show" | "showChange", visible: boolean) => void;
+    emit: (event: 'update:popupVisible' | 'popupVisibleChange' | 'update:show' | 'showChange', visible: boolean) => void;
 }) => {
     computedPopupVisible: import("vue").ComputedRef<boolean>;
     handlePopupVisibleChange: (visible: boolean) => void;

package/es/_utils/color.d.ts

@@ -1,8 +1,8 @@
 export declare const gradientType: {
-    readonly linearGradient: "linear-gradient";
-    readonly repeatingLinearGradient: "repeating-linear-gradient";
-    readonly radialGradient: "radial-gradient";
-    readonly repeatingRadialGradient: "repeating-radial-gradient";
+    readonly linearGradient: 'linear-gradient';
+    readonly repeatingLinearGradient: 'repeating-linear-gradient';
+    readonly radialGradient: 'radial-gradient';
+    readonly repeatingRadialGradient: 'repeating-radial-gradient';
 };
 export type GradientType = (typeof gradientType)[keyof typeof gradientType];
 export declare function isGradientString(gradientString?: string): boolean;
@@ -26,10 +26,10 @@ export declare const formatInputToRgb: (color: string) => {
     a?: number;
 } | false;
 export declare const formatInputToHSVA: (color: string) => {
-    a: number;
     h: number;
     s: number;
     v: number;
+    a: number;
 };
 export declare const hexToRgb: (color: string) => any;
 export declare const rgbToHex: (r: number, g: number, b: number) => string;

package/es/_utils/constant.d.ts

@@ -1,17 +1,17 @@
-export declare const SIZES: readonly ["mini", "small", "medium", "large"];
+export declare const SIZES: readonly ['mini', 'small', 'medium', 'large'];
 export type Size = (typeof SIZES)[number];
-export declare const BORDER_SHAPES: readonly ["square", "round", "circle"];
+export declare const BORDER_SHAPES: readonly ['square', 'round', 'circle'];
 export type BorderShape = (typeof BORDER_SHAPES)[number];
-export declare const STATUSES: readonly ["normal", "success", "warning", "danger"];
+export declare const STATUSES: readonly ['normal', 'success', 'warning', 'danger'];
 export type Status = (typeof STATUSES)[number];
-export declare const MESSAGE_TYPES: readonly ["info", "success", "warning", "error"];
+export declare const MESSAGE_TYPES: readonly ['info', 'success', 'warning', 'error'];
 export type MessageType = (typeof MESSAGE_TYPES)[number];
-export declare const TRIGGER_POSITIONS: readonly ["top", "tl", "tr", "bottom", "bl", "br", "left", "lt", "lb", "right", "rt", "rb"];
+export declare const TRIGGER_POSITIONS: readonly ['top', 'tl', 'tr', 'bottom', 'bl', 'br', 'left', 'lt', 'lb', 'right', 'rt', 'rb'];
 export type TriggerPosition = (typeof TRIGGER_POSITIONS)[number];
-export declare const TRIGGER_EVENTS: readonly ["hover", "click", "focus", "contextMenu"];
+export declare const TRIGGER_EVENTS: readonly ['hover', 'click', 'focus', 'contextMenu'];
 export type TriggerEvent = (typeof TRIGGER_EVENTS)[number];
-export declare const DIRECTIONS: readonly ["horizontal", "vertical"];
+export declare const DIRECTIONS: readonly ['horizontal', 'vertical'];
 export type Direction = (typeof DIRECTIONS)[number];
 export declare const INPUT_EVENTS: string[];
-export declare const TEXT_ALIGNS: readonly ["left", "center", "right"];
+export declare const TEXT_ALIGNS: readonly ['left', 'center', 'right'];
 export type TextAlign = (typeof TEXT_ALIGNS)[number];

package/es/_utils/date.d.ts

@@ -1,17 +1,17 @@
 import originDayjs, { Dayjs, OpUnitType, UnitType } from 'dayjs';
 export declare const dayjs: typeof originDayjs;
 export declare const methods: {
-    add(time: Dayjs, value: number, unit: UnitType): originDayjs.Dayjs;
-    subtract(time: Dayjs, value: number, unit: UnitType): originDayjs.Dayjs;
-    startOf(time: Dayjs, unit: OpUnitType): originDayjs.Dayjs;
-    startOfWeek(time: Dayjs, weekStart: number): originDayjs.Dayjs;
-    endOf(time: Dayjs, unit: OpUnitType): originDayjs.Dayjs;
-    set(time: Dayjs, unit: UnitType, value: number): originDayjs.Dayjs;
+    add(time: Dayjs, value: number, unit: UnitType): Dayjs;
+    subtract(time: Dayjs, value: number, unit: UnitType): Dayjs;
+    startOf(time: Dayjs, unit: OpUnitType): Dayjs;
+    startOfWeek(time: Dayjs, weekStart: number): Dayjs;
+    endOf(time: Dayjs, unit: OpUnitType): Dayjs;
+    set(time: Dayjs, unit: UnitType, value: number): Dayjs;
     isSameWeek(date1: Dayjs, date2: Dayjs, weekStart: number): boolean;
 };
-export declare function getNow(utcOffset?: number, timezone?: string): originDayjs.Dayjs;
+export declare function getNow(utcOffset?: number, timezone?: string): Dayjs;
 export declare function toLocal(date: Dayjs, utcOffset?: number, timezone?: string): Dayjs;
-export declare function getSortedDayjsArray(values: Dayjs[], _fixedTime?: boolean): originDayjs.Dayjs[];
+export declare function getSortedDayjsArray(values: Dayjs[], _fixedTime?: boolean): Dayjs[];
 export declare function isValueChange(prevValue: Dayjs | (Dayjs | undefined)[] | undefined, currentValue: Dayjs | (Dayjs | undefined)[] | undefined): boolean;
 type DateValue = Date | string | number;
 export declare function getDayjsValue(time: DateValue, format: string, utcOffset?: number, timezone?: string): Dayjs;

package/es/_utils/debounce.d.ts

@@ -1,4 +1,4 @@
 export declare function debounce<T extends unknown[]>(callback: (...args: T) => void, delay: number): {
     (...args: T): void;
-    cancel(): void;
+    cancel: () => void;
 };

package/es/_utils/dom.d.ts

@@ -12,7 +12,7 @@ export declare const on: <T extends DOMEventTarget, K extends Extract<keyof DOME
 export declare const off: <T extends DOMEventTarget, K extends Extract<keyof DOMEventMap<T>, string>>(element: T, type: K, handler: (ev: DOMEventMap<T>[K]) => void, options?: boolean | EventListenerOptions) => void;
 export declare const findDomNode: (vnode: VNode) => HTMLElement;
 export declare const contains: (root: Node | null | undefined, ele: Node | null) => boolean;
-export declare const OVERLAY_TYPES: readonly ["modal", "message", "notification", "drawer"];
+export declare const OVERLAY_TYPES: readonly ['modal', 'message', 'notification', 'drawer'];
 export declare const getOverlay: (type: (typeof OVERLAY_TYPES)[number]) => HTMLDivElement;
 export declare const querySelector: (selectors: string, container?: Document | HTMLElement) => HTMLElement | undefined;
 export declare const getElement: (target: string | HTMLElement | undefined, container?: Document | HTMLElement) => HTMLElement | undefined;

package/es/_utils/style.d.ts

@@ -1,3 +1,3 @@
 export declare function fixedWidth(width: number): Record<string, unknown>;
 export declare function setTransformStyle(value: string): Record<string, unknown>;
-export declare function getStyle(element: HTMLElement | null, prop: string | null): string | number | ((index: number) => string) | CSSRule | ((property: string, value: string | null, priority?: string) => void) | null;
+export declare function getStyle(element: HTMLElement | null, prop: string | null): string | number | CSSRule | ((index: number) => string) | ((property: string, value: string | null, priority?: string) => void) | null;

package/es/_utils/throttle-by-raf.d.ts

@@ -1,4 +1,4 @@
 export declare function throttleByRaf<T extends unknown[]>(cb: (...args: T) => void): {
     (...args: T): void;
-    cancel(): void;
+    cancel: () => void;
 };

package/es/_utils/vue-utils.d.ts

@@ -33,11 +33,11 @@ export declare const getValueFromSlotsOrProps: (name: string, props?: Data, slot
 export declare const isComponentInstance: (value: any) => value is ComponentPublicInstance;
 export declare const isElement: (vn: VNode) => boolean;
 export declare const isComponent: (vn: VNode, _type?: VNodeTypes) => _type is Component;
-export declare const isText: (vn: VNode, _children: VNode["children"]) => _children is string;
+export declare const isText: (vn: VNode, _children: VNode['children']) => _children is string;
 export declare const isNamedComponent: (child: VNode, name: string) => boolean;
-export declare const isTextChildren: (child: VNode, _children: VNode["children"]) => _children is string;
-export declare const isArrayChildren: (vn: VNode, _children: VNode["children"]) => _children is VNode[];
-export declare const isSlotsChildren: (vn: VNode, _children: VNode["children"]) => _children is Slots;
+export declare const isTextChildren: (child: VNode, _children: VNode['children']) => _children is string;
+export declare const isArrayChildren: (vn: VNode, _children: VNode['children']) => _children is VNode[];
+export declare const isSlotsChildren: (vn: VNode, _children: VNode['children']) => _children is Slots;
 export declare const getChildrenString: (children: VNode[]) => string;
 export declare const getVNodeChildrenString: (vn: VNode) => string;
 export declare const getChildrenFunc: (vn: VNode) => RenderFunction | undefined;

package/es/affix/{affix.vue.d.ts → affix.vue.d.vue.ts}

@@ -1,4 +1,5 @@
 import type { PropType } from 'vue';
+declare const updatePosition: () => void;
 declare var __VLS_18: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_18) => any;
@@ -18,7 +19,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         type: PropType<string | HTMLElement | Window>;
     };
 }>, {
-    updatePosition: () => void;
+    updatePosition: typeof updatePosition;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (_fixed: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{

package/es/alert/{alert.vue.d.ts → alert.vue.d.vue.ts}

@@ -14,7 +14,7 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     type: {
-        type: PropType<MessageType | "normal">;
+        type: PropType<MessageType | 'normal'>;
         default: string;
     };
     showIcon: {
@@ -35,11 +35,11 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: boolean;
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    close: (_ev: Event) => any;
     afterClose: () => any;
+    close: (_ev: Event) => any;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     type: {
-        type: PropType<MessageType | "normal">;
+        type: PropType<MessageType | 'normal'>;
         default: string;
     };
     showIcon: {
@@ -60,14 +60,14 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         default: boolean;
     };
 }>> & Readonly<{
-    onClose?: ((_ev: Event) => any) | undefined;
     onAfterClose?: (() => any) | undefined;
+    onClose?: ((_ev: Event) => any) | undefined;
 }>, {
-    type: "normal" | "success" | "warning" | "info" | "error";
-    center: boolean;
-    closable: boolean;
+    type: "error" | "info" | "normal" | "success" | "warning";
     showIcon: boolean;
+    closable: boolean;
     banner: boolean;
+    center: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;