@vunk/plus 1.13.0 → 1.14.0

package/ant/_util/cssinjs/index.d.ts

@@ -0,0 +1,195 @@
+import useCacheToken from './hooks/useCacheToken';
+import type { CSSInterpolation, CSSObject } from './hooks/useStyleRegister';
+import useStyleRegister, { extractStyle } from './hooks/useStyleRegister';
+import Keyframes from './Keyframes';
+import type { Linter } from './linters';
+import { legacyNotSelectorLinter, logicalPropertiesLinter, parentSelectorLinter } from './linters';
+import type { StyleContextProps, StyleProviderProps } from './StyleContext';
+import { createCache, useStyleInject, useStyleProvider, StyleProvider } from './StyleContext';
+import type { DerivativeFunc, TokenType } from './theme';
+import { createTheme, Theme } from './theme';
+import type { Transformer } from './transformers/interface';
+import legacyLogicalPropertiesTransformer from './transformers/legacyLogicalProperties';
+import px2remTransformer from './transformers/px2rem';
+declare const cssinjs: {
+    Theme: typeof Theme;
+    createTheme: typeof createTheme;
+    useStyleRegister: typeof useStyleRegister;
+    useCacheToken: typeof useCacheToken;
+    createCache: typeof createCache;
+    useStyleInject: () => import("vue").ShallowRef<Partial<StyleContextProps>>;
+    useStyleProvider: (props: import("./StyleContext").UseStyleProviderProps) => import("vue").ShallowRef<Partial<StyleContextProps>, Partial<StyleContextProps>>;
+    Keyframes: typeof Keyframes;
+    extractStyle: typeof extractStyle;
+    legacyLogicalPropertiesTransformer: Transformer;
+    px2remTransformer: (options?: import("./transformers/px2rem").Options) => Transformer;
+    logicalPropertiesLinter: Linter;
+    legacyNotSelectorLinter: Linter;
+    parentSelectorLinter: Linter;
+    StyleProvider: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            autoClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            mock: {
+                type: import("vue").PropType<"server" | "client">;
+                default: "server" | "client";
+            };
+            cache: {
+                type: import("vue").PropType<import("./Cache").default>;
+                default: import("./Cache").default;
+            };
+            defaultCache: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hashPriority: {
+                type: import("vue").PropType<import("./StyleContext").HashPriority>;
+                default: import("./StyleContext").HashPriority;
+            };
+            container: {
+                type: import("vue").PropType<Element | ShadowRoot>;
+                default: Element | ShadowRoot;
+            };
+            ssrInline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            transformers: {
+                type: import("vue").PropType<Transformer[]>;
+                default: Transformer[];
+            };
+            linters: {
+                type: import("vue").PropType<Linter[]>;
+                default: Linter[];
+            };
+        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            autoClear: boolean;
+            mock: "server" | "client";
+            cache: import("./Cache").default;
+            defaultCache: boolean;
+            hashPriority: import("./StyleContext").HashPriority;
+            container: Element | ShadowRoot;
+            ssrInline: boolean;
+            transformers: Transformer[];
+            linters: Linter[];
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            autoClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            mock: {
+                type: import("vue").PropType<"server" | "client">;
+                default: "server" | "client";
+            };
+            cache: {
+                type: import("vue").PropType<import("./Cache").default>;
+                default: import("./Cache").default;
+            };
+            defaultCache: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hashPriority: {
+                type: import("vue").PropType<import("./StyleContext").HashPriority>;
+                default: import("./StyleContext").HashPriority;
+            };
+            container: {
+                type: import("vue").PropType<Element | ShadowRoot>;
+                default: Element | ShadowRoot;
+            };
+            ssrInline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            transformers: {
+                type: import("vue").PropType<Transformer[]>;
+                default: Transformer[];
+            };
+            linters: {
+                type: import("vue").PropType<Linter[]>;
+                default: Linter[];
+            };
+        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[], {}, {}, {}, {
+            autoClear: boolean;
+            mock: "server" | "client";
+            cache: import("./Cache").default;
+            defaultCache: boolean;
+            hashPriority: import("./StyleContext").HashPriority;
+            container: Element | ShadowRoot;
+            ssrInline: boolean;
+            transformers: Transformer[];
+            linters: Linter[];
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        autoClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        mock: {
+            type: import("vue").PropType<"server" | "client">;
+            default: "server" | "client";
+        };
+        cache: {
+            type: import("vue").PropType<import("./Cache").default>;
+            default: import("./Cache").default;
+        };
+        defaultCache: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hashPriority: {
+            type: import("vue").PropType<import("./StyleContext").HashPriority>;
+            default: import("./StyleContext").HashPriority;
+        };
+        container: {
+            type: import("vue").PropType<Element | ShadowRoot>;
+            default: Element | ShadowRoot;
+        };
+        ssrInline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        transformers: {
+            type: import("vue").PropType<Transformer[]>;
+            default: Transformer[];
+        };
+        linters: {
+            type: import("vue").PropType<Linter[]>;
+            default: Linter[];
+        };
+    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        autoClear: boolean;
+        mock: "server" | "client";
+        cache: import("./Cache").default;
+        defaultCache: boolean;
+        hashPriority: import("./StyleContext").HashPriority;
+        container: Element | ShadowRoot;
+        ssrInline: boolean;
+        transformers: Transformer[];
+        linters: Linter[];
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
+};
+export { Theme, createTheme, useStyleRegister, useCacheToken, createCache, useStyleInject, useStyleProvider, Keyframes, extractStyle, legacyLogicalPropertiesTransformer, px2remTransformer, logicalPropertiesLinter, legacyNotSelectorLinter, parentSelectorLinter, StyleProvider, };
+export type { TokenType, CSSObject, CSSInterpolation, DerivativeFunc, Transformer, Linter, StyleContextProps, StyleProviderProps, };
+export declare const _experimental: {
+    supportModernCSS: () => boolean;
+};
+export default cssinjs;

package/ant/_util/cssinjs/linters/contentQuotesLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/ant/_util/cssinjs/linters/hashedAnimationLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/ant/_util/cssinjs/linters/index.d.ts

@@ -0,0 +1,6 @@
+export { default as contentQuotesLinter } from './contentQuotesLinter';
+export { default as hashedAnimationLinter } from './hashedAnimationLinter';
+export type { Linter } from './interface';
+export { default as legacyNotSelectorLinter } from './legacyNotSelectorLinter';
+export { default as logicalPropertiesLinter } from './logicalPropertiesLinter';
+export { default as parentSelectorLinter } from './parentSelectorLinter';

package/ant/_util/cssinjs/linters/interface.d.ts

@@ -0,0 +1,8 @@
+export interface LinterInfo {
+    path?: string;
+    hashId?: string;
+    parentSelectors: string[];
+}
+export interface Linter {
+    (key: string, value: string | number, info: LinterInfo): void;
+}

package/ant/_util/cssinjs/linters/legacyNotSelectorLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/ant/_util/cssinjs/linters/logicalPropertiesLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/ant/_util/cssinjs/linters/parentSelectorLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from '..';
+declare const linter: Linter;
+export default linter;

package/ant/_util/cssinjs/linters/utils.d.ts

@@ -0,0 +1,2 @@
+import type { LinterInfo } from './interface';
+export declare function lintWarning(message: string, info: LinterInfo): void;

package/ant/_util/cssinjs/theme/Theme.d.ts

@@ -0,0 +1,11 @@
+import type { DerivativeFunc, TokenType } from './interface';
+/**
+ * Theme with algorithms to derive tokens from design tokens.
+ * Use `createTheme` first which will help to manage the theme instance cache.
+ */
+export default class Theme<DesignToken extends TokenType, DerivativeToken extends TokenType> {
+    private derivatives;
+    readonly id: number;
+    constructor(derivatives: DerivativeFunc<DesignToken, DerivativeToken> | DerivativeFunc<DesignToken, DerivativeToken>[]);
+    getDerivativeToken(token: DesignToken): DerivativeToken;
+}

package/ant/_util/cssinjs/theme/ThemeCache.d.ts

@@ -0,0 +1,20 @@
+import type Theme from './Theme';
+import type { DerivativeFunc } from './interface';
+type DerivativeOptions = DerivativeFunc<any, any>[];
+export declare function sameDerivativeOption(left: DerivativeOptions, right: DerivativeOptions): boolean;
+export default class ThemeCache {
+    static MAX_CACHE_SIZE: number;
+    static MAX_CACHE_OFFSET: number;
+    private readonly cache;
+    private keys;
+    private cacheCallTimes;
+    constructor();
+    size(): number;
+    private internalGet;
+    get(derivativeOption: DerivativeOptions): Theme<any, any> | undefined;
+    has(derivativeOption: DerivativeOptions): boolean;
+    set(derivativeOption: DerivativeOptions, value: Theme<any, any>): void;
+    private deleteByPath;
+    delete(derivativeOption: DerivativeOptions): Theme<any, any> | undefined;
+}
+export {};

package/ant/_util/cssinjs/theme/createTheme.d.ts

@@ -0,0 +1,6 @@
+import Theme from './Theme';
+import type { DerivativeFunc, TokenType } from './interface';
+/**
+ * Same as new Theme, but will always return same one if `derivative` not changed.
+ */
+export default function createTheme<DesignToken extends TokenType, DerivativeToken extends TokenType>(derivatives: DerivativeFunc<DesignToken, DerivativeToken>[] | DerivativeFunc<DesignToken, DerivativeToken>): Theme<any, any>;

package/ant/_util/cssinjs/theme/index.d.ts

@@ -0,0 +1,4 @@
+export { default as createTheme } from './createTheme';
+export { default as Theme } from './Theme';
+export { default as ThemeCache } from './ThemeCache';
+export type { TokenType, DerivativeFunc } from './interface';

package/ant/_util/cssinjs/theme/interface.d.ts

@@ -0,0 +1,2 @@
+export type TokenType = object;
+export type DerivativeFunc<DesignToken extends TokenType, DerivativeToken extends TokenType> = (designToken: DesignToken, derivativeToken?: DerivativeToken) => DerivativeToken;

package/ant/_util/cssinjs/transformers/interface.d.ts

@@ -0,0 +1,4 @@
+import type { CSSObject } from '..';
+export interface Transformer {
+    visit?: (cssObj: CSSObject) => CSSObject;
+}

package/ant/_util/cssinjs/transformers/legacyLogicalProperties.d.ts

@@ -0,0 +1,12 @@
+import type { Transformer } from './interface';
+/**
+ * Convert css logical properties to legacy properties.
+ * Such as: `margin-block-start` to `margin-top`.
+ * Transform list:
+ * - inset
+ * - margin
+ * - padding
+ * - border
+ */
+declare const transform: Transformer;
+export default transform;

package/ant/_util/cssinjs/transformers/px2rem.d.ts

@@ -0,0 +1,20 @@
+import type { Transformer } from './interface';
+export interface Options {
+    /**
+     * The root font size.
+     * @default 16
+     */
+    rootValue?: number;
+    /**
+     * The decimal numbers to allow the REM units to grow to.
+     * @default 5
+     */
+    precision?: number;
+    /**
+     * Whether to allow px to be converted in media queries.
+     * @default false
+     */
+    mediaQuery?: boolean;
+}
+declare const transform: (options?: Options) => Transformer;
+export default transform;

package/ant/_util/cssinjs/util.d.ts

@@ -0,0 +1,8 @@
+export declare function flattenToken(token: any): string;
+/**
+ * Convert derivative token to key string
+ */
+export declare function token2key(token: any, salt: string): string;
+export declare function supportLayer(): boolean;
+export declare function supportWhere(): boolean;
+export declare function supportLogicProps(): boolean;

package/ant/_util/firstNotUndefined.d.ts

@@ -0,0 +1,2 @@
+declare function firstNotUndefined<T>(arr?: T[]): T;
+export default firstNotUndefined;

package/ant/_util/gapSize.d.ts

@@ -0,0 +1,3 @@
+import type { SizeType } from '../config-provider/SizeContext';
+export declare function isPresetSize(size?: SizeType | string | number): size is SizeType;
+export declare function isValidGapNumber(size?: SizeType | string | number): size is number;

package/ant/_util/getScrollBarSize.d.ts

@@ -0,0 +1,5 @@
+export default function getScrollBarSize(fresh?: boolean): number;
+export declare function getTargetScrollBarSize(target: HTMLElement): {
+    width: number;
+    height: number;
+};

package/ant/_util/hooks/_vueuse/resolveUnref.d.ts

@@ -0,0 +1,5 @@
+import type { MaybeComputedRef } from './types';
+/**
+ * Get the value of value/ref/getter.
+ */
+export declare function resolveUnref<T>(r: MaybeComputedRef<T>): T;

package/ant/_util/hooks/_vueuse/types.d.ts

@@ -0,0 +1,114 @@
+import type { ComputedRef, Ref, WatchOptions, WatchSource } from 'vue';
+/**
+ * Any function
+ */
+export type Fn = () => void;
+/**
+ * A ref that allow to set null or undefined
+ */
+export type RemovableRef<T> = Omit<Ref<T>, 'value'> & {
+    get value(): T;
+    set value(value: T | null | undefined);
+};
+/**
+ * @deprecated Use `RemovableRef`
+ */
+export type RemoveableRef<T> = RemovableRef<T>;
+/**
+ * Maybe it's a ref, or a plain value
+ *
+ * ```ts
+ * type MaybeRef<T> = T | Ref<T>
+ * ```
+ */
+export type MaybeRef<T> = T | Ref<T>;
+/**
+ * Maybe it's a ref, or a plain value, or a getter function
+ *
+ * ```ts
+ * type MaybeComputedRef<T> = (() => T) | T | Ref<T> | ComputedRef<T>
+ * ```
+ */
+export type MaybeComputedRef<T> = MaybeReadonlyRef<T> | MaybeRef<T>;
+/**
+ * Maybe it's a computed ref, or a getter function
+ *
+ * ```ts
+ * type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>
+ * ```
+ */
+export type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+/**
+ * Make all the nested attributes of an object or array to MaybeRef<T>
+ *
+ * Good for accepting options that will be wrapped with `reactive` or `ref`
+ *
+ * ```ts
+ * UnwrapRef<DeepMaybeRef<T>> === T
+ * ```
+ */
+export type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? {
+    [K in keyof T]: DeepMaybeRef<T[K]>;
+} : MaybeRef<T>;
+/**
+ * Infers the element type of an array
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : never;
+export type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
+export type Awaitable<T> = Promise<T> | T;
+export type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+export interface Pausable {
+    /**
+     * A ref indicate whether a pausable instance is active
+     */
+    isActive: Ref<boolean>;
+    /**
+     * Temporary pause the effect from executing
+     */
+    pause: Fn;
+    /**
+     * Resume the effects
+     */
+    resume: Fn;
+}
+export interface Stoppable {
+    /**
+     * A ref indicate whether a stoppable instance is executing
+     */
+    isPending: Ref<boolean>;
+    /**
+     * Stop the effect from executing
+     */
+    stop: Fn;
+    /**
+     * Start the effects
+     */
+    start: Fn;
+}
+/**
+ * @deprecated Use `Stoppable`
+ */
+export type Stopable = Stoppable;
+export interface ConfigurableFlush {
+    /**
+     * Timing for monitoring changes, refer to WatchOptions for more details
+     *
+     * @default 'pre'
+     */
+    flush?: WatchOptions['flush'];
+}
+export interface ConfigurableFlushSync {
+    /**
+     * Timing for monitoring changes, refer to WatchOptions for more details.
+     * Unlike `watch()`, the default is set to `sync`
+     *
+     * @default 'sync'
+     */
+    flush?: WatchOptions['flush'];
+}
+export type MapSources<T> = {
+    [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never;
+};
+export type MapOldSources<T, Immediate> = {
+    [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never;
+};

package/ant/_util/hooks/_vueuse/unrefElement.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentPublicInstance } from 'vue';
+import type { MaybeComputedRef, MaybeRef } from './types';
+export type VueInstance = ComponentPublicInstance;
+export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
+export type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeComputedRef<T>;
+export type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
+export type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance ? Exclude<MaybeElement, VueInstance> : T | undefined;
+/**
+ * Get the dom element of a ref of element or Vue component instance
+ *
+ * @param elRef
+ */
+export declare function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): UnRefElementReturn<T>;

package/ant/_util/hooks/useBreakpoint.d.ts

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

package/ant/_util/hooks/useFlexGapSupport.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("vue").ShallowRef<boolean, boolean>;
+export default _default;

package/ant/_util/hooks/useMergedState.d.ts

@@ -0,0 +1,7 @@
+import type { 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/ant/_util/hooks/useRefs.d.ts

@@ -0,0 +1,7 @@
+import type { Ref, ComponentPublicInstance } from 'vue';
+import type { 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/ant/_util/hooks/useScrollLocker.d.ts

@@ -0,0 +1,6 @@
+import type { 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/ant/_util/hooks/useState.d.ts

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

package/ant/_util/isValid.d.ts

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

package/ant/_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/ant/_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/ant/_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/ant/_util/props-util/index.d.ts

@@ -0,0 +1,33 @@
+import { camelize } from '../util';
+import initDefaultProps from './initDefaultProps';
+import type { VueInstance } from '../hooks/_vueuse/unrefElement';
+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?: any[], 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): boolean;
+export declare function isEmptySlot(c: any): any;
+export declare function isStringElement(c: any): boolean;
+export declare function filterEmpty(children?: any[]): any[];
+export declare function filterEmptyWithUndefined(children: any[]): any[];
+declare function isValidElement(element: any): boolean;
+declare function getPropsSlot(slots: any, props: any, prop?: string): any;
+export declare const getTextFromElement: (ele: any) => any;
+export { splitAttrs, hasProp, getOptionProps, getComponent, getKey, parseStyleText, initDefaultProps, isValidElement, camelize, getSlot, findDOMNode, flattenChildren, getPropsSlot, };
+export default hasProp;