@kine-design/core 0.0.1-beta.1 → 0.0.1-beta.2

package/dist/components/base/cascader/useCascader.d.ts

@@ -7,16 +7,28 @@ export interface FlatCascaderOption {
     pathLabel: string;
 }
 export declare function useCascader(props: CascaderProps, ctx: any): {
-    isOpen: any;
-    searchQuery: any;
-    activePath: any;
-    columns: any;
-    filteredOptions: any;
-    isSearching: any;
-    selectedPath: any;
-    selectedPaths: any;
-    displayLabel: any;
-    selectedTags: any;
+    isOpen: import('vue').Ref<boolean, boolean>;
+    searchQuery: import('vue').Ref<string, string>;
+    activePath: import('vue').Ref<{
+        value: string | number;
+        label: string;
+        children?: /*elided*/ any[] | undefined;
+        disabled?: boolean | undefined;
+        leaf?: boolean | undefined;
+    }[], CascaderOption[] | {
+        value: string | number;
+        label: string;
+        children?: /*elided*/ any[] | undefined;
+        disabled?: boolean | undefined;
+        leaf?: boolean | undefined;
+    }[]>;
+    columns: import('vue').ComputedRef<CascaderOption[][]>;
+    filteredOptions: import('vue').ComputedRef<FlatCascaderOption[]>;
+    isSearching: import('vue').ComputedRef<boolean | undefined>;
+    selectedPath: import('vue').ComputedRef<CascaderOption[]>;
+    selectedPaths: import('vue').ComputedRef<CascaderOption[][]>;
+    displayLabel: import('vue').ComputedRef<string>;
+    selectedTags: import('vue').ComputedRef<string[]>;
     open: () => void;
     close: () => void;
     onTriggerClick: () => void;
@@ -26,6 +38,6 @@ export declare function useCascader(props: CascaderProps, ctx: any): {
     onDeleteTag: (tagIndex: number) => void;
     onClear: (e: MouseEvent) => void;
     isActiveOption: (option: CascaderOption, colIndex: number) => boolean;
-    isSelectedOption: (option: CascaderOption, colIndex: number) => any;
+    isSelectedOption: (option: CascaderOption, colIndex: number) => boolean;
     isFlatOptionSelected: (item: FlatCascaderOption) => boolean;
 };

package/dist/components/base/checkbox/useCheckbox.d.ts

@@ -1,9 +1,10 @@
-import { EmitsOptions, SlotsType } from '@vue/runtime-core';
 import { CheckboxProps } from './props';
-export default function useCheckbox<Props extends Required<CheckboxProps>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(props: Props, ctx: any): {
+export default function useCheckbox<Props extends Required<CheckboxProps>>(props: Props, ctx: any): {
     checkboxClass: (string | {
         'm-disabled': boolean;
+        'm-indeterminate': boolean;
     })[];
-    checked: any;
+    checked: import('vue').Ref<boolean, boolean>;
+    indeterminate: boolean;
     onClick: (e: MouseEvent) => void;
 };

package/dist/components/base/collapse/useCollapse.d.ts

@@ -1,9 +1,9 @@
 import { CollapseProps } from './props';
 export default function useCollapse(props: Required<CollapseProps>, ctx: any): {
-    activeNames: any;
+    activeNames: import('vue').ComputedRef<(string | number)[]>;
     isActive: (name: string | number) => boolean;
     toggle: (name: string | number, disabled: boolean) => void;
-    collapseClass: any;
+    collapseClass: import('vue').ComputedRef<string[]>;
     getItemClass: (name: string | number, disabled: boolean) => (string | {
         'm-collapse-item-active': boolean;
         'm-collapse-item-disabled'?: undefined;

package/dist/components/base/datePicker/useDatePicker.d.ts

@@ -1,6 +1,6 @@
 import { default as dayjs } from 'dayjs';
 import { Ref } from 'vue';
-import { DatePickerProps, DateRefType, CalendarItem } from './props';
+import { DatePickerProps, CalendarType, DateRefType, CalendarItem } from './props';
 /** 时间部分的内部状态 */
 export type TimeRefType = {
     hours: number;
@@ -26,13 +26,145 @@ export declare const toDayjs: (value: string | Date | undefined) => dayjs.Dayjs;
  */
 export declare const generateTimeColumn: (max: number, step: number) => number[];
 export declare function useDatePicker(props: DatePickerProps): {
-    dateRef: any;
-    displayValue: any;
-    spanClass: any;
-    currentRef: any;
-    calendarTypeRef: any;
-    yearsRef: any;
-    timeRef: any;
+    dateRef: Ref<{
+        year: number;
+        month: number;
+        day: number;
+    }, DateRefType | {
+        year: number;
+        month: number;
+        day: number;
+    }>;
+    displayValue: Ref<string, string>;
+    spanClass: Ref<(string | undefined)[], (string | undefined)[]>;
+    currentRef: Ref<{
+        clone: () => dayjs.Dayjs;
+        isValid: () => boolean;
+        year: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        month: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        date: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        day: {
+            (): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+            (value: number): dayjs.Dayjs;
+        };
+        hour: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        minute: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        second: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        millisecond: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        set: (unit: dayjs.UnitType, value: number) => dayjs.Dayjs;
+        get: (unit: dayjs.UnitType) => number;
+        add: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
+        subtract: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
+        startOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
+        endOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
+        format: (template?: string) => string;
+        diff: (date?: dayjs.ConfigType, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) => number;
+        valueOf: () => number;
+        unix: () => number;
+        daysInMonth: () => number;
+        toDate: () => Date;
+        toJSON: () => string;
+        toISOString: () => string;
+        toString: () => string;
+        utcOffset: () => number;
+        isBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        isSame: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        isAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        locale: {
+            (): string;
+            (preset: string | ILocale, object?: Partial<ILocale>): dayjs.Dayjs;
+        };
+    }, dayjs.Dayjs | {
+        clone: () => dayjs.Dayjs;
+        isValid: () => boolean;
+        year: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        month: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        date: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        day: {
+            (): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+            (value: number): dayjs.Dayjs;
+        };
+        hour: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        minute: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        second: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        millisecond: {
+            (): number;
+            (value: number): dayjs.Dayjs;
+        };
+        set: (unit: dayjs.UnitType, value: number) => dayjs.Dayjs;
+        get: (unit: dayjs.UnitType) => number;
+        add: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
+        subtract: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
+        startOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
+        endOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
+        format: (template?: string) => string;
+        diff: (date?: dayjs.ConfigType, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) => number;
+        valueOf: () => number;
+        unix: () => number;
+        daysInMonth: () => number;
+        toDate: () => Date;
+        toJSON: () => string;
+        toISOString: () => string;
+        toString: () => string;
+        utcOffset: () => number;
+        isBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        isSame: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        isAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        locale: {
+            (): string;
+            (preset: string | ILocale, object?: Partial<ILocale>): dayjs.Dayjs;
+        };
+    }>;
+    calendarTypeRef: Ref<CalendarType, CalendarType>;
+    yearsRef: Ref<number[], number[]>;
+    timeRef: Ref<{
+        hours: number;
+        minutes: number;
+        seconds: number;
+    }, TimeRefType | {
+        hours: number;
+        minutes: number;
+        seconds: number;
+    }>;
     updateDateRef: (value: string | Date | undefined) => void;
     getCalendar: (MDateRefValue: Ref<DateRefType>) => CalendarItem[][];
     toPrevMonth: () => void;

package/dist/components/base/dropdown/useDropdown.d.ts

@@ -1,8 +1,8 @@
 import { DropdownItemProps, DropdownProps } from './props';
 export default function useDropdown(props: Required<DropdownProps>, ctx: any): {
-    visible: any;
-    triggerRef: any;
-    menuRef: any;
+    visible: import('vue').Ref<boolean, boolean>;
+    triggerRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    menuRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
     open: () => void;
     close: () => void;
     toggle: () => void;
@@ -10,8 +10,14 @@ export default function useDropdown(props: Required<DropdownProps>, ctx: any): {
     handleMouseenter: () => void;
     handleMouseleave: () => void;
     handleItemClick: (item: DropdownItemProps) => void;
-    dropdownClass: any;
-    menuClass: any;
+    dropdownClass: import('vue').ComputedRef<(string | {
+        'm-dropdown-open': boolean;
+        'm-dropdown-disabled'?: undefined;
+    } | {
+        'm-dropdown-disabled': boolean;
+        'm-dropdown-open'?: undefined;
+    })[]>;
+    menuClass: import('vue').ComputedRef<string[]>;
     getItemClass: (item: DropdownItemProps) => (string | {
         'm-dropdown-item-disabled': boolean | undefined;
         'm-dropdown-item-divided'?: undefined;

package/dist/components/base/image/useImage.d.ts

@@ -2,11 +2,11 @@ import { ImageProps } from './props';
 /** 图片加载状态 */
 export type ImageLoadStatus = 'loading' | 'loaded' | 'error';
 export declare function useImage(props: Required<ImageProps>, emit: (event: 'load' | 'error' | 'switch', payload: Event | number) => void): {
-    status: any;
-    previewVisible: any;
-    previewIndex: any;
-    previewScale: any;
-    previewRotate: any;
+    status: import('vue').Ref<ImageLoadStatus, ImageLoadStatus>;
+    previewVisible: import('vue').Ref<boolean, boolean>;
+    previewIndex: import('vue').Ref<number, number>;
+    previewScale: import('vue').Ref<number, number>;
+    previewRotate: import('vue').Ref<number, number>;
     handleLoad: (e: Event) => void;
     handleError: (e: Event) => void;
     openPreview: () => void;

package/dist/components/base/input/useInput.d.ts

@@ -1,6 +1,5 @@
 import { HTMLElementEvent } from '../../types/template';
-import { EmitsOptions, SlotsType } from '@vue/runtime-core';
-export default function useInput<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(props: Props, ctx: any): {
+export default function useInput<Props extends Record<string, any>>(props: Props, ctx: any): {
     baseProps: {
         autofocus: any;
         value: any;

package/dist/components/base/inputNumber/useInputNumber.d.ts

@@ -1,8 +1,8 @@
 import { InputNumberProps } from './props';
 import { HTMLElementEvent } from '../../types/template';
-export type InputNumber = string | number;
+export type InputNumber = string | number | null;
 export default function useInputNumber(props: Required<InputNumberProps>, ctx: any): {
-    currentValue: any;
+    currentValue: import('vue').Ref<string | number, string | number>;
     handleInputChange: (e: HTMLElementEvent<HTMLInputElement>) => void;
     handleInputBlur: () => void;
     handleKeydown: (e: KeyboardEvent) => void;

package/dist/components/base/popover/usePopover.d.ts

@@ -1,4 +1,4 @@
-import { PopperConfig, PositionStyle, usePopper } from '../../../compositions/popper/usePopper.ts';
+import { Placement, PopperConfig, PositionStyle, usePopper } from '../../../compositions/popper/usePopper.ts';
 import { PopoverProps } from './props';
 import { Ref } from 'vue';
 export type IPopper = ReturnType<typeof usePopper>;
@@ -35,11 +35,11 @@ export declare class PopoverImpl {
 export default function usePopover(props: Required<PopoverProps>, ctx: any): {
     popoverEnter: () => void;
     popoverLeave: () => void;
-    popoverRef: any;
-    contentRef: any;
-    arrowRef: any;
-    popperInstance: any;
-    style: any;
-    arrowStyle: any;
-    placement: any;
+    popoverRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    contentRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    arrowRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    popperInstance: import('vue').ShallowRef<PopoverImpl | undefined, PopoverImpl | undefined>;
+    style: Ref<any, any>;
+    arrowStyle: Ref<any, any>;
+    placement: Ref<Placement, Placement>;
 };

package/dist/components/base/progress/useProgress.d.ts

@@ -1,4 +1,4 @@
 import { ProgressProps } from './props';
 export default function useProgress(props: Required<ProgressProps>): {
-    percentage: any;
+    percentage: import('vue').ComputedRef<string | number>;
 };

package/dist/components/base/rate/useRate.d.ts

@@ -1,6 +1,6 @@
 import { RateProps } from './props';
 export default function useRate(props: Required<RateProps>, emit: (event: string, ...args: unknown[]) => void): {
-    hoverValue: any;
+    hoverValue: import('vue').Ref<number | null, number | null>;
     getStarState: (index: number) => "full" | "half" | "empty";
     onMouseEnter: (e: MouseEvent, index: number) => void;
     onMouseMove: (e: MouseEvent, index: number) => void;

package/dist/components/base/select/useSelect.d.ts

@@ -8,14 +8,14 @@ export interface SelectOptionItem {
     isSelected: boolean;
 }
 export declare function useSelect(props: SelectProps, ctx: any): {
-    inputValue: any;
-    isOpen: any;
-    fetchLoading: any;
-    inputReadonly: any;
-    displayOptions: any;
-    selectedTags: any;
-    lastOptionRef: any;
-    optionsContainerRef: any;
+    inputValue: import('vue').Ref<string, string>;
+    isOpen: import('vue').Ref<boolean, boolean>;
+    fetchLoading: import('vue').Ref<boolean, boolean>;
+    inputReadonly: Readonly<import('vue').Ref<boolean, boolean>>;
+    displayOptions: import('vue').ComputedRef<SelectOptionItem[]>;
+    selectedTags: import('vue').ComputedRef<SelectOptionItem[]>;
+    lastOptionRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    optionsContainerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     onSelect: (index: number) => void;
     onDeleteTag: (index: number) => void;
     onInput: () => void;

package/dist/components/base/slider/useSlider.d.ts

@@ -1,6 +1,6 @@
 import { SliderProps } from './props';
 export default function useSlider(props: Required<SliderProps>, ctx: any): {
-    btnRef: any;
-    sliderRef: any;
-    perRef: any;
+    btnRef: import('vue').Ref<HTMLElement | null | undefined, HTMLElement | null | undefined>;
+    sliderRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    perRef: import('vue').Ref<number, number>;
 };

package/dist/components/base/steps/index.d.ts

@@ -4,7 +4,7 @@ export declare const StepsCore: {
     stepProps: import('../../types/props').MCOPO<import('./props').StepProps>;
     useSteps: typeof useSteps;
     useStep: typeof useStep;
-    stepsContextKey: InjectionKey<import('./useSteps').StepsContext>;
+    stepsContextKey: import('vue').InjectionKey<import('./useSteps').StepsContext>;
     resolveStepStatus: typeof resolveStepStatus;
 };
 export type { StepsProps, StepProps, StepItem, StepStatus, StepsDirection } from './props';

package/dist/components/base/steps/useSteps.d.ts

@@ -22,7 +22,7 @@ export declare const stepsContextKey: InjectionKey<StepsContext>;
  * 负责将当前激活状态通过 provide 下发给 MStep 子组件
  */
 export declare function useSteps(props: StepsProps): {
-    stepsClass: any;
+    stepsClass: import('vue').ComputedRef<string[]>;
     context: StepsContext;
 };
 /**
@@ -37,8 +37,8 @@ export declare function resolveStepStatus(index: number, overrideStatus: StepSta
  * 从父级注入 StepsContext，计算当前步骤的状态与样式类
  */
 export declare function useStep(index: number, overrideStatus?: StepStatus): {
-    status: any;
-    stepClass: any;
-    isLast: any;
-    ctx: any;
+    status: import('vue').ComputedRef<StepStatus>;
+    stepClass: import('vue').ComputedRef<string[]>;
+    isLast: import('vue').ComputedRef<boolean>;
+    ctx: StepsContext | null;
 };

package/dist/components/base/switch/useSwitch.d.ts

@@ -1,9 +1,14 @@
 import { SwitchProps } from './props';
-import { EmitsOptions, SlotsType } from '@vue/runtime-core';
 export declare const switchIsBoolean: (value: SwitchProps["modelValue"]) => value is boolean;
 export declare const getIsActive: (value: SwitchProps["modelValue"], activeValue: SwitchProps["activeValue"]) => boolean;
-export default function useSwitch<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(props: Props, ctx: any): {
+export default function useSwitch<Props extends Record<string, any>>(props: Props, ctx: any): {
     getInfo: (key: keyof Pick<SwitchProps, "activeInfo" | "inactiveInfo">) => any;
     changeSwitch: () => void;
-    switchClass: any;
+    switchClass: import('vue').ComputedRef<(string | {
+        'm-switch-loading': any;
+        'm-switch-disabled'?: undefined;
+    } | {
+        'm-switch-disabled': any;
+        'm-switch-loading'?: undefined;
+    })[]>;
 };

package/dist/components/base/tabs/useTabs.d.ts

@@ -1,8 +1,8 @@
 export default function useTabs<Props extends Record<string, unknown>>(props: Props, ctx: any): {
-    activeTab: any;
+    activeTab: import('vue').ComputedRef<string | number>;
     isActive: (name: string | number) => boolean;
     switchTab: (name: string | number, disabled?: boolean) => void;
-    tabsClass: any;
+    tabsClass: import('vue').ComputedRef<string[]>;
     navClass: string;
     getNavItemClass: (name: string | number, disabled?: boolean) => string[];
     contentClass: string;

package/dist/components/base/timePicker/useTimePicker.d.ts

@@ -6,12 +6,20 @@ import { TimePickerProps, TimeRefType } from './props';
  */
 export declare const generateColumn: (max: number, step: number) => number[];
 export declare function useTimePicker(props: TimePickerProps): {
-    timeRef: any;
-    displayValue: any;
-    spanClass: any;
-    hoursColumn: any;
-    minutesColumn: any;
-    secondsColumn: any;
+    timeRef: import('vue').Ref<{
+        hours: number;
+        minutes: number;
+        seconds: number;
+    }, TimeRefType | {
+        hours: number;
+        minutes: number;
+        seconds: number;
+    }>;
+    displayValue: import('vue').Ref<string, string>;
+    spanClass: import('vue').Ref<(string | undefined)[], (string | undefined)[]>;
+    hoursColumn: import('vue').ComputedRef<number[]>;
+    minutesColumn: import('vue').ComputedRef<number[]>;
+    secondsColumn: import('vue').ComputedRef<number[]>;
     updateTimeRef: (value: string | undefined) => void;
     selectHour: (hour: number) => void;
     selectMinute: (minute: number) => void;

package/dist/components/base/tooltip/useTooltip.d.ts

@@ -6,10 +6,20 @@ export type TooltipStyle = {
     zIndex: string;
 };
 export default function useTooltip(props: Required<TooltipProps>): {
-    visible: any;
-    tooltipStyle: any;
-    triggerRef: any;
-    tooltipRef: any;
+    visible: import('vue').Ref<boolean, boolean>;
+    tooltipStyle: import('vue').Ref<Record<string, never> | {
+        position: string;
+        left: string;
+        top: string;
+        zIndex: string;
+    }, TooltipStyle | Record<string, never> | {
+        position: string;
+        left: string;
+        top: string;
+        zIndex: string;
+    }>;
+    triggerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    tooltipRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     show: () => Promise<void>;
     hide: () => void;
 };

package/dist/components/base/transfer/useTransfer.d.ts

@@ -1,19 +1,19 @@
-import { TransferProps } from './props';
+import { TransferItem, TransferProps } from './props';
 export declare function useTransfer(props: TransferProps, ctx: any): {
-    leftSearch: any;
-    rightSearch: any;
-    leftData: any;
-    rightData: any;
-    filteredLeftData: any;
-    filteredRightData: any;
-    leftChecked: any;
-    rightChecked: any;
-    hasLeftChecked: any;
-    hasRightChecked: any;
-    isLeftAllChecked: any;
-    isLeftIndeterminate: any;
-    isRightAllChecked: any;
-    isRightIndeterminate: any;
+    leftSearch: import('vue').Ref<string, string>;
+    rightSearch: import('vue').Ref<string, string>;
+    leftData: import('vue').ComputedRef<TransferItem[]>;
+    rightData: import('vue').ComputedRef<TransferItem[]>;
+    filteredLeftData: import('vue').ComputedRef<TransferItem[]>;
+    filteredRightData: import('vue').ComputedRef<TransferItem[]>;
+    leftChecked: import('vue').Ref<Set<string | number> & Omit<Set<string | number>, keyof Set<any>>, Set<string | number> | (Set<string | number> & Omit<Set<string | number>, keyof Set<any>>)>;
+    rightChecked: import('vue').Ref<Set<string | number> & Omit<Set<string | number>, keyof Set<any>>, Set<string | number> | (Set<string | number> & Omit<Set<string | number>, keyof Set<any>>)>;
+    hasLeftChecked: import('vue').ComputedRef<boolean>;
+    hasRightChecked: import('vue').ComputedRef<boolean>;
+    isLeftAllChecked: import('vue').ComputedRef<boolean>;
+    isLeftIndeterminate: import('vue').ComputedRef<boolean>;
+    isRightAllChecked: import('vue').ComputedRef<boolean>;
+    isRightIndeterminate: import('vue').ComputedRef<boolean>;
     toggleLeftCheck: (key: string | number, disabled: boolean) => void;
     toggleRightCheck: (key: string | number, disabled: boolean) => void;
     toggleLeftAll: () => void;

package/dist/components/base/tree/index.d.ts

@@ -2,7 +2,7 @@ export declare const TreeCore: {
     props: import('../../types/props').MCOPO<import('./props').TreeProps>;
     treeNodeProps: import('../../types/props').MCOPO<import('./props').TreeNodeProps>;
     useTree: (options: import('./useTree').UseTreeOptions) => {
-        treeRef: any;
+        treeRef: import('vue').ShallowRef<import('./tree').default | undefined, import('./tree').default | undefined>;
         getNodesByKeys: (keys: import('./props').TreeNodeData["key"][]) => import('./props').TreeNodeData[];
         handleToggleExpand: (node: import('./props').TreeNodeData, e: MouseEvent) => void;
         handleToggleChecked: (node: import('./props').TreeNodeData, checked: boolean) => void;

package/dist/components/base/tree/useTree.d.ts

@@ -1,3 +1,4 @@
+import { default as Tree } from './tree';
 import { TreeData, TreeNodeData, TreeProps } from './props';
 /**
  * 为没有 key 的节点递归生成唯一标识
@@ -24,7 +25,7 @@ export interface UseTreeOptions {
  * - getNodesByKeys：根据 key 批量获取节点
  */
 export declare const useTree: (options: UseTreeOptions) => {
-    treeRef: any;
+    treeRef: import('vue').ShallowRef<Tree | undefined, Tree | undefined>;
     getNodesByKeys: (keys: TreeNodeData["key"][]) => TreeNodeData[];
     handleToggleExpand: (node: TreeNodeData, e: MouseEvent) => void;
     handleToggleChecked: (node: TreeNodeData, checked: boolean) => void;

package/dist/components/message/message/useMessage.d.ts

@@ -13,7 +13,17 @@ export interface MessageItem {
  * 管理消息的增删与自动关闭定时器
  */
 export declare function useMessageQueue(): {
-    messages: any;
+    messages: import('vue').Ref<{
+        id: number;
+        type: MessageType;
+        content: string;
+        duration: number;
+    }[], MessageItem[] | {
+        id: number;
+        type: MessageType;
+        content: string;
+        duration: number;
+    }[]>;
     add: (props: {
         type?: MessageType;
         content: string;

package/dist/components/message/notification/useNotification.d.ts

@@ -27,7 +27,23 @@ export interface NotificationAddOptions {
  * 管理通知的增删与自动关闭定时器
  */
 export declare function useNotificationQueue(): {
-    notifications: any;
+    notifications: import('vue').Ref<{
+        id: number;
+        title: string;
+        message: string;
+        type: NotificationType;
+        duration: number;
+        position: NotificationPosition;
+        closable: boolean;
+    }[], NotificationItem[] | {
+        id: number;
+        title: string;
+        message: string;
+        type: NotificationType;
+        duration: number;
+        position: NotificationPosition;
+        closable: boolean;
+    }[]>;
     add: (options: NotificationAddOptions) => number;
     remove: (id: number) => void;
 };

package/dist/components/message/popover/MPopover.d.ts

@@ -1,2 +1,7 @@
-declare const _default: any;
+import { PopoverProps } from './props';
+declare const _default: import('vue').DefineSetupFnComponent<PopoverProps, ("update:show" | "open:popper" | "close:popper")[], {}, PopoverProps & {
+    "onUpdate:show"?: ((...args: any[]) => any) | undefined;
+    "onOpen:popper"?: ((...args: any[]) => any) | undefined;
+    "onClose:popper"?: ((...args: any[]) => any) | undefined;
+}, import('vue').PublicProps>;
 export default _default;

package/dist/components/message/popover/usePopover.d.ts

@@ -43,12 +43,12 @@ export declare function usePopover(options: Options<{
     getContent: <T>(props: PopoverProps, getContentSlot: () => T, useTeleport: (options: any) => ArrayElement<T> | T, _instance?: PopoverImpl | null) => T | ArrayElement<T> | null;
     popoverEnter: () => void;
     popoverLeave: () => void;
-    popoverRef: any;
-    contentRef: any;
-    arrowRef: any;
-    popperInstance: any;
-    style: any;
-    arrowStyle: any;
+    popoverRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    contentRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    arrowRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    popperInstance: import('vue').ShallowRef<PopoverImpl | undefined, PopoverImpl | undefined>;
+    style: Ref<any, any>;
+    arrowStyle: Ref<any, any>;
     lifecycle: {
         onBeforeDestroyEvents: Function[];
     };

package/dist/components/other/darkMode/useDarkMode.d.ts

@@ -4,7 +4,7 @@ declare function applyDarkAttr(isDark: boolean): void;
 export declare function useDarkMode(props: DarkModeProps, ctx: {
     emit: (event: string, ...args: any[]) => void;
 }): {
-    isDark: any;
+    isDark: import('vue').Ref<boolean, boolean>;
     toggle: () => void;
     applyDarkAttr: typeof applyDarkAttr;
 };