@antsoo-lib/components 0.0.1

package/dist/src/_util/hooks/_vueuse/useResizeObserver.d.ts

@@ -0,0 +1,44 @@
+import { ConfigurableWindow } from './_configurable';
+import { MaybeComputedElementRef } from './unrefElement';
+import { ShallowRef } from 'vue';
+export interface ResizeObserverSize {
+    readonly inlineSize: number;
+    readonly blockSize: number;
+}
+export interface ResizeObserverEntry {
+    readonly target: Element;
+    readonly contentRect: DOMRectReadOnly;
+    readonly borderBoxSize?: ReadonlyArray<ResizeObserverSize>;
+    readonly contentBoxSize?: ReadonlyArray<ResizeObserverSize>;
+    readonly devicePixelContentBoxSize?: ReadonlyArray<ResizeObserverSize>;
+}
+export type ResizeObserverCallback = (entries: ReadonlyArray<ResizeObserverEntry>, observer: ResizeObserver) => void;
+export interface UseResizeObserverOptions extends ConfigurableWindow {
+    /**
+     * Sets which box model the observer will observe changes to. Possible values
+     * are `content-box` (the default), `border-box` and `device-pixel-content-box`.
+     *
+     * @default 'content-box'
+     */
+    box?: ResizeObserverBoxOptions;
+}
+declare class ResizeObserver {
+    constructor(callback: ResizeObserverCallback);
+    disconnect(): void;
+    observe(target: Element, options?: UseResizeObserverOptions): void;
+    unobserve(target: Element): void;
+}
+/**
+ * Reports changes to the dimensions of an Element's content or the border-box
+ *
+ * @see https://vueuse.org/useResizeObserver
+ * @param target
+ * @param callback
+ * @param options
+ */
+export declare function useResizeObserver(target: MaybeComputedElementRef, callback: ResizeObserverCallback, options?: UseResizeObserverOptions): {
+    isSupported: ShallowRef<boolean | undefined, boolean | undefined>;
+    stop: () => void;
+};
+export type UseResizeObserverReturn = ReturnType<typeof useResizeObserver>;
+export {};

package/dist/src/_util/hooks/_vueuse/useSupported.d.ts

@@ -0,0 +1,2 @@
+import { ShallowRef } from 'vue';
+export declare function useSupported(callback: () => unknown, sync?: boolean): ShallowRef<boolean | undefined, boolean | undefined>;

package/dist/src/_util/hooks/useBreakpoint.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { ScreenMap } from '../../_util/responsiveObserve';
+declare function useBreakpoint(): Ref<ScreenMap>;
+export default useBreakpoint;

package/dist/src/_util/hooks/useDestroyed.d.ts

@@ -0,0 +1,3 @@
+import { ShallowRef } from 'vue';
+declare const useDestroyed: () => ShallowRef<boolean, boolean>;
+export default useDestroyed;

package/dist/src/_util/hooks/useFlexGapSupport.d.ts

@@ -0,0 +1,3 @@
+import { ShallowRef } from 'vue';
+declare const _default: () => ShallowRef<boolean, boolean>;
+export default _default;

package/dist/src/_util/hooks/useId.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+/** Is client side and not jsdom */
+export declare const isBrowserClient: boolean;
+/** Get unique id for accessibility usage */
+export declare function getUUID(): number | string;
+export default function useId(id?: Ref<string, string>): string;

package/dist/src/_util/hooks/useLayoutState.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+export type Updater<State> = (prev: State) => State;
+/**
+ * Execute code before next frame but async
+ */
+export declare function useLayoutState<State>(defaultState: State): [Ref<State>, (updater: Updater<State>) => void];

package/dist/src/_util/hooks/useMemo.d.ts

@@ -0,0 +1,2 @@
+import { Ref, WatchSource } from 'vue';
+export default function useMemo<T>(getValue: () => T, condition: (WatchSource<unknown> | object)[], shouldUpdate?: (prev: any[], next: any[]) => boolean): Ref<T, T>;

package/dist/src/_util/hooks/useMergedState.d.ts

@@ -0,0 +1,7 @@
+import { Ref, UnwrapRef } from 'vue';
+export default function useMergedState<T, R = Ref<T>>(defaultStateValue: T | (() => T), option?: {
+    defaultValue?: T | (() => T);
+    value?: Ref<T> | Ref<UnwrapRef<T>>;
+    onChange?: (val: T, prevValue: T) => void;
+    postState?: (val: T) => T;
+}): [R, (val: T) => void];

package/dist/src/_util/hooks/useRefs.d.ts

@@ -0,0 +1,7 @@
+import { ComponentPublicInstance, Ref } from 'vue';
+import { Key } from '../type';
+type RefType = HTMLElement | ComponentPublicInstance;
+export type RefsValue = Map<Key, RefType>;
+type UseRef = [(key: Key) => (el: RefType) => void, Ref<RefsValue>];
+declare const useRefs: () => UseRef;
+export default useRefs;

package/dist/src/_util/hooks/useScrollLocker.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+/**../vc-util/Dom/dynam
+ * Test usage export. Do not use in your production
+ */
+export declare function isBodyOverflowing(): boolean;
+export default function useScrollLocker(lock?: Ref<boolean>): void;

package/dist/src/_util/hooks/useState.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useState<T, R = Ref<T>>(defaultStateValue?: T | (() => T)): [R, (val: T) => void];

package/dist/src/_util/isNumeric.d.ts

@@ -0,0 +1,2 @@
+declare const isNumeric: (value: any) => boolean;
+export default isNumeric;

package/dist/src/_util/isValid.d.ts

@@ -0,0 +1,2 @@
+declare const isValid: (value: any) => boolean;
+export default isValid;

package/dist/src/_util/isValidValue.d.ts

@@ -0,0 +1 @@
+export default function (val: any): boolean;

package/dist/src/_util/json2mq.d.ts

@@ -0,0 +1,5 @@
+/**
+ * source by `json2mq`
+ * https://github.com/akiran/json2mq.git
+ */
+export default function (query: any[]): string;

package/dist/src/_util/omit.d.ts

@@ -0,0 +1,2 @@
+declare function omit<T extends object, K extends keyof T>(obj: T, fields: K[]): Omit<T, K>;
+export default omit;

package/dist/src/_util/pickAttrs.d.ts

@@ -0,0 +1,11 @@
+export interface PickConfig {
+    aria?: boolean;
+    data?: boolean;
+    attr?: boolean;
+}
+/**
+ * Picker props from exist props with filter
+ * @param props Passed props
+ * @param ariaOnly boolean | { aria?: boolean; data?: boolean; attr?: boolean; } filter config
+ */
+export default function pickAttrs(props: object, ariaOnly?: boolean | PickConfig): {};

package/dist/src/_util/placements.d.ts

@@ -0,0 +1,65 @@
+export interface AdjustOverflow {
+    adjustX?: 0 | 1;
+    adjustY?: 0 | 1;
+}
+export interface PlacementsConfig {
+    arrowWidth?: number;
+    horizontalArrowShift?: number;
+    verticalArrowShift?: number;
+    arrowPointAtCenter?: boolean;
+    autoAdjustOverflow?: boolean | AdjustOverflow;
+}
+export declare function getOverflowOptions(autoAdjustOverflow?: boolean | AdjustOverflow): {
+    adjustX: number;
+    adjustY: number;
+};
+export default function getPlacements(config: PlacementsConfig): {
+    left: {
+        points: string[];
+        offset: number[];
+    };
+    right: {
+        points: string[];
+        offset: number[];
+    };
+    top: {
+        points: string[];
+        offset: number[];
+    };
+    bottom: {
+        points: string[];
+        offset: number[];
+    };
+    topLeft: {
+        points: string[];
+        offset: number[];
+    };
+    leftTop: {
+        points: string[];
+        offset: number[];
+    };
+    topRight: {
+        points: string[];
+        offset: number[];
+    };
+    rightTop: {
+        points: string[];
+        offset: number[];
+    };
+    bottomRight: {
+        points: string[];
+        offset: number[];
+    };
+    rightBottom: {
+        points: string[];
+        offset: number[];
+    };
+    bottomLeft: {
+        points: string[];
+        offset: number[];
+    };
+    leftBottom: {
+        points: string[];
+        offset: number[];
+    };
+};

package/dist/src/_util/props-util/index.d.ts

@@ -0,0 +1,33 @@
+import { VueInstance } from '../hooks/_vueuse/unrefElement';
+import { camelize } from '../util';
+import { default as initDefaultProps } from './initDefaultProps';
+declare const splitAttrs: (attrs: any) => {
+    onEvents: Record<string, any>;
+    events: Record<string, any>;
+    extraAttrs: Record<string, any>;
+};
+declare const parseStyleText: (cssText?: string, camel?: boolean) => {};
+declare const hasProp: (instance: any, prop: string) => boolean;
+export declare const skipFlattenKey: unique symbol;
+declare const flattenChildren: (children?: never[], filterEmpty?: boolean) => any[];
+declare const getSlot: (self: any, name?: string, options?: {}) => any[];
+declare const findDOMNode: (instance: any) => any;
+declare const getOptionProps: (instance: VueInstance) => {};
+declare const getComponent: (instance: any, prop?: string, options?: any, execute?: boolean) => any;
+declare const getKey: (ele: any) => any;
+export declare function getEvents(ele?: any, on?: boolean): Record<string, any>;
+export declare function getClass(ele: any): {};
+export declare function getStyle(ele: any, camel?: boolean): any;
+export declare function getComponentName(opts: any): any;
+export declare function isFragment(c: any): boolean;
+export declare function isEmptyContent(c: any): boolean;
+export declare function isEmptyElement(c: any): any;
+export declare function isEmptySlot(c: any): any;
+export declare function isStringElement(c: any): any;
+export declare function filterEmpty(children?: never[]): any[];
+export declare function filterEmptyWithUndefined(children: any[]): any[] | undefined;
+declare function isValidElement(element: any): any;
+declare function getPropsSlot(slots: any, props: any, prop?: string): any;
+export declare const getTextFromElement: (ele: any) => any;
+export { camelize, findDOMNode, flattenChildren, getComponent, getKey, getOptionProps, getPropsSlot, getSlot, hasProp, initDefaultProps, isValidElement, parseStyleText, splitAttrs, };
+export default hasProp;

package/dist/src/_util/props-util/initDefaultProps.d.ts

@@ -0,0 +1,6 @@
+import { PropType } from 'vue';
+import { VueTypeDef, VueTypeValidableDef } from 'vue-types';
+declare const initDefaultProps: <T>(types: T, defaultProps: { [K in keyof T]?: T[K] extends VueTypeValidableDef<infer U> ? U : T[K] extends VueTypeDef<infer U> ? U : T[K] extends {
+    type: PropType<infer U>;
+} ? U : any; }) => T;
+export default initDefaultProps;

package/dist/src/_util/raf.d.ts

@@ -0,0 +1,5 @@
+declare function wrapperRaf(callback: () => void, times?: number): number;
+declare namespace wrapperRaf {
+    var cancel: (id: number) => void;
+}
+export default wrapperRaf;

package/dist/src/_util/reactivePick.d.ts

@@ -0,0 +1,9 @@
+import { UnwrapRef } from 'vue';
+/**
+ * Reactively pick fields from a reactive object
+ *
+ * @see https://vueuse.js.org/reactivePick
+ */
+export declare function reactivePick<T extends object, K extends keyof T>(obj: T, ...keys: K[]): {
+    [S in K]: UnwrapRef<T[S]>;
+};

package/dist/src/_util/requestAnimationTimeout.d.ts

@@ -0,0 +1,4 @@
+export declare const cancelAnimationTimeout: (frame: any) => any;
+export declare const requestAnimationTimeout: (callback: any, delay?: number) => {
+    id: any;
+};

package/dist/src/_util/responsiveObserve.d.ts

@@ -0,0 +1,22 @@
+import { ComputedRef } from 'vue';
+export type Breakpoint = 'xxxl' | 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type BreakpointMap = Record<Breakpoint, string>;
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export type ScreenSizeMap = Partial<Record<Breakpoint, number>>;
+export declare const responsiveArray: Breakpoint[];
+type SubscribeFunc = (screens: ScreenMap) => void;
+export default function useResponsiveObserver(): ComputedRef<{
+    matchHandlers: {
+        [prop: string]: {
+            mql: MediaQueryList;
+            listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
+        };
+    };
+    dispatch(pointMap: ScreenMap): boolean;
+    subscribe(func: SubscribeFunc): number;
+    unsubscribe(paramToken: number): void;
+    unregister(): void;
+    register(): void;
+    responsiveMap: BreakpointMap;
+}>;
+export {};

package/dist/src/_util/scrollTo.d.ts

@@ -0,0 +1,10 @@
+interface ScrollToOptions {
+    /** Scroll container, default as window */
+    getContainer?: () => HTMLElement | Window | Document;
+    /** Scroll end callback */
+    callback?: () => any;
+    /** Animation duration, default as 450 */
+    duration?: number;
+}
+export default function scrollTo(y: number, options?: ScrollToOptions): void;
+export {};

package/dist/src/_util/setStyle.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties } from 'vue';
+/**
+ * Easy to set element style, return previous style
+ * IE browser compatible(IE browser doesn't merge overflow style, need to set it separately)
+ * https://github.com/ant-design/ant-design/issues/19393
+ *
+ */
+export interface SetStyleOptions {
+    element?: HTMLElement;
+}
+declare function setStyle(style: CSSProperties, options?: SetStyleOptions): CSSProperties;
+export default setStyle;

package/dist/src/_util/shallowequal.d.ts

@@ -0,0 +1 @@
+export default function (value: any, other: any): boolean;

package/dist/src/_util/static-style-extract/index.d.ts

@@ -0,0 +1,2 @@
+import { CustomRender } from './interface';
+export declare function extractStyle(customTheme?: CustomRender): string;

package/dist/src/_util/static-style-extract/interface.d.ts

@@ -0,0 +1,2 @@
+import { VueNode } from '../type';
+export type CustomRender = (node: VueNode) => VueNode;

package/dist/src/_util/statusUtils.d.ts

@@ -0,0 +1,6 @@
+import { ValidateStatus } from '../form/FormItem';
+declare const InputStatuses: readonly ["warning", "error", ""];
+export type InputStatus = (typeof InputStatuses)[number];
+export declare function getStatusClassNames(prefixCls: string, status?: ValidateStatus, hasFeedback?: boolean): any;
+export declare const getMergedStatus: (contextStatus?: ValidateStatus, customStatus?: InputStatus) => "" | "validating" | "error" | "success" | "warning" | undefined;
+export {};

package/dist/src/_util/styleChecker.d.ts

@@ -0,0 +1,4 @@
+export declare const canUseDocElement: () => false | HTMLElement;
+export declare function isStyleSupport(styleName: string | string[], styleValue?: any): boolean;
+export declare const detectFlexGapSupported: () => boolean;
+export default isStyleSupport;

package/dist/src/_util/throttleByAnimationFrame.d.ts

@@ -0,0 +1,6 @@
+type throttledFn = (...args: any[]) => void;
+interface throttledCancelFn {
+    cancel: () => void;
+}
+declare function throttleByAnimationFrame<T extends any[]>(fn: (...args: T) => void): throttledFn & throttledCancelFn;
+export default throttleByAnimationFrame;

package/dist/src/_util/toReactive.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+type MaybeRef<T> = T | Ref<T>;
+/**
+ * Converts ref to reactive.
+ *
+ * @see https://vueuse.org/toReactive
+ * @param objectRef A ref of object
+ */
+export declare function toReactive<T extends object>(objectRef: MaybeRef<T>): T;
+export {};

package/dist/src/_util/transButton.d.ts

@@ -0,0 +1,35 @@
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const TransButton: DefineComponent<ExtractPropTypes<{
+    noStyle: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    onClick: FunctionConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    autofocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    noStyle: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    onClick: FunctionConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    autofocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    autofocus: boolean;
+    noStyle: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default TransButton;

package/dist/src/_util/transKeys.d.ts

@@ -0,0 +1,2 @@
+export declare const groupKeysMap: (keys: string[]) => Map<string, number>;
+export declare const groupDisabledKeysMap: <RecordType extends any[]>(dataSource: RecordType) => Map<string, number>;

package/dist/src/_util/transition.d.ts

@@ -0,0 +1,18 @@
+import { BaseTransitionProps, CSSProperties, Ref, TransitionGroupProps, TransitionProps } from 'vue';
+declare const SelectPlacements: ["bottomLeft", "bottomRight", "topLeft", "topRight"];
+export type SelectCommonPlacement = (typeof SelectPlacements)[number];
+declare const getTransitionDirection: (placement: SelectCommonPlacement | undefined) => "slide-up" | "slide-down";
+export declare const getTransitionProps: (transitionName: string, opt?: TransitionProps) => TransitionProps;
+export declare const getTransitionGroupProps: (transitionName: string, opt?: TransitionProps) => TransitionGroupProps;
+export declare type MotionEvent = (TransitionEvent | AnimationEvent) & {
+    deadline?: boolean;
+};
+export declare type MotionEventHandler = (element: Element, done?: () => void) => CSSProperties;
+export declare type MotionEndEventHandler = (element: Element, done?: () => void) => boolean | void;
+export interface CSSMotionProps extends Partial<BaseTransitionProps<Element>> {
+    name?: string;
+    css?: boolean;
+}
+declare const collapseMotion: (name: string | undefined, style: Ref<CSSProperties>, className: Ref<string>) => CSSMotionProps;
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { collapseMotion, getTransitionDirection, getTransitionName };

package/dist/src/_util/type.d.ts

@@ -0,0 +1,62 @@
+import { Plugin, PropType, Ref, SlotsType, VNode } from 'vue';
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769
+ * Extract the type of an element of an array/tuple without performing indexing
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never;
+/**
+ * https://github.com/Microsoft/TypeScript/issues/29729
+ */
+export type LiteralUnion<T extends string> = T | (string & {});
+export type Data = Record<string, unknown>;
+export type Key = string | number;
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+export interface PropOptions<T = any, D = T> {
+    type?: PropType<T> | true | null;
+    required?: boolean;
+    default?: D | DefaultFactory<D> | null | undefined | object;
+    validator?: (value: unknown) => boolean;
+}
+declare type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+export type VueNode = VNodeChildAtom | VNodeChildAtom[] | VNode;
+export declare const withInstall: <T>(comp: T) => T & Plugin;
+export type MaybeRef<T> = T | Ref<T>;
+export declare function eventType<T>(): {
+    type: PropType<T | T[]>;
+};
+export declare function objectType<T = {}>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function booleanType(defaultVal?: boolean): {
+    type: BooleanConstructor;
+    default: boolean;
+};
+export declare function functionType<T = () => {}>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function anyType<T = any>(defaultVal?: T, required?: boolean): {
+    default: T;
+    type: PropType<T>;
+};
+export declare function vNodeType<T = VueNode>(): {
+    type: PropType<T>;
+};
+export declare function arrayType<T extends any[]>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function stringType<T extends string = string>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function someType<T>(types?: any[], defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export type CustomSlotsType<T> = SlotsType<T>;
+export type AnyObject = Record<PropertyKey, any>;
+export {};

package/dist/src/_util/unreachableException.d.ts

@@ -0,0 +1,4 @@
+export default class UnreachableException {
+    error: Error;
+    constructor(value: any);
+}

package/dist/src/_util/util.d.ts

@@ -0,0 +1,18 @@
+import { VueNode } from './type';
+export declare const isFunction: (val: any) => boolean;
+export declare const controlDefaultValue: any;
+export declare const isArray: (arg: any) => arg is any[];
+export declare const isString: (val: any) => val is string;
+export declare const isSymbol: (val: any) => val is symbol;
+export declare const isObject: (val: any) => boolean;
+declare const isOn: (key: any) => boolean;
+declare const cacheStringFunction: (fn: any) => (str: any) => any;
+declare const camelize: (str: any) => any;
+declare const hyphenate: (str: any) => any;
+declare const capitalize: (str: any) => any;
+declare function resolvePropValue(options: any, props: any, key: any, value: any): any;
+export declare function getDataAndAriaProps(props: any): {};
+export declare function toPx(val: any): any;
+export declare function renderHelper<T = Record<string, any>>(v: VueNode | ((arg0: T) => VueNode), props?: T, defaultV?: any): any;
+export declare function wrapPromiseFn(openFn: (resolve: VoidFunction) => VoidFunction): any;
+export { cacheStringFunction, camelize, capitalize, hyphenate, isOn, resolvePropValue };

package/dist/src/_util/vnode.d.ts

@@ -0,0 +1,11 @@
+import { Slots, VNode, VNodeArrayChildren, VNodeProps } from 'vue';
+import { RefObject } from './createRef';
+type NodeProps = Record<string, any> & Omit<VNodeProps, 'ref'> & {
+    ref?: VNodeProps['ref'] | RefObject;
+};
+export declare function cloneElement<T, U>(vnode: VNode<T, U> | VNode<T, U>[], nodeProps?: NodeProps, override?: boolean, mergeRef?: boolean): VNode<T, U>;
+export declare function cloneVNodes(vnodes: any, nodeProps?: {}, override?: boolean): any;
+export declare function deepCloneElement<T, U>(vnode: VNode<T, U> | VNode<T, U>[], nodeProps?: NodeProps, override?: boolean, mergeRef?: boolean): any;
+export declare function triggerVNodeUpdate(vm: VNode, attrs: Record<string, any>, dom: any): void;
+export declare function customRenderSlot(slots: Slots, name: string, props: Record<string, unknown>, fallback?: () => VNodeArrayChildren): VNodeArrayChildren | undefined;
+export {};

package/dist/src/_util/vue-types/index.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties } from 'vue';
+import { VueTypeValidableDef, VueTypesInterface } from 'vue-types';
+import { VueNode } from '../type';
+export declare function withUndefined<T extends {
+    default?: any;
+}>(type: T): T;
+declare const _default: VueTypesInterface & {
+    readonly looseBool: VueTypeValidableDef<boolean>;
+    readonly style: VueTypeValidableDef<CSSProperties>;
+    readonly VueNode: VueTypeValidableDef<VueNode>;
+};
+export default _default;

package/dist/src/_util/warning.d.ts

@@ -0,0 +1,6 @@
+import { resetWarned } from '../vc-util/warning';
+export { resetWarned };
+export declare function noop(): void;
+type Warning = (valid: boolean, component: string, message?: string) => void;
+declare let warning: Warning;
+export default warning;

package/dist/src/_util/wave/WaveEffect.d.ts

@@ -0,0 +1,6 @@
+export interface WaveEffectProps {
+    className: string;
+    target: HTMLElement;
+}
+declare function showWaveEffect(node: HTMLElement, className: string): () => void;
+export default showWaveEffect;

package/dist/src/_util/wave/index.d.ts

@@ -0,0 +1,14 @@
+import { DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface WaveProps {
+    disabled?: boolean;
+}
+declare const _default: DefineComponent<ExtractPropTypes<{
+    disabled: BooleanConstructor;
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}> | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    disabled: BooleanConstructor;
+}>> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/_util/wave/style.d.ts

@@ -0,0 +1,7 @@
+import { FullToken, UseComponentStyleResult } from '../../theme/internal';
+import { Ref } from 'vue';
+export interface ComponentToken {
+}
+export type WaveToken = FullToken<'Wave'>;
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;

package/dist/src/_util/wave/useWave.d.ts

@@ -0,0 +1,4 @@
+import { ComputedRef, Ref } from 'vue';
+export default function useWave(className: Ref<string>, wave?: ComputedRef<{
+    disabled?: boolean;
+}>): VoidFunction;

package/dist/src/_util/wave/util.d.ts

@@ -0,0 +1,3 @@
+export declare function isNotGrey(color: string): boolean;
+export declare function isValidWaveColor(color: string): boolean | "";
+export declare function getTargetWaveColor(node: HTMLElement): string | null;